Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

40 files changed, 31018 insertions, 0 deletions

diff --git a/APEX_1.4/module/particles/src/autogen/AttractorFieldSamplerData.cpp b/APEX_1.4/module/particles/src/autogen/AttractorFieldSamplerData.cpp
new file mode 100644
index 00000000..818522a6
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/AttractorFieldSamplerData.cpp
@@ -0,0 +1,363 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "AttractorFieldSamplerData.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace AttractorFieldSamplerDataNS;
+
+const char* const AttractorFieldSamplerDataFactory::vptr =
+    NvParameterized::getVptr<AttractorFieldSamplerData, AttractorFieldSamplerData::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->Name), NULL, 0 }, // Name
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->AttractorFieldSampler), NULL, 0 }, // AttractorFieldSampler
+};
+
+
+bool AttractorFieldSamplerData::mBuiltFlag = false;
+NvParameterized::MutexType AttractorFieldSamplerData::mBuiltFlagMutex;
+
+AttractorFieldSamplerData::AttractorFieldSamplerData(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &AttractorFieldSamplerDataFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+AttractorFieldSamplerData::~AttractorFieldSamplerData()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void AttractorFieldSamplerData::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~AttractorFieldSamplerData();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* AttractorFieldSamplerData::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* AttractorFieldSamplerData::getParameterDefinitionTree(void) const
+{
+	AttractorFieldSamplerData* tmpParam = const_cast<AttractorFieldSamplerData*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType AttractorFieldSamplerData::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType AttractorFieldSamplerData::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void AttractorFieldSamplerData::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<AttractorFieldSamplerData::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void AttractorFieldSamplerData::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void AttractorFieldSamplerData::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Containst he asset properties for this attractor field sampler", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="Name"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("Name", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Attractor FS Name", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="AttractorFieldSampler"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("AttractorFieldSampler", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Attractor FS Name", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "AttractorFSAssetParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void AttractorFieldSamplerData::initStrings(void)
+{
+	Name.isAllocated = false;
+	Name.buf = (const char*)"defaultAttractorFieldSampler";
+}
+
+void AttractorFieldSamplerData::initDynamicArrays(void)
+{
+}
+
+void AttractorFieldSamplerData::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void AttractorFieldSamplerData::initReferences(void)
+{
+	AttractorFieldSampler = NULL;
+
+}
+
+void AttractorFieldSamplerData::freeDynamicArrays(void)
+{
+}
+
+void AttractorFieldSamplerData::freeStrings(void)
+{
+
+	if (Name.isAllocated && Name.buf)
+	{
+		mParameterizedTraits->strfree((char*)Name.buf);
+	}
+}
+
+void AttractorFieldSamplerData::freeReferences(void)
+{
+	if (AttractorFieldSampler)
+	{
+		AttractorFieldSampler->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/AttractorFieldSamplerEffect.cpp b/APEX_1.4/module/particles/src/autogen/AttractorFieldSamplerEffect.cpp
new file mode 100644
index 00000000..640c6e85
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/AttractorFieldSamplerEffect.cpp
@@ -0,0 +1,1362 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "AttractorFieldSamplerEffect.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace AttractorFieldSamplerEffectNS;
+
+const char* const AttractorFieldSamplerEffectFactory::vptr =
+    NvParameterized::getVptr<AttractorFieldSamplerEffect, AttractorFieldSamplerEffect::ClassAlignment>();
+
+const uint32_t NumParamDefs = 32;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 31, 2, 3, 4, 8, 12, 13, 14, 15, 16, 17, 5, 6, 7, 9, 10, 11, 18, 19, 20, 21, 23,
+	27, 22, 24, 25, 26, 28, 29, 30,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->EffectProperties), CHILDREN(2), 10 }, // EffectProperties
+	{ TYPE_STRING, false, (size_t)(&((EffectProperties_Type*)0)->UserString), NULL, 0 }, // EffectProperties.UserString
+	{ TYPE_BOOL, false, (size_t)(&((EffectProperties_Type*)0)->Enable), NULL, 0 }, // EffectProperties.Enable
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Position), CHILDREN(12), 3 }, // EffectProperties.Position
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateX), NULL, 0 }, // EffectProperties.Position.TranslateX
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateY), NULL, 0 }, // EffectProperties.Position.TranslateY
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateZ), NULL, 0 }, // EffectProperties.Position.TranslateZ
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Orientation), CHILDREN(15), 3 }, // EffectProperties.Orientation
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateX), NULL, 0 }, // EffectProperties.Orientation.RotateX
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateY), NULL, 0 }, // EffectProperties.Orientation.RotateY
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateZ), NULL, 0 }, // EffectProperties.Orientation.RotateZ
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->InitialDelayTime), NULL, 0 }, // EffectProperties.InitialDelayTime
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->Duration), NULL, 0 }, // EffectProperties.Duration
+	{ TYPE_U32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatCount), NULL, 0 }, // EffectProperties.RepeatCount
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatDelay), NULL, 0 }, // EffectProperties.RepeatDelay
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RandomizeRepeatTime), NULL, 0 }, // EffectProperties.RandomizeRepeatTime
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Path), CHILDREN(18), 6 }, // EffectProperties.Path
+	{ TYPE_ENUM, false, (size_t)(&((EffectPath_Type*)0)->PlaybackMode), NULL, 0 }, // EffectProperties.Path.PlaybackMode
+	{ TYPE_F32, false, (size_t)(&((EffectPath_Type*)0)->PathDuration), NULL, 0 }, // EffectProperties.Path.PathDuration
+	{ TYPE_U32, false, (size_t)(&((EffectPath_Type*)0)->LoopIndex), NULL, 0 }, // EffectProperties.Path.LoopIndex
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->ControlPoints), CHILDREN(24), 1 }, // EffectProperties.Path.ControlPoints
+	{ TYPE_TRANSFORM, false, 1 * sizeof(physx::PxTransform), NULL, 0 }, // EffectProperties.Path.ControlPoints[]
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Scale), CHILDREN(25), 1 }, // EffectProperties.Path.Scale
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(26), 2 }, // EffectProperties.Path.Scale[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Scale[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Scale[].y
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Speed), CHILDREN(28), 1 }, // EffectProperties.Path.Speed
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(29), 2 }, // EffectProperties.Path.Speed[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Speed[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Speed[].y
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->AttractorFieldSampler), NULL, 0 }, // AttractorFieldSampler
+};
+
+
+bool AttractorFieldSamplerEffect::mBuiltFlag = false;
+NvParameterized::MutexType AttractorFieldSamplerEffect::mBuiltFlagMutex;
+
+AttractorFieldSamplerEffect::AttractorFieldSamplerEffect(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &AttractorFieldSamplerEffectFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+AttractorFieldSamplerEffect::~AttractorFieldSamplerEffect()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void AttractorFieldSamplerEffect::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~AttractorFieldSamplerEffect();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* AttractorFieldSamplerEffect::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* AttractorFieldSamplerEffect::getParameterDefinitionTree(void) const
+{
+	AttractorFieldSamplerEffect* tmpParam = const_cast<AttractorFieldSamplerEffect*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType AttractorFieldSamplerEffect::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType AttractorFieldSamplerEffect::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void AttractorFieldSamplerEffect::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<AttractorFieldSamplerEffect::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void AttractorFieldSamplerEffect::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void AttractorFieldSamplerEffect::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An attractor effect", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="EffectProperties"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("EffectProperties", TYPE_STRUCT, "EffectProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Attractor FS Properties", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="EffectProperties.UserString"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("UserString", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An aribtrary user string that can be set by an artist/designer/programmer", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="EffectProperties.Enable"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("Enable", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Whether or not this effect is to be initially enabled on startup", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("Position", TYPE_STRUCT, "TranslateObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The position of this effect relative to the parent", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="EffectProperties.Position.TranslateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("TranslateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="EffectProperties.Position.TranslateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("TranslateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="EffectProperties.Position.TranslateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("TranslateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("Orientation", TYPE_STRUCT, "OrientObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The orientation of this effect, relative to the parent orientation", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="EffectProperties.Orientation.RotateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("RotateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the X axis (0-360 degrees)", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="EffectProperties.Orientation.RotateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("RotateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Y axis (0-360 degrees)", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=11, longName="EffectProperties.Orientation.RotateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11];
+		ParamDef->init("RotateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Z axis (0-360 degrees)", true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=12, longName="EffectProperties.InitialDelayTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12];
+		ParamDef->init("InitialDelayTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "Initial time to delay before spawning this effect", true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=13, longName="EffectProperties.Duration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13];
+		ParamDef->init("Duration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The duration of the effect in secontds", true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=14, longName="EffectProperties.RepeatCount"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14];
+		ParamDef->init("RepeatCount", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(1), true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The number of times to repeat the effect; 9999 means repeate forever", true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=15, longName="EffectProperties.RepeatDelay"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15];
+		ParamDef->init("RepeatDelay", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The time to delay activation each time the effect repeats in seconds; this can be different than the initial delay time", true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=16, longName="EffectProperties.RandomizeRepeatTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16];
+		ParamDef->init("RandomizeRepeatTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Amount of randomization to the repeat cycle; a value of zero (default) means no random and a value of one means completely random.", true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17];
+		ParamDef->init("Path", TYPE_STRUCT, "EffectPath", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An optional pre-defined path for this effect to travel on", true);
+		ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=18, longName="EffectProperties.Path.PlaybackMode"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18];
+		ParamDef->init("PlaybackMode", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The mode to play back the path", true);
+		ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "LOOP", "PLAY_ONCE", "PING_PONG" };
+		ParamDefTable[18].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=19, longName="EffectProperties.Path.PathDuration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19];
+		ParamDef->init("PathDuration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		HintTable[2].init("shortDescription", "The duration of the path if one is not otherwise provided", true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=20, longName="EffectProperties.Path.LoopIndex"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20];
+		ParamDef->init("LoopIndex", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "The array index to loop back to", true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21];
+		ParamDef->init("ControlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=22, longName="EffectProperties.Path.ControlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22];
+		ParamDef->init("ControlPoints", TYPE_TRANSFORM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23];
+		ParamDef->init("Scale", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24];
+		ParamDef->init("Scale", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=25, longName="EffectProperties.Path.Scale[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=26, longName="EffectProperties.Path.Scale[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27];
+		ParamDef->init("Speed", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28];
+		ParamDef->init("Speed", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=29, longName="EffectProperties.Path.Speed[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=30, longName="EffectProperties.Path.Speed[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=31, longName="AttractorFieldSampler"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31];
+		ParamDef->init("AttractorFieldSampler", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Attractor FS Asset", true);
+		ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "AttractorFSAsset" };
+		ParamDefTable[31].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(31);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="EffectProperties"
+	{
+		static Definition* Children[10];
+		Children[0] = PDEF_PTR(2);
+		Children[1] = PDEF_PTR(3);
+		Children[2] = PDEF_PTR(4);
+		Children[3] = PDEF_PTR(8);
+		Children[4] = PDEF_PTR(12);
+		Children[5] = PDEF_PTR(13);
+		Children[6] = PDEF_PTR(14);
+		Children[7] = PDEF_PTR(15);
+		Children[8] = PDEF_PTR(16);
+		Children[9] = PDEF_PTR(17);
+
+		ParamDefTable[1].setChildren(Children, 10);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(5);
+		Children[1] = PDEF_PTR(6);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[4].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(9);
+		Children[1] = PDEF_PTR(10);
+		Children[2] = PDEF_PTR(11);
+
+		ParamDefTable[8].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		static Definition* Children[6];
+		Children[0] = PDEF_PTR(18);
+		Children[1] = PDEF_PTR(19);
+		Children[2] = PDEF_PTR(20);
+		Children[3] = PDEF_PTR(21);
+		Children[4] = PDEF_PTR(23);
+		Children[5] = PDEF_PTR(27);
+
+		ParamDefTable[17].setChildren(Children, 6);
+	}
+
+	// SetChildren for: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(22);
+
+		ParamDefTable[21].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(24);
+
+		ParamDefTable[23].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(25);
+		Children[1] = PDEF_PTR(26);
+
+		ParamDefTable[24].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(28);
+
+		ParamDefTable[27].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(29);
+		Children[1] = PDEF_PTR(30);
+
+		ParamDefTable[28].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void AttractorFieldSamplerEffect::initStrings(void)
+{
+	EffectProperties.UserString.isAllocated = true;
+	EffectProperties.UserString.buf = NULL;
+}
+
+void AttractorFieldSamplerEffect::initDynamicArrays(void)
+{
+	EffectProperties.Path.ControlPoints.buf = NULL;
+	EffectProperties.Path.ControlPoints.isAllocated = true;
+	EffectProperties.Path.ControlPoints.elementSize = sizeof(physx::PxTransform);
+	EffectProperties.Path.ControlPoints.arraySizes[0] = 0;
+	EffectProperties.Path.Scale.buf = NULL;
+	EffectProperties.Path.Scale.isAllocated = true;
+	EffectProperties.Path.Scale.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Scale.arraySizes[0] = 0;
+	EffectProperties.Path.Speed.buf = NULL;
+	EffectProperties.Path.Speed.isAllocated = true;
+	EffectProperties.Path.Speed.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Speed.arraySizes[0] = 0;
+}
+
+void AttractorFieldSamplerEffect::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	EffectProperties.Enable = bool(1);
+	EffectProperties.Position.TranslateX = float(0.000000000);
+	EffectProperties.Position.TranslateY = float(0.000000000);
+	EffectProperties.Position.TranslateZ = float(0.000000000);
+	EffectProperties.Orientation.RotateX = float(0.000000000);
+	EffectProperties.Orientation.RotateY = float(0.000000000);
+	EffectProperties.Orientation.RotateZ = float(0.000000000);
+	EffectProperties.InitialDelayTime = float(0.000000000);
+	EffectProperties.Duration = float(0.000000000);
+	EffectProperties.RepeatCount = uint32_t(1);
+	EffectProperties.RepeatDelay = float(0.000000000);
+	EffectProperties.RandomizeRepeatTime = float(0.000000000);
+	EffectProperties.Path.PlaybackMode = (const char*)"LOOP";
+	EffectProperties.Path.PathDuration = float(4.000000000);
+	EffectProperties.Path.LoopIndex = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void AttractorFieldSamplerEffect::initReferences(void)
+{
+	AttractorFieldSampler = NULL;
+
+}
+
+void AttractorFieldSamplerEffect::freeDynamicArrays(void)
+{
+	if (EffectProperties.Path.ControlPoints.isAllocated && EffectProperties.Path.ControlPoints.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.ControlPoints.buf);
+	}
+	if (EffectProperties.Path.Scale.isAllocated && EffectProperties.Path.Scale.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Scale.buf);
+	}
+	if (EffectProperties.Path.Speed.isAllocated && EffectProperties.Path.Speed.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Speed.buf);
+	}
+}
+
+void AttractorFieldSamplerEffect::freeStrings(void)
+{
+
+	if (EffectProperties.UserString.isAllocated && EffectProperties.UserString.buf)
+	{
+		mParameterizedTraits->strfree((char*)EffectProperties.UserString.buf);
+	}
+}
+
+void AttractorFieldSamplerEffect::freeReferences(void)
+{
+	if (AttractorFieldSampler)
+	{
+		AttractorFieldSampler->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/EffectPackageActorParams.cpp b/APEX_1.4/module/particles/src/autogen/EffectPackageActorParams.cpp
new file mode 100644
index 00000000..ca305693
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/EffectPackageActorParams.cpp
@@ -0,0 +1,368 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "EffectPackageActorParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace EffectPackageActorParamsNS;
+
+const char* const EffectPackageActorParamsFactory::vptr =
+    NvParameterized::getVptr<EffectPackageActorParams, EffectPackageActorParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 4;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_TRANSFORM, false, (size_t)(&((ParametersStruct*)0)->InitialPose), NULL, 0 }, // InitialPose
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->objectScale), NULL, 0 }, // objectScale
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->Enabled), NULL, 0 }, // Enabled
+};
+
+
+bool EffectPackageActorParams::mBuiltFlag = false;
+NvParameterized::MutexType EffectPackageActorParams::mBuiltFlagMutex;
+
+EffectPackageActorParams::EffectPackageActorParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &EffectPackageActorParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+EffectPackageActorParams::~EffectPackageActorParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void EffectPackageActorParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~EffectPackageActorParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* EffectPackageActorParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* EffectPackageActorParams::getParameterDefinitionTree(void) const
+{
+	EffectPackageActorParams* tmpParam = const_cast<EffectPackageActorParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType EffectPackageActorParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType EffectPackageActorParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void EffectPackageActorParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<EffectPackageActorParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void EffectPackageActorParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void EffectPackageActorParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The individual effect package actor properties", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="InitialPose"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("InitialPose", TYPE_TRANSFORM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Helpful tooltip information goes here", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="objectScale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("objectScale", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "A uniform overall scale factor for this effect actor", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="Enabled"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("Enabled", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Helpful tooltip information goes here", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	mBuiltFlag = true;
+
+}
+void EffectPackageActorParams::initStrings(void)
+{
+}
+
+void EffectPackageActorParams::initDynamicArrays(void)
+{
+}
+
+void EffectPackageActorParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	InitialPose = physx::PxTransform(init(0,0,0,0,0,0,1));
+	objectScale = float(1.000000000);
+	Enabled = bool(1);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void EffectPackageActorParams::initReferences(void)
+{
+}
+
+void EffectPackageActorParams::freeDynamicArrays(void)
+{
+}
+
+void EffectPackageActorParams::freeStrings(void)
+{
+}
+
+void EffectPackageActorParams::freeReferences(void)
+{
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/EffectPackageAssetParams.cpp b/APEX_1.4/module/particles/src/autogen/EffectPackageAssetParams.cpp
new file mode 100644
index 00000000..1c36c949
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/EffectPackageAssetParams.cpp
@@ -0,0 +1,1613 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "EffectPackageAssetParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace EffectPackageAssetParamsNS;
+
+const char* const EffectPackageAssetParamsFactory::vptr =
+    NvParameterized::getVptr<EffectPackageAssetParams, EffectPackageAssetParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 40;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 23, 37, 39, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+	21, 22, 24, 25, 26, 27, 29, 33, 28, 30, 31, 32, 34, 35, 36, 38,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 4 },
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->LODSettings), CHILDREN(4), 21 }, // LODSettings
+	{ TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->UniqueRenderVolume), NULL, 0 }, // LODSettings.UniqueRenderVolume
+	{ TYPE_F32, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeDistanceBegin), NULL, 0 }, // LODSettings.FadeDistanceBegin
+	{ TYPE_F32, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeDistanceEnd), NULL, 0 }, // LODSettings.FadeDistanceEnd
+	{ TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->RandomizeEmitterRate), NULL, 0 }, // LODSettings.RandomizeEmitterRate
+	{ TYPE_F32, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeOutRate), NULL, 0 }, // LODSettings.FadeOutRate
+	{ TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->CullByDistance), NULL, 0 }, // LODSettings.CullByDistance
+	{ TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->CullOffScreen), NULL, 0 }, // LODSettings.CullOffScreen
+	{ TYPE_F32, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->OffScreenCullTime), NULL, 0 }, // LODSettings.OffScreenCullTime
+	{ TYPE_F32, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->NonVisibleDeleteTime), NULL, 0 }, // LODSettings.NonVisibleDeleteTime
+	{ TYPE_F32, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->ScreenCullSize), NULL, 0 }, // LODSettings.ScreenCullSize
+	{ TYPE_F32, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->ScreenCullDistance), NULL, 0 }, // LODSettings.ScreenCullDistance
+	{ TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeEmitterRate), NULL, 0 }, // LODSettings.FadeEmitterRate
+	{ TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeAttractorFieldStrength), NULL, 0 }, // LODSettings.FadeAttractorFieldStrength
+	{ TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeJetFieldStrength), NULL, 0 }, // LODSettings.FadeJetFieldStrength
+	{ TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeTurbulenceVelocity), NULL, 0 }, // LODSettings.FadeTurbulenceVelocity
+	{ TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeTurbulenceNoise), NULL, 0 }, // LODSettings.FadeTurbulenceNoise
+	{ TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeTurbulenceExternalVelocity), NULL, 0 }, // LODSettings.FadeTurbulenceExternalVelocity
+	{ TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeTurbulenceVelocityWeight), NULL, 0 }, // LODSettings.FadeTurbulenceVelocityWeight
+	{ TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeHeatSourceTemperature), NULL, 0 }, // LODSettings.FadeHeatSourceTemperature
+	{ TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeForceFieldStrength), NULL, 0 }, // LODSettings.FadeForceFieldStrength
+	{ TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeForceFieldScale), NULL, 0 }, // LODSettings.FadeForceFieldScale
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->Path), CHILDREN(25), 6 }, // Path
+	{ TYPE_ENUM, false, (size_t)(&((EffectPath_Type*)0)->PlaybackMode), NULL, 0 }, // Path.PlaybackMode
+	{ TYPE_F32, false, (size_t)(&((EffectPath_Type*)0)->PathDuration), NULL, 0 }, // Path.PathDuration
+	{ TYPE_U32, false, (size_t)(&((EffectPath_Type*)0)->LoopIndex), NULL, 0 }, // Path.LoopIndex
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->ControlPoints), CHILDREN(31), 1 }, // Path.ControlPoints
+	{ TYPE_TRANSFORM, false, 1 * sizeof(physx::PxTransform), NULL, 0 }, // Path.ControlPoints[]
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Scale), CHILDREN(32), 1 }, // Path.Scale
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(33), 2 }, // Path.Scale[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // Path.Scale[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // Path.Scale[].y
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Speed), CHILDREN(35), 1 }, // Path.Speed
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(36), 2 }, // Path.Speed[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // Path.Speed[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // Path.Speed[].y
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->Effects), CHILDREN(38), 1 }, // Effects
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // Effects[]
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->toolString), NULL, 0 }, // toolString
+};
+
+
+bool EffectPackageAssetParams::mBuiltFlag = false;
+NvParameterized::MutexType EffectPackageAssetParams::mBuiltFlagMutex;
+
+EffectPackageAssetParams::EffectPackageAssetParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &EffectPackageAssetParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+EffectPackageAssetParams::~EffectPackageAssetParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void EffectPackageAssetParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~EffectPackageAssetParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* EffectPackageAssetParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* EffectPackageAssetParams::getParameterDefinitionTree(void) const
+{
+	EffectPackageAssetParams* tmpParam = const_cast<EffectPackageAssetParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType EffectPackageAssetParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType EffectPackageAssetParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void EffectPackageAssetParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<EffectPackageAssetParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [0] - Effects (not an array of structs) */
+
+void EffectPackageAssetParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void EffectPackageAssetParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The effect package asset", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="LODSettings"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("LODSettings", TYPE_STRUCT, "LevelOfDetailSettings", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "LOD Settings for this effect package", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="LODSettings.UniqueRenderVolume"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("UniqueRenderVolume", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Set to true if this effect should have a unique render volume; to get a separate draw call from all other instances of this effect", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="LODSettings.FadeDistanceBegin"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("FadeDistanceBegin", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(5000.000000000), true);
+		HintTable[1].init("min", double(0.100000001), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(5000.000000000), true);
+		HintTable[1].init("min", double(0.100000001), true);
+		HintTable[2].init("shortDescription", "Distance to begin fading out the effect", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="LODSettings.FadeDistanceEnd"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("FadeDistanceEnd", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(5000.000000000), true);
+		HintTable[1].init("min", double(0.100000001), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(5000.000000000), true);
+		HintTable[1].init("min", double(0.100000001), true);
+		HintTable[2].init("shortDescription", "Distance to finish fading out the effect", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="LODSettings.RandomizeEmitterRate"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("RandomizeEmitterRate", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "If true the emitter rate is randomized from the min to max values", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="LODSettings.FadeOutRate"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("FadeOutRate", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(10.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(10.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Time over which to fade out effect completely", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="LODSettings.CullByDistance"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("CullByDistance", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Whether or not to cull effects based on their distance from the camera; requires a valid view matrix", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="LODSettings.CullOffScreen"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("CullOffScreen", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Whether or not to cull this effect if it is off screen", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="LODSettings.OffScreenCullTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("OffScreenCullTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(99.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(99.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Time the effect should be offscreen before it is disabled", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="LODSettings.NonVisibleDeleteTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("NonVisibleDeleteTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(99.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(99.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The time an effect is non-visible before we delete it, rathern than just disabling it's state", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=11, longName="LODSettings.ScreenCullSize"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11];
+		ParamDef->init("ScreenCullSize", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("DISPLAY_NAME", "ScreenCullingSize", true);
+		HintTable[1].init("max", double(1.000000000), true);
+		HintTable[2].init("min", double(0.010000000), true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("DISPLAY_NAME", "ScreenCullingSize", true);
+		HintTable[1].init("max", double(1.000000000), true);
+		HintTable[2].init("min", double(0.010000000), true);
+		HintTable[3].init("shortDescription", "Bounding volme to cull the effect when near the edge of the screen", true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=12, longName="LODSettings.ScreenCullDistance"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12];
+		ParamDef->init("ScreenCullDistance", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "Radius to camera that we bypass screen culling entirely because the effect is too close to the screen; default is 3 meters", true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=13, longName="LODSettings.FadeEmitterRate"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13];
+		ParamDef->init("FadeEmitterRate", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Control the emitter rate with Fade Distance LOD setting", true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=14, longName="LODSettings.FadeAttractorFieldStrength"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14];
+		ParamDef->init("FadeAttractorFieldStrength", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Helpful tooltip information goes here", true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=15, longName="LODSettings.FadeJetFieldStrength"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15];
+		ParamDef->init("FadeJetFieldStrength", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Helpful tooltip information goes here", true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=16, longName="LODSettings.FadeTurbulenceVelocity"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16];
+		ParamDef->init("FadeTurbulenceVelocity", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Helpful tooltip information goes here", true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=17, longName="LODSettings.FadeTurbulenceNoise"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17];
+		ParamDef->init("FadeTurbulenceNoise", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Helpful tooltip information goes here", true);
+		ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=18, longName="LODSettings.FadeTurbulenceExternalVelocity"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18];
+		ParamDef->init("FadeTurbulenceExternalVelocity", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Helpful tooltip information goes here", true);
+		ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=19, longName="LODSettings.FadeTurbulenceVelocityWeight"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19];
+		ParamDef->init("FadeTurbulenceVelocityWeight", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Helpful tooltip information goes here", true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=20, longName="LODSettings.FadeHeatSourceTemperature"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20];
+		ParamDef->init("FadeHeatSourceTemperature", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Helpful tooltip information goes here", true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=21, longName="LODSettings.FadeForceFieldStrength"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21];
+		ParamDef->init("FadeForceFieldStrength", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Helpful tooltip information goes here", true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=22, longName="LODSettings.FadeForceFieldScale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22];
+		ParamDef->init("FadeForceFieldScale", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Helpful tooltip information goes here", true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=23, longName="Path"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23];
+		ParamDef->init("Path", TYPE_STRUCT, "EffectPath", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An optional path for this effect to travel on", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=24, longName="Path.PlaybackMode"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24];
+		ParamDef->init("PlaybackMode", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The mode to play back the path", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "LOOP", "PLAY_ONCE", "PING_PONG" };
+		ParamDefTable[24].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=25, longName="Path.PathDuration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25];
+		ParamDef->init("PathDuration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		HintTable[2].init("shortDescription", "The duration of the path if one is not otherwise provided", true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=26, longName="Path.LoopIndex"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26];
+		ParamDef->init("LoopIndex", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "The array index to loop back to", true);
+		ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=27, longName="Path.ControlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27];
+		ParamDef->init("ControlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=28, longName="Path.ControlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28];
+		ParamDef->init("ControlPoints", TYPE_TRANSFORM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=29, longName="Path.Scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29];
+		ParamDef->init("Scale", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=30, longName="Path.Scale[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30];
+		ParamDef->init("Scale", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=31, longName="Path.Scale[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=32, longName="Path.Scale[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[32];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[32].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=33, longName="Path.Speed"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[33];
+		ParamDef->init("Speed", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[33].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[33].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=34, longName="Path.Speed[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[34];
+		ParamDef->init("Speed", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[34].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[34].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=35, longName="Path.Speed[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[35];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[35].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[35].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=36, longName="Path.Speed[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[36];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[36].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=37, longName="Effects"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[37];
+		ParamDef->init("Effects", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("RIGHT_CLICK", "ENABLE_EFFECT DISABLE_EFFECT COPY_EFFECT_PROPERTIES PASTE_EFFECT_PROPERTIES", true);
+		ParamDefTable[37].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("RIGHT_CLICK", "ENABLE_EFFECT DISABLE_EFFECT COPY_EFFECT_PROPERTIES PASTE_EFFECT_PROPERTIES", true);
+		HintTable[4].init("shortDescription", "Effect Setting", true);
+		ParamDefTable[37].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "EmitterEffect", "HeatSourceEffect", "JetFieldSamplerEffect", "AttractorFieldSamplerEffect", "TurbulenceFieldSamplerEffect", "ForceFieldEffect", "NoiseFieldSamplerEffect", "VortexFieldSamplerEffect", "SubstanceSourceEffect", "WindFieldSamplerEffect", "RigidBodyEffect", "VelocitySourceEffect", "FlameEmitterEffect" };
+		ParamDefTable[37].setRefVariantVals((const char**)RefVariantVals, 13);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=38, longName="Effects[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[38];
+		ParamDef->init("Effects", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("RIGHT_CLICK", "ENABLE_EFFECT DISABLE_EFFECT COPY_EFFECT_PROPERTIES PASTE_EFFECT_PROPERTIES", true);
+		ParamDefTable[38].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("RIGHT_CLICK", "ENABLE_EFFECT DISABLE_EFFECT COPY_EFFECT_PROPERTIES PASTE_EFFECT_PROPERTIES", true);
+		HintTable[4].init("shortDescription", "Effect Setting", true);
+		ParamDefTable[38].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "EmitterEffect", "HeatSourceEffect", "JetFieldSamplerEffect", "AttractorFieldSamplerEffect", "TurbulenceFieldSamplerEffect", "ForceFieldEffect", "NoiseFieldSamplerEffect", "VortexFieldSamplerEffect", "SubstanceSourceEffect", "WindFieldSamplerEffect", "RigidBodyEffect", "VelocitySourceEffect", "FlameEmitterEffect" };
+		ParamDefTable[38].setRefVariantVals((const char**)RefVariantVals, 13);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=39, longName="toolString"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[39];
+		ParamDef->init("toolString", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("READONLY", uint64_t(1), true);
+		ParamDefTable[39].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("READONLY", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Describes the authoring tool. Info about used tool and runtime during effect creation", true);
+		ParamDefTable[39].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[4];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(23);
+		Children[2] = PDEF_PTR(37);
+		Children[3] = PDEF_PTR(39);
+
+		ParamDefTable[0].setChildren(Children, 4);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="LODSettings"
+	{
+		static Definition* Children[21];
+		Children[0] = PDEF_PTR(2);
+		Children[1] = PDEF_PTR(3);
+		Children[2] = PDEF_PTR(4);
+		Children[3] = PDEF_PTR(5);
+		Children[4] = PDEF_PTR(6);
+		Children[5] = PDEF_PTR(7);
+		Children[6] = PDEF_PTR(8);
+		Children[7] = PDEF_PTR(9);
+		Children[8] = PDEF_PTR(10);
+		Children[9] = PDEF_PTR(11);
+		Children[10] = PDEF_PTR(12);
+		Children[11] = PDEF_PTR(13);
+		Children[12] = PDEF_PTR(14);
+		Children[13] = PDEF_PTR(15);
+		Children[14] = PDEF_PTR(16);
+		Children[15] = PDEF_PTR(17);
+		Children[16] = PDEF_PTR(18);
+		Children[17] = PDEF_PTR(19);
+		Children[18] = PDEF_PTR(20);
+		Children[19] = PDEF_PTR(21);
+		Children[20] = PDEF_PTR(22);
+
+		ParamDefTable[1].setChildren(Children, 21);
+	}
+
+	// SetChildren for: nodeIndex=23, longName="Path"
+	{
+		static Definition* Children[6];
+		Children[0] = PDEF_PTR(24);
+		Children[1] = PDEF_PTR(25);
+		Children[2] = PDEF_PTR(26);
+		Children[3] = PDEF_PTR(27);
+		Children[4] = PDEF_PTR(29);
+		Children[5] = PDEF_PTR(33);
+
+		ParamDefTable[23].setChildren(Children, 6);
+	}
+
+	// SetChildren for: nodeIndex=27, longName="Path.ControlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(28);
+
+		ParamDefTable[27].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=29, longName="Path.Scale"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(30);
+
+		ParamDefTable[29].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=30, longName="Path.Scale[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(31);
+		Children[1] = PDEF_PTR(32);
+
+		ParamDefTable[30].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=33, longName="Path.Speed"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(34);
+
+		ParamDefTable[33].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=34, longName="Path.Speed[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(35);
+		Children[1] = PDEF_PTR(36);
+
+		ParamDefTable[34].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=37, longName="Effects"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(38);
+
+		ParamDefTable[37].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void EffectPackageAssetParams::initStrings(void)
+{
+	toolString.isAllocated = true;
+	toolString.buf = NULL;
+}
+
+void EffectPackageAssetParams::initDynamicArrays(void)
+{
+	Path.ControlPoints.buf = NULL;
+	Path.ControlPoints.isAllocated = true;
+	Path.ControlPoints.elementSize = sizeof(physx::PxTransform);
+	Path.ControlPoints.arraySizes[0] = 0;
+	Path.Scale.buf = NULL;
+	Path.Scale.isAllocated = true;
+	Path.Scale.elementSize = sizeof(ControlPoint_Type);
+	Path.Scale.arraySizes[0] = 0;
+	Path.Speed.buf = NULL;
+	Path.Speed.isAllocated = true;
+	Path.Speed.elementSize = sizeof(ControlPoint_Type);
+	Path.Speed.arraySizes[0] = 0;
+	Effects.buf = NULL;
+	Effects.isAllocated = true;
+	Effects.elementSize = sizeof(NvParameterized::Interface*);
+	Effects.arraySizes[0] = 0;
+}
+
+void EffectPackageAssetParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	LODSettings.UniqueRenderVolume = bool(0);
+	LODSettings.FadeDistanceBegin = float(50000.000000000);
+	LODSettings.FadeDistanceEnd = float(5000.000000000);
+	LODSettings.RandomizeEmitterRate = bool(0);
+	LODSettings.FadeOutRate = float(0.200000003);
+	LODSettings.CullByDistance = bool(0);
+	LODSettings.CullOffScreen = bool(0);
+	LODSettings.OffScreenCullTime = float(1.000000000);
+	LODSettings.NonVisibleDeleteTime = float(4.000000000);
+	LODSettings.ScreenCullSize = float(0.100000001);
+	LODSettings.ScreenCullDistance = float(3.000000000);
+	LODSettings.FadeEmitterRate = bool(1);
+	LODSettings.FadeAttractorFieldStrength = bool(1);
+	LODSettings.FadeJetFieldStrength = bool(1);
+	LODSettings.FadeTurbulenceVelocity = bool(0);
+	LODSettings.FadeTurbulenceNoise = bool(0);
+	LODSettings.FadeTurbulenceExternalVelocity = bool(0);
+	LODSettings.FadeTurbulenceVelocityWeight = bool(0);
+	LODSettings.FadeHeatSourceTemperature = bool(0);
+	LODSettings.FadeForceFieldStrength = bool(0);
+	LODSettings.FadeForceFieldScale = bool(0);
+	Path.PlaybackMode = (const char*)"LOOP";
+	Path.PathDuration = float(4.000000000);
+	Path.LoopIndex = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void EffectPackageAssetParams::initReferences(void)
+{
+}
+
+void EffectPackageAssetParams::freeDynamicArrays(void)
+{
+	if (Path.ControlPoints.isAllocated && Path.ControlPoints.buf)
+	{
+		mParameterizedTraits->free(Path.ControlPoints.buf);
+	}
+	if (Path.Scale.isAllocated && Path.Scale.buf)
+	{
+		mParameterizedTraits->free(Path.Scale.buf);
+	}
+	if (Path.Speed.isAllocated && Path.Speed.buf)
+	{
+		mParameterizedTraits->free(Path.Speed.buf);
+	}
+	if (Effects.isAllocated && Effects.buf)
+	{
+		mParameterizedTraits->free(Effects.buf);
+	}
+}
+
+void EffectPackageAssetParams::freeStrings(void)
+{
+
+	if (toolString.isAllocated && toolString.buf)
+	{
+		mParameterizedTraits->strfree((char*)toolString.buf);
+	}
+}
+
+void EffectPackageAssetParams::freeReferences(void)
+{
+
+	for (int i = 0; i < Effects.arraySizes[0]; ++i)
+	{
+		if (Effects.buf[i])
+		{
+			Effects.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/EffectPackageData.cpp b/APEX_1.4/module/particles/src/autogen/EffectPackageData.cpp
new file mode 100644
index 00000000..c92b2177
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/EffectPackageData.cpp
@@ -0,0 +1,363 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "EffectPackageData.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace EffectPackageDataNS;
+
+const char* const EffectPackageDataFactory::vptr =
+    NvParameterized::getVptr<EffectPackageData, EffectPackageData::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->Name), NULL, 0 }, // Name
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->EffectPackage), NULL, 0 }, // EffectPackage
+};
+
+
+bool EffectPackageData::mBuiltFlag = false;
+NvParameterized::MutexType EffectPackageData::mBuiltFlagMutex;
+
+EffectPackageData::EffectPackageData(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &EffectPackageDataFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+EffectPackageData::~EffectPackageData()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void EffectPackageData::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~EffectPackageData();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* EffectPackageData::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* EffectPackageData::getParameterDefinitionTree(void) const
+{
+	EffectPackageData* tmpParam = const_cast<EffectPackageData*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType EffectPackageData::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType EffectPackageData::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void EffectPackageData::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<EffectPackageData::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void EffectPackageData::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void EffectPackageData::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the Effect Package Properties", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="Name"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("Name", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Effect package name", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="EffectPackage"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("EffectPackage", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Effect package parameters", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "EffectPackageAssetParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void EffectPackageData::initStrings(void)
+{
+	Name.isAllocated = false;
+	Name.buf = (const char*)"defaultEffectPackage";
+}
+
+void EffectPackageData::initDynamicArrays(void)
+{
+}
+
+void EffectPackageData::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void EffectPackageData::initReferences(void)
+{
+	EffectPackage = NULL;
+
+}
+
+void EffectPackageData::freeDynamicArrays(void)
+{
+}
+
+void EffectPackageData::freeStrings(void)
+{
+
+	if (Name.isAllocated && Name.buf)
+	{
+		mParameterizedTraits->strfree((char*)Name.buf);
+	}
+}
+
+void EffectPackageData::freeReferences(void)
+{
+	if (EffectPackage)
+	{
+		EffectPackage->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/EffectPackageDatabaseParams.cpp b/APEX_1.4/module/particles/src/autogen/EffectPackageDatabaseParams.cpp
new file mode 100644
index 00000000..059ddc3e
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/EffectPackageDatabaseParams.cpp
@@ -0,0 +1,400 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "EffectPackageDatabaseParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace EffectPackageDatabaseParamsNS;
+
+const char* const EffectPackageDatabaseParamsFactory::vptr =
+    NvParameterized::getVptr<EffectPackageDatabaseParams, EffectPackageDatabaseParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->EffectPackages), CHILDREN(1), 1 }, // EffectPackages
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // EffectPackages[]
+};
+
+
+bool EffectPackageDatabaseParams::mBuiltFlag = false;
+NvParameterized::MutexType EffectPackageDatabaseParams::mBuiltFlagMutex;
+
+EffectPackageDatabaseParams::EffectPackageDatabaseParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &EffectPackageDatabaseParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+EffectPackageDatabaseParams::~EffectPackageDatabaseParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void EffectPackageDatabaseParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~EffectPackageDatabaseParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* EffectPackageDatabaseParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* EffectPackageDatabaseParams::getParameterDefinitionTree(void) const
+{
+	EffectPackageDatabaseParams* tmpParam = const_cast<EffectPackageDatabaseParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType EffectPackageDatabaseParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType EffectPackageDatabaseParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void EffectPackageDatabaseParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<EffectPackageDatabaseParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [0] - EffectPackages (not an array of structs) */
+
+void EffectPackageDatabaseParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void EffectPackageDatabaseParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The collection of all effect packages", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="EffectPackages"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("EffectPackages", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "ENABLE_EFFECT_PACKAGE DISABLE_EFFECT_PACKAGE COPY_EFFECT_PACKAGE_PROPERTIES PASTE_EFFECT_PACKAGE_PROPERTIES DISABLE_ALL_EFFECT_PACKAGES", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "ENABLE_EFFECT_PACKAGE DISABLE_EFFECT_PACKAGE COPY_EFFECT_PACKAGE_PROPERTIES PASTE_EFFECT_PACKAGE_PROPERTIES DISABLE_ALL_EFFECT_PACKAGES", true);
+		HintTable[5].init("shortDescription", "The arary of EffectPackages", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "EffectPackageData" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="EffectPackages[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("EffectPackages", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "ENABLE_EFFECT_PACKAGE DISABLE_EFFECT_PACKAGE COPY_EFFECT_PACKAGE_PROPERTIES PASTE_EFFECT_PACKAGE_PROPERTIES DISABLE_ALL_EFFECT_PACKAGES", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "ENABLE_EFFECT_PACKAGE DISABLE_EFFECT_PACKAGE COPY_EFFECT_PACKAGE_PROPERTIES PASTE_EFFECT_PACKAGE_PROPERTIES DISABLE_ALL_EFFECT_PACKAGES", true);
+		HintTable[5].init("shortDescription", "The arary of EffectPackages", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "EffectPackageData" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="EffectPackages"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void EffectPackageDatabaseParams::initStrings(void)
+{
+}
+
+void EffectPackageDatabaseParams::initDynamicArrays(void)
+{
+	EffectPackages.buf = NULL;
+	EffectPackages.isAllocated = true;
+	EffectPackages.elementSize = sizeof(NvParameterized::Interface*);
+	EffectPackages.arraySizes[0] = 0;
+}
+
+void EffectPackageDatabaseParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void EffectPackageDatabaseParams::initReferences(void)
+{
+}
+
+void EffectPackageDatabaseParams::freeDynamicArrays(void)
+{
+	if (EffectPackages.isAllocated && EffectPackages.buf)
+	{
+		mParameterizedTraits->free(EffectPackages.buf);
+	}
+}
+
+void EffectPackageDatabaseParams::freeStrings(void)
+{
+}
+
+void EffectPackageDatabaseParams::freeReferences(void)
+{
+
+	for (int i = 0; i < EffectPackages.arraySizes[0]; ++i)
+	{
+		if (EffectPackages.buf[i])
+		{
+			EffectPackages.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/EffectPackageEmitterDatabaseParams.cpp b/APEX_1.4/module/particles/src/autogen/EffectPackageEmitterDatabaseParams.cpp
new file mode 100644
index 00000000..c10a0b56
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/EffectPackageEmitterDatabaseParams.cpp
@@ -0,0 +1,400 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "EffectPackageEmitterDatabaseParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace EffectPackageEmitterDatabaseParamsNS;
+
+const char* const EffectPackageEmitterDatabaseParamsFactory::vptr =
+    NvParameterized::getVptr<EffectPackageEmitterDatabaseParams, EffectPackageEmitterDatabaseParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->Emitters), CHILDREN(1), 1 }, // Emitters
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // Emitters[]
+};
+
+
+bool EffectPackageEmitterDatabaseParams::mBuiltFlag = false;
+NvParameterized::MutexType EffectPackageEmitterDatabaseParams::mBuiltFlagMutex;
+
+EffectPackageEmitterDatabaseParams::EffectPackageEmitterDatabaseParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &EffectPackageEmitterDatabaseParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+EffectPackageEmitterDatabaseParams::~EffectPackageEmitterDatabaseParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void EffectPackageEmitterDatabaseParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~EffectPackageEmitterDatabaseParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* EffectPackageEmitterDatabaseParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* EffectPackageEmitterDatabaseParams::getParameterDefinitionTree(void) const
+{
+	EffectPackageEmitterDatabaseParams* tmpParam = const_cast<EffectPackageEmitterDatabaseParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType EffectPackageEmitterDatabaseParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType EffectPackageEmitterDatabaseParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void EffectPackageEmitterDatabaseParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<EffectPackageEmitterDatabaseParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [0] - Emitters (not an array of structs) */
+
+void EffectPackageEmitterDatabaseParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void EffectPackageEmitterDatabaseParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The collection of all emitter assets", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="Emitters"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("Emitters", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "COPY_EMITTER_PROPERTIES PASTE_EMITTER_PROPERTIES", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "COPY_EMITTER_PROPERTIES PASTE_EMITTER_PROPERTIES", true);
+		HintTable[5].init("shortDescription", "The array of emitters", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "EmitterData" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="Emitters[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("Emitters", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "COPY_EMITTER_PROPERTIES PASTE_EMITTER_PROPERTIES", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "COPY_EMITTER_PROPERTIES PASTE_EMITTER_PROPERTIES", true);
+		HintTable[5].init("shortDescription", "The array of emitters", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "EmitterData" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="Emitters"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void EffectPackageEmitterDatabaseParams::initStrings(void)
+{
+}
+
+void EffectPackageEmitterDatabaseParams::initDynamicArrays(void)
+{
+	Emitters.buf = NULL;
+	Emitters.isAllocated = true;
+	Emitters.elementSize = sizeof(NvParameterized::Interface*);
+	Emitters.arraySizes[0] = 0;
+}
+
+void EffectPackageEmitterDatabaseParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void EffectPackageEmitterDatabaseParams::initReferences(void)
+{
+}
+
+void EffectPackageEmitterDatabaseParams::freeDynamicArrays(void)
+{
+	if (Emitters.isAllocated && Emitters.buf)
+	{
+		mParameterizedTraits->free(Emitters.buf);
+	}
+}
+
+void EffectPackageEmitterDatabaseParams::freeStrings(void)
+{
+}
+
+void EffectPackageEmitterDatabaseParams::freeReferences(void)
+{
+
+	for (int i = 0; i < Emitters.arraySizes[0]; ++i)
+	{
+		if (Emitters.buf[i])
+		{
+			Emitters.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/EffectPackageFieldSamplerDatabaseParams.cpp b/APEX_1.4/module/particles/src/autogen/EffectPackageFieldSamplerDatabaseParams.cpp
new file mode 100644
index 00000000..6295edc3
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/EffectPackageFieldSamplerDatabaseParams.cpp
@@ -0,0 +1,400 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "EffectPackageFieldSamplerDatabaseParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace EffectPackageFieldSamplerDatabaseParamsNS;
+
+const char* const EffectPackageFieldSamplerDatabaseParamsFactory::vptr =
+    NvParameterized::getVptr<EffectPackageFieldSamplerDatabaseParams, EffectPackageFieldSamplerDatabaseParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->FieldSamplers), CHILDREN(1), 1 }, // FieldSamplers
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // FieldSamplers[]
+};
+
+
+bool EffectPackageFieldSamplerDatabaseParams::mBuiltFlag = false;
+NvParameterized::MutexType EffectPackageFieldSamplerDatabaseParams::mBuiltFlagMutex;
+
+EffectPackageFieldSamplerDatabaseParams::EffectPackageFieldSamplerDatabaseParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &EffectPackageFieldSamplerDatabaseParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+EffectPackageFieldSamplerDatabaseParams::~EffectPackageFieldSamplerDatabaseParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void EffectPackageFieldSamplerDatabaseParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~EffectPackageFieldSamplerDatabaseParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* EffectPackageFieldSamplerDatabaseParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* EffectPackageFieldSamplerDatabaseParams::getParameterDefinitionTree(void) const
+{
+	EffectPackageFieldSamplerDatabaseParams* tmpParam = const_cast<EffectPackageFieldSamplerDatabaseParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType EffectPackageFieldSamplerDatabaseParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType EffectPackageFieldSamplerDatabaseParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void EffectPackageFieldSamplerDatabaseParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<EffectPackageFieldSamplerDatabaseParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [0] - FieldSamplers (not an array of structs) */
+
+void EffectPackageFieldSamplerDatabaseParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void EffectPackageFieldSamplerDatabaseParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The collection of all field sampler assets", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="FieldSamplers"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("FieldSamplers", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "COPY_FIELD_SAMPLER_PROPERTIES PASTE_FIELD_SAMPLER_PROPERTIES", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "COPY_FIELD_SAMPLER_PROPERTIES PASTE_FIELD_SAMPLER_PROPERTIES", true);
+		HintTable[5].init("shortDescription", "The arary of FieldSamplers", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "AttractorFieldSamplerData", "ForceFieldData", "HeatSourceData", "JetFieldSamplerData", "TurbulenceFieldSamplerData", "VortexFieldSamplerData", "NoiseFieldSamplerData", "SubstanceSourceData", "WindFieldSamplerData", "VelocitySourceData", "FlameEmitterData" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 11);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="FieldSamplers[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("FieldSamplers", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "COPY_FIELD_SAMPLER_PROPERTIES PASTE_FIELD_SAMPLER_PROPERTIES", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "COPY_FIELD_SAMPLER_PROPERTIES PASTE_FIELD_SAMPLER_PROPERTIES", true);
+		HintTable[5].init("shortDescription", "The arary of FieldSamplers", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "AttractorFieldSamplerData", "ForceFieldData", "HeatSourceData", "JetFieldSamplerData", "TurbulenceFieldSamplerData", "VortexFieldSamplerData", "NoiseFieldSamplerData", "SubstanceSourceData", "WindFieldSamplerData", "VelocitySourceData", "FlameEmitterData" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 11);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="FieldSamplers"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void EffectPackageFieldSamplerDatabaseParams::initStrings(void)
+{
+}
+
+void EffectPackageFieldSamplerDatabaseParams::initDynamicArrays(void)
+{
+	FieldSamplers.buf = NULL;
+	FieldSamplers.isAllocated = true;
+	FieldSamplers.elementSize = sizeof(NvParameterized::Interface*);
+	FieldSamplers.arraySizes[0] = 0;
+}
+
+void EffectPackageFieldSamplerDatabaseParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void EffectPackageFieldSamplerDatabaseParams::initReferences(void)
+{
+}
+
+void EffectPackageFieldSamplerDatabaseParams::freeDynamicArrays(void)
+{
+	if (FieldSamplers.isAllocated && FieldSamplers.buf)
+	{
+		mParameterizedTraits->free(FieldSamplers.buf);
+	}
+}
+
+void EffectPackageFieldSamplerDatabaseParams::freeStrings(void)
+{
+}
+
+void EffectPackageFieldSamplerDatabaseParams::freeReferences(void)
+{
+
+	for (int i = 0; i < FieldSamplers.arraySizes[0]; ++i)
+	{
+		if (FieldSamplers.buf[i])
+		{
+			FieldSamplers.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/EffectPackageGraphicsMaterialsParams.cpp b/APEX_1.4/module/particles/src/autogen/EffectPackageGraphicsMaterialsParams.cpp
new file mode 100644
index 00000000..651c80a0
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/EffectPackageGraphicsMaterialsParams.cpp
@@ -0,0 +1,392 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "EffectPackageGraphicsMaterialsParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace EffectPackageGraphicsMaterialsParamsNS;
+
+const char* const EffectPackageGraphicsMaterialsParamsFactory::vptr =
+    NvParameterized::getVptr<EffectPackageGraphicsMaterialsParams, EffectPackageGraphicsMaterialsParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->GraphicsMaterials), CHILDREN(1), 1 }, // GraphicsMaterials
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // GraphicsMaterials[]
+};
+
+
+bool EffectPackageGraphicsMaterialsParams::mBuiltFlag = false;
+NvParameterized::MutexType EffectPackageGraphicsMaterialsParams::mBuiltFlagMutex;
+
+EffectPackageGraphicsMaterialsParams::EffectPackageGraphicsMaterialsParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &EffectPackageGraphicsMaterialsParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+EffectPackageGraphicsMaterialsParams::~EffectPackageGraphicsMaterialsParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void EffectPackageGraphicsMaterialsParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~EffectPackageGraphicsMaterialsParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* EffectPackageGraphicsMaterialsParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* EffectPackageGraphicsMaterialsParams::getParameterDefinitionTree(void) const
+{
+	EffectPackageGraphicsMaterialsParams* tmpParam = const_cast<EffectPackageGraphicsMaterialsParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType EffectPackageGraphicsMaterialsParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType EffectPackageGraphicsMaterialsParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void EffectPackageGraphicsMaterialsParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<EffectPackageGraphicsMaterialsParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [0] - GraphicsMaterials (not an array of structs) */
+
+void EffectPackageGraphicsMaterialsParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void EffectPackageGraphicsMaterialsParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The collection of graphics and volumetric material assets", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="GraphicsMaterials"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("GraphicsMaterials", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("READONLY", uint64_t(0), true);
+		HintTable[2].init("RIGHT_CLICK", "COPY_GRAPHICS_MATERIAL_PROPERTIES PASTE_GRAPHICS_MATERIAL_PROPERTIES", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("READONLY", uint64_t(0), true);
+		HintTable[2].init("RIGHT_CLICK", "COPY_GRAPHICS_MATERIAL_PROPERTIES PASTE_GRAPHICS_MATERIAL_PROPERTIES", true);
+		HintTable[3].init("shortDescription", "The array of graphics materials", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "GraphicsMaterialData", "VolumeRenderMaterialData" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 2);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="GraphicsMaterials[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("GraphicsMaterials", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("READONLY", uint64_t(0), true);
+		HintTable[2].init("RIGHT_CLICK", "COPY_GRAPHICS_MATERIAL_PROPERTIES PASTE_GRAPHICS_MATERIAL_PROPERTIES", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("READONLY", uint64_t(0), true);
+		HintTable[2].init("RIGHT_CLICK", "COPY_GRAPHICS_MATERIAL_PROPERTIES PASTE_GRAPHICS_MATERIAL_PROPERTIES", true);
+		HintTable[3].init("shortDescription", "The array of graphics materials", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "GraphicsMaterialData", "VolumeRenderMaterialData" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 2);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="GraphicsMaterials"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void EffectPackageGraphicsMaterialsParams::initStrings(void)
+{
+}
+
+void EffectPackageGraphicsMaterialsParams::initDynamicArrays(void)
+{
+	GraphicsMaterials.buf = NULL;
+	GraphicsMaterials.isAllocated = true;
+	GraphicsMaterials.elementSize = sizeof(NvParameterized::Interface*);
+	GraphicsMaterials.arraySizes[0] = 0;
+}
+
+void EffectPackageGraphicsMaterialsParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void EffectPackageGraphicsMaterialsParams::initReferences(void)
+{
+}
+
+void EffectPackageGraphicsMaterialsParams::freeDynamicArrays(void)
+{
+	if (GraphicsMaterials.isAllocated && GraphicsMaterials.buf)
+	{
+		mParameterizedTraits->free(GraphicsMaterials.buf);
+	}
+}
+
+void EffectPackageGraphicsMaterialsParams::freeStrings(void)
+{
+}
+
+void EffectPackageGraphicsMaterialsParams::freeReferences(void)
+{
+
+	for (int i = 0; i < GraphicsMaterials.arraySizes[0]; ++i)
+	{
+		if (GraphicsMaterials.buf[i])
+		{
+			GraphicsMaterials.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/EffectPackageIOFXDatabaseParams.cpp b/APEX_1.4/module/particles/src/autogen/EffectPackageIOFXDatabaseParams.cpp
new file mode 100644
index 00000000..49b45674
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/EffectPackageIOFXDatabaseParams.cpp
@@ -0,0 +1,400 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "EffectPackageIOFXDatabaseParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace EffectPackageIOFXDatabaseParamsNS;
+
+const char* const EffectPackageIOFXDatabaseParamsFactory::vptr =
+    NvParameterized::getVptr<EffectPackageIOFXDatabaseParams, EffectPackageIOFXDatabaseParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->GraphicsEffects), CHILDREN(1), 1 }, // GraphicsEffects
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // GraphicsEffects[]
+};
+
+
+bool EffectPackageIOFXDatabaseParams::mBuiltFlag = false;
+NvParameterized::MutexType EffectPackageIOFXDatabaseParams::mBuiltFlagMutex;
+
+EffectPackageIOFXDatabaseParams::EffectPackageIOFXDatabaseParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &EffectPackageIOFXDatabaseParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+EffectPackageIOFXDatabaseParams::~EffectPackageIOFXDatabaseParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void EffectPackageIOFXDatabaseParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~EffectPackageIOFXDatabaseParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* EffectPackageIOFXDatabaseParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* EffectPackageIOFXDatabaseParams::getParameterDefinitionTree(void) const
+{
+	EffectPackageIOFXDatabaseParams* tmpParam = const_cast<EffectPackageIOFXDatabaseParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType EffectPackageIOFXDatabaseParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType EffectPackageIOFXDatabaseParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void EffectPackageIOFXDatabaseParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<EffectPackageIOFXDatabaseParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [0] - GraphicsEffects (not an array of structs) */
+
+void EffectPackageIOFXDatabaseParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void EffectPackageIOFXDatabaseParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The collection of graphics effect assets (IOFX)", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="GraphicsEffects"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("GraphicsEffects", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "COPY_IOFX_PROPERTIES PASTE_IOFX_PROPERTIES", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "COPY_IOFX_PROPERTIES PASTE_IOFX_PROPERTIES", true);
+		HintTable[5].init("shortDescription", "The array of graphics effect definition data", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "GraphicsEffectData" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="GraphicsEffects[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("GraphicsEffects", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "COPY_IOFX_PROPERTIES PASTE_IOFX_PROPERTIES", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "COPY_IOFX_PROPERTIES PASTE_IOFX_PROPERTIES", true);
+		HintTable[5].init("shortDescription", "The array of graphics effect definition data", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "GraphicsEffectData" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="GraphicsEffects"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void EffectPackageIOFXDatabaseParams::initStrings(void)
+{
+}
+
+void EffectPackageIOFXDatabaseParams::initDynamicArrays(void)
+{
+	GraphicsEffects.buf = NULL;
+	GraphicsEffects.isAllocated = true;
+	GraphicsEffects.elementSize = sizeof(NvParameterized::Interface*);
+	GraphicsEffects.arraySizes[0] = 0;
+}
+
+void EffectPackageIOFXDatabaseParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void EffectPackageIOFXDatabaseParams::initReferences(void)
+{
+}
+
+void EffectPackageIOFXDatabaseParams::freeDynamicArrays(void)
+{
+	if (GraphicsEffects.isAllocated && GraphicsEffects.buf)
+	{
+		mParameterizedTraits->free(GraphicsEffects.buf);
+	}
+}
+
+void EffectPackageIOFXDatabaseParams::freeStrings(void)
+{
+}
+
+void EffectPackageIOFXDatabaseParams::freeReferences(void)
+{
+
+	for (int i = 0; i < GraphicsEffects.arraySizes[0]; ++i)
+	{
+		if (GraphicsEffects.buf[i])
+		{
+			GraphicsEffects.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/EffectPackageIOSDatabaseParams.cpp b/APEX_1.4/module/particles/src/autogen/EffectPackageIOSDatabaseParams.cpp
new file mode 100644
index 00000000..f71aa4fb
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/EffectPackageIOSDatabaseParams.cpp
@@ -0,0 +1,400 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "EffectPackageIOSDatabaseParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace EffectPackageIOSDatabaseParamsNS;
+
+const char* const EffectPackageIOSDatabaseParamsFactory::vptr =
+    NvParameterized::getVptr<EffectPackageIOSDatabaseParams, EffectPackageIOSDatabaseParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->ParticleSimulations), CHILDREN(1), 1 }, // ParticleSimulations
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // ParticleSimulations[]
+};
+
+
+bool EffectPackageIOSDatabaseParams::mBuiltFlag = false;
+NvParameterized::MutexType EffectPackageIOSDatabaseParams::mBuiltFlagMutex;
+
+EffectPackageIOSDatabaseParams::EffectPackageIOSDatabaseParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &EffectPackageIOSDatabaseParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+EffectPackageIOSDatabaseParams::~EffectPackageIOSDatabaseParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void EffectPackageIOSDatabaseParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~EffectPackageIOSDatabaseParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* EffectPackageIOSDatabaseParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* EffectPackageIOSDatabaseParams::getParameterDefinitionTree(void) const
+{
+	EffectPackageIOSDatabaseParams* tmpParam = const_cast<EffectPackageIOSDatabaseParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType EffectPackageIOSDatabaseParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType EffectPackageIOSDatabaseParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void EffectPackageIOSDatabaseParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<EffectPackageIOSDatabaseParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [0] - ParticleSimulations (not an array of structs) */
+
+void EffectPackageIOSDatabaseParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void EffectPackageIOSDatabaseParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The collection of particle simulation assets (IOS)", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="ParticleSimulations"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("ParticleSimulations", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "COPY_IOS_PROPERTIES PASTE_IOS_PROPERTIES", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "COPY_IOS_PROPERTIES PASTE_IOS_PROPERTIES", true);
+		HintTable[5].init("shortDescription", "The arary of particle simulation data", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ParticleSimulationData" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="ParticleSimulations[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("ParticleSimulations", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "COPY_IOS_PROPERTIES PASTE_IOS_PROPERTIES", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true);
+		HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true);
+		HintTable[2].init("INCLUDED", uint64_t(1), true);
+		HintTable[3].init("READONLY", uint64_t(0), true);
+		HintTable[4].init("RIGHT_CLICK", "COPY_IOS_PROPERTIES PASTE_IOS_PROPERTIES", true);
+		HintTable[5].init("shortDescription", "The arary of particle simulation data", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ParticleSimulationData" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="ParticleSimulations"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void EffectPackageIOSDatabaseParams::initStrings(void)
+{
+}
+
+void EffectPackageIOSDatabaseParams::initDynamicArrays(void)
+{
+	ParticleSimulations.buf = NULL;
+	ParticleSimulations.isAllocated = true;
+	ParticleSimulations.elementSize = sizeof(NvParameterized::Interface*);
+	ParticleSimulations.arraySizes[0] = 0;
+}
+
+void EffectPackageIOSDatabaseParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void EffectPackageIOSDatabaseParams::initReferences(void)
+{
+}
+
+void EffectPackageIOSDatabaseParams::freeDynamicArrays(void)
+{
+	if (ParticleSimulations.isAllocated && ParticleSimulations.buf)
+	{
+		mParameterizedTraits->free(ParticleSimulations.buf);
+	}
+}
+
+void EffectPackageIOSDatabaseParams::freeStrings(void)
+{
+}
+
+void EffectPackageIOSDatabaseParams::freeReferences(void)
+{
+
+	for (int i = 0; i < ParticleSimulations.arraySizes[0]; ++i)
+	{
+		if (ParticleSimulations.buf[i])
+		{
+			ParticleSimulations.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/EmitterData.cpp b/APEX_1.4/module/particles/src/autogen/EmitterData.cpp
new file mode 100644
index 00000000..428c2900
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/EmitterData.cpp
@@ -0,0 +1,363 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "EmitterData.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace EmitterDataNS;
+
+const char* const EmitterDataFactory::vptr =
+    NvParameterized::getVptr<EmitterData, EmitterData::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->Name), NULL, 0 }, // Name
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->Emitter), NULL, 0 }, // Emitter
+};
+
+
+bool EmitterData::mBuiltFlag = false;
+NvParameterized::MutexType EmitterData::mBuiltFlagMutex;
+
+EmitterData::EmitterData(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &EmitterDataFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+EmitterData::~EmitterData()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void EmitterData::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~EmitterData();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* EmitterData::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* EmitterData::getParameterDefinitionTree(void) const
+{
+	EmitterData* tmpParam = const_cast<EmitterData*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType EmitterData::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType EmitterData::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void EmitterData::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<EmitterData::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void EmitterData::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void EmitterData::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the asset properties for this emitter", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="Name"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("Name", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Emitter name", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="Emitter"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("Emitter", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Emitter properties", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ApexEmitterAssetParameters" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void EmitterData::initStrings(void)
+{
+	Name.isAllocated = false;
+	Name.buf = (const char*)"defaultEmitter";
+}
+
+void EmitterData::initDynamicArrays(void)
+{
+}
+
+void EmitterData::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void EmitterData::initReferences(void)
+{
+	Emitter = NULL;
+
+}
+
+void EmitterData::freeDynamicArrays(void)
+{
+}
+
+void EmitterData::freeStrings(void)
+{
+
+	if (Name.isAllocated && Name.buf)
+	{
+		mParameterizedTraits->strfree((char*)Name.buf);
+	}
+}
+
+void EmitterData::freeReferences(void)
+{
+	if (Emitter)
+	{
+		Emitter->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/EmitterEffect.cpp b/APEX_1.4/module/particles/src/autogen/EmitterEffect.cpp
new file mode 100644
index 00000000..41bd6d6f
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/EmitterEffect.cpp
@@ -0,0 +1,1769 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "EmitterEffect.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace EmitterEffectNS;
+
+const char* const EmitterEffectFactory::vptr =
+    NvParameterized::getVptr<EmitterEffect, EmitterEffect::ClassAlignment>();
+
+const uint32_t NumParamDefs = 45;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 31, 44, 2, 3, 4, 8, 12, 13, 14, 15, 16, 17, 5, 6, 7, 9, 10, 11, 18, 19, 20, 21,
+	23, 27, 22, 24, 25, 26, 28, 29, 30, 32, 38, 33, 34, 35, 36, 37, 39, 40, 41, 42, 43,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->EffectProperties), CHILDREN(3), 10 }, // EffectProperties
+	{ TYPE_STRING, false, (size_t)(&((EffectProperties_Type*)0)->UserString), NULL, 0 }, // EffectProperties.UserString
+	{ TYPE_BOOL, false, (size_t)(&((EffectProperties_Type*)0)->Enable), NULL, 0 }, // EffectProperties.Enable
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Position), CHILDREN(13), 3 }, // EffectProperties.Position
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateX), NULL, 0 }, // EffectProperties.Position.TranslateX
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateY), NULL, 0 }, // EffectProperties.Position.TranslateY
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateZ), NULL, 0 }, // EffectProperties.Position.TranslateZ
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Orientation), CHILDREN(16), 3 }, // EffectProperties.Orientation
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateX), NULL, 0 }, // EffectProperties.Orientation.RotateX
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateY), NULL, 0 }, // EffectProperties.Orientation.RotateY
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateZ), NULL, 0 }, // EffectProperties.Orientation.RotateZ
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->InitialDelayTime), NULL, 0 }, // EffectProperties.InitialDelayTime
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->Duration), NULL, 0 }, // EffectProperties.Duration
+	{ TYPE_U32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatCount), NULL, 0 }, // EffectProperties.RepeatCount
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatDelay), NULL, 0 }, // EffectProperties.RepeatDelay
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RandomizeRepeatTime), NULL, 0 }, // EffectProperties.RandomizeRepeatTime
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Path), CHILDREN(19), 6 }, // EffectProperties.Path
+	{ TYPE_ENUM, false, (size_t)(&((EffectPath_Type*)0)->PlaybackMode), NULL, 0 }, // EffectProperties.Path.PlaybackMode
+	{ TYPE_F32, false, (size_t)(&((EffectPath_Type*)0)->PathDuration), NULL, 0 }, // EffectProperties.Path.PathDuration
+	{ TYPE_U32, false, (size_t)(&((EffectPath_Type*)0)->LoopIndex), NULL, 0 }, // EffectProperties.Path.LoopIndex
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->ControlPoints), CHILDREN(25), 1 }, // EffectProperties.Path.ControlPoints
+	{ TYPE_TRANSFORM, false, 1 * sizeof(physx::PxTransform), NULL, 0 }, // EffectProperties.Path.ControlPoints[]
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Scale), CHILDREN(26), 1 }, // EffectProperties.Path.Scale
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(27), 2 }, // EffectProperties.Path.Scale[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Scale[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Scale[].y
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Speed), CHILDREN(29), 1 }, // EffectProperties.Path.Speed
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(30), 2 }, // EffectProperties.Path.Speed[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Speed[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Speed[].y
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->EmitterVelocityChanges), CHILDREN(32), 2 }, // EmitterVelocityChanges
+	{ TYPE_STRUCT, false, (size_t)(&((EmitterVelocityProperties_Type*)0)->AdjustLifetime), CHILDREN(34), 5 }, // EmitterVelocityChanges.AdjustLifetime
+	{ TYPE_BOOL, false, (size_t)(&((EmitterVelocityAdjust_Type*)0)->AdjustEnabled), NULL, 0 }, // EmitterVelocityChanges.AdjustLifetime.AdjustEnabled
+	{ TYPE_F32, false, (size_t)(&((EmitterVelocityAdjust_Type*)0)->VelocityLow), NULL, 0 }, // EmitterVelocityChanges.AdjustLifetime.VelocityLow
+	{ TYPE_F32, false, (size_t)(&((EmitterVelocityAdjust_Type*)0)->VelocityHigh), NULL, 0 }, // EmitterVelocityChanges.AdjustLifetime.VelocityHigh
+	{ TYPE_F32, false, (size_t)(&((EmitterVelocityAdjust_Type*)0)->LowValue), NULL, 0 }, // EmitterVelocityChanges.AdjustLifetime.LowValue
+	{ TYPE_F32, false, (size_t)(&((EmitterVelocityAdjust_Type*)0)->HighValue), NULL, 0 }, // EmitterVelocityChanges.AdjustLifetime.HighValue
+	{ TYPE_STRUCT, false, (size_t)(&((EmitterVelocityProperties_Type*)0)->AdjustEmitterRate), CHILDREN(39), 5 }, // EmitterVelocityChanges.AdjustEmitterRate
+	{ TYPE_BOOL, false, (size_t)(&((EmitterVelocityAdjust_Type*)0)->AdjustEnabled), NULL, 0 }, // EmitterVelocityChanges.AdjustEmitterRate.AdjustEnabled
+	{ TYPE_F32, false, (size_t)(&((EmitterVelocityAdjust_Type*)0)->VelocityLow), NULL, 0 }, // EmitterVelocityChanges.AdjustEmitterRate.VelocityLow
+	{ TYPE_F32, false, (size_t)(&((EmitterVelocityAdjust_Type*)0)->VelocityHigh), NULL, 0 }, // EmitterVelocityChanges.AdjustEmitterRate.VelocityHigh
+	{ TYPE_F32, false, (size_t)(&((EmitterVelocityAdjust_Type*)0)->LowValue), NULL, 0 }, // EmitterVelocityChanges.AdjustEmitterRate.LowValue
+	{ TYPE_F32, false, (size_t)(&((EmitterVelocityAdjust_Type*)0)->HighValue), NULL, 0 }, // EmitterVelocityChanges.AdjustEmitterRate.HighValue
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->Emitter), NULL, 0 }, // Emitter
+};
+
+
+bool EmitterEffect::mBuiltFlag = false;
+NvParameterized::MutexType EmitterEffect::mBuiltFlagMutex;
+
+EmitterEffect::EmitterEffect(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &EmitterEffectFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+EmitterEffect::~EmitterEffect()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void EmitterEffect::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~EmitterEffect();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* EmitterEffect::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* EmitterEffect::getParameterDefinitionTree(void) const
+{
+	EmitterEffect* tmpParam = const_cast<EmitterEffect*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType EmitterEffect::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType EmitterEffect::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void EmitterEffect::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<EmitterEffect::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void EmitterEffect::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void EmitterEffect::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An emitter effect", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="EffectProperties"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("EffectProperties", TYPE_STRUCT, "EffectProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Emitter Effect Properties", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="EffectProperties.UserString"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("UserString", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An aribtrary user string that can be set by an artist/designer/programmer", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="EffectProperties.Enable"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("Enable", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Whether or not this effect is to be initially enabled on startup", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("Position", TYPE_STRUCT, "TranslateObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The position of this effect relative to the parent", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="EffectProperties.Position.TranslateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("TranslateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="EffectProperties.Position.TranslateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("TranslateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="EffectProperties.Position.TranslateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("TranslateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("Orientation", TYPE_STRUCT, "OrientObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The orientation of this effect, relative to the parent orientation", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="EffectProperties.Orientation.RotateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("RotateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the X axis (0-360 degrees)", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="EffectProperties.Orientation.RotateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("RotateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Y axis (0-360 degrees)", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=11, longName="EffectProperties.Orientation.RotateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11];
+		ParamDef->init("RotateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Z axis (0-360 degrees)", true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=12, longName="EffectProperties.InitialDelayTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12];
+		ParamDef->init("InitialDelayTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "Initial time to delay before spawning this effect", true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=13, longName="EffectProperties.Duration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13];
+		ParamDef->init("Duration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The duration of the effect in secontds", true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=14, longName="EffectProperties.RepeatCount"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14];
+		ParamDef->init("RepeatCount", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(1), true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The number of times to repeat the effect; 9999 means repeate forever", true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=15, longName="EffectProperties.RepeatDelay"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15];
+		ParamDef->init("RepeatDelay", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The time to delay activation each time the effect repeats in seconds; this can be different than the initial delay time", true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=16, longName="EffectProperties.RandomizeRepeatTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16];
+		ParamDef->init("RandomizeRepeatTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Amount of randomization to the repeat cycle; a value of zero (default) means no random and a value of one means completely random.", true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17];
+		ParamDef->init("Path", TYPE_STRUCT, "EffectPath", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An optional pre-defined path for this effect to travel on", true);
+		ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=18, longName="EffectProperties.Path.PlaybackMode"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18];
+		ParamDef->init("PlaybackMode", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The mode to play back the path", true);
+		ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "LOOP", "PLAY_ONCE", "PING_PONG" };
+		ParamDefTable[18].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=19, longName="EffectProperties.Path.PathDuration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19];
+		ParamDef->init("PathDuration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		HintTable[2].init("shortDescription", "The duration of the path if one is not otherwise provided", true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=20, longName="EffectProperties.Path.LoopIndex"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20];
+		ParamDef->init("LoopIndex", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "The array index to loop back to", true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21];
+		ParamDef->init("ControlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=22, longName="EffectProperties.Path.ControlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22];
+		ParamDef->init("ControlPoints", TYPE_TRANSFORM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23];
+		ParamDef->init("Scale", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24];
+		ParamDef->init("Scale", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=25, longName="EffectProperties.Path.Scale[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=26, longName="EffectProperties.Path.Scale[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27];
+		ParamDef->init("Speed", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28];
+		ParamDef->init("Speed", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=29, longName="EffectProperties.Path.Speed[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=30, longName="EffectProperties.Path.Speed[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=31, longName="EmitterVelocityChanges"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31];
+		ParamDef->init("EmitterVelocityChanges", TYPE_STRUCT, "EmitterVelocityProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Adjust the Velocity of the Emitter", true);
+		ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=32, longName="EmitterVelocityChanges.AdjustLifetime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[32];
+		ParamDef->init("AdjustLifetime", TYPE_STRUCT, "EmitterVelocityAdjust", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Optionally adjust the lifetime of emitted particles based on the velocity of the emitter", true);
+		ParamDefTable[32].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=33, longName="EmitterVelocityChanges.AdjustLifetime.AdjustEnabled"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[33];
+		ParamDef->init("AdjustEnabled", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "True if adjusting emitter properties based on velocity", true);
+		ParamDefTable[33].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=34, longName="EmitterVelocityChanges.AdjustLifetime.VelocityLow"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[34];
+		ParamDef->init("VelocityLow", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[34].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Low velocity range to match the low", true);
+		ParamDefTable[34].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=35, longName="EmitterVelocityChanges.AdjustLifetime.VelocityHigh"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[35];
+		ParamDef->init("VelocityHigh", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[35].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "High velocity range to match the high value", true);
+		ParamDefTable[35].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=36, longName="EmitterVelocityChanges.AdjustLifetime.LowValue"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[36];
+		ParamDef->init("LowValue", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[36].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The multiplier when the velocity equals VelocityLow", true);
+		ParamDefTable[36].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=37, longName="EmitterVelocityChanges.AdjustLifetime.HighValue"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[37];
+		ParamDef->init("HighValue", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[37].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The multiplier when the velocity equals VelocityHigh", true);
+		ParamDefTable[37].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=38, longName="EmitterVelocityChanges.AdjustEmitterRate"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[38];
+		ParamDef->init("AdjustEmitterRate", TYPE_STRUCT, "EmitterVelocityAdjust", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Optionally adjust the rate of the emitted particles based on the velocity of the emitter", true);
+		ParamDefTable[38].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=39, longName="EmitterVelocityChanges.AdjustEmitterRate.AdjustEnabled"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[39];
+		ParamDef->init("AdjustEnabled", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "True if adjusting emitter properties based on velocity", true);
+		ParamDefTable[39].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=40, longName="EmitterVelocityChanges.AdjustEmitterRate.VelocityLow"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[40];
+		ParamDef->init("VelocityLow", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[40].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Low velocity range to match the low", true);
+		ParamDefTable[40].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=41, longName="EmitterVelocityChanges.AdjustEmitterRate.VelocityHigh"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[41];
+		ParamDef->init("VelocityHigh", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[41].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "High velocity range to match the high value", true);
+		ParamDefTable[41].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=42, longName="EmitterVelocityChanges.AdjustEmitterRate.LowValue"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[42];
+		ParamDef->init("LowValue", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[42].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The multiplier when the velocity equals VelocityLow", true);
+		ParamDefTable[42].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=43, longName="EmitterVelocityChanges.AdjustEmitterRate.HighValue"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[43];
+		ParamDef->init("HighValue", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[43].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The multiplier when the velocity equals VelocityHigh", true);
+		ParamDefTable[43].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=44, longName="Emitter"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[44];
+		ParamDef->init("Emitter", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Emitter Asset", true);
+		ParamDefTable[44].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ApexEmitterAsset" };
+		ParamDefTable[44].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(31);
+		Children[2] = PDEF_PTR(44);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="EffectProperties"
+	{
+		static Definition* Children[10];
+		Children[0] = PDEF_PTR(2);
+		Children[1] = PDEF_PTR(3);
+		Children[2] = PDEF_PTR(4);
+		Children[3] = PDEF_PTR(8);
+		Children[4] = PDEF_PTR(12);
+		Children[5] = PDEF_PTR(13);
+		Children[6] = PDEF_PTR(14);
+		Children[7] = PDEF_PTR(15);
+		Children[8] = PDEF_PTR(16);
+		Children[9] = PDEF_PTR(17);
+
+		ParamDefTable[1].setChildren(Children, 10);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(5);
+		Children[1] = PDEF_PTR(6);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[4].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(9);
+		Children[1] = PDEF_PTR(10);
+		Children[2] = PDEF_PTR(11);
+
+		ParamDefTable[8].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		static Definition* Children[6];
+		Children[0] = PDEF_PTR(18);
+		Children[1] = PDEF_PTR(19);
+		Children[2] = PDEF_PTR(20);
+		Children[3] = PDEF_PTR(21);
+		Children[4] = PDEF_PTR(23);
+		Children[5] = PDEF_PTR(27);
+
+		ParamDefTable[17].setChildren(Children, 6);
+	}
+
+	// SetChildren for: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(22);
+
+		ParamDefTable[21].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(24);
+
+		ParamDefTable[23].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(25);
+		Children[1] = PDEF_PTR(26);
+
+		ParamDefTable[24].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(28);
+
+		ParamDefTable[27].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(29);
+		Children[1] = PDEF_PTR(30);
+
+		ParamDefTable[28].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=31, longName="EmitterVelocityChanges"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(32);
+		Children[1] = PDEF_PTR(38);
+
+		ParamDefTable[31].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=32, longName="EmitterVelocityChanges.AdjustLifetime"
+	{
+		static Definition* Children[5];
+		Children[0] = PDEF_PTR(33);
+		Children[1] = PDEF_PTR(34);
+		Children[2] = PDEF_PTR(35);
+		Children[3] = PDEF_PTR(36);
+		Children[4] = PDEF_PTR(37);
+
+		ParamDefTable[32].setChildren(Children, 5);
+	}
+
+	// SetChildren for: nodeIndex=38, longName="EmitterVelocityChanges.AdjustEmitterRate"
+	{
+		static Definition* Children[5];
+		Children[0] = PDEF_PTR(39);
+		Children[1] = PDEF_PTR(40);
+		Children[2] = PDEF_PTR(41);
+		Children[3] = PDEF_PTR(42);
+		Children[4] = PDEF_PTR(43);
+
+		ParamDefTable[38].setChildren(Children, 5);
+	}
+
+	mBuiltFlag = true;
+
+}
+void EmitterEffect::initStrings(void)
+{
+	EffectProperties.UserString.isAllocated = true;
+	EffectProperties.UserString.buf = NULL;
+}
+
+void EmitterEffect::initDynamicArrays(void)
+{
+	EffectProperties.Path.ControlPoints.buf = NULL;
+	EffectProperties.Path.ControlPoints.isAllocated = true;
+	EffectProperties.Path.ControlPoints.elementSize = sizeof(physx::PxTransform);
+	EffectProperties.Path.ControlPoints.arraySizes[0] = 0;
+	EffectProperties.Path.Scale.buf = NULL;
+	EffectProperties.Path.Scale.isAllocated = true;
+	EffectProperties.Path.Scale.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Scale.arraySizes[0] = 0;
+	EffectProperties.Path.Speed.buf = NULL;
+	EffectProperties.Path.Speed.isAllocated = true;
+	EffectProperties.Path.Speed.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Speed.arraySizes[0] = 0;
+}
+
+void EmitterEffect::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	EffectProperties.Enable = bool(1);
+	EffectProperties.Position.TranslateX = float(0.000000000);
+	EffectProperties.Position.TranslateY = float(0.000000000);
+	EffectProperties.Position.TranslateZ = float(0.000000000);
+	EffectProperties.Orientation.RotateX = float(0.000000000);
+	EffectProperties.Orientation.RotateY = float(0.000000000);
+	EffectProperties.Orientation.RotateZ = float(0.000000000);
+	EffectProperties.InitialDelayTime = float(0.000000000);
+	EffectProperties.Duration = float(0.000000000);
+	EffectProperties.RepeatCount = uint32_t(1);
+	EffectProperties.RepeatDelay = float(0.000000000);
+	EffectProperties.RandomizeRepeatTime = float(0.000000000);
+	EffectProperties.Path.PlaybackMode = (const char*)"LOOP";
+	EffectProperties.Path.PathDuration = float(4.000000000);
+	EffectProperties.Path.LoopIndex = uint32_t(0);
+	EmitterVelocityChanges.AdjustLifetime.AdjustEnabled = bool(0);
+	EmitterVelocityChanges.AdjustLifetime.VelocityLow = float(2.000000000);
+	EmitterVelocityChanges.AdjustLifetime.VelocityHigh = float(10.000000000);
+	EmitterVelocityChanges.AdjustLifetime.LowValue = float(1.000000000);
+	EmitterVelocityChanges.AdjustLifetime.HighValue = float(0.000000000);
+	EmitterVelocityChanges.AdjustEmitterRate.AdjustEnabled = bool(0);
+	EmitterVelocityChanges.AdjustEmitterRate.VelocityLow = float(2.000000000);
+	EmitterVelocityChanges.AdjustEmitterRate.VelocityHigh = float(10.000000000);
+	EmitterVelocityChanges.AdjustEmitterRate.LowValue = float(1.000000000);
+	EmitterVelocityChanges.AdjustEmitterRate.HighValue = float(0.000000000);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void EmitterEffect::initReferences(void)
+{
+	Emitter = NULL;
+
+}
+
+void EmitterEffect::freeDynamicArrays(void)
+{
+	if (EffectProperties.Path.ControlPoints.isAllocated && EffectProperties.Path.ControlPoints.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.ControlPoints.buf);
+	}
+	if (EffectProperties.Path.Scale.isAllocated && EffectProperties.Path.Scale.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Scale.buf);
+	}
+	if (EffectProperties.Path.Speed.isAllocated && EffectProperties.Path.Speed.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Speed.buf);
+	}
+}
+
+void EmitterEffect::freeStrings(void)
+{
+
+	if (EffectProperties.UserString.isAllocated && EffectProperties.UserString.buf)
+	{
+		mParameterizedTraits->strfree((char*)EffectProperties.UserString.buf);
+	}
+}
+
+void EmitterEffect::freeReferences(void)
+{
+	if (Emitter)
+	{
+		Emitter->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/FlameEmitterData.cpp b/APEX_1.4/module/particles/src/autogen/FlameEmitterData.cpp
new file mode 100644
index 00000000..26107f7b
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/FlameEmitterData.cpp
@@ -0,0 +1,363 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "FlameEmitterData.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace FlameEmitterDataNS;
+
+const char* const FlameEmitterDataFactory::vptr =
+    NvParameterized::getVptr<FlameEmitterData, FlameEmitterData::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->Name), NULL, 0 }, // Name
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->FlameEmitter), NULL, 0 }, // FlameEmitter
+};
+
+
+bool FlameEmitterData::mBuiltFlag = false;
+NvParameterized::MutexType FlameEmitterData::mBuiltFlagMutex;
+
+FlameEmitterData::FlameEmitterData(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &FlameEmitterDataFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+FlameEmitterData::~FlameEmitterData()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void FlameEmitterData::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~FlameEmitterData();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* FlameEmitterData::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* FlameEmitterData::getParameterDefinitionTree(void) const
+{
+	FlameEmitterData* tmpParam = const_cast<FlameEmitterData*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType FlameEmitterData::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType FlameEmitterData::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void FlameEmitterData::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<FlameEmitterData::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void FlameEmitterData::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void FlameEmitterData::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the asset properties for this flame emitter", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="Name"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("Name", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Flame Emitter Name", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="FlameEmitter"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("FlameEmitter", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Flame Emitter properties", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "FlameEmitterAssetParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void FlameEmitterData::initStrings(void)
+{
+	Name.isAllocated = false;
+	Name.buf = (const char*)"defaultFlameEmitter";
+}
+
+void FlameEmitterData::initDynamicArrays(void)
+{
+}
+
+void FlameEmitterData::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void FlameEmitterData::initReferences(void)
+{
+	FlameEmitter = NULL;
+
+}
+
+void FlameEmitterData::freeDynamicArrays(void)
+{
+}
+
+void FlameEmitterData::freeStrings(void)
+{
+
+	if (Name.isAllocated && Name.buf)
+	{
+		mParameterizedTraits->strfree((char*)Name.buf);
+	}
+}
+
+void FlameEmitterData::freeReferences(void)
+{
+	if (FlameEmitter)
+	{
+		FlameEmitter->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/FlameEmitterEffect.cpp b/APEX_1.4/module/particles/src/autogen/FlameEmitterEffect.cpp
new file mode 100644
index 00000000..7b5e81aa
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/FlameEmitterEffect.cpp
@@ -0,0 +1,1356 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "FlameEmitterEffect.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace FlameEmitterEffectNS;
+
+const char* const FlameEmitterEffectFactory::vptr =
+    NvParameterized::getVptr<FlameEmitterEffect, FlameEmitterEffect::ClassAlignment>();
+
+const uint32_t NumParamDefs = 32;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 31, 2, 3, 4, 8, 12, 13, 14, 15, 16, 17, 5, 6, 7, 9, 10, 11, 18, 19, 20, 21, 23,
+	27, 22, 24, 25, 26, 28, 29, 30,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->EffectProperties), CHILDREN(2), 10 }, // EffectProperties
+	{ TYPE_STRING, false, (size_t)(&((EffectProperties_Type*)0)->UserString), NULL, 0 }, // EffectProperties.UserString
+	{ TYPE_BOOL, false, (size_t)(&((EffectProperties_Type*)0)->Enable), NULL, 0 }, // EffectProperties.Enable
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Position), CHILDREN(12), 3 }, // EffectProperties.Position
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateX), NULL, 0 }, // EffectProperties.Position.TranslateX
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateY), NULL, 0 }, // EffectProperties.Position.TranslateY
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateZ), NULL, 0 }, // EffectProperties.Position.TranslateZ
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Orientation), CHILDREN(15), 3 }, // EffectProperties.Orientation
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateX), NULL, 0 }, // EffectProperties.Orientation.RotateX
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateY), NULL, 0 }, // EffectProperties.Orientation.RotateY
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateZ), NULL, 0 }, // EffectProperties.Orientation.RotateZ
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->InitialDelayTime), NULL, 0 }, // EffectProperties.InitialDelayTime
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->Duration), NULL, 0 }, // EffectProperties.Duration
+	{ TYPE_U32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatCount), NULL, 0 }, // EffectProperties.RepeatCount
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatDelay), NULL, 0 }, // EffectProperties.RepeatDelay
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RandomizeRepeatTime), NULL, 0 }, // EffectProperties.RandomizeRepeatTime
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Path), CHILDREN(18), 6 }, // EffectProperties.Path
+	{ TYPE_ENUM, false, (size_t)(&((EffectPath_Type*)0)->PlaybackMode), NULL, 0 }, // EffectProperties.Path.PlaybackMode
+	{ TYPE_F32, false, (size_t)(&((EffectPath_Type*)0)->PathDuration), NULL, 0 }, // EffectProperties.Path.PathDuration
+	{ TYPE_U32, false, (size_t)(&((EffectPath_Type*)0)->LoopIndex), NULL, 0 }, // EffectProperties.Path.LoopIndex
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->ControlPoints), CHILDREN(24), 1 }, // EffectProperties.Path.ControlPoints
+	{ TYPE_TRANSFORM, false, 1 * sizeof(physx::PxTransform), NULL, 0 }, // EffectProperties.Path.ControlPoints[]
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Scale), CHILDREN(25), 1 }, // EffectProperties.Path.Scale
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(26), 2 }, // EffectProperties.Path.Scale[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Scale[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Scale[].y
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Speed), CHILDREN(28), 1 }, // EffectProperties.Path.Speed
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(29), 2 }, // EffectProperties.Path.Speed[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Speed[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Speed[].y
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->FlameEmitter), NULL, 0 }, // FlameEmitter
+};
+
+
+bool FlameEmitterEffect::mBuiltFlag = false;
+NvParameterized::MutexType FlameEmitterEffect::mBuiltFlagMutex;
+
+FlameEmitterEffect::FlameEmitterEffect(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &FlameEmitterEffectFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+FlameEmitterEffect::~FlameEmitterEffect()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void FlameEmitterEffect::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~FlameEmitterEffect();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* FlameEmitterEffect::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* FlameEmitterEffect::getParameterDefinitionTree(void) const
+{
+	FlameEmitterEffect* tmpParam = const_cast<FlameEmitterEffect*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType FlameEmitterEffect::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType FlameEmitterEffect::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void FlameEmitterEffect::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<FlameEmitterEffect::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void FlameEmitterEffect::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void FlameEmitterEffect::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "A flame emitter effect", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="EffectProperties"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("EffectProperties", TYPE_STRUCT, "EffectProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Flame Emitter Properties", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="EffectProperties.UserString"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("UserString", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An aribtrary user string that can be set by an artist/designer/programmer", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="EffectProperties.Enable"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("Enable", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Whether or not this effect is to be initially enabled on startup", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("Position", TYPE_STRUCT, "TranslateObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The position of this effect relative to the parent", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="EffectProperties.Position.TranslateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("TranslateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="EffectProperties.Position.TranslateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("TranslateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="EffectProperties.Position.TranslateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("TranslateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("Orientation", TYPE_STRUCT, "OrientObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The orientation of this effect, relative to the parent orientation", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="EffectProperties.Orientation.RotateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("RotateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the X axis (0-360 degrees)", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="EffectProperties.Orientation.RotateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("RotateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Y axis (0-360 degrees)", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=11, longName="EffectProperties.Orientation.RotateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11];
+		ParamDef->init("RotateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Z axis (0-360 degrees)", true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=12, longName="EffectProperties.InitialDelayTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12];
+		ParamDef->init("InitialDelayTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "Initial time to delay before spawning this effect", true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=13, longName="EffectProperties.Duration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13];
+		ParamDef->init("Duration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The duration of the effect in secontds", true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=14, longName="EffectProperties.RepeatCount"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14];
+		ParamDef->init("RepeatCount", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(1), true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The number of times to repeat the effect; 9999 means repeate forever", true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=15, longName="EffectProperties.RepeatDelay"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15];
+		ParamDef->init("RepeatDelay", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The time to delay activation each time the effect repeats in seconds; this can be different than the initial delay time", true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=16, longName="EffectProperties.RandomizeRepeatTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16];
+		ParamDef->init("RandomizeRepeatTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Amount of randomization to the repeat cycle; a value of zero (default) means no random and a value of one means completely random.", true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17];
+		ParamDef->init("Path", TYPE_STRUCT, "EffectPath", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An optional pre-defined path for this effect to travel on", true);
+		ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=18, longName="EffectProperties.Path.PlaybackMode"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18];
+		ParamDef->init("PlaybackMode", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The mode to play back the path", true);
+		ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "LOOP", "PLAY_ONCE", "PING_PONG" };
+		ParamDefTable[18].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=19, longName="EffectProperties.Path.PathDuration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19];
+		ParamDef->init("PathDuration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		HintTable[2].init("shortDescription", "The duration of the path if one is not otherwise provided", true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=20, longName="EffectProperties.Path.LoopIndex"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20];
+		ParamDef->init("LoopIndex", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "The array index to loop back to", true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21];
+		ParamDef->init("ControlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=22, longName="EffectProperties.Path.ControlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22];
+		ParamDef->init("ControlPoints", TYPE_TRANSFORM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23];
+		ParamDef->init("Scale", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24];
+		ParamDef->init("Scale", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=25, longName="EffectProperties.Path.Scale[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=26, longName="EffectProperties.Path.Scale[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27];
+		ParamDef->init("Speed", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28];
+		ParamDef->init("Speed", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=29, longName="EffectProperties.Path.Speed[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=30, longName="EffectProperties.Path.Speed[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=31, longName="FlameEmitter"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31];
+		ParamDef->init("FlameEmitter", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Flame Emitter Asset", true);
+		ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "FlameEmitterAsset" };
+		ParamDefTable[31].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(31);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="EffectProperties"
+	{
+		static Definition* Children[10];
+		Children[0] = PDEF_PTR(2);
+		Children[1] = PDEF_PTR(3);
+		Children[2] = PDEF_PTR(4);
+		Children[3] = PDEF_PTR(8);
+		Children[4] = PDEF_PTR(12);
+		Children[5] = PDEF_PTR(13);
+		Children[6] = PDEF_PTR(14);
+		Children[7] = PDEF_PTR(15);
+		Children[8] = PDEF_PTR(16);
+		Children[9] = PDEF_PTR(17);
+
+		ParamDefTable[1].setChildren(Children, 10);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(5);
+		Children[1] = PDEF_PTR(6);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[4].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(9);
+		Children[1] = PDEF_PTR(10);
+		Children[2] = PDEF_PTR(11);
+
+		ParamDefTable[8].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		static Definition* Children[6];
+		Children[0] = PDEF_PTR(18);
+		Children[1] = PDEF_PTR(19);
+		Children[2] = PDEF_PTR(20);
+		Children[3] = PDEF_PTR(21);
+		Children[4] = PDEF_PTR(23);
+		Children[5] = PDEF_PTR(27);
+
+		ParamDefTable[17].setChildren(Children, 6);
+	}
+
+	// SetChildren for: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(22);
+
+		ParamDefTable[21].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(24);
+
+		ParamDefTable[23].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(25);
+		Children[1] = PDEF_PTR(26);
+
+		ParamDefTable[24].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(28);
+
+		ParamDefTable[27].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(29);
+		Children[1] = PDEF_PTR(30);
+
+		ParamDefTable[28].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void FlameEmitterEffect::initStrings(void)
+{
+	EffectProperties.UserString.isAllocated = true;
+	EffectProperties.UserString.buf = NULL;
+}
+
+void FlameEmitterEffect::initDynamicArrays(void)
+{
+	EffectProperties.Path.ControlPoints.buf = NULL;
+	EffectProperties.Path.ControlPoints.isAllocated = true;
+	EffectProperties.Path.ControlPoints.elementSize = sizeof(physx::PxTransform);
+	EffectProperties.Path.ControlPoints.arraySizes[0] = 0;
+	EffectProperties.Path.Scale.buf = NULL;
+	EffectProperties.Path.Scale.isAllocated = true;
+	EffectProperties.Path.Scale.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Scale.arraySizes[0] = 0;
+	EffectProperties.Path.Speed.buf = NULL;
+	EffectProperties.Path.Speed.isAllocated = true;
+	EffectProperties.Path.Speed.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Speed.arraySizes[0] = 0;
+}
+
+void FlameEmitterEffect::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	EffectProperties.Enable = bool(1);
+	EffectProperties.Position.TranslateX = float(0.000000000);
+	EffectProperties.Position.TranslateY = float(0.000000000);
+	EffectProperties.Position.TranslateZ = float(0.000000000);
+	EffectProperties.Orientation.RotateX = float(0.000000000);
+	EffectProperties.Orientation.RotateY = float(0.000000000);
+	EffectProperties.Orientation.RotateZ = float(0.000000000);
+	EffectProperties.InitialDelayTime = float(0.000000000);
+	EffectProperties.Duration = float(0.000000000);
+	EffectProperties.RepeatCount = uint32_t(1);
+	EffectProperties.RepeatDelay = float(0.000000000);
+	EffectProperties.RandomizeRepeatTime = float(0.000000000);
+	EffectProperties.Path.PlaybackMode = (const char*)"LOOP";
+	EffectProperties.Path.PathDuration = float(4.000000000);
+	EffectProperties.Path.LoopIndex = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void FlameEmitterEffect::initReferences(void)
+{
+	FlameEmitter = NULL;
+
+}
+
+void FlameEmitterEffect::freeDynamicArrays(void)
+{
+	if (EffectProperties.Path.ControlPoints.isAllocated && EffectProperties.Path.ControlPoints.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.ControlPoints.buf);
+	}
+	if (EffectProperties.Path.Scale.isAllocated && EffectProperties.Path.Scale.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Scale.buf);
+	}
+	if (EffectProperties.Path.Speed.isAllocated && EffectProperties.Path.Speed.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Speed.buf);
+	}
+}
+
+void FlameEmitterEffect::freeStrings(void)
+{
+
+	if (EffectProperties.UserString.isAllocated && EffectProperties.UserString.buf)
+	{
+		mParameterizedTraits->strfree((char*)EffectProperties.UserString.buf);
+	}
+}
+
+void FlameEmitterEffect::freeReferences(void)
+{
+	if (FlameEmitter)
+	{
+		FlameEmitter->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/ForceFieldData.cpp b/APEX_1.4/module/particles/src/autogen/ForceFieldData.cpp
new file mode 100644
index 00000000..51a4f604
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/ForceFieldData.cpp
@@ -0,0 +1,363 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ForceFieldData.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace ForceFieldDataNS;
+
+const char* const ForceFieldDataFactory::vptr =
+    NvParameterized::getVptr<ForceFieldData, ForceFieldData::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->Name), NULL, 0 }, // Name
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->ForceField), NULL, 0 }, // ForceField
+};
+
+
+bool ForceFieldData::mBuiltFlag = false;
+NvParameterized::MutexType ForceFieldData::mBuiltFlagMutex;
+
+ForceFieldData::ForceFieldData(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ForceFieldDataFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ForceFieldData::~ForceFieldData()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ForceFieldData::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ForceFieldData();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ForceFieldData::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ForceFieldData::getParameterDefinitionTree(void) const
+{
+	ForceFieldData* tmpParam = const_cast<ForceFieldData*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ForceFieldData::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ForceFieldData::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ForceFieldData::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ForceFieldData::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ForceFieldData::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ForceFieldData::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the asset properties for this force field sampler", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="Name"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("Name", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Forcefield Name", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="ForceField"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("ForceField", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Forcefield properties", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ForceFieldAssetParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ForceFieldData::initStrings(void)
+{
+	Name.isAllocated = false;
+	Name.buf = (const char*)"defaultForceField";
+}
+
+void ForceFieldData::initDynamicArrays(void)
+{
+}
+
+void ForceFieldData::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ForceFieldData::initReferences(void)
+{
+	ForceField = NULL;
+
+}
+
+void ForceFieldData::freeDynamicArrays(void)
+{
+}
+
+void ForceFieldData::freeStrings(void)
+{
+
+	if (Name.isAllocated && Name.buf)
+	{
+		mParameterizedTraits->strfree((char*)Name.buf);
+	}
+}
+
+void ForceFieldData::freeReferences(void)
+{
+	if (ForceField)
+	{
+		ForceField->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/ForceFieldEffect.cpp b/APEX_1.4/module/particles/src/autogen/ForceFieldEffect.cpp
new file mode 100644
index 00000000..dc3bed74
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/ForceFieldEffect.cpp
@@ -0,0 +1,1362 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ForceFieldEffect.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace ForceFieldEffectNS;
+
+const char* const ForceFieldEffectFactory::vptr =
+    NvParameterized::getVptr<ForceFieldEffect, ForceFieldEffect::ClassAlignment>();
+
+const uint32_t NumParamDefs = 32;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 31, 2, 3, 4, 8, 12, 13, 14, 15, 16, 17, 5, 6, 7, 9, 10, 11, 18, 19, 20, 21, 23,
+	27, 22, 24, 25, 26, 28, 29, 30,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->EffectProperties), CHILDREN(2), 10 }, // EffectProperties
+	{ TYPE_STRING, false, (size_t)(&((EffectProperties_Type*)0)->UserString), NULL, 0 }, // EffectProperties.UserString
+	{ TYPE_BOOL, false, (size_t)(&((EffectProperties_Type*)0)->Enable), NULL, 0 }, // EffectProperties.Enable
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Position), CHILDREN(12), 3 }, // EffectProperties.Position
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateX), NULL, 0 }, // EffectProperties.Position.TranslateX
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateY), NULL, 0 }, // EffectProperties.Position.TranslateY
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateZ), NULL, 0 }, // EffectProperties.Position.TranslateZ
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Orientation), CHILDREN(15), 3 }, // EffectProperties.Orientation
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateX), NULL, 0 }, // EffectProperties.Orientation.RotateX
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateY), NULL, 0 }, // EffectProperties.Orientation.RotateY
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateZ), NULL, 0 }, // EffectProperties.Orientation.RotateZ
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->InitialDelayTime), NULL, 0 }, // EffectProperties.InitialDelayTime
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->Duration), NULL, 0 }, // EffectProperties.Duration
+	{ TYPE_U32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatCount), NULL, 0 }, // EffectProperties.RepeatCount
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatDelay), NULL, 0 }, // EffectProperties.RepeatDelay
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RandomizeRepeatTime), NULL, 0 }, // EffectProperties.RandomizeRepeatTime
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Path), CHILDREN(18), 6 }, // EffectProperties.Path
+	{ TYPE_ENUM, false, (size_t)(&((EffectPath_Type*)0)->PlaybackMode), NULL, 0 }, // EffectProperties.Path.PlaybackMode
+	{ TYPE_F32, false, (size_t)(&((EffectPath_Type*)0)->PathDuration), NULL, 0 }, // EffectProperties.Path.PathDuration
+	{ TYPE_U32, false, (size_t)(&((EffectPath_Type*)0)->LoopIndex), NULL, 0 }, // EffectProperties.Path.LoopIndex
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->ControlPoints), CHILDREN(24), 1 }, // EffectProperties.Path.ControlPoints
+	{ TYPE_TRANSFORM, false, 1 * sizeof(physx::PxTransform), NULL, 0 }, // EffectProperties.Path.ControlPoints[]
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Scale), CHILDREN(25), 1 }, // EffectProperties.Path.Scale
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(26), 2 }, // EffectProperties.Path.Scale[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Scale[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Scale[].y
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Speed), CHILDREN(28), 1 }, // EffectProperties.Path.Speed
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(29), 2 }, // EffectProperties.Path.Speed[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Speed[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Speed[].y
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->ForceField), NULL, 0 }, // ForceField
+};
+
+
+bool ForceFieldEffect::mBuiltFlag = false;
+NvParameterized::MutexType ForceFieldEffect::mBuiltFlagMutex;
+
+ForceFieldEffect::ForceFieldEffect(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ForceFieldEffectFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ForceFieldEffect::~ForceFieldEffect()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ForceFieldEffect::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ForceFieldEffect();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ForceFieldEffect::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ForceFieldEffect::getParameterDefinitionTree(void) const
+{
+	ForceFieldEffect* tmpParam = const_cast<ForceFieldEffect*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ForceFieldEffect::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ForceFieldEffect::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ForceFieldEffect::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ForceFieldEffect::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ForceFieldEffect::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ForceFieldEffect::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "A forcefield effect", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="EffectProperties"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("EffectProperties", TYPE_STRUCT, "EffectProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Forcefield Properties", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="EffectProperties.UserString"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("UserString", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An aribtrary user string that can be set by an artist/designer/programmer", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="EffectProperties.Enable"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("Enable", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Whether or not this effect is to be initially enabled on startup", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("Position", TYPE_STRUCT, "TranslateObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The position of this effect relative to the parent", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="EffectProperties.Position.TranslateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("TranslateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="EffectProperties.Position.TranslateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("TranslateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="EffectProperties.Position.TranslateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("TranslateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("Orientation", TYPE_STRUCT, "OrientObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The orientation of this effect, relative to the parent orientation", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="EffectProperties.Orientation.RotateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("RotateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the X axis (0-360 degrees)", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="EffectProperties.Orientation.RotateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("RotateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Y axis (0-360 degrees)", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=11, longName="EffectProperties.Orientation.RotateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11];
+		ParamDef->init("RotateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Z axis (0-360 degrees)", true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=12, longName="EffectProperties.InitialDelayTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12];
+		ParamDef->init("InitialDelayTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "Initial time to delay before spawning this effect", true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=13, longName="EffectProperties.Duration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13];
+		ParamDef->init("Duration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The duration of the effect in secontds", true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=14, longName="EffectProperties.RepeatCount"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14];
+		ParamDef->init("RepeatCount", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(1), true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The number of times to repeat the effect; 9999 means repeate forever", true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=15, longName="EffectProperties.RepeatDelay"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15];
+		ParamDef->init("RepeatDelay", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The time to delay activation each time the effect repeats in seconds; this can be different than the initial delay time", true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=16, longName="EffectProperties.RandomizeRepeatTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16];
+		ParamDef->init("RandomizeRepeatTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Amount of randomization to the repeat cycle; a value of zero (default) means no random and a value of one means completely random.", true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17];
+		ParamDef->init("Path", TYPE_STRUCT, "EffectPath", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An optional pre-defined path for this effect to travel on", true);
+		ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=18, longName="EffectProperties.Path.PlaybackMode"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18];
+		ParamDef->init("PlaybackMode", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The mode to play back the path", true);
+		ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "LOOP", "PLAY_ONCE", "PING_PONG" };
+		ParamDefTable[18].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=19, longName="EffectProperties.Path.PathDuration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19];
+		ParamDef->init("PathDuration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		HintTable[2].init("shortDescription", "The duration of the path if one is not otherwise provided", true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=20, longName="EffectProperties.Path.LoopIndex"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20];
+		ParamDef->init("LoopIndex", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "The array index to loop back to", true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21];
+		ParamDef->init("ControlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=22, longName="EffectProperties.Path.ControlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22];
+		ParamDef->init("ControlPoints", TYPE_TRANSFORM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23];
+		ParamDef->init("Scale", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24];
+		ParamDef->init("Scale", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=25, longName="EffectProperties.Path.Scale[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=26, longName="EffectProperties.Path.Scale[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27];
+		ParamDef->init("Speed", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28];
+		ParamDef->init("Speed", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=29, longName="EffectProperties.Path.Speed[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=30, longName="EffectProperties.Path.Speed[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=31, longName="ForceField"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31];
+		ParamDef->init("ForceField", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Forcefield Asset", true);
+		ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ForceFieldAsset" };
+		ParamDefTable[31].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(31);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="EffectProperties"
+	{
+		static Definition* Children[10];
+		Children[0] = PDEF_PTR(2);
+		Children[1] = PDEF_PTR(3);
+		Children[2] = PDEF_PTR(4);
+		Children[3] = PDEF_PTR(8);
+		Children[4] = PDEF_PTR(12);
+		Children[5] = PDEF_PTR(13);
+		Children[6] = PDEF_PTR(14);
+		Children[7] = PDEF_PTR(15);
+		Children[8] = PDEF_PTR(16);
+		Children[9] = PDEF_PTR(17);
+
+		ParamDefTable[1].setChildren(Children, 10);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(5);
+		Children[1] = PDEF_PTR(6);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[4].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(9);
+		Children[1] = PDEF_PTR(10);
+		Children[2] = PDEF_PTR(11);
+
+		ParamDefTable[8].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		static Definition* Children[6];
+		Children[0] = PDEF_PTR(18);
+		Children[1] = PDEF_PTR(19);
+		Children[2] = PDEF_PTR(20);
+		Children[3] = PDEF_PTR(21);
+		Children[4] = PDEF_PTR(23);
+		Children[5] = PDEF_PTR(27);
+
+		ParamDefTable[17].setChildren(Children, 6);
+	}
+
+	// SetChildren for: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(22);
+
+		ParamDefTable[21].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(24);
+
+		ParamDefTable[23].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(25);
+		Children[1] = PDEF_PTR(26);
+
+		ParamDefTable[24].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(28);
+
+		ParamDefTable[27].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(29);
+		Children[1] = PDEF_PTR(30);
+
+		ParamDefTable[28].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ForceFieldEffect::initStrings(void)
+{
+	EffectProperties.UserString.isAllocated = true;
+	EffectProperties.UserString.buf = NULL;
+}
+
+void ForceFieldEffect::initDynamicArrays(void)
+{
+	EffectProperties.Path.ControlPoints.buf = NULL;
+	EffectProperties.Path.ControlPoints.isAllocated = true;
+	EffectProperties.Path.ControlPoints.elementSize = sizeof(physx::PxTransform);
+	EffectProperties.Path.ControlPoints.arraySizes[0] = 0;
+	EffectProperties.Path.Scale.buf = NULL;
+	EffectProperties.Path.Scale.isAllocated = true;
+	EffectProperties.Path.Scale.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Scale.arraySizes[0] = 0;
+	EffectProperties.Path.Speed.buf = NULL;
+	EffectProperties.Path.Speed.isAllocated = true;
+	EffectProperties.Path.Speed.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Speed.arraySizes[0] = 0;
+}
+
+void ForceFieldEffect::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	EffectProperties.Enable = bool(1);
+	EffectProperties.Position.TranslateX = float(0.000000000);
+	EffectProperties.Position.TranslateY = float(0.000000000);
+	EffectProperties.Position.TranslateZ = float(0.000000000);
+	EffectProperties.Orientation.RotateX = float(0.000000000);
+	EffectProperties.Orientation.RotateY = float(0.000000000);
+	EffectProperties.Orientation.RotateZ = float(0.000000000);
+	EffectProperties.InitialDelayTime = float(0.000000000);
+	EffectProperties.Duration = float(0.000000000);
+	EffectProperties.RepeatCount = uint32_t(1);
+	EffectProperties.RepeatDelay = float(0.000000000);
+	EffectProperties.RandomizeRepeatTime = float(0.000000000);
+	EffectProperties.Path.PlaybackMode = (const char*)"LOOP";
+	EffectProperties.Path.PathDuration = float(4.000000000);
+	EffectProperties.Path.LoopIndex = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ForceFieldEffect::initReferences(void)
+{
+	ForceField = NULL;
+
+}
+
+void ForceFieldEffect::freeDynamicArrays(void)
+{
+	if (EffectProperties.Path.ControlPoints.isAllocated && EffectProperties.Path.ControlPoints.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.ControlPoints.buf);
+	}
+	if (EffectProperties.Path.Scale.isAllocated && EffectProperties.Path.Scale.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Scale.buf);
+	}
+	if (EffectProperties.Path.Speed.isAllocated && EffectProperties.Path.Speed.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Speed.buf);
+	}
+}
+
+void ForceFieldEffect::freeStrings(void)
+{
+
+	if (EffectProperties.UserString.isAllocated && EffectProperties.UserString.buf)
+	{
+		mParameterizedTraits->strfree((char*)EffectProperties.UserString.buf);
+	}
+}
+
+void ForceFieldEffect::freeReferences(void)
+{
+	if (ForceField)
+	{
+		ForceField->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/GraphicsEffectData.cpp b/APEX_1.4/module/particles/src/autogen/GraphicsEffectData.cpp
new file mode 100644
index 00000000..dece3c93
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/GraphicsEffectData.cpp
@@ -0,0 +1,363 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "GraphicsEffectData.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace GraphicsEffectDataNS;
+
+const char* const GraphicsEffectDataFactory::vptr =
+    NvParameterized::getVptr<GraphicsEffectData, GraphicsEffectData::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->Name), NULL, 0 }, // Name
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->IOFX), NULL, 0 }, // IOFX
+};
+
+
+bool GraphicsEffectData::mBuiltFlag = false;
+NvParameterized::MutexType GraphicsEffectData::mBuiltFlagMutex;
+
+GraphicsEffectData::GraphicsEffectData(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &GraphicsEffectDataFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+GraphicsEffectData::~GraphicsEffectData()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void GraphicsEffectData::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~GraphicsEffectData();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* GraphicsEffectData::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* GraphicsEffectData::getParameterDefinitionTree(void) const
+{
+	GraphicsEffectData* tmpParam = const_cast<GraphicsEffectData*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType GraphicsEffectData::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType GraphicsEffectData::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void GraphicsEffectData::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<GraphicsEffectData::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void GraphicsEffectData::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void GraphicsEffectData::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the asset properties for this graphics effect (IOFX)", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="Name"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("Name", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Sprite IOFX Name", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="IOFX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("IOFX", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Sprite IOFX properties", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "IofxAssetParameters" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void GraphicsEffectData::initStrings(void)
+{
+	Name.isAllocated = false;
+	Name.buf = (const char*)"defaultSpriteIOFX";
+}
+
+void GraphicsEffectData::initDynamicArrays(void)
+{
+}
+
+void GraphicsEffectData::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void GraphicsEffectData::initReferences(void)
+{
+	IOFX = NULL;
+
+}
+
+void GraphicsEffectData::freeDynamicArrays(void)
+{
+}
+
+void GraphicsEffectData::freeStrings(void)
+{
+
+	if (Name.isAllocated && Name.buf)
+	{
+		mParameterizedTraits->strfree((char*)Name.buf);
+	}
+}
+
+void GraphicsEffectData::freeReferences(void)
+{
+	if (IOFX)
+	{
+		IOFX->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/GraphicsMaterialData.cpp b/APEX_1.4/module/particles/src/autogen/GraphicsMaterialData.cpp
new file mode 100644
index 00000000..dc30bb65
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/GraphicsMaterialData.cpp
@@ -0,0 +1,886 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "GraphicsMaterialData.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace GraphicsMaterialDataNS;
+
+const char* const GraphicsMaterialDataFactory::vptr =
+    NvParameterized::getVptr<GraphicsMaterialData, GraphicsMaterialData::ClassAlignment>();
+
+const uint32_t NumParamDefs = 20;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 16 },
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->Name), NULL, 0 }, // Name
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->ApplicationMaterialName), NULL, 0 }, // ApplicationMaterialName
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->UserProperties), NULL, 0 }, // UserProperties
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->RenderTechnique), NULL, 0 }, // RenderTechnique
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->DiffuseTexture), NULL, 0 }, // DiffuseTexture
+	{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->CellColumn), NULL, 0 }, // CellColumn
+	{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->CellRow), NULL, 0 }, // CellRow
+	{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->CellCount), NULL, 0 }, // CellCount
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->CrossBlend), NULL, 0 }, // CrossBlend
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->ColorMultiplier), NULL, 0 }, // ColorMultiplier
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->UsePSM), NULL, 0 }, // UsePSM
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->Resolution), NULL, 0 }, // Resolution
+	{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->FullResPercent), NULL, 0 }, // FullResPercent
+	{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->HalfResPercent), NULL, 0 }, // HalfResPercent
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->PSM_ShadowBias), NULL, 0 }, // PSM_ShadowBias
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->PSM_Frustum), CHILDREN(16), 3 }, // PSM_Frustum
+	{ TYPE_BOOL, false, (size_t)(&((FrustumPSM_Type*)0)->ShowFrustum), NULL, 0 }, // PSM_Frustum.ShowFrustum
+	{ TYPE_F32, false, (size_t)(&((FrustumPSM_Type*)0)->FrustumDepth), NULL, 0 }, // PSM_Frustum.FrustumDepth
+	{ TYPE_F32, false, (size_t)(&((FrustumPSM_Type*)0)->FrustumSize), NULL, 0 }, // PSM_Frustum.FrustumSize
+};
+
+
+bool GraphicsMaterialData::mBuiltFlag = false;
+NvParameterized::MutexType GraphicsMaterialData::mBuiltFlagMutex;
+
+GraphicsMaterialData::GraphicsMaterialData(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &GraphicsMaterialDataFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+GraphicsMaterialData::~GraphicsMaterialData()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void GraphicsMaterialData::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~GraphicsMaterialData();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* GraphicsMaterialData::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* GraphicsMaterialData::getParameterDefinitionTree(void) const
+{
+	GraphicsMaterialData* tmpParam = const_cast<GraphicsMaterialData*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType GraphicsMaterialData::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType GraphicsMaterialData::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void GraphicsMaterialData::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<GraphicsMaterialData::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void GraphicsMaterialData::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void GraphicsMaterialData::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the asset properties for this graphics material", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="Name"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("Name", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "The name of this graphics material", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="ApplicationMaterialName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("ApplicationMaterialName", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The name of the material to match up with the application's material system", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="UserProperties"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("UserProperties", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Optional user properties string", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="RenderTechnique"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("RenderTechnique", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Which sprite rendering technique to apply", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "SPRITE_ONE", "SPRITE_ONE", "SPRITE_ALPHA", "SPRITE_SOLID", "SPRITE_TEXTURE", "SPRITE_WIREFRAME" };
+		ParamDefTable[4].setEnumVals((const char**)EnumVals, 6);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="DiffuseTexture"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("DiffuseTexture", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("NAME_CALLBACK", uint64_t(1), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("NAME_CALLBACK", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The diffuse source texture to render the sprite with.", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="CellColumn"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("CellColumn", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(32), true);
+		HintTable[1].init("min", uint64_t(1), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(32), true);
+		HintTable[1].init("min", uint64_t(1), true);
+		HintTable[2].init("shortDescription", "The number of columns in the celled texture", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="CellRow"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("CellRow", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(32), true);
+		HintTable[1].init("min", uint64_t(1), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(32), true);
+		HintTable[1].init("min", uint64_t(1), true);
+		HintTable[2].init("shortDescription", "The number of rows in the celled texture", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="CellCount"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("CellCount", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(1024), true);
+		HintTable[1].init("min", uint64_t(1), true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(1024), true);
+		HintTable[1].init("min", uint64_t(1), true);
+		HintTable[2].init("shortDescription", "The total number of frames in the celled animation", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="CrossBlend"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("CrossBlend", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "True if cross blending celled animated sprites", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="ColorMultiplier"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("ColorMultiplier", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(10.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(10.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Multiply this constant times the output color", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=11, longName="UsePSM"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11];
+		ParamDef->init("UsePSM", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Whether or not to use the PSM pipeline or not", true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=12, longName="Resolution"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12];
+		ParamDef->init("Resolution", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Whether or not to use full-res, half-res, quarter res, or multi-resoluation particle rendering", true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "FULL", "HALF", "QUARTER", "MULTI" };
+		ParamDefTable[12].setEnumVals((const char**)EnumVals, 4);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=13, longName="FullResPercent"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13];
+		ParamDef->init("FullResPercent", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(100), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(100), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Percentage of particles to render at full resolution, is using the multi-res feature", true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=14, longName="HalfResPercent"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14];
+		ParamDef->init("HalfResPercent", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(100), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(100), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Percentage of particles to reunder at half-resolution; remaining percentage maps to quarter resolution if rendering using the multi-res feature", true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=15, longName="PSM_ShadowBias"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15];
+		ParamDef->init("PSM_ShadowBias", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(2.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(2.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Helpful ToolTip goes here", true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=16, longName="PSM_Frustum"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16];
+		ParamDef->init("PSM_Frustum", TYPE_STRUCT, "FrustumPSM", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The frustum properties for PSM", true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=17, longName="PSM_Frustum.ShowFrustum"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17];
+		ParamDef->init("ShowFrustum", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Debug visualize the frustum", true);
+		ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=18, longName="PSM_Frustum.FrustumDepth"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18];
+		ParamDef->init("FrustumDepth", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The depth to use to build the non-orthographic projection", true);
+		ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=19, longName="PSM_Frustum.FrustumSize"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19];
+		ParamDef->init("FrustumSize", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(100.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The overall bounding volume width/height to use to compute the PSM view frustum", true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[16];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+		Children[3] = PDEF_PTR(4);
+		Children[4] = PDEF_PTR(5);
+		Children[5] = PDEF_PTR(6);
+		Children[6] = PDEF_PTR(7);
+		Children[7] = PDEF_PTR(8);
+		Children[8] = PDEF_PTR(9);
+		Children[9] = PDEF_PTR(10);
+		Children[10] = PDEF_PTR(11);
+		Children[11] = PDEF_PTR(12);
+		Children[12] = PDEF_PTR(13);
+		Children[13] = PDEF_PTR(14);
+		Children[14] = PDEF_PTR(15);
+		Children[15] = PDEF_PTR(16);
+
+		ParamDefTable[0].setChildren(Children, 16);
+	}
+
+	// SetChildren for: nodeIndex=16, longName="PSM_Frustum"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(17);
+		Children[1] = PDEF_PTR(18);
+		Children[2] = PDEF_PTR(19);
+
+		ParamDefTable[16].setChildren(Children, 3);
+	}
+
+	mBuiltFlag = true;
+
+}
+void GraphicsMaterialData::initStrings(void)
+{
+	Name.isAllocated = false;
+	Name.buf = (const char*)"defaultGraphicsMaterial";
+	ApplicationMaterialName.isAllocated = true;
+	ApplicationMaterialName.buf = NULL;
+	UserProperties.isAllocated = true;
+	UserProperties.buf = NULL;
+	DiffuseTexture.isAllocated = false;
+	DiffuseTexture.buf = (const char*)"DefaultSprite.dds";
+}
+
+void GraphicsMaterialData::initDynamicArrays(void)
+{
+}
+
+void GraphicsMaterialData::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	RenderTechnique = (const char*)"SPRITE_ONE";
+	CellColumn = uint32_t(1);
+	CellRow = uint32_t(1);
+	CellCount = uint32_t(1);
+	CrossBlend = bool(0);
+	ColorMultiplier = float(1.000000000);
+	UsePSM = bool(0);
+	Resolution = (const char*)"FULL";
+	FullResPercent = uint32_t(0);
+	HalfResPercent = uint32_t(80);
+	PSM_ShadowBias = float(1.000000000);
+	PSM_Frustum.ShowFrustum = bool(0);
+	PSM_Frustum.FrustumDepth = float(10.000000000);
+	PSM_Frustum.FrustumSize = float(10.000000000);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void GraphicsMaterialData::initReferences(void)
+{
+}
+
+void GraphicsMaterialData::freeDynamicArrays(void)
+{
+}
+
+void GraphicsMaterialData::freeStrings(void)
+{
+
+	if (Name.isAllocated && Name.buf)
+	{
+		mParameterizedTraits->strfree((char*)Name.buf);
+	}
+
+	if (ApplicationMaterialName.isAllocated && ApplicationMaterialName.buf)
+	{
+		mParameterizedTraits->strfree((char*)ApplicationMaterialName.buf);
+	}
+
+	if (UserProperties.isAllocated && UserProperties.buf)
+	{
+		mParameterizedTraits->strfree((char*)UserProperties.buf);
+	}
+
+	if (DiffuseTexture.isAllocated && DiffuseTexture.buf)
+	{
+		mParameterizedTraits->strfree((char*)DiffuseTexture.buf);
+	}
+}
+
+void GraphicsMaterialData::freeReferences(void)
+{
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/HeatSourceData.cpp b/APEX_1.4/module/particles/src/autogen/HeatSourceData.cpp
new file mode 100644
index 00000000..648c54e7
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/HeatSourceData.cpp
@@ -0,0 +1,363 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "HeatSourceData.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace HeatSourceDataNS;
+
+const char* const HeatSourceDataFactory::vptr =
+    NvParameterized::getVptr<HeatSourceData, HeatSourceData::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->Name), NULL, 0 }, // Name
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->HeatSource), NULL, 0 }, // HeatSource
+};
+
+
+bool HeatSourceData::mBuiltFlag = false;
+NvParameterized::MutexType HeatSourceData::mBuiltFlagMutex;
+
+HeatSourceData::HeatSourceData(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &HeatSourceDataFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+HeatSourceData::~HeatSourceData()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void HeatSourceData::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~HeatSourceData();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* HeatSourceData::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* HeatSourceData::getParameterDefinitionTree(void) const
+{
+	HeatSourceData* tmpParam = const_cast<HeatSourceData*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType HeatSourceData::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType HeatSourceData::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void HeatSourceData::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<HeatSourceData::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void HeatSourceData::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void HeatSourceData::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the asset properties for this heat source asset", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="Name"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("Name", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Heat Source name", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="HeatSource"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("HeatSource", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Heat Source properties", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "HeatSourceAssetParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void HeatSourceData::initStrings(void)
+{
+	Name.isAllocated = false;
+	Name.buf = (const char*)"defaultHeatSource";
+}
+
+void HeatSourceData::initDynamicArrays(void)
+{
+}
+
+void HeatSourceData::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void HeatSourceData::initReferences(void)
+{
+	HeatSource = NULL;
+
+}
+
+void HeatSourceData::freeDynamicArrays(void)
+{
+}
+
+void HeatSourceData::freeStrings(void)
+{
+
+	if (Name.isAllocated && Name.buf)
+	{
+		mParameterizedTraits->strfree((char*)Name.buf);
+	}
+}
+
+void HeatSourceData::freeReferences(void)
+{
+	if (HeatSource)
+	{
+		HeatSource->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/HeatSourceEffect.cpp b/APEX_1.4/module/particles/src/autogen/HeatSourceEffect.cpp
new file mode 100644
index 00000000..f7ed8122
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/HeatSourceEffect.cpp
@@ -0,0 +1,1356 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "HeatSourceEffect.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace HeatSourceEffectNS;
+
+const char* const HeatSourceEffectFactory::vptr =
+    NvParameterized::getVptr<HeatSourceEffect, HeatSourceEffect::ClassAlignment>();
+
+const uint32_t NumParamDefs = 32;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 31, 2, 3, 4, 8, 12, 13, 14, 15, 16, 17, 5, 6, 7, 9, 10, 11, 18, 19, 20, 21, 23,
+	27, 22, 24, 25, 26, 28, 29, 30,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->EffectProperties), CHILDREN(2), 10 }, // EffectProperties
+	{ TYPE_STRING, false, (size_t)(&((EffectProperties_Type*)0)->UserString), NULL, 0 }, // EffectProperties.UserString
+	{ TYPE_BOOL, false, (size_t)(&((EffectProperties_Type*)0)->Enable), NULL, 0 }, // EffectProperties.Enable
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Position), CHILDREN(12), 3 }, // EffectProperties.Position
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateX), NULL, 0 }, // EffectProperties.Position.TranslateX
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateY), NULL, 0 }, // EffectProperties.Position.TranslateY
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateZ), NULL, 0 }, // EffectProperties.Position.TranslateZ
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Orientation), CHILDREN(15), 3 }, // EffectProperties.Orientation
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateX), NULL, 0 }, // EffectProperties.Orientation.RotateX
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateY), NULL, 0 }, // EffectProperties.Orientation.RotateY
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateZ), NULL, 0 }, // EffectProperties.Orientation.RotateZ
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->InitialDelayTime), NULL, 0 }, // EffectProperties.InitialDelayTime
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->Duration), NULL, 0 }, // EffectProperties.Duration
+	{ TYPE_U32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatCount), NULL, 0 }, // EffectProperties.RepeatCount
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatDelay), NULL, 0 }, // EffectProperties.RepeatDelay
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RandomizeRepeatTime), NULL, 0 }, // EffectProperties.RandomizeRepeatTime
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Path), CHILDREN(18), 6 }, // EffectProperties.Path
+	{ TYPE_ENUM, false, (size_t)(&((EffectPath_Type*)0)->PlaybackMode), NULL, 0 }, // EffectProperties.Path.PlaybackMode
+	{ TYPE_F32, false, (size_t)(&((EffectPath_Type*)0)->PathDuration), NULL, 0 }, // EffectProperties.Path.PathDuration
+	{ TYPE_U32, false, (size_t)(&((EffectPath_Type*)0)->LoopIndex), NULL, 0 }, // EffectProperties.Path.LoopIndex
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->ControlPoints), CHILDREN(24), 1 }, // EffectProperties.Path.ControlPoints
+	{ TYPE_TRANSFORM, false, 1 * sizeof(physx::PxTransform), NULL, 0 }, // EffectProperties.Path.ControlPoints[]
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Scale), CHILDREN(25), 1 }, // EffectProperties.Path.Scale
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(26), 2 }, // EffectProperties.Path.Scale[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Scale[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Scale[].y
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Speed), CHILDREN(28), 1 }, // EffectProperties.Path.Speed
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(29), 2 }, // EffectProperties.Path.Speed[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Speed[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Speed[].y
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->HeatSource), NULL, 0 }, // HeatSource
+};
+
+
+bool HeatSourceEffect::mBuiltFlag = false;
+NvParameterized::MutexType HeatSourceEffect::mBuiltFlagMutex;
+
+HeatSourceEffect::HeatSourceEffect(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &HeatSourceEffectFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+HeatSourceEffect::~HeatSourceEffect()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void HeatSourceEffect::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~HeatSourceEffect();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* HeatSourceEffect::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* HeatSourceEffect::getParameterDefinitionTree(void) const
+{
+	HeatSourceEffect* tmpParam = const_cast<HeatSourceEffect*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType HeatSourceEffect::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType HeatSourceEffect::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void HeatSourceEffect::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<HeatSourceEffect::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void HeatSourceEffect::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void HeatSourceEffect::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "A heat source effect", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="EffectProperties"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("EffectProperties", TYPE_STRUCT, "EffectProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Properties of Heat Source Asset", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="EffectProperties.UserString"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("UserString", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An aribtrary user string that can be set by an artist/designer/programmer", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="EffectProperties.Enable"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("Enable", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Whether or not this effect is to be initially enabled on startup", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("Position", TYPE_STRUCT, "TranslateObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The position of this effect relative to the parent", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="EffectProperties.Position.TranslateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("TranslateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="EffectProperties.Position.TranslateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("TranslateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="EffectProperties.Position.TranslateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("TranslateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("Orientation", TYPE_STRUCT, "OrientObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The orientation of this effect, relative to the parent orientation", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="EffectProperties.Orientation.RotateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("RotateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the X axis (0-360 degrees)", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="EffectProperties.Orientation.RotateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("RotateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Y axis (0-360 degrees)", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=11, longName="EffectProperties.Orientation.RotateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11];
+		ParamDef->init("RotateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Z axis (0-360 degrees)", true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=12, longName="EffectProperties.InitialDelayTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12];
+		ParamDef->init("InitialDelayTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "Initial time to delay before spawning this effect", true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=13, longName="EffectProperties.Duration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13];
+		ParamDef->init("Duration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The duration of the effect in secontds", true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=14, longName="EffectProperties.RepeatCount"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14];
+		ParamDef->init("RepeatCount", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(1), true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The number of times to repeat the effect; 9999 means repeate forever", true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=15, longName="EffectProperties.RepeatDelay"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15];
+		ParamDef->init("RepeatDelay", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The time to delay activation each time the effect repeats in seconds; this can be different than the initial delay time", true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=16, longName="EffectProperties.RandomizeRepeatTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16];
+		ParamDef->init("RandomizeRepeatTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Amount of randomization to the repeat cycle; a value of zero (default) means no random and a value of one means completely random.", true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17];
+		ParamDef->init("Path", TYPE_STRUCT, "EffectPath", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An optional pre-defined path for this effect to travel on", true);
+		ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=18, longName="EffectProperties.Path.PlaybackMode"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18];
+		ParamDef->init("PlaybackMode", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The mode to play back the path", true);
+		ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "LOOP", "PLAY_ONCE", "PING_PONG" };
+		ParamDefTable[18].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=19, longName="EffectProperties.Path.PathDuration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19];
+		ParamDef->init("PathDuration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		HintTable[2].init("shortDescription", "The duration of the path if one is not otherwise provided", true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=20, longName="EffectProperties.Path.LoopIndex"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20];
+		ParamDef->init("LoopIndex", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "The array index to loop back to", true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21];
+		ParamDef->init("ControlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=22, longName="EffectProperties.Path.ControlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22];
+		ParamDef->init("ControlPoints", TYPE_TRANSFORM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23];
+		ParamDef->init("Scale", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24];
+		ParamDef->init("Scale", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=25, longName="EffectProperties.Path.Scale[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=26, longName="EffectProperties.Path.Scale[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27];
+		ParamDef->init("Speed", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28];
+		ParamDef->init("Speed", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=29, longName="EffectProperties.Path.Speed[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=30, longName="EffectProperties.Path.Speed[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=31, longName="HeatSource"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31];
+		ParamDef->init("HeatSource", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Heat Source Asset", true);
+		ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "HeatSourceAsset" };
+		ParamDefTable[31].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(31);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="EffectProperties"
+	{
+		static Definition* Children[10];
+		Children[0] = PDEF_PTR(2);
+		Children[1] = PDEF_PTR(3);
+		Children[2] = PDEF_PTR(4);
+		Children[3] = PDEF_PTR(8);
+		Children[4] = PDEF_PTR(12);
+		Children[5] = PDEF_PTR(13);
+		Children[6] = PDEF_PTR(14);
+		Children[7] = PDEF_PTR(15);
+		Children[8] = PDEF_PTR(16);
+		Children[9] = PDEF_PTR(17);
+
+		ParamDefTable[1].setChildren(Children, 10);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(5);
+		Children[1] = PDEF_PTR(6);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[4].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(9);
+		Children[1] = PDEF_PTR(10);
+		Children[2] = PDEF_PTR(11);
+
+		ParamDefTable[8].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		static Definition* Children[6];
+		Children[0] = PDEF_PTR(18);
+		Children[1] = PDEF_PTR(19);
+		Children[2] = PDEF_PTR(20);
+		Children[3] = PDEF_PTR(21);
+		Children[4] = PDEF_PTR(23);
+		Children[5] = PDEF_PTR(27);
+
+		ParamDefTable[17].setChildren(Children, 6);
+	}
+
+	// SetChildren for: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(22);
+
+		ParamDefTable[21].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(24);
+
+		ParamDefTable[23].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(25);
+		Children[1] = PDEF_PTR(26);
+
+		ParamDefTable[24].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(28);
+
+		ParamDefTable[27].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(29);
+		Children[1] = PDEF_PTR(30);
+
+		ParamDefTable[28].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void HeatSourceEffect::initStrings(void)
+{
+	EffectProperties.UserString.isAllocated = true;
+	EffectProperties.UserString.buf = NULL;
+}
+
+void HeatSourceEffect::initDynamicArrays(void)
+{
+	EffectProperties.Path.ControlPoints.buf = NULL;
+	EffectProperties.Path.ControlPoints.isAllocated = true;
+	EffectProperties.Path.ControlPoints.elementSize = sizeof(physx::PxTransform);
+	EffectProperties.Path.ControlPoints.arraySizes[0] = 0;
+	EffectProperties.Path.Scale.buf = NULL;
+	EffectProperties.Path.Scale.isAllocated = true;
+	EffectProperties.Path.Scale.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Scale.arraySizes[0] = 0;
+	EffectProperties.Path.Speed.buf = NULL;
+	EffectProperties.Path.Speed.isAllocated = true;
+	EffectProperties.Path.Speed.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Speed.arraySizes[0] = 0;
+}
+
+void HeatSourceEffect::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	EffectProperties.Enable = bool(1);
+	EffectProperties.Position.TranslateX = float(0.000000000);
+	EffectProperties.Position.TranslateY = float(0.000000000);
+	EffectProperties.Position.TranslateZ = float(0.000000000);
+	EffectProperties.Orientation.RotateX = float(0.000000000);
+	EffectProperties.Orientation.RotateY = float(0.000000000);
+	EffectProperties.Orientation.RotateZ = float(0.000000000);
+	EffectProperties.InitialDelayTime = float(0.000000000);
+	EffectProperties.Duration = float(0.000000000);
+	EffectProperties.RepeatCount = uint32_t(1);
+	EffectProperties.RepeatDelay = float(0.000000000);
+	EffectProperties.RandomizeRepeatTime = float(0.000000000);
+	EffectProperties.Path.PlaybackMode = (const char*)"LOOP";
+	EffectProperties.Path.PathDuration = float(4.000000000);
+	EffectProperties.Path.LoopIndex = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void HeatSourceEffect::initReferences(void)
+{
+	HeatSource = NULL;
+
+}
+
+void HeatSourceEffect::freeDynamicArrays(void)
+{
+	if (EffectProperties.Path.ControlPoints.isAllocated && EffectProperties.Path.ControlPoints.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.ControlPoints.buf);
+	}
+	if (EffectProperties.Path.Scale.isAllocated && EffectProperties.Path.Scale.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Scale.buf);
+	}
+	if (EffectProperties.Path.Speed.isAllocated && EffectProperties.Path.Speed.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Speed.buf);
+	}
+}
+
+void HeatSourceEffect::freeStrings(void)
+{
+
+	if (EffectProperties.UserString.isAllocated && EffectProperties.UserString.buf)
+	{
+		mParameterizedTraits->strfree((char*)EffectProperties.UserString.buf);
+	}
+}
+
+void HeatSourceEffect::freeReferences(void)
+{
+	if (HeatSource)
+	{
+		HeatSource->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/JetFieldSamplerData.cpp b/APEX_1.4/module/particles/src/autogen/JetFieldSamplerData.cpp
new file mode 100644
index 00000000..5981bac8
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/JetFieldSamplerData.cpp
@@ -0,0 +1,363 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "JetFieldSamplerData.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace JetFieldSamplerDataNS;
+
+const char* const JetFieldSamplerDataFactory::vptr =
+    NvParameterized::getVptr<JetFieldSamplerData, JetFieldSamplerData::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->Name), NULL, 0 }, // Name
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->JetFieldSampler), NULL, 0 }, // JetFieldSampler
+};
+
+
+bool JetFieldSamplerData::mBuiltFlag = false;
+NvParameterized::MutexType JetFieldSamplerData::mBuiltFlagMutex;
+
+JetFieldSamplerData::JetFieldSamplerData(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &JetFieldSamplerDataFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+JetFieldSamplerData::~JetFieldSamplerData()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void JetFieldSamplerData::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~JetFieldSamplerData();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* JetFieldSamplerData::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* JetFieldSamplerData::getParameterDefinitionTree(void) const
+{
+	JetFieldSamplerData* tmpParam = const_cast<JetFieldSamplerData*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType JetFieldSamplerData::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType JetFieldSamplerData::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void JetFieldSamplerData::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<JetFieldSamplerData::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void JetFieldSamplerData::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void JetFieldSamplerData::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the asset properties for this jet field sampler", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="Name"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("Name", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Jet FS Name", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="JetFieldSampler"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("JetFieldSampler", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Jet FS properties", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "JetFSAssetParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void JetFieldSamplerData::initStrings(void)
+{
+	Name.isAllocated = false;
+	Name.buf = (const char*)"defaultJetFieldSampler";
+}
+
+void JetFieldSamplerData::initDynamicArrays(void)
+{
+}
+
+void JetFieldSamplerData::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void JetFieldSamplerData::initReferences(void)
+{
+	JetFieldSampler = NULL;
+
+}
+
+void JetFieldSamplerData::freeDynamicArrays(void)
+{
+}
+
+void JetFieldSamplerData::freeStrings(void)
+{
+
+	if (Name.isAllocated && Name.buf)
+	{
+		mParameterizedTraits->strfree((char*)Name.buf);
+	}
+}
+
+void JetFieldSamplerData::freeReferences(void)
+{
+	if (JetFieldSampler)
+	{
+		JetFieldSampler->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/JetFieldSamplerEffect.cpp b/APEX_1.4/module/particles/src/autogen/JetFieldSamplerEffect.cpp
new file mode 100644
index 00000000..4353b16b
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/JetFieldSamplerEffect.cpp
@@ -0,0 +1,1362 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "JetFieldSamplerEffect.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace JetFieldSamplerEffectNS;
+
+const char* const JetFieldSamplerEffectFactory::vptr =
+    NvParameterized::getVptr<JetFieldSamplerEffect, JetFieldSamplerEffect::ClassAlignment>();
+
+const uint32_t NumParamDefs = 32;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 31, 2, 3, 4, 8, 12, 13, 14, 15, 16, 17, 5, 6, 7, 9, 10, 11, 18, 19, 20, 21, 23,
+	27, 22, 24, 25, 26, 28, 29, 30,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->EffectProperties), CHILDREN(2), 10 }, // EffectProperties
+	{ TYPE_STRING, false, (size_t)(&((EffectProperties_Type*)0)->UserString), NULL, 0 }, // EffectProperties.UserString
+	{ TYPE_BOOL, false, (size_t)(&((EffectProperties_Type*)0)->Enable), NULL, 0 }, // EffectProperties.Enable
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Position), CHILDREN(12), 3 }, // EffectProperties.Position
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateX), NULL, 0 }, // EffectProperties.Position.TranslateX
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateY), NULL, 0 }, // EffectProperties.Position.TranslateY
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateZ), NULL, 0 }, // EffectProperties.Position.TranslateZ
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Orientation), CHILDREN(15), 3 }, // EffectProperties.Orientation
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateX), NULL, 0 }, // EffectProperties.Orientation.RotateX
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateY), NULL, 0 }, // EffectProperties.Orientation.RotateY
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateZ), NULL, 0 }, // EffectProperties.Orientation.RotateZ
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->InitialDelayTime), NULL, 0 }, // EffectProperties.InitialDelayTime
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->Duration), NULL, 0 }, // EffectProperties.Duration
+	{ TYPE_U32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatCount), NULL, 0 }, // EffectProperties.RepeatCount
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatDelay), NULL, 0 }, // EffectProperties.RepeatDelay
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RandomizeRepeatTime), NULL, 0 }, // EffectProperties.RandomizeRepeatTime
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Path), CHILDREN(18), 6 }, // EffectProperties.Path
+	{ TYPE_ENUM, false, (size_t)(&((EffectPath_Type*)0)->PlaybackMode), NULL, 0 }, // EffectProperties.Path.PlaybackMode
+	{ TYPE_F32, false, (size_t)(&((EffectPath_Type*)0)->PathDuration), NULL, 0 }, // EffectProperties.Path.PathDuration
+	{ TYPE_U32, false, (size_t)(&((EffectPath_Type*)0)->LoopIndex), NULL, 0 }, // EffectProperties.Path.LoopIndex
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->ControlPoints), CHILDREN(24), 1 }, // EffectProperties.Path.ControlPoints
+	{ TYPE_TRANSFORM, false, 1 * sizeof(physx::PxTransform), NULL, 0 }, // EffectProperties.Path.ControlPoints[]
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Scale), CHILDREN(25), 1 }, // EffectProperties.Path.Scale
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(26), 2 }, // EffectProperties.Path.Scale[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Scale[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Scale[].y
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Speed), CHILDREN(28), 1 }, // EffectProperties.Path.Speed
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(29), 2 }, // EffectProperties.Path.Speed[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Speed[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Speed[].y
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->JetFieldSampler), NULL, 0 }, // JetFieldSampler
+};
+
+
+bool JetFieldSamplerEffect::mBuiltFlag = false;
+NvParameterized::MutexType JetFieldSamplerEffect::mBuiltFlagMutex;
+
+JetFieldSamplerEffect::JetFieldSamplerEffect(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &JetFieldSamplerEffectFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+JetFieldSamplerEffect::~JetFieldSamplerEffect()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void JetFieldSamplerEffect::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~JetFieldSamplerEffect();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* JetFieldSamplerEffect::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* JetFieldSamplerEffect::getParameterDefinitionTree(void) const
+{
+	JetFieldSamplerEffect* tmpParam = const_cast<JetFieldSamplerEffect*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType JetFieldSamplerEffect::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType JetFieldSamplerEffect::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void JetFieldSamplerEffect::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<JetFieldSamplerEffect::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void JetFieldSamplerEffect::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void JetFieldSamplerEffect::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "A jet field sampler effect", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="EffectProperties"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("EffectProperties", TYPE_STRUCT, "EffectProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Jet FS Properties", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="EffectProperties.UserString"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("UserString", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An aribtrary user string that can be set by an artist/designer/programmer", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="EffectProperties.Enable"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("Enable", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Whether or not this effect is to be initially enabled on startup", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("Position", TYPE_STRUCT, "TranslateObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The position of this effect relative to the parent", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="EffectProperties.Position.TranslateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("TranslateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="EffectProperties.Position.TranslateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("TranslateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="EffectProperties.Position.TranslateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("TranslateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("Orientation", TYPE_STRUCT, "OrientObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The orientation of this effect, relative to the parent orientation", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="EffectProperties.Orientation.RotateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("RotateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the X axis (0-360 degrees)", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="EffectProperties.Orientation.RotateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("RotateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Y axis (0-360 degrees)", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=11, longName="EffectProperties.Orientation.RotateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11];
+		ParamDef->init("RotateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Z axis (0-360 degrees)", true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=12, longName="EffectProperties.InitialDelayTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12];
+		ParamDef->init("InitialDelayTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "Initial time to delay before spawning this effect", true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=13, longName="EffectProperties.Duration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13];
+		ParamDef->init("Duration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The duration of the effect in secontds", true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=14, longName="EffectProperties.RepeatCount"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14];
+		ParamDef->init("RepeatCount", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(1), true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The number of times to repeat the effect; 9999 means repeate forever", true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=15, longName="EffectProperties.RepeatDelay"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15];
+		ParamDef->init("RepeatDelay", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The time to delay activation each time the effect repeats in seconds; this can be different than the initial delay time", true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=16, longName="EffectProperties.RandomizeRepeatTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16];
+		ParamDef->init("RandomizeRepeatTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Amount of randomization to the repeat cycle; a value of zero (default) means no random and a value of one means completely random.", true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17];
+		ParamDef->init("Path", TYPE_STRUCT, "EffectPath", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An optional pre-defined path for this effect to travel on", true);
+		ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=18, longName="EffectProperties.Path.PlaybackMode"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18];
+		ParamDef->init("PlaybackMode", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The mode to play back the path", true);
+		ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "LOOP", "PLAY_ONCE", "PING_PONG" };
+		ParamDefTable[18].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=19, longName="EffectProperties.Path.PathDuration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19];
+		ParamDef->init("PathDuration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		HintTable[2].init("shortDescription", "The duration of the path if one is not otherwise provided", true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=20, longName="EffectProperties.Path.LoopIndex"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20];
+		ParamDef->init("LoopIndex", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "The array index to loop back to", true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21];
+		ParamDef->init("ControlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=22, longName="EffectProperties.Path.ControlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22];
+		ParamDef->init("ControlPoints", TYPE_TRANSFORM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23];
+		ParamDef->init("Scale", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24];
+		ParamDef->init("Scale", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=25, longName="EffectProperties.Path.Scale[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=26, longName="EffectProperties.Path.Scale[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27];
+		ParamDef->init("Speed", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28];
+		ParamDef->init("Speed", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=29, longName="EffectProperties.Path.Speed[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=30, longName="EffectProperties.Path.Speed[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=31, longName="JetFieldSampler"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31];
+		ParamDef->init("JetFieldSampler", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Jet FS Asset", true);
+		ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "JetFSAsset" };
+		ParamDefTable[31].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(31);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="EffectProperties"
+	{
+		static Definition* Children[10];
+		Children[0] = PDEF_PTR(2);
+		Children[1] = PDEF_PTR(3);
+		Children[2] = PDEF_PTR(4);
+		Children[3] = PDEF_PTR(8);
+		Children[4] = PDEF_PTR(12);
+		Children[5] = PDEF_PTR(13);
+		Children[6] = PDEF_PTR(14);
+		Children[7] = PDEF_PTR(15);
+		Children[8] = PDEF_PTR(16);
+		Children[9] = PDEF_PTR(17);
+
+		ParamDefTable[1].setChildren(Children, 10);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(5);
+		Children[1] = PDEF_PTR(6);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[4].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(9);
+		Children[1] = PDEF_PTR(10);
+		Children[2] = PDEF_PTR(11);
+
+		ParamDefTable[8].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		static Definition* Children[6];
+		Children[0] = PDEF_PTR(18);
+		Children[1] = PDEF_PTR(19);
+		Children[2] = PDEF_PTR(20);
+		Children[3] = PDEF_PTR(21);
+		Children[4] = PDEF_PTR(23);
+		Children[5] = PDEF_PTR(27);
+
+		ParamDefTable[17].setChildren(Children, 6);
+	}
+
+	// SetChildren for: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(22);
+
+		ParamDefTable[21].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(24);
+
+		ParamDefTable[23].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(25);
+		Children[1] = PDEF_PTR(26);
+
+		ParamDefTable[24].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(28);
+
+		ParamDefTable[27].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(29);
+		Children[1] = PDEF_PTR(30);
+
+		ParamDefTable[28].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void JetFieldSamplerEffect::initStrings(void)
+{
+	EffectProperties.UserString.isAllocated = true;
+	EffectProperties.UserString.buf = NULL;
+}
+
+void JetFieldSamplerEffect::initDynamicArrays(void)
+{
+	EffectProperties.Path.ControlPoints.buf = NULL;
+	EffectProperties.Path.ControlPoints.isAllocated = true;
+	EffectProperties.Path.ControlPoints.elementSize = sizeof(physx::PxTransform);
+	EffectProperties.Path.ControlPoints.arraySizes[0] = 0;
+	EffectProperties.Path.Scale.buf = NULL;
+	EffectProperties.Path.Scale.isAllocated = true;
+	EffectProperties.Path.Scale.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Scale.arraySizes[0] = 0;
+	EffectProperties.Path.Speed.buf = NULL;
+	EffectProperties.Path.Speed.isAllocated = true;
+	EffectProperties.Path.Speed.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Speed.arraySizes[0] = 0;
+}
+
+void JetFieldSamplerEffect::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	EffectProperties.Enable = bool(1);
+	EffectProperties.Position.TranslateX = float(0.000000000);
+	EffectProperties.Position.TranslateY = float(0.000000000);
+	EffectProperties.Position.TranslateZ = float(0.000000000);
+	EffectProperties.Orientation.RotateX = float(0.000000000);
+	EffectProperties.Orientation.RotateY = float(0.000000000);
+	EffectProperties.Orientation.RotateZ = float(0.000000000);
+	EffectProperties.InitialDelayTime = float(0.000000000);
+	EffectProperties.Duration = float(0.000000000);
+	EffectProperties.RepeatCount = uint32_t(1);
+	EffectProperties.RepeatDelay = float(0.000000000);
+	EffectProperties.RandomizeRepeatTime = float(0.000000000);
+	EffectProperties.Path.PlaybackMode = (const char*)"LOOP";
+	EffectProperties.Path.PathDuration = float(4.000000000);
+	EffectProperties.Path.LoopIndex = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void JetFieldSamplerEffect::initReferences(void)
+{
+	JetFieldSampler = NULL;
+
+}
+
+void JetFieldSamplerEffect::freeDynamicArrays(void)
+{
+	if (EffectProperties.Path.ControlPoints.isAllocated && EffectProperties.Path.ControlPoints.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.ControlPoints.buf);
+	}
+	if (EffectProperties.Path.Scale.isAllocated && EffectProperties.Path.Scale.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Scale.buf);
+	}
+	if (EffectProperties.Path.Speed.isAllocated && EffectProperties.Path.Speed.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Speed.buf);
+	}
+}
+
+void JetFieldSamplerEffect::freeStrings(void)
+{
+
+	if (EffectProperties.UserString.isAllocated && EffectProperties.UserString.buf)
+	{
+		mParameterizedTraits->strfree((char*)EffectProperties.UserString.buf);
+	}
+}
+
+void JetFieldSamplerEffect::freeReferences(void)
+{
+	if (JetFieldSampler)
+	{
+		JetFieldSampler->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/NoiseFieldSamplerData.cpp b/APEX_1.4/module/particles/src/autogen/NoiseFieldSamplerData.cpp
new file mode 100644
index 00000000..ca78ce4a
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/NoiseFieldSamplerData.cpp
@@ -0,0 +1,363 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "NoiseFieldSamplerData.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace NoiseFieldSamplerDataNS;
+
+const char* const NoiseFieldSamplerDataFactory::vptr =
+    NvParameterized::getVptr<NoiseFieldSamplerData, NoiseFieldSamplerData::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->Name), NULL, 0 }, // Name
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->NoiseFieldSampler), NULL, 0 }, // NoiseFieldSampler
+};
+
+
+bool NoiseFieldSamplerData::mBuiltFlag = false;
+NvParameterized::MutexType NoiseFieldSamplerData::mBuiltFlagMutex;
+
+NoiseFieldSamplerData::NoiseFieldSamplerData(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &NoiseFieldSamplerDataFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+NoiseFieldSamplerData::~NoiseFieldSamplerData()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void NoiseFieldSamplerData::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~NoiseFieldSamplerData();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* NoiseFieldSamplerData::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* NoiseFieldSamplerData::getParameterDefinitionTree(void) const
+{
+	NoiseFieldSamplerData* tmpParam = const_cast<NoiseFieldSamplerData*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType NoiseFieldSamplerData::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType NoiseFieldSamplerData::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void NoiseFieldSamplerData::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<NoiseFieldSamplerData::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void NoiseFieldSamplerData::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void NoiseFieldSamplerData::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the asset properties for this noise field sampler", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="Name"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("Name", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Noise FS Name", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="NoiseFieldSampler"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("NoiseFieldSampler", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Noise FS properties", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "NoiseFSAssetParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void NoiseFieldSamplerData::initStrings(void)
+{
+	Name.isAllocated = false;
+	Name.buf = (const char*)"defaultNoiseFieldSampler";
+}
+
+void NoiseFieldSamplerData::initDynamicArrays(void)
+{
+}
+
+void NoiseFieldSamplerData::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void NoiseFieldSamplerData::initReferences(void)
+{
+	NoiseFieldSampler = NULL;
+
+}
+
+void NoiseFieldSamplerData::freeDynamicArrays(void)
+{
+}
+
+void NoiseFieldSamplerData::freeStrings(void)
+{
+
+	if (Name.isAllocated && Name.buf)
+	{
+		mParameterizedTraits->strfree((char*)Name.buf);
+	}
+}
+
+void NoiseFieldSamplerData::freeReferences(void)
+{
+	if (NoiseFieldSampler)
+	{
+		NoiseFieldSampler->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/NoiseFieldSamplerEffect.cpp b/APEX_1.4/module/particles/src/autogen/NoiseFieldSamplerEffect.cpp
new file mode 100644
index 00000000..99a0cf62
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/NoiseFieldSamplerEffect.cpp
@@ -0,0 +1,1362 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "NoiseFieldSamplerEffect.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace NoiseFieldSamplerEffectNS;
+
+const char* const NoiseFieldSamplerEffectFactory::vptr =
+    NvParameterized::getVptr<NoiseFieldSamplerEffect, NoiseFieldSamplerEffect::ClassAlignment>();
+
+const uint32_t NumParamDefs = 32;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 31, 2, 3, 4, 8, 12, 13, 14, 15, 16, 17, 5, 6, 7, 9, 10, 11, 18, 19, 20, 21, 23,
+	27, 22, 24, 25, 26, 28, 29, 30,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->EffectProperties), CHILDREN(2), 10 }, // EffectProperties
+	{ TYPE_STRING, false, (size_t)(&((EffectProperties_Type*)0)->UserString), NULL, 0 }, // EffectProperties.UserString
+	{ TYPE_BOOL, false, (size_t)(&((EffectProperties_Type*)0)->Enable), NULL, 0 }, // EffectProperties.Enable
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Position), CHILDREN(12), 3 }, // EffectProperties.Position
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateX), NULL, 0 }, // EffectProperties.Position.TranslateX
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateY), NULL, 0 }, // EffectProperties.Position.TranslateY
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateZ), NULL, 0 }, // EffectProperties.Position.TranslateZ
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Orientation), CHILDREN(15), 3 }, // EffectProperties.Orientation
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateX), NULL, 0 }, // EffectProperties.Orientation.RotateX
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateY), NULL, 0 }, // EffectProperties.Orientation.RotateY
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateZ), NULL, 0 }, // EffectProperties.Orientation.RotateZ
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->InitialDelayTime), NULL, 0 }, // EffectProperties.InitialDelayTime
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->Duration), NULL, 0 }, // EffectProperties.Duration
+	{ TYPE_U32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatCount), NULL, 0 }, // EffectProperties.RepeatCount
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatDelay), NULL, 0 }, // EffectProperties.RepeatDelay
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RandomizeRepeatTime), NULL, 0 }, // EffectProperties.RandomizeRepeatTime
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Path), CHILDREN(18), 6 }, // EffectProperties.Path
+	{ TYPE_ENUM, false, (size_t)(&((EffectPath_Type*)0)->PlaybackMode), NULL, 0 }, // EffectProperties.Path.PlaybackMode
+	{ TYPE_F32, false, (size_t)(&((EffectPath_Type*)0)->PathDuration), NULL, 0 }, // EffectProperties.Path.PathDuration
+	{ TYPE_U32, false, (size_t)(&((EffectPath_Type*)0)->LoopIndex), NULL, 0 }, // EffectProperties.Path.LoopIndex
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->ControlPoints), CHILDREN(24), 1 }, // EffectProperties.Path.ControlPoints
+	{ TYPE_TRANSFORM, false, 1 * sizeof(physx::PxTransform), NULL, 0 }, // EffectProperties.Path.ControlPoints[]
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Scale), CHILDREN(25), 1 }, // EffectProperties.Path.Scale
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(26), 2 }, // EffectProperties.Path.Scale[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Scale[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Scale[].y
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Speed), CHILDREN(28), 1 }, // EffectProperties.Path.Speed
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(29), 2 }, // EffectProperties.Path.Speed[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Speed[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Speed[].y
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->NoiseFieldSampler), NULL, 0 }, // NoiseFieldSampler
+};
+
+
+bool NoiseFieldSamplerEffect::mBuiltFlag = false;
+NvParameterized::MutexType NoiseFieldSamplerEffect::mBuiltFlagMutex;
+
+NoiseFieldSamplerEffect::NoiseFieldSamplerEffect(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &NoiseFieldSamplerEffectFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+NoiseFieldSamplerEffect::~NoiseFieldSamplerEffect()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void NoiseFieldSamplerEffect::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~NoiseFieldSamplerEffect();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* NoiseFieldSamplerEffect::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* NoiseFieldSamplerEffect::getParameterDefinitionTree(void) const
+{
+	NoiseFieldSamplerEffect* tmpParam = const_cast<NoiseFieldSamplerEffect*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType NoiseFieldSamplerEffect::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType NoiseFieldSamplerEffect::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void NoiseFieldSamplerEffect::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<NoiseFieldSamplerEffect::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void NoiseFieldSamplerEffect::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void NoiseFieldSamplerEffect::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "A noise field sampler effect", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="EffectProperties"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("EffectProperties", TYPE_STRUCT, "EffectProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Noise FS Properties", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="EffectProperties.UserString"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("UserString", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An aribtrary user string that can be set by an artist/designer/programmer", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="EffectProperties.Enable"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("Enable", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Whether or not this effect is to be initially enabled on startup", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("Position", TYPE_STRUCT, "TranslateObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The position of this effect relative to the parent", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="EffectProperties.Position.TranslateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("TranslateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="EffectProperties.Position.TranslateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("TranslateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="EffectProperties.Position.TranslateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("TranslateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("Orientation", TYPE_STRUCT, "OrientObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The orientation of this effect, relative to the parent orientation", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="EffectProperties.Orientation.RotateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("RotateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the X axis (0-360 degrees)", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="EffectProperties.Orientation.RotateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("RotateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Y axis (0-360 degrees)", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=11, longName="EffectProperties.Orientation.RotateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11];
+		ParamDef->init("RotateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Z axis (0-360 degrees)", true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=12, longName="EffectProperties.InitialDelayTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12];
+		ParamDef->init("InitialDelayTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "Initial time to delay before spawning this effect", true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=13, longName="EffectProperties.Duration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13];
+		ParamDef->init("Duration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The duration of the effect in secontds", true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=14, longName="EffectProperties.RepeatCount"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14];
+		ParamDef->init("RepeatCount", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(1), true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The number of times to repeat the effect; 9999 means repeate forever", true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=15, longName="EffectProperties.RepeatDelay"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15];
+		ParamDef->init("RepeatDelay", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The time to delay activation each time the effect repeats in seconds; this can be different than the initial delay time", true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=16, longName="EffectProperties.RandomizeRepeatTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16];
+		ParamDef->init("RandomizeRepeatTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Amount of randomization to the repeat cycle; a value of zero (default) means no random and a value of one means completely random.", true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17];
+		ParamDef->init("Path", TYPE_STRUCT, "EffectPath", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An optional pre-defined path for this effect to travel on", true);
+		ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=18, longName="EffectProperties.Path.PlaybackMode"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18];
+		ParamDef->init("PlaybackMode", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The mode to play back the path", true);
+		ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "LOOP", "PLAY_ONCE", "PING_PONG" };
+		ParamDefTable[18].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=19, longName="EffectProperties.Path.PathDuration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19];
+		ParamDef->init("PathDuration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		HintTable[2].init("shortDescription", "The duration of the path if one is not otherwise provided", true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=20, longName="EffectProperties.Path.LoopIndex"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20];
+		ParamDef->init("LoopIndex", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "The array index to loop back to", true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21];
+		ParamDef->init("ControlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=22, longName="EffectProperties.Path.ControlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22];
+		ParamDef->init("ControlPoints", TYPE_TRANSFORM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23];
+		ParamDef->init("Scale", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24];
+		ParamDef->init("Scale", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=25, longName="EffectProperties.Path.Scale[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=26, longName="EffectProperties.Path.Scale[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27];
+		ParamDef->init("Speed", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28];
+		ParamDef->init("Speed", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=29, longName="EffectProperties.Path.Speed[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=30, longName="EffectProperties.Path.Speed[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=31, longName="NoiseFieldSampler"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31];
+		ParamDef->init("NoiseFieldSampler", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Noise FS Asset", true);
+		ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "NoiseFSAsset" };
+		ParamDefTable[31].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(31);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="EffectProperties"
+	{
+		static Definition* Children[10];
+		Children[0] = PDEF_PTR(2);
+		Children[1] = PDEF_PTR(3);
+		Children[2] = PDEF_PTR(4);
+		Children[3] = PDEF_PTR(8);
+		Children[4] = PDEF_PTR(12);
+		Children[5] = PDEF_PTR(13);
+		Children[6] = PDEF_PTR(14);
+		Children[7] = PDEF_PTR(15);
+		Children[8] = PDEF_PTR(16);
+		Children[9] = PDEF_PTR(17);
+
+		ParamDefTable[1].setChildren(Children, 10);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(5);
+		Children[1] = PDEF_PTR(6);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[4].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(9);
+		Children[1] = PDEF_PTR(10);
+		Children[2] = PDEF_PTR(11);
+
+		ParamDefTable[8].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		static Definition* Children[6];
+		Children[0] = PDEF_PTR(18);
+		Children[1] = PDEF_PTR(19);
+		Children[2] = PDEF_PTR(20);
+		Children[3] = PDEF_PTR(21);
+		Children[4] = PDEF_PTR(23);
+		Children[5] = PDEF_PTR(27);
+
+		ParamDefTable[17].setChildren(Children, 6);
+	}
+
+	// SetChildren for: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(22);
+
+		ParamDefTable[21].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(24);
+
+		ParamDefTable[23].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(25);
+		Children[1] = PDEF_PTR(26);
+
+		ParamDefTable[24].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(28);
+
+		ParamDefTable[27].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(29);
+		Children[1] = PDEF_PTR(30);
+
+		ParamDefTable[28].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void NoiseFieldSamplerEffect::initStrings(void)
+{
+	EffectProperties.UserString.isAllocated = true;
+	EffectProperties.UserString.buf = NULL;
+}
+
+void NoiseFieldSamplerEffect::initDynamicArrays(void)
+{
+	EffectProperties.Path.ControlPoints.buf = NULL;
+	EffectProperties.Path.ControlPoints.isAllocated = true;
+	EffectProperties.Path.ControlPoints.elementSize = sizeof(physx::PxTransform);
+	EffectProperties.Path.ControlPoints.arraySizes[0] = 0;
+	EffectProperties.Path.Scale.buf = NULL;
+	EffectProperties.Path.Scale.isAllocated = true;
+	EffectProperties.Path.Scale.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Scale.arraySizes[0] = 0;
+	EffectProperties.Path.Speed.buf = NULL;
+	EffectProperties.Path.Speed.isAllocated = true;
+	EffectProperties.Path.Speed.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Speed.arraySizes[0] = 0;
+}
+
+void NoiseFieldSamplerEffect::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	EffectProperties.Enable = bool(1);
+	EffectProperties.Position.TranslateX = float(0.000000000);
+	EffectProperties.Position.TranslateY = float(0.000000000);
+	EffectProperties.Position.TranslateZ = float(0.000000000);
+	EffectProperties.Orientation.RotateX = float(0.000000000);
+	EffectProperties.Orientation.RotateY = float(0.000000000);
+	EffectProperties.Orientation.RotateZ = float(0.000000000);
+	EffectProperties.InitialDelayTime = float(0.000000000);
+	EffectProperties.Duration = float(0.000000000);
+	EffectProperties.RepeatCount = uint32_t(1);
+	EffectProperties.RepeatDelay = float(0.000000000);
+	EffectProperties.RandomizeRepeatTime = float(0.000000000);
+	EffectProperties.Path.PlaybackMode = (const char*)"LOOP";
+	EffectProperties.Path.PathDuration = float(4.000000000);
+	EffectProperties.Path.LoopIndex = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void NoiseFieldSamplerEffect::initReferences(void)
+{
+	NoiseFieldSampler = NULL;
+
+}
+
+void NoiseFieldSamplerEffect::freeDynamicArrays(void)
+{
+	if (EffectProperties.Path.ControlPoints.isAllocated && EffectProperties.Path.ControlPoints.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.ControlPoints.buf);
+	}
+	if (EffectProperties.Path.Scale.isAllocated && EffectProperties.Path.Scale.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Scale.buf);
+	}
+	if (EffectProperties.Path.Speed.isAllocated && EffectProperties.Path.Speed.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Speed.buf);
+	}
+}
+
+void NoiseFieldSamplerEffect::freeStrings(void)
+{
+
+	if (EffectProperties.UserString.isAllocated && EffectProperties.UserString.buf)
+	{
+		mParameterizedTraits->strfree((char*)EffectProperties.UserString.buf);
+	}
+}
+
+void NoiseFieldSamplerEffect::freeReferences(void)
+{
+	if (NoiseFieldSampler)
+	{
+		NoiseFieldSampler->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/ParticleSimulationData.cpp b/APEX_1.4/module/particles/src/autogen/ParticleSimulationData.cpp
new file mode 100644
index 00000000..456f9503
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/ParticleSimulationData.cpp
@@ -0,0 +1,363 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ParticleSimulationData.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace ParticleSimulationDataNS;
+
+const char* const ParticleSimulationDataFactory::vptr =
+    NvParameterized::getVptr<ParticleSimulationData, ParticleSimulationData::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->Name), NULL, 0 }, // Name
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->IOS), NULL, 0 }, // IOS
+};
+
+
+bool ParticleSimulationData::mBuiltFlag = false;
+NvParameterized::MutexType ParticleSimulationData::mBuiltFlagMutex;
+
+ParticleSimulationData::ParticleSimulationData(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ParticleSimulationDataFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ParticleSimulationData::~ParticleSimulationData()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ParticleSimulationData::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ParticleSimulationData();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ParticleSimulationData::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ParticleSimulationData::getParameterDefinitionTree(void) const
+{
+	ParticleSimulationData* tmpParam = const_cast<ParticleSimulationData*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ParticleSimulationData::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ParticleSimulationData::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ParticleSimulationData::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ParticleSimulationData::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ParticleSimulationData::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ParticleSimulationData::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the asset properties for this particle simulation (IOS)", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="Name"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("Name", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Basic IOS Name", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="IOS"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("IOS", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Basic IOS properties", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "BasicIOSAssetParam", "ParticleIosAssetParam" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 2);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ParticleSimulationData::initStrings(void)
+{
+	Name.isAllocated = false;
+	Name.buf = (const char*)"defaultBasicIOS";
+}
+
+void ParticleSimulationData::initDynamicArrays(void)
+{
+}
+
+void ParticleSimulationData::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ParticleSimulationData::initReferences(void)
+{
+	IOS = NULL;
+
+}
+
+void ParticleSimulationData::freeDynamicArrays(void)
+{
+}
+
+void ParticleSimulationData::freeStrings(void)
+{
+
+	if (Name.isAllocated && Name.buf)
+	{
+		mParameterizedTraits->strfree((char*)Name.buf);
+	}
+}
+
+void ParticleSimulationData::freeReferences(void)
+{
+	if (IOS)
+	{
+		IOS->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/ParticlesDebugRenderParams.cpp b/APEX_1.4/module/particles/src/autogen/ParticlesDebugRenderParams.cpp
new file mode 100644
index 00000000..f052ee11
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/ParticlesDebugRenderParams.cpp
@@ -0,0 +1,333 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ParticlesDebugRenderParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace ParticlesDebugRenderParamsNS;
+
+const char* const ParticlesDebugRenderParamsFactory::vptr =
+    NvParameterized::getVptr<ParticlesDebugRenderParams, ParticlesDebugRenderParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->VISUALIZE_HEAT_SOURCE_ACTOR), NULL, 0 }, // VISUALIZE_HEAT_SOURCE_ACTOR
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->VISUALIZE_EFFECT_PACKAGE_ACTOR), NULL, 0 }, // VISUALIZE_EFFECT_PACKAGE_ACTOR
+};
+
+
+bool ParticlesDebugRenderParams::mBuiltFlag = false;
+NvParameterized::MutexType ParticlesDebugRenderParams::mBuiltFlagMutex;
+
+ParticlesDebugRenderParams::ParticlesDebugRenderParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ParticlesDebugRenderParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ParticlesDebugRenderParams::~ParticlesDebugRenderParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ParticlesDebugRenderParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ParticlesDebugRenderParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ParticlesDebugRenderParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ParticlesDebugRenderParams::getParameterDefinitionTree(void) const
+{
+	ParticlesDebugRenderParams* tmpParam = const_cast<ParticlesDebugRenderParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ParticlesDebugRenderParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ParticlesDebugRenderParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ParticlesDebugRenderParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ParticlesDebugRenderParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ParticlesDebugRenderParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ParticlesDebugRenderParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="VISUALIZE_HEAT_SOURCE_ACTOR"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("VISUALIZE_HEAT_SOURCE_ACTOR", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "This option allows user to enable or disable debug visualization of a heat source actor", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="VISUALIZE_EFFECT_PACKAGE_ACTOR"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("VISUALIZE_EFFECT_PACKAGE_ACTOR", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "This option allows user to enable or disable debug visualization of an effect package actor", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ParticlesDebugRenderParams::initStrings(void)
+{
+}
+
+void ParticlesDebugRenderParams::initDynamicArrays(void)
+{
+}
+
+void ParticlesDebugRenderParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	VISUALIZE_HEAT_SOURCE_ACTOR = bool(false);
+	VISUALIZE_EFFECT_PACKAGE_ACTOR = bool(false);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ParticlesDebugRenderParams::initReferences(void)
+{
+}
+
+void ParticlesDebugRenderParams::freeDynamicArrays(void)
+{
+}
+
+void ParticlesDebugRenderParams::freeStrings(void)
+{
+}
+
+void ParticlesDebugRenderParams::freeReferences(void)
+{
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/ParticlesModuleParameters.cpp b/APEX_1.4/module/particles/src/autogen/ParticlesModuleParameters.cpp
new file mode 100644
index 00000000..382ede54
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/ParticlesModuleParameters.cpp
@@ -0,0 +1,318 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ParticlesModuleParameters.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace ParticlesModuleParametersNS;
+
+const char* const ParticlesModuleParametersFactory::vptr =
+    NvParameterized::getVptr<ParticlesModuleParameters, ParticlesModuleParameters::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->unused), NULL, 0 }, // unused
+};
+
+
+bool ParticlesModuleParameters::mBuiltFlag = false;
+NvParameterized::MutexType ParticlesModuleParameters::mBuiltFlagMutex;
+
+ParticlesModuleParameters::ParticlesModuleParameters(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ParticlesModuleParametersFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ParticlesModuleParameters::~ParticlesModuleParameters()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ParticlesModuleParameters::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ParticlesModuleParameters();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ParticlesModuleParameters::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ParticlesModuleParameters::getParameterDefinitionTree(void) const
+{
+	ParticlesModuleParameters* tmpParam = const_cast<ParticlesModuleParameters*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ParticlesModuleParameters::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ParticlesModuleParameters::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ParticlesModuleParameters::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ParticlesModuleParameters::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ParticlesModuleParameters::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ParticlesModuleParameters::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "This class is used for initializing the ModuleParticles.", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="unused"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("unused", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "No parameters necessary", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ParticlesModuleParameters::initStrings(void)
+{
+}
+
+void ParticlesModuleParameters::initDynamicArrays(void)
+{
+}
+
+void ParticlesModuleParameters::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	unused = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ParticlesModuleParameters::initReferences(void)
+{
+}
+
+void ParticlesModuleParameters::freeDynamicArrays(void)
+{
+}
+
+void ParticlesModuleParameters::freeStrings(void)
+{
+}
+
+void ParticlesModuleParameters::freeReferences(void)
+{
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/RigidBodyEffect.cpp b/APEX_1.4/module/particles/src/autogen/RigidBodyEffect.cpp
new file mode 100644
index 00000000..0f6a1a42
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/RigidBodyEffect.cpp
@@ -0,0 +1,1587 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "RigidBodyEffect.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace RigidBodyEffectNS;
+
+const char* const RigidBodyEffectFactory::vptr =
+    NvParameterized::getVptr<RigidBodyEffect, RigidBodyEffect::ClassAlignment>();
+
+const uint32_t NumParamDefs = 41;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 2, 3, 4, 8, 12, 13, 14, 15, 16, 17, 5,
+	6, 7, 9, 10, 11, 18, 19, 20, 21, 23, 27, 22, 24, 25, 26, 28, 29, 30,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 11 },
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->EffectProperties), CHILDREN(11), 10 }, // EffectProperties
+	{ TYPE_STRING, false, (size_t)(&((EffectProperties_Type*)0)->UserString), NULL, 0 }, // EffectProperties.UserString
+	{ TYPE_BOOL, false, (size_t)(&((EffectProperties_Type*)0)->Enable), NULL, 0 }, // EffectProperties.Enable
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Position), CHILDREN(21), 3 }, // EffectProperties.Position
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateX), NULL, 0 }, // EffectProperties.Position.TranslateX
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateY), NULL, 0 }, // EffectProperties.Position.TranslateY
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateZ), NULL, 0 }, // EffectProperties.Position.TranslateZ
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Orientation), CHILDREN(24), 3 }, // EffectProperties.Orientation
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateX), NULL, 0 }, // EffectProperties.Orientation.RotateX
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateY), NULL, 0 }, // EffectProperties.Orientation.RotateY
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateZ), NULL, 0 }, // EffectProperties.Orientation.RotateZ
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->InitialDelayTime), NULL, 0 }, // EffectProperties.InitialDelayTime
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->Duration), NULL, 0 }, // EffectProperties.Duration
+	{ TYPE_U32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatCount), NULL, 0 }, // EffectProperties.RepeatCount
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatDelay), NULL, 0 }, // EffectProperties.RepeatDelay
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RandomizeRepeatTime), NULL, 0 }, // EffectProperties.RandomizeRepeatTime
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Path), CHILDREN(27), 6 }, // EffectProperties.Path
+	{ TYPE_ENUM, false, (size_t)(&((EffectPath_Type*)0)->PlaybackMode), NULL, 0 }, // EffectProperties.Path.PlaybackMode
+	{ TYPE_F32, false, (size_t)(&((EffectPath_Type*)0)->PathDuration), NULL, 0 }, // EffectProperties.Path.PathDuration
+	{ TYPE_U32, false, (size_t)(&((EffectPath_Type*)0)->LoopIndex), NULL, 0 }, // EffectProperties.Path.LoopIndex
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->ControlPoints), CHILDREN(33), 1 }, // EffectProperties.Path.ControlPoints
+	{ TYPE_TRANSFORM, false, 1 * sizeof(physx::PxTransform), NULL, 0 }, // EffectProperties.Path.ControlPoints[]
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Scale), CHILDREN(34), 1 }, // EffectProperties.Path.Scale
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(35), 2 }, // EffectProperties.Path.Scale[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Scale[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Scale[].y
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Speed), CHILDREN(37), 1 }, // EffectProperties.Path.Speed
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(38), 2 }, // EffectProperties.Path.Speed[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Speed[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Speed[].y
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->Type), NULL, 0 }, // Type
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->CollisionFilterDataName), NULL, 0 }, // CollisionFilterDataName
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->Dynamic), NULL, 0 }, // Dynamic
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->Gravity), NULL, 0 }, // Gravity
+	{ TYPE_VEC3, false, (size_t)(&((ParametersStruct*)0)->Extents), NULL, 0 }, // Extents
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->Mass), NULL, 0 }, // Mass
+	{ TYPE_VEC3, false, (size_t)(&((ParametersStruct*)0)->InitialLinearVelocity), NULL, 0 }, // InitialLinearVelocity
+	{ TYPE_VEC3, false, (size_t)(&((ParametersStruct*)0)->InitialAngularVelocity), NULL, 0 }, // InitialAngularVelocity
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->LinearDamping), NULL, 0 }, // LinearDamping
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->AngularDamping), NULL, 0 }, // AngularDamping
+};
+
+
+bool RigidBodyEffect::mBuiltFlag = false;
+NvParameterized::MutexType RigidBodyEffect::mBuiltFlagMutex;
+
+RigidBodyEffect::RigidBodyEffect(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &RigidBodyEffectFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+RigidBodyEffect::~RigidBodyEffect()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void RigidBodyEffect::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~RigidBodyEffect();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* RigidBodyEffect::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* RigidBodyEffect::getParameterDefinitionTree(void) const
+{
+	RigidBodyEffect* tmpParam = const_cast<RigidBodyEffect*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType RigidBodyEffect::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType RigidBodyEffect::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void RigidBodyEffect::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<RigidBodyEffect::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void RigidBodyEffect::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void RigidBodyEffect::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An effect comprised of a primitive rigid body shape", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="EffectProperties"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("EffectProperties", TYPE_STRUCT, "EffectProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Rigid Body Properties", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="EffectProperties.UserString"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("UserString", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An aribtrary user string that can be set by an artist/designer/programmer", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="EffectProperties.Enable"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("Enable", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Whether or not this effect is to be initially enabled on startup", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("Position", TYPE_STRUCT, "TranslateObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The position of this effect relative to the parent", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="EffectProperties.Position.TranslateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("TranslateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="EffectProperties.Position.TranslateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("TranslateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="EffectProperties.Position.TranslateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("TranslateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("Orientation", TYPE_STRUCT, "OrientObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The orientation of this effect, relative to the parent orientation", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="EffectProperties.Orientation.RotateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("RotateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the X axis (0-360 degrees)", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="EffectProperties.Orientation.RotateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("RotateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Y axis (0-360 degrees)", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=11, longName="EffectProperties.Orientation.RotateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11];
+		ParamDef->init("RotateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Z axis (0-360 degrees)", true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=12, longName="EffectProperties.InitialDelayTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12];
+		ParamDef->init("InitialDelayTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "Initial time to delay before spawning this effect", true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=13, longName="EffectProperties.Duration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13];
+		ParamDef->init("Duration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The duration of the effect in secontds", true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=14, longName="EffectProperties.RepeatCount"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14];
+		ParamDef->init("RepeatCount", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(1), true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The number of times to repeat the effect; 9999 means repeate forever", true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=15, longName="EffectProperties.RepeatDelay"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15];
+		ParamDef->init("RepeatDelay", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The time to delay activation each time the effect repeats in seconds; this can be different than the initial delay time", true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=16, longName="EffectProperties.RandomizeRepeatTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16];
+		ParamDef->init("RandomizeRepeatTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Amount of randomization to the repeat cycle; a value of zero (default) means no random and a value of one means completely random.", true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17];
+		ParamDef->init("Path", TYPE_STRUCT, "EffectPath", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An optional pre-defined path for this effect to travel on", true);
+		ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=18, longName="EffectProperties.Path.PlaybackMode"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18];
+		ParamDef->init("PlaybackMode", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The mode to play back the path", true);
+		ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "LOOP", "PLAY_ONCE", "PING_PONG" };
+		ParamDefTable[18].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=19, longName="EffectProperties.Path.PathDuration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19];
+		ParamDef->init("PathDuration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		HintTable[2].init("shortDescription", "The duration of the path if one is not otherwise provided", true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=20, longName="EffectProperties.Path.LoopIndex"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20];
+		ParamDef->init("LoopIndex", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "The array index to loop back to", true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21];
+		ParamDef->init("ControlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=22, longName="EffectProperties.Path.ControlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22];
+		ParamDef->init("ControlPoints", TYPE_TRANSFORM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23];
+		ParamDef->init("Scale", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24];
+		ParamDef->init("Scale", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=25, longName="EffectProperties.Path.Scale[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=26, longName="EffectProperties.Path.Scale[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27];
+		ParamDef->init("Speed", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28];
+		ParamDef->init("Speed", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=29, longName="EffectProperties.Path.Speed[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=30, longName="EffectProperties.Path.Speed[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=31, longName="Type"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31];
+		ParamDef->init("Type", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "What type of rigid body primitive this is", true);
+		ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "SPHERE", "CAPSULE", "BOX" };
+		ParamDefTable[31].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=32, longName="CollisionFilterDataName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[32];
+		ParamDef->init("CollisionFilterDataName", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The collision filter data name", true);
+		ParamDefTable[32].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=33, longName="Dynamic"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[33];
+		ParamDef->init("Dynamic", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Whether the rigid body is dynamic or kinematic", true);
+		ParamDefTable[33].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=34, longName="Gravity"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[34];
+		ParamDef->init("Gravity", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "A flag to determine if the object responds to gravity or not", true);
+		ParamDefTable[34].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=35, longName="Extents"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[35];
+		ParamDef->init("Extents", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The extents of the primitve, radius, height, or box dimensions XYZ", true);
+		ParamDefTable[35].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=36, longName="Mass"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[36];
+		ParamDef->init("Mass", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The mass of the object", true);
+		ParamDefTable[36].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=37, longName="InitialLinearVelocity"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[37];
+		ParamDef->init("InitialLinearVelocity", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The initial linear velocity (if dynamic)", true);
+		ParamDefTable[37].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=38, longName="InitialAngularVelocity"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[38];
+		ParamDef->init("InitialAngularVelocity", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The initial angular velocity (if dynamic)", true);
+		ParamDefTable[38].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=39, longName="LinearDamping"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[39];
+		ParamDef->init("LinearDamping", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The linear damping on the rigid body", true);
+		ParamDefTable[39].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=40, longName="AngularDamping"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[40];
+		ParamDef->init("AngularDamping", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The angular damping on the rigid body", true);
+		ParamDefTable[40].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[11];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(31);
+		Children[2] = PDEF_PTR(32);
+		Children[3] = PDEF_PTR(33);
+		Children[4] = PDEF_PTR(34);
+		Children[5] = PDEF_PTR(35);
+		Children[6] = PDEF_PTR(36);
+		Children[7] = PDEF_PTR(37);
+		Children[8] = PDEF_PTR(38);
+		Children[9] = PDEF_PTR(39);
+		Children[10] = PDEF_PTR(40);
+
+		ParamDefTable[0].setChildren(Children, 11);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="EffectProperties"
+	{
+		static Definition* Children[10];
+		Children[0] = PDEF_PTR(2);
+		Children[1] = PDEF_PTR(3);
+		Children[2] = PDEF_PTR(4);
+		Children[3] = PDEF_PTR(8);
+		Children[4] = PDEF_PTR(12);
+		Children[5] = PDEF_PTR(13);
+		Children[6] = PDEF_PTR(14);
+		Children[7] = PDEF_PTR(15);
+		Children[8] = PDEF_PTR(16);
+		Children[9] = PDEF_PTR(17);
+
+		ParamDefTable[1].setChildren(Children, 10);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(5);
+		Children[1] = PDEF_PTR(6);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[4].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(9);
+		Children[1] = PDEF_PTR(10);
+		Children[2] = PDEF_PTR(11);
+
+		ParamDefTable[8].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		static Definition* Children[6];
+		Children[0] = PDEF_PTR(18);
+		Children[1] = PDEF_PTR(19);
+		Children[2] = PDEF_PTR(20);
+		Children[3] = PDEF_PTR(21);
+		Children[4] = PDEF_PTR(23);
+		Children[5] = PDEF_PTR(27);
+
+		ParamDefTable[17].setChildren(Children, 6);
+	}
+
+	// SetChildren for: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(22);
+
+		ParamDefTable[21].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(24);
+
+		ParamDefTable[23].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(25);
+		Children[1] = PDEF_PTR(26);
+
+		ParamDefTable[24].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(28);
+
+		ParamDefTable[27].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(29);
+		Children[1] = PDEF_PTR(30);
+
+		ParamDefTable[28].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void RigidBodyEffect::initStrings(void)
+{
+	EffectProperties.UserString.isAllocated = true;
+	EffectProperties.UserString.buf = NULL;
+	CollisionFilterDataName.isAllocated = false;
+	CollisionFilterDataName.buf = (const char*)"rigidbody=all";
+}
+
+void RigidBodyEffect::initDynamicArrays(void)
+{
+	EffectProperties.Path.ControlPoints.buf = NULL;
+	EffectProperties.Path.ControlPoints.isAllocated = true;
+	EffectProperties.Path.ControlPoints.elementSize = sizeof(physx::PxTransform);
+	EffectProperties.Path.ControlPoints.arraySizes[0] = 0;
+	EffectProperties.Path.Scale.buf = NULL;
+	EffectProperties.Path.Scale.isAllocated = true;
+	EffectProperties.Path.Scale.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Scale.arraySizes[0] = 0;
+	EffectProperties.Path.Speed.buf = NULL;
+	EffectProperties.Path.Speed.isAllocated = true;
+	EffectProperties.Path.Speed.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Speed.arraySizes[0] = 0;
+}
+
+void RigidBodyEffect::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	EffectProperties.Enable = bool(1);
+	EffectProperties.Position.TranslateX = float(0.000000000);
+	EffectProperties.Position.TranslateY = float(0.000000000);
+	EffectProperties.Position.TranslateZ = float(0.000000000);
+	EffectProperties.Orientation.RotateX = float(0.000000000);
+	EffectProperties.Orientation.RotateY = float(0.000000000);
+	EffectProperties.Orientation.RotateZ = float(0.000000000);
+	EffectProperties.InitialDelayTime = float(0.000000000);
+	EffectProperties.Duration = float(0.000000000);
+	EffectProperties.RepeatCount = uint32_t(1);
+	EffectProperties.RepeatDelay = float(0.000000000);
+	EffectProperties.RandomizeRepeatTime = float(0.000000000);
+	EffectProperties.Path.PlaybackMode = (const char*)"LOOP";
+	EffectProperties.Path.PathDuration = float(4.000000000);
+	EffectProperties.Path.LoopIndex = uint32_t(0);
+	Type = (const char*)"SPHERE";
+	Dynamic = bool(0);
+	Gravity = bool(1);
+	Extents = physx::PxVec3(init(1.000000000,1.000000000,1.000000000));
+	Mass = float(1.000000000);
+	InitialLinearVelocity = physx::PxVec3(init(0.000000000,0.000000000,0.000000000));
+	InitialAngularVelocity = physx::PxVec3(init(0.000000000,0.000000000,0.000000000));
+	LinearDamping = float(0.000000000);
+	AngularDamping = float(0.000000000);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void RigidBodyEffect::initReferences(void)
+{
+}
+
+void RigidBodyEffect::freeDynamicArrays(void)
+{
+	if (EffectProperties.Path.ControlPoints.isAllocated && EffectProperties.Path.ControlPoints.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.ControlPoints.buf);
+	}
+	if (EffectProperties.Path.Scale.isAllocated && EffectProperties.Path.Scale.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Scale.buf);
+	}
+	if (EffectProperties.Path.Speed.isAllocated && EffectProperties.Path.Speed.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Speed.buf);
+	}
+}
+
+void RigidBodyEffect::freeStrings(void)
+{
+
+	if (EffectProperties.UserString.isAllocated && EffectProperties.UserString.buf)
+	{
+		mParameterizedTraits->strfree((char*)EffectProperties.UserString.buf);
+	}
+
+	if (CollisionFilterDataName.isAllocated && CollisionFilterDataName.buf)
+	{
+		mParameterizedTraits->strfree((char*)CollisionFilterDataName.buf);
+	}
+}
+
+void RigidBodyEffect::freeReferences(void)
+{
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/SubstanceSourceData.cpp b/APEX_1.4/module/particles/src/autogen/SubstanceSourceData.cpp
new file mode 100644
index 00000000..2bdbef5f
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/SubstanceSourceData.cpp
@@ -0,0 +1,363 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "SubstanceSourceData.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace SubstanceSourceDataNS;
+
+const char* const SubstanceSourceDataFactory::vptr =
+    NvParameterized::getVptr<SubstanceSourceData, SubstanceSourceData::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->Name), NULL, 0 }, // Name
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->SubstanceSource), NULL, 0 }, // SubstanceSource
+};
+
+
+bool SubstanceSourceData::mBuiltFlag = false;
+NvParameterized::MutexType SubstanceSourceData::mBuiltFlagMutex;
+
+SubstanceSourceData::SubstanceSourceData(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &SubstanceSourceDataFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+SubstanceSourceData::~SubstanceSourceData()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void SubstanceSourceData::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~SubstanceSourceData();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* SubstanceSourceData::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* SubstanceSourceData::getParameterDefinitionTree(void) const
+{
+	SubstanceSourceData* tmpParam = const_cast<SubstanceSourceData*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType SubstanceSourceData::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType SubstanceSourceData::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void SubstanceSourceData::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<SubstanceSourceData::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void SubstanceSourceData::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void SubstanceSourceData::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the asset properties for this substance source", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="Name"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("Name", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Substance Source Name", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="SubstanceSource"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("SubstanceSource", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Substance Source properties", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "SubstanceSourceAssetParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void SubstanceSourceData::initStrings(void)
+{
+	Name.isAllocated = false;
+	Name.buf = (const char*)"defaultSubstanceSource";
+}
+
+void SubstanceSourceData::initDynamicArrays(void)
+{
+}
+
+void SubstanceSourceData::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void SubstanceSourceData::initReferences(void)
+{
+	SubstanceSource = NULL;
+
+}
+
+void SubstanceSourceData::freeDynamicArrays(void)
+{
+}
+
+void SubstanceSourceData::freeStrings(void)
+{
+
+	if (Name.isAllocated && Name.buf)
+	{
+		mParameterizedTraits->strfree((char*)Name.buf);
+	}
+}
+
+void SubstanceSourceData::freeReferences(void)
+{
+	if (SubstanceSource)
+	{
+		SubstanceSource->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/SubstanceSourceEffect.cpp b/APEX_1.4/module/particles/src/autogen/SubstanceSourceEffect.cpp
new file mode 100644
index 00000000..58007910
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/SubstanceSourceEffect.cpp
@@ -0,0 +1,1356 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "SubstanceSourceEffect.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace SubstanceSourceEffectNS;
+
+const char* const SubstanceSourceEffectFactory::vptr =
+    NvParameterized::getVptr<SubstanceSourceEffect, SubstanceSourceEffect::ClassAlignment>();
+
+const uint32_t NumParamDefs = 32;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 31, 2, 3, 4, 8, 12, 13, 14, 15, 16, 17, 5, 6, 7, 9, 10, 11, 18, 19, 20, 21, 23,
+	27, 22, 24, 25, 26, 28, 29, 30,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->EffectProperties), CHILDREN(2), 10 }, // EffectProperties
+	{ TYPE_STRING, false, (size_t)(&((EffectProperties_Type*)0)->UserString), NULL, 0 }, // EffectProperties.UserString
+	{ TYPE_BOOL, false, (size_t)(&((EffectProperties_Type*)0)->Enable), NULL, 0 }, // EffectProperties.Enable
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Position), CHILDREN(12), 3 }, // EffectProperties.Position
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateX), NULL, 0 }, // EffectProperties.Position.TranslateX
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateY), NULL, 0 }, // EffectProperties.Position.TranslateY
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateZ), NULL, 0 }, // EffectProperties.Position.TranslateZ
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Orientation), CHILDREN(15), 3 }, // EffectProperties.Orientation
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateX), NULL, 0 }, // EffectProperties.Orientation.RotateX
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateY), NULL, 0 }, // EffectProperties.Orientation.RotateY
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateZ), NULL, 0 }, // EffectProperties.Orientation.RotateZ
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->InitialDelayTime), NULL, 0 }, // EffectProperties.InitialDelayTime
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->Duration), NULL, 0 }, // EffectProperties.Duration
+	{ TYPE_U32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatCount), NULL, 0 }, // EffectProperties.RepeatCount
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatDelay), NULL, 0 }, // EffectProperties.RepeatDelay
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RandomizeRepeatTime), NULL, 0 }, // EffectProperties.RandomizeRepeatTime
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Path), CHILDREN(18), 6 }, // EffectProperties.Path
+	{ TYPE_ENUM, false, (size_t)(&((EffectPath_Type*)0)->PlaybackMode), NULL, 0 }, // EffectProperties.Path.PlaybackMode
+	{ TYPE_F32, false, (size_t)(&((EffectPath_Type*)0)->PathDuration), NULL, 0 }, // EffectProperties.Path.PathDuration
+	{ TYPE_U32, false, (size_t)(&((EffectPath_Type*)0)->LoopIndex), NULL, 0 }, // EffectProperties.Path.LoopIndex
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->ControlPoints), CHILDREN(24), 1 }, // EffectProperties.Path.ControlPoints
+	{ TYPE_TRANSFORM, false, 1 * sizeof(physx::PxTransform), NULL, 0 }, // EffectProperties.Path.ControlPoints[]
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Scale), CHILDREN(25), 1 }, // EffectProperties.Path.Scale
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(26), 2 }, // EffectProperties.Path.Scale[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Scale[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Scale[].y
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Speed), CHILDREN(28), 1 }, // EffectProperties.Path.Speed
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(29), 2 }, // EffectProperties.Path.Speed[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Speed[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Speed[].y
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->SubstanceSource), NULL, 0 }, // SubstanceSource
+};
+
+
+bool SubstanceSourceEffect::mBuiltFlag = false;
+NvParameterized::MutexType SubstanceSourceEffect::mBuiltFlagMutex;
+
+SubstanceSourceEffect::SubstanceSourceEffect(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &SubstanceSourceEffectFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+SubstanceSourceEffect::~SubstanceSourceEffect()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void SubstanceSourceEffect::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~SubstanceSourceEffect();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* SubstanceSourceEffect::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* SubstanceSourceEffect::getParameterDefinitionTree(void) const
+{
+	SubstanceSourceEffect* tmpParam = const_cast<SubstanceSourceEffect*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType SubstanceSourceEffect::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType SubstanceSourceEffect::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void SubstanceSourceEffect::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<SubstanceSourceEffect::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void SubstanceSourceEffect::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void SubstanceSourceEffect::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "A substance source effect", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="EffectProperties"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("EffectProperties", TYPE_STRUCT, "EffectProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Substance Source Properties", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="EffectProperties.UserString"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("UserString", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An aribtrary user string that can be set by an artist/designer/programmer", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="EffectProperties.Enable"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("Enable", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Whether or not this effect is to be initially enabled on startup", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("Position", TYPE_STRUCT, "TranslateObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The position of this effect relative to the parent", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="EffectProperties.Position.TranslateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("TranslateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="EffectProperties.Position.TranslateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("TranslateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="EffectProperties.Position.TranslateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("TranslateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("Orientation", TYPE_STRUCT, "OrientObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The orientation of this effect, relative to the parent orientation", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="EffectProperties.Orientation.RotateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("RotateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the X axis (0-360 degrees)", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="EffectProperties.Orientation.RotateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("RotateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Y axis (0-360 degrees)", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=11, longName="EffectProperties.Orientation.RotateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11];
+		ParamDef->init("RotateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Z axis (0-360 degrees)", true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=12, longName="EffectProperties.InitialDelayTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12];
+		ParamDef->init("InitialDelayTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "Initial time to delay before spawning this effect", true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=13, longName="EffectProperties.Duration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13];
+		ParamDef->init("Duration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The duration of the effect in secontds", true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=14, longName="EffectProperties.RepeatCount"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14];
+		ParamDef->init("RepeatCount", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(1), true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The number of times to repeat the effect; 9999 means repeate forever", true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=15, longName="EffectProperties.RepeatDelay"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15];
+		ParamDef->init("RepeatDelay", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The time to delay activation each time the effect repeats in seconds; this can be different than the initial delay time", true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=16, longName="EffectProperties.RandomizeRepeatTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16];
+		ParamDef->init("RandomizeRepeatTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Amount of randomization to the repeat cycle; a value of zero (default) means no random and a value of one means completely random.", true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17];
+		ParamDef->init("Path", TYPE_STRUCT, "EffectPath", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An optional pre-defined path for this effect to travel on", true);
+		ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=18, longName="EffectProperties.Path.PlaybackMode"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18];
+		ParamDef->init("PlaybackMode", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The mode to play back the path", true);
+		ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "LOOP", "PLAY_ONCE", "PING_PONG" };
+		ParamDefTable[18].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=19, longName="EffectProperties.Path.PathDuration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19];
+		ParamDef->init("PathDuration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		HintTable[2].init("shortDescription", "The duration of the path if one is not otherwise provided", true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=20, longName="EffectProperties.Path.LoopIndex"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20];
+		ParamDef->init("LoopIndex", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "The array index to loop back to", true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21];
+		ParamDef->init("ControlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=22, longName="EffectProperties.Path.ControlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22];
+		ParamDef->init("ControlPoints", TYPE_TRANSFORM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23];
+		ParamDef->init("Scale", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24];
+		ParamDef->init("Scale", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=25, longName="EffectProperties.Path.Scale[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=26, longName="EffectProperties.Path.Scale[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27];
+		ParamDef->init("Speed", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28];
+		ParamDef->init("Speed", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=29, longName="EffectProperties.Path.Speed[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=30, longName="EffectProperties.Path.Speed[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=31, longName="SubstanceSource"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31];
+		ParamDef->init("SubstanceSource", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Substance Source Asset", true);
+		ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "SubstanceSourceAsset" };
+		ParamDefTable[31].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(31);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="EffectProperties"
+	{
+		static Definition* Children[10];
+		Children[0] = PDEF_PTR(2);
+		Children[1] = PDEF_PTR(3);
+		Children[2] = PDEF_PTR(4);
+		Children[3] = PDEF_PTR(8);
+		Children[4] = PDEF_PTR(12);
+		Children[5] = PDEF_PTR(13);
+		Children[6] = PDEF_PTR(14);
+		Children[7] = PDEF_PTR(15);
+		Children[8] = PDEF_PTR(16);
+		Children[9] = PDEF_PTR(17);
+
+		ParamDefTable[1].setChildren(Children, 10);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(5);
+		Children[1] = PDEF_PTR(6);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[4].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(9);
+		Children[1] = PDEF_PTR(10);
+		Children[2] = PDEF_PTR(11);
+
+		ParamDefTable[8].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		static Definition* Children[6];
+		Children[0] = PDEF_PTR(18);
+		Children[1] = PDEF_PTR(19);
+		Children[2] = PDEF_PTR(20);
+		Children[3] = PDEF_PTR(21);
+		Children[4] = PDEF_PTR(23);
+		Children[5] = PDEF_PTR(27);
+
+		ParamDefTable[17].setChildren(Children, 6);
+	}
+
+	// SetChildren for: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(22);
+
+		ParamDefTable[21].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(24);
+
+		ParamDefTable[23].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(25);
+		Children[1] = PDEF_PTR(26);
+
+		ParamDefTable[24].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(28);
+
+		ParamDefTable[27].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(29);
+		Children[1] = PDEF_PTR(30);
+
+		ParamDefTable[28].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void SubstanceSourceEffect::initStrings(void)
+{
+	EffectProperties.UserString.isAllocated = true;
+	EffectProperties.UserString.buf = NULL;
+}
+
+void SubstanceSourceEffect::initDynamicArrays(void)
+{
+	EffectProperties.Path.ControlPoints.buf = NULL;
+	EffectProperties.Path.ControlPoints.isAllocated = true;
+	EffectProperties.Path.ControlPoints.elementSize = sizeof(physx::PxTransform);
+	EffectProperties.Path.ControlPoints.arraySizes[0] = 0;
+	EffectProperties.Path.Scale.buf = NULL;
+	EffectProperties.Path.Scale.isAllocated = true;
+	EffectProperties.Path.Scale.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Scale.arraySizes[0] = 0;
+	EffectProperties.Path.Speed.buf = NULL;
+	EffectProperties.Path.Speed.isAllocated = true;
+	EffectProperties.Path.Speed.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Speed.arraySizes[0] = 0;
+}
+
+void SubstanceSourceEffect::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	EffectProperties.Enable = bool(1);
+	EffectProperties.Position.TranslateX = float(0.000000000);
+	EffectProperties.Position.TranslateY = float(0.000000000);
+	EffectProperties.Position.TranslateZ = float(0.000000000);
+	EffectProperties.Orientation.RotateX = float(0.000000000);
+	EffectProperties.Orientation.RotateY = float(0.000000000);
+	EffectProperties.Orientation.RotateZ = float(0.000000000);
+	EffectProperties.InitialDelayTime = float(0.000000000);
+	EffectProperties.Duration = float(0.000000000);
+	EffectProperties.RepeatCount = uint32_t(1);
+	EffectProperties.RepeatDelay = float(0.000000000);
+	EffectProperties.RandomizeRepeatTime = float(0.000000000);
+	EffectProperties.Path.PlaybackMode = (const char*)"LOOP";
+	EffectProperties.Path.PathDuration = float(4.000000000);
+	EffectProperties.Path.LoopIndex = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void SubstanceSourceEffect::initReferences(void)
+{
+	SubstanceSource = NULL;
+
+}
+
+void SubstanceSourceEffect::freeDynamicArrays(void)
+{
+	if (EffectProperties.Path.ControlPoints.isAllocated && EffectProperties.Path.ControlPoints.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.ControlPoints.buf);
+	}
+	if (EffectProperties.Path.Scale.isAllocated && EffectProperties.Path.Scale.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Scale.buf);
+	}
+	if (EffectProperties.Path.Speed.isAllocated && EffectProperties.Path.Speed.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Speed.buf);
+	}
+}
+
+void SubstanceSourceEffect::freeStrings(void)
+{
+
+	if (EffectProperties.UserString.isAllocated && EffectProperties.UserString.buf)
+	{
+		mParameterizedTraits->strfree((char*)EffectProperties.UserString.buf);
+	}
+}
+
+void SubstanceSourceEffect::freeReferences(void)
+{
+	if (SubstanceSource)
+	{
+		SubstanceSource->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/TurbulenceFieldSamplerData.cpp b/APEX_1.4/module/particles/src/autogen/TurbulenceFieldSamplerData.cpp
new file mode 100644
index 00000000..4816cf54
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/TurbulenceFieldSamplerData.cpp
@@ -0,0 +1,363 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "TurbulenceFieldSamplerData.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace TurbulenceFieldSamplerDataNS;
+
+const char* const TurbulenceFieldSamplerDataFactory::vptr =
+    NvParameterized::getVptr<TurbulenceFieldSamplerData, TurbulenceFieldSamplerData::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->Name), NULL, 0 }, // Name
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->TurbulenceFieldSampler), NULL, 0 }, // TurbulenceFieldSampler
+};
+
+
+bool TurbulenceFieldSamplerData::mBuiltFlag = false;
+NvParameterized::MutexType TurbulenceFieldSamplerData::mBuiltFlagMutex;
+
+TurbulenceFieldSamplerData::TurbulenceFieldSamplerData(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &TurbulenceFieldSamplerDataFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+TurbulenceFieldSamplerData::~TurbulenceFieldSamplerData()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void TurbulenceFieldSamplerData::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~TurbulenceFieldSamplerData();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* TurbulenceFieldSamplerData::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* TurbulenceFieldSamplerData::getParameterDefinitionTree(void) const
+{
+	TurbulenceFieldSamplerData* tmpParam = const_cast<TurbulenceFieldSamplerData*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType TurbulenceFieldSamplerData::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType TurbulenceFieldSamplerData::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void TurbulenceFieldSamplerData::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<TurbulenceFieldSamplerData::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void TurbulenceFieldSamplerData::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void TurbulenceFieldSamplerData::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the asset properties for this turbulence field sampler", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="Name"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("Name", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Turbulence FS Name", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="TurbulenceFieldSampler"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("TurbulenceFieldSampler", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Turbulence FS properties", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "TurbulenceFSAssetParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void TurbulenceFieldSamplerData::initStrings(void)
+{
+	Name.isAllocated = false;
+	Name.buf = (const char*)"defaultTurbulenceFieldSampler";
+}
+
+void TurbulenceFieldSamplerData::initDynamicArrays(void)
+{
+}
+
+void TurbulenceFieldSamplerData::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void TurbulenceFieldSamplerData::initReferences(void)
+{
+	TurbulenceFieldSampler = NULL;
+
+}
+
+void TurbulenceFieldSamplerData::freeDynamicArrays(void)
+{
+}
+
+void TurbulenceFieldSamplerData::freeStrings(void)
+{
+
+	if (Name.isAllocated && Name.buf)
+	{
+		mParameterizedTraits->strfree((char*)Name.buf);
+	}
+}
+
+void TurbulenceFieldSamplerData::freeReferences(void)
+{
+	if (TurbulenceFieldSampler)
+	{
+		TurbulenceFieldSampler->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/TurbulenceFieldSamplerEffect.cpp b/APEX_1.4/module/particles/src/autogen/TurbulenceFieldSamplerEffect.cpp
new file mode 100644
index 00000000..e7744755
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/TurbulenceFieldSamplerEffect.cpp
@@ -0,0 +1,1362 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "TurbulenceFieldSamplerEffect.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace TurbulenceFieldSamplerEffectNS;
+
+const char* const TurbulenceFieldSamplerEffectFactory::vptr =
+    NvParameterized::getVptr<TurbulenceFieldSamplerEffect, TurbulenceFieldSamplerEffect::ClassAlignment>();
+
+const uint32_t NumParamDefs = 32;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 31, 2, 3, 4, 8, 12, 13, 14, 15, 16, 17, 5, 6, 7, 9, 10, 11, 18, 19, 20, 21, 23,
+	27, 22, 24, 25, 26, 28, 29, 30,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->EffectProperties), CHILDREN(2), 10 }, // EffectProperties
+	{ TYPE_STRING, false, (size_t)(&((EffectProperties_Type*)0)->UserString), NULL, 0 }, // EffectProperties.UserString
+	{ TYPE_BOOL, false, (size_t)(&((EffectProperties_Type*)0)->Enable), NULL, 0 }, // EffectProperties.Enable
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Position), CHILDREN(12), 3 }, // EffectProperties.Position
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateX), NULL, 0 }, // EffectProperties.Position.TranslateX
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateY), NULL, 0 }, // EffectProperties.Position.TranslateY
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateZ), NULL, 0 }, // EffectProperties.Position.TranslateZ
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Orientation), CHILDREN(15), 3 }, // EffectProperties.Orientation
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateX), NULL, 0 }, // EffectProperties.Orientation.RotateX
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateY), NULL, 0 }, // EffectProperties.Orientation.RotateY
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateZ), NULL, 0 }, // EffectProperties.Orientation.RotateZ
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->InitialDelayTime), NULL, 0 }, // EffectProperties.InitialDelayTime
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->Duration), NULL, 0 }, // EffectProperties.Duration
+	{ TYPE_U32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatCount), NULL, 0 }, // EffectProperties.RepeatCount
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatDelay), NULL, 0 }, // EffectProperties.RepeatDelay
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RandomizeRepeatTime), NULL, 0 }, // EffectProperties.RandomizeRepeatTime
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Path), CHILDREN(18), 6 }, // EffectProperties.Path
+	{ TYPE_ENUM, false, (size_t)(&((EffectPath_Type*)0)->PlaybackMode), NULL, 0 }, // EffectProperties.Path.PlaybackMode
+	{ TYPE_F32, false, (size_t)(&((EffectPath_Type*)0)->PathDuration), NULL, 0 }, // EffectProperties.Path.PathDuration
+	{ TYPE_U32, false, (size_t)(&((EffectPath_Type*)0)->LoopIndex), NULL, 0 }, // EffectProperties.Path.LoopIndex
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->ControlPoints), CHILDREN(24), 1 }, // EffectProperties.Path.ControlPoints
+	{ TYPE_TRANSFORM, false, 1 * sizeof(physx::PxTransform), NULL, 0 }, // EffectProperties.Path.ControlPoints[]
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Scale), CHILDREN(25), 1 }, // EffectProperties.Path.Scale
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(26), 2 }, // EffectProperties.Path.Scale[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Scale[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Scale[].y
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Speed), CHILDREN(28), 1 }, // EffectProperties.Path.Speed
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(29), 2 }, // EffectProperties.Path.Speed[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Speed[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Speed[].y
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->TurbulenceFieldSampler), NULL, 0 }, // TurbulenceFieldSampler
+};
+
+
+bool TurbulenceFieldSamplerEffect::mBuiltFlag = false;
+NvParameterized::MutexType TurbulenceFieldSamplerEffect::mBuiltFlagMutex;
+
+TurbulenceFieldSamplerEffect::TurbulenceFieldSamplerEffect(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &TurbulenceFieldSamplerEffectFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+TurbulenceFieldSamplerEffect::~TurbulenceFieldSamplerEffect()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void TurbulenceFieldSamplerEffect::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~TurbulenceFieldSamplerEffect();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* TurbulenceFieldSamplerEffect::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* TurbulenceFieldSamplerEffect::getParameterDefinitionTree(void) const
+{
+	TurbulenceFieldSamplerEffect* tmpParam = const_cast<TurbulenceFieldSamplerEffect*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType TurbulenceFieldSamplerEffect::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType TurbulenceFieldSamplerEffect::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void TurbulenceFieldSamplerEffect::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<TurbulenceFieldSamplerEffect::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void TurbulenceFieldSamplerEffect::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void TurbulenceFieldSamplerEffect::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "A turbulence effect", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="EffectProperties"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("EffectProperties", TYPE_STRUCT, "EffectProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Turbulence FS Properties", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="EffectProperties.UserString"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("UserString", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An aribtrary user string that can be set by an artist/designer/programmer", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="EffectProperties.Enable"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("Enable", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Whether or not this effect is to be initially enabled on startup", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("Position", TYPE_STRUCT, "TranslateObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The position of this effect relative to the parent", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="EffectProperties.Position.TranslateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("TranslateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="EffectProperties.Position.TranslateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("TranslateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="EffectProperties.Position.TranslateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("TranslateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("Orientation", TYPE_STRUCT, "OrientObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The orientation of this effect, relative to the parent orientation", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="EffectProperties.Orientation.RotateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("RotateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the X axis (0-360 degrees)", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="EffectProperties.Orientation.RotateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("RotateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Y axis (0-360 degrees)", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=11, longName="EffectProperties.Orientation.RotateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11];
+		ParamDef->init("RotateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Z axis (0-360 degrees)", true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=12, longName="EffectProperties.InitialDelayTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12];
+		ParamDef->init("InitialDelayTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "Initial time to delay before spawning this effect", true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=13, longName="EffectProperties.Duration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13];
+		ParamDef->init("Duration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The duration of the effect in secontds", true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=14, longName="EffectProperties.RepeatCount"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14];
+		ParamDef->init("RepeatCount", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(1), true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The number of times to repeat the effect; 9999 means repeate forever", true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=15, longName="EffectProperties.RepeatDelay"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15];
+		ParamDef->init("RepeatDelay", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The time to delay activation each time the effect repeats in seconds; this can be different than the initial delay time", true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=16, longName="EffectProperties.RandomizeRepeatTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16];
+		ParamDef->init("RandomizeRepeatTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Amount of randomization to the repeat cycle; a value of zero (default) means no random and a value of one means completely random.", true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17];
+		ParamDef->init("Path", TYPE_STRUCT, "EffectPath", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An optional pre-defined path for this effect to travel on", true);
+		ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=18, longName="EffectProperties.Path.PlaybackMode"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18];
+		ParamDef->init("PlaybackMode", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The mode to play back the path", true);
+		ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "LOOP", "PLAY_ONCE", "PING_PONG" };
+		ParamDefTable[18].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=19, longName="EffectProperties.Path.PathDuration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19];
+		ParamDef->init("PathDuration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		HintTable[2].init("shortDescription", "The duration of the path if one is not otherwise provided", true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=20, longName="EffectProperties.Path.LoopIndex"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20];
+		ParamDef->init("LoopIndex", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "The array index to loop back to", true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21];
+		ParamDef->init("ControlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=22, longName="EffectProperties.Path.ControlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22];
+		ParamDef->init("ControlPoints", TYPE_TRANSFORM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23];
+		ParamDef->init("Scale", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24];
+		ParamDef->init("Scale", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=25, longName="EffectProperties.Path.Scale[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=26, longName="EffectProperties.Path.Scale[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27];
+		ParamDef->init("Speed", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28];
+		ParamDef->init("Speed", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=29, longName="EffectProperties.Path.Speed[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=30, longName="EffectProperties.Path.Speed[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=31, longName="TurbulenceFieldSampler"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31];
+		ParamDef->init("TurbulenceFieldSampler", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Turbulence FS Asset", true);
+		ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "TurbulenceFSAsset" };
+		ParamDefTable[31].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(31);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="EffectProperties"
+	{
+		static Definition* Children[10];
+		Children[0] = PDEF_PTR(2);
+		Children[1] = PDEF_PTR(3);
+		Children[2] = PDEF_PTR(4);
+		Children[3] = PDEF_PTR(8);
+		Children[4] = PDEF_PTR(12);
+		Children[5] = PDEF_PTR(13);
+		Children[6] = PDEF_PTR(14);
+		Children[7] = PDEF_PTR(15);
+		Children[8] = PDEF_PTR(16);
+		Children[9] = PDEF_PTR(17);
+
+		ParamDefTable[1].setChildren(Children, 10);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(5);
+		Children[1] = PDEF_PTR(6);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[4].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(9);
+		Children[1] = PDEF_PTR(10);
+		Children[2] = PDEF_PTR(11);
+
+		ParamDefTable[8].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		static Definition* Children[6];
+		Children[0] = PDEF_PTR(18);
+		Children[1] = PDEF_PTR(19);
+		Children[2] = PDEF_PTR(20);
+		Children[3] = PDEF_PTR(21);
+		Children[4] = PDEF_PTR(23);
+		Children[5] = PDEF_PTR(27);
+
+		ParamDefTable[17].setChildren(Children, 6);
+	}
+
+	// SetChildren for: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(22);
+
+		ParamDefTable[21].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(24);
+
+		ParamDefTable[23].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(25);
+		Children[1] = PDEF_PTR(26);
+
+		ParamDefTable[24].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(28);
+
+		ParamDefTable[27].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(29);
+		Children[1] = PDEF_PTR(30);
+
+		ParamDefTable[28].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void TurbulenceFieldSamplerEffect::initStrings(void)
+{
+	EffectProperties.UserString.isAllocated = true;
+	EffectProperties.UserString.buf = NULL;
+}
+
+void TurbulenceFieldSamplerEffect::initDynamicArrays(void)
+{
+	EffectProperties.Path.ControlPoints.buf = NULL;
+	EffectProperties.Path.ControlPoints.isAllocated = true;
+	EffectProperties.Path.ControlPoints.elementSize = sizeof(physx::PxTransform);
+	EffectProperties.Path.ControlPoints.arraySizes[0] = 0;
+	EffectProperties.Path.Scale.buf = NULL;
+	EffectProperties.Path.Scale.isAllocated = true;
+	EffectProperties.Path.Scale.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Scale.arraySizes[0] = 0;
+	EffectProperties.Path.Speed.buf = NULL;
+	EffectProperties.Path.Speed.isAllocated = true;
+	EffectProperties.Path.Speed.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Speed.arraySizes[0] = 0;
+}
+
+void TurbulenceFieldSamplerEffect::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	EffectProperties.Enable = bool(1);
+	EffectProperties.Position.TranslateX = float(0.000000000);
+	EffectProperties.Position.TranslateY = float(0.000000000);
+	EffectProperties.Position.TranslateZ = float(0.000000000);
+	EffectProperties.Orientation.RotateX = float(0.000000000);
+	EffectProperties.Orientation.RotateY = float(0.000000000);
+	EffectProperties.Orientation.RotateZ = float(0.000000000);
+	EffectProperties.InitialDelayTime = float(0.000000000);
+	EffectProperties.Duration = float(0.000000000);
+	EffectProperties.RepeatCount = uint32_t(1);
+	EffectProperties.RepeatDelay = float(0.000000000);
+	EffectProperties.RandomizeRepeatTime = float(0.000000000);
+	EffectProperties.Path.PlaybackMode = (const char*)"LOOP";
+	EffectProperties.Path.PathDuration = float(4.000000000);
+	EffectProperties.Path.LoopIndex = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void TurbulenceFieldSamplerEffect::initReferences(void)
+{
+	TurbulenceFieldSampler = NULL;
+
+}
+
+void TurbulenceFieldSamplerEffect::freeDynamicArrays(void)
+{
+	if (EffectProperties.Path.ControlPoints.isAllocated && EffectProperties.Path.ControlPoints.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.ControlPoints.buf);
+	}
+	if (EffectProperties.Path.Scale.isAllocated && EffectProperties.Path.Scale.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Scale.buf);
+	}
+	if (EffectProperties.Path.Speed.isAllocated && EffectProperties.Path.Speed.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Speed.buf);
+	}
+}
+
+void TurbulenceFieldSamplerEffect::freeStrings(void)
+{
+
+	if (EffectProperties.UserString.isAllocated && EffectProperties.UserString.buf)
+	{
+		mParameterizedTraits->strfree((char*)EffectProperties.UserString.buf);
+	}
+}
+
+void TurbulenceFieldSamplerEffect::freeReferences(void)
+{
+	if (TurbulenceFieldSampler)
+	{
+		TurbulenceFieldSampler->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/VelocitySourceData.cpp b/APEX_1.4/module/particles/src/autogen/VelocitySourceData.cpp
new file mode 100644
index 00000000..32ceac93
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/VelocitySourceData.cpp
@@ -0,0 +1,363 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "VelocitySourceData.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace VelocitySourceDataNS;
+
+const char* const VelocitySourceDataFactory::vptr =
+    NvParameterized::getVptr<VelocitySourceData, VelocitySourceData::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->Name), NULL, 0 }, // Name
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->VelocitySource), NULL, 0 }, // VelocitySource
+};
+
+
+bool VelocitySourceData::mBuiltFlag = false;
+NvParameterized::MutexType VelocitySourceData::mBuiltFlagMutex;
+
+VelocitySourceData::VelocitySourceData(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &VelocitySourceDataFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+VelocitySourceData::~VelocitySourceData()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void VelocitySourceData::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~VelocitySourceData();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* VelocitySourceData::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* VelocitySourceData::getParameterDefinitionTree(void) const
+{
+	VelocitySourceData* tmpParam = const_cast<VelocitySourceData*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType VelocitySourceData::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType VelocitySourceData::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void VelocitySourceData::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<VelocitySourceData::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void VelocitySourceData::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void VelocitySourceData::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the asset properties for this velocity source", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="Name"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("Name", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Velocity Source Name", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="VelocitySource"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("VelocitySource", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Velocity Source properties", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "VelocitySourceAssetParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void VelocitySourceData::initStrings(void)
+{
+	Name.isAllocated = false;
+	Name.buf = (const char*)"defaultVelocitySource";
+}
+
+void VelocitySourceData::initDynamicArrays(void)
+{
+}
+
+void VelocitySourceData::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void VelocitySourceData::initReferences(void)
+{
+	VelocitySource = NULL;
+
+}
+
+void VelocitySourceData::freeDynamicArrays(void)
+{
+}
+
+void VelocitySourceData::freeStrings(void)
+{
+
+	if (Name.isAllocated && Name.buf)
+	{
+		mParameterizedTraits->strfree((char*)Name.buf);
+	}
+}
+
+void VelocitySourceData::freeReferences(void)
+{
+	if (VelocitySource)
+	{
+		VelocitySource->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/VelocitySourceEffect.cpp b/APEX_1.4/module/particles/src/autogen/VelocitySourceEffect.cpp
new file mode 100644
index 00000000..71af2d18
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/VelocitySourceEffect.cpp
@@ -0,0 +1,1356 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "VelocitySourceEffect.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace VelocitySourceEffectNS;
+
+const char* const VelocitySourceEffectFactory::vptr =
+    NvParameterized::getVptr<VelocitySourceEffect, VelocitySourceEffect::ClassAlignment>();
+
+const uint32_t NumParamDefs = 32;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 31, 2, 3, 4, 8, 12, 13, 14, 15, 16, 17, 5, 6, 7, 9, 10, 11, 18, 19, 20, 21, 23,
+	27, 22, 24, 25, 26, 28, 29, 30,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->EffectProperties), CHILDREN(2), 10 }, // EffectProperties
+	{ TYPE_STRING, false, (size_t)(&((EffectProperties_Type*)0)->UserString), NULL, 0 }, // EffectProperties.UserString
+	{ TYPE_BOOL, false, (size_t)(&((EffectProperties_Type*)0)->Enable), NULL, 0 }, // EffectProperties.Enable
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Position), CHILDREN(12), 3 }, // EffectProperties.Position
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateX), NULL, 0 }, // EffectProperties.Position.TranslateX
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateY), NULL, 0 }, // EffectProperties.Position.TranslateY
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateZ), NULL, 0 }, // EffectProperties.Position.TranslateZ
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Orientation), CHILDREN(15), 3 }, // EffectProperties.Orientation
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateX), NULL, 0 }, // EffectProperties.Orientation.RotateX
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateY), NULL, 0 }, // EffectProperties.Orientation.RotateY
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateZ), NULL, 0 }, // EffectProperties.Orientation.RotateZ
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->InitialDelayTime), NULL, 0 }, // EffectProperties.InitialDelayTime
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->Duration), NULL, 0 }, // EffectProperties.Duration
+	{ TYPE_U32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatCount), NULL, 0 }, // EffectProperties.RepeatCount
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatDelay), NULL, 0 }, // EffectProperties.RepeatDelay
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RandomizeRepeatTime), NULL, 0 }, // EffectProperties.RandomizeRepeatTime
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Path), CHILDREN(18), 6 }, // EffectProperties.Path
+	{ TYPE_ENUM, false, (size_t)(&((EffectPath_Type*)0)->PlaybackMode), NULL, 0 }, // EffectProperties.Path.PlaybackMode
+	{ TYPE_F32, false, (size_t)(&((EffectPath_Type*)0)->PathDuration), NULL, 0 }, // EffectProperties.Path.PathDuration
+	{ TYPE_U32, false, (size_t)(&((EffectPath_Type*)0)->LoopIndex), NULL, 0 }, // EffectProperties.Path.LoopIndex
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->ControlPoints), CHILDREN(24), 1 }, // EffectProperties.Path.ControlPoints
+	{ TYPE_TRANSFORM, false, 1 * sizeof(physx::PxTransform), NULL, 0 }, // EffectProperties.Path.ControlPoints[]
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Scale), CHILDREN(25), 1 }, // EffectProperties.Path.Scale
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(26), 2 }, // EffectProperties.Path.Scale[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Scale[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Scale[].y
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Speed), CHILDREN(28), 1 }, // EffectProperties.Path.Speed
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(29), 2 }, // EffectProperties.Path.Speed[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Speed[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Speed[].y
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->VelocitySource), NULL, 0 }, // VelocitySource
+};
+
+
+bool VelocitySourceEffect::mBuiltFlag = false;
+NvParameterized::MutexType VelocitySourceEffect::mBuiltFlagMutex;
+
+VelocitySourceEffect::VelocitySourceEffect(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &VelocitySourceEffectFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+VelocitySourceEffect::~VelocitySourceEffect()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void VelocitySourceEffect::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~VelocitySourceEffect();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* VelocitySourceEffect::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* VelocitySourceEffect::getParameterDefinitionTree(void) const
+{
+	VelocitySourceEffect* tmpParam = const_cast<VelocitySourceEffect*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType VelocitySourceEffect::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType VelocitySourceEffect::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void VelocitySourceEffect::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<VelocitySourceEffect::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void VelocitySourceEffect::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void VelocitySourceEffect::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "A velocity source effect", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="EffectProperties"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("EffectProperties", TYPE_STRUCT, "EffectProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Velocity Source Properties", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="EffectProperties.UserString"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("UserString", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An aribtrary user string that can be set by an artist/designer/programmer", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="EffectProperties.Enable"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("Enable", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Whether or not this effect is to be initially enabled on startup", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("Position", TYPE_STRUCT, "TranslateObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The position of this effect relative to the parent", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="EffectProperties.Position.TranslateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("TranslateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="EffectProperties.Position.TranslateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("TranslateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="EffectProperties.Position.TranslateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("TranslateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("Orientation", TYPE_STRUCT, "OrientObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The orientation of this effect, relative to the parent orientation", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="EffectProperties.Orientation.RotateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("RotateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the X axis (0-360 degrees)", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="EffectProperties.Orientation.RotateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("RotateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Y axis (0-360 degrees)", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=11, longName="EffectProperties.Orientation.RotateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11];
+		ParamDef->init("RotateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Z axis (0-360 degrees)", true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=12, longName="EffectProperties.InitialDelayTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12];
+		ParamDef->init("InitialDelayTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "Initial time to delay before spawning this effect", true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=13, longName="EffectProperties.Duration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13];
+		ParamDef->init("Duration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The duration of the effect in secontds", true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=14, longName="EffectProperties.RepeatCount"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14];
+		ParamDef->init("RepeatCount", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(1), true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The number of times to repeat the effect; 9999 means repeate forever", true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=15, longName="EffectProperties.RepeatDelay"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15];
+		ParamDef->init("RepeatDelay", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The time to delay activation each time the effect repeats in seconds; this can be different than the initial delay time", true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=16, longName="EffectProperties.RandomizeRepeatTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16];
+		ParamDef->init("RandomizeRepeatTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Amount of randomization to the repeat cycle; a value of zero (default) means no random and a value of one means completely random.", true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17];
+		ParamDef->init("Path", TYPE_STRUCT, "EffectPath", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An optional pre-defined path for this effect to travel on", true);
+		ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=18, longName="EffectProperties.Path.PlaybackMode"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18];
+		ParamDef->init("PlaybackMode", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The mode to play back the path", true);
+		ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "LOOP", "PLAY_ONCE", "PING_PONG" };
+		ParamDefTable[18].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=19, longName="EffectProperties.Path.PathDuration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19];
+		ParamDef->init("PathDuration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		HintTable[2].init("shortDescription", "The duration of the path if one is not otherwise provided", true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=20, longName="EffectProperties.Path.LoopIndex"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20];
+		ParamDef->init("LoopIndex", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "The array index to loop back to", true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21];
+		ParamDef->init("ControlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=22, longName="EffectProperties.Path.ControlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22];
+		ParamDef->init("ControlPoints", TYPE_TRANSFORM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23];
+		ParamDef->init("Scale", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24];
+		ParamDef->init("Scale", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=25, longName="EffectProperties.Path.Scale[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=26, longName="EffectProperties.Path.Scale[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27];
+		ParamDef->init("Speed", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28];
+		ParamDef->init("Speed", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=29, longName="EffectProperties.Path.Speed[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=30, longName="EffectProperties.Path.Speed[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=31, longName="VelocitySource"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31];
+		ParamDef->init("VelocitySource", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Velocity Source Asset", true);
+		ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "VelocitySourceAsset" };
+		ParamDefTable[31].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(31);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="EffectProperties"
+	{
+		static Definition* Children[10];
+		Children[0] = PDEF_PTR(2);
+		Children[1] = PDEF_PTR(3);
+		Children[2] = PDEF_PTR(4);
+		Children[3] = PDEF_PTR(8);
+		Children[4] = PDEF_PTR(12);
+		Children[5] = PDEF_PTR(13);
+		Children[6] = PDEF_PTR(14);
+		Children[7] = PDEF_PTR(15);
+		Children[8] = PDEF_PTR(16);
+		Children[9] = PDEF_PTR(17);
+
+		ParamDefTable[1].setChildren(Children, 10);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(5);
+		Children[1] = PDEF_PTR(6);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[4].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(9);
+		Children[1] = PDEF_PTR(10);
+		Children[2] = PDEF_PTR(11);
+
+		ParamDefTable[8].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		static Definition* Children[6];
+		Children[0] = PDEF_PTR(18);
+		Children[1] = PDEF_PTR(19);
+		Children[2] = PDEF_PTR(20);
+		Children[3] = PDEF_PTR(21);
+		Children[4] = PDEF_PTR(23);
+		Children[5] = PDEF_PTR(27);
+
+		ParamDefTable[17].setChildren(Children, 6);
+	}
+
+	// SetChildren for: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(22);
+
+		ParamDefTable[21].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(24);
+
+		ParamDefTable[23].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(25);
+		Children[1] = PDEF_PTR(26);
+
+		ParamDefTable[24].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(28);
+
+		ParamDefTable[27].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(29);
+		Children[1] = PDEF_PTR(30);
+
+		ParamDefTable[28].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void VelocitySourceEffect::initStrings(void)
+{
+	EffectProperties.UserString.isAllocated = true;
+	EffectProperties.UserString.buf = NULL;
+}
+
+void VelocitySourceEffect::initDynamicArrays(void)
+{
+	EffectProperties.Path.ControlPoints.buf = NULL;
+	EffectProperties.Path.ControlPoints.isAllocated = true;
+	EffectProperties.Path.ControlPoints.elementSize = sizeof(physx::PxTransform);
+	EffectProperties.Path.ControlPoints.arraySizes[0] = 0;
+	EffectProperties.Path.Scale.buf = NULL;
+	EffectProperties.Path.Scale.isAllocated = true;
+	EffectProperties.Path.Scale.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Scale.arraySizes[0] = 0;
+	EffectProperties.Path.Speed.buf = NULL;
+	EffectProperties.Path.Speed.isAllocated = true;
+	EffectProperties.Path.Speed.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Speed.arraySizes[0] = 0;
+}
+
+void VelocitySourceEffect::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	EffectProperties.Enable = bool(1);
+	EffectProperties.Position.TranslateX = float(0.000000000);
+	EffectProperties.Position.TranslateY = float(0.000000000);
+	EffectProperties.Position.TranslateZ = float(0.000000000);
+	EffectProperties.Orientation.RotateX = float(0.000000000);
+	EffectProperties.Orientation.RotateY = float(0.000000000);
+	EffectProperties.Orientation.RotateZ = float(0.000000000);
+	EffectProperties.InitialDelayTime = float(0.000000000);
+	EffectProperties.Duration = float(0.000000000);
+	EffectProperties.RepeatCount = uint32_t(1);
+	EffectProperties.RepeatDelay = float(0.000000000);
+	EffectProperties.RandomizeRepeatTime = float(0.000000000);
+	EffectProperties.Path.PlaybackMode = (const char*)"LOOP";
+	EffectProperties.Path.PathDuration = float(4.000000000);
+	EffectProperties.Path.LoopIndex = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void VelocitySourceEffect::initReferences(void)
+{
+	VelocitySource = NULL;
+
+}
+
+void VelocitySourceEffect::freeDynamicArrays(void)
+{
+	if (EffectProperties.Path.ControlPoints.isAllocated && EffectProperties.Path.ControlPoints.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.ControlPoints.buf);
+	}
+	if (EffectProperties.Path.Scale.isAllocated && EffectProperties.Path.Scale.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Scale.buf);
+	}
+	if (EffectProperties.Path.Speed.isAllocated && EffectProperties.Path.Speed.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Speed.buf);
+	}
+}
+
+void VelocitySourceEffect::freeStrings(void)
+{
+
+	if (EffectProperties.UserString.isAllocated && EffectProperties.UserString.buf)
+	{
+		mParameterizedTraits->strfree((char*)EffectProperties.UserString.buf);
+	}
+}
+
+void VelocitySourceEffect::freeReferences(void)
+{
+	if (VelocitySource)
+	{
+		VelocitySource->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/VolumeRenderMaterialData.cpp b/APEX_1.4/module/particles/src/autogen/VolumeRenderMaterialData.cpp
new file mode 100644
index 00000000..a62c9463
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/VolumeRenderMaterialData.cpp
@@ -0,0 +1,1349 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "VolumeRenderMaterialData.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace VolumeRenderMaterialDataNS;
+
+const char* const VolumeRenderMaterialDataFactory::vptr =
+    NvParameterized::getVptr<VolumeRenderMaterialData, VolumeRenderMaterialData::ClassAlignment>();
+
+const uint32_t NumParamDefs = 36;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+	24, 25, 26, 27, 28, 29, 30, 34, 35, 31, 32, 33,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 32 },
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->Name), NULL, 0 }, // Name
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->ApplicationMaterialName), NULL, 0 }, // ApplicationMaterialName
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->UserProperties), NULL, 0 }, // UserProperties
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->RenderMode), NULL, 0 }, // RenderMode
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->RenderMethod), NULL, 0 }, // RenderMethod
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->ResolutionScale), NULL, 0 }, // ResolutionScale
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->FillMode), NULL, 0 }, // FillMode
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->GenerateShadows), NULL, 0 }, // GenerateShadows
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->BlurShadows), NULL, 0 }, // BlurShadows
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->GenerateMipmaps), NULL, 0 }, // GenerateMipmaps
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->EnableStencilOpt), NULL, 0 }, // EnableStencilOpt
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->StepScale), NULL, 0 }, // StepScale
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->Density), NULL, 0 }, // Density
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->EdgeFade), NULL, 0 }, // EdgeFade
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->OpacityThreshold), NULL, 0 }, // OpacityThreshold
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->RayJitter), NULL, 0 }, // RayJitter
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->IsoValue), NULL, 0 }, // IsoValue
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->IsoValueSign), NULL, 0 }, // IsoValueSign
+	{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->ShadowSamples), NULL, 0 }, // ShadowSamples
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->ShadowDistance), NULL, 0 }, // ShadowDistance
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->ShadowDensity), NULL, 0 }, // ShadowDensity
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->ShadowJitter), NULL, 0 }, // ShadowJitter
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->ShadowAmount), NULL, 0 }, // ShadowAmount
+	{ TYPE_VEC3, false, (size_t)(&((ParametersStruct*)0)->LightDir), NULL, 0 }, // LightDir
+	{ TYPE_VEC4, false, (size_t)(&((ParametersStruct*)0)->LightColor), NULL, 0 }, // LightColor
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->BlockEmptyThreshold), NULL, 0 }, // BlockEmptyThreshold
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->ReadDepth), NULL, 0 }, // ReadDepth
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->ColorMapScale), NULL, 0 }, // ColorMapScale
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->ColorMapOffset), NULL, 0 }, // ColorMapOffset
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->ColorMap), CHILDREN(32), 1 }, // ColorMap
+	{ TYPE_STRUCT, false, 1 * sizeof(colorLifeStruct_Type), CHILDREN(33), 2 }, // ColorMap[]
+	{ TYPE_F32, false, (size_t)(&((colorLifeStruct_Type*)0)->density), NULL, 0 }, // ColorMap[].density
+	{ TYPE_VEC4, false, (size_t)(&((colorLifeStruct_Type*)0)->color), NULL, 0 }, // ColorMap[].color
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->TextureRangeMin), NULL, 0 }, // TextureRangeMin
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->TextureRangeMax), NULL, 0 }, // TextureRangeMax
+};
+
+
+bool VolumeRenderMaterialData::mBuiltFlag = false;
+NvParameterized::MutexType VolumeRenderMaterialData::mBuiltFlagMutex;
+
+VolumeRenderMaterialData::VolumeRenderMaterialData(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &VolumeRenderMaterialDataFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+VolumeRenderMaterialData::~VolumeRenderMaterialData()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void VolumeRenderMaterialData::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~VolumeRenderMaterialData();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* VolumeRenderMaterialData::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* VolumeRenderMaterialData::getParameterDefinitionTree(void) const
+{
+	VolumeRenderMaterialData* tmpParam = const_cast<VolumeRenderMaterialData*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType VolumeRenderMaterialData::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType VolumeRenderMaterialData::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void VolumeRenderMaterialData::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<VolumeRenderMaterialData::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void VolumeRenderMaterialData::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void VolumeRenderMaterialData::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the volume render material properties for this asset", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="Name"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("Name", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "The name of this volume render material", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="ApplicationMaterialName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("ApplicationMaterialName", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The name of the material to match up with the application's material system", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="UserProperties"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("UserProperties", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Optional user properties string", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="RenderMode"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("RenderMode", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Volume rendering mode", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "VOLUME", "VOLUME_COLORMAP", "VOLUME_SHADOWED", "VOXELS", "ISOSURFACE" };
+		ParamDefTable[4].setEnumVals((const char**)EnumVals, 5);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="RenderMethod"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("RenderMethod", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Determines whether to do raycasting or slice based rendering, default is raycasting", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "RAYCASTING", "SLICE_BASED" };
+		ParamDefTable[5].setEnumVals((const char**)EnumVals, 2);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="ResolutionScale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("ResolutionScale", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Resolution scale to use", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "NO_SCALE", "HALF_SCALE", "QUARTER_SCALE" };
+		ParamDefTable[6].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="FillMode"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("FillMode", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Debugging option to render the volume in wireframe mode; default is solid of course", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "SOLID", "WIREFRAME" };
+		ParamDefTable[7].setEnumVals((const char**)EnumVals, 2);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="GenerateShadows"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("GenerateShadows", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Generate shadow volume", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="BlurShadows"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("BlurShadows", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Blur shadow volume", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="GenerateMipmaps"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("GenerateMipmaps", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The maximum clamp range to use when copying velocity/desnity to the 3d volume texture; this range will be scaled 0-255; it's important to tune the proper range value", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=11, longName="EnableStencilOpt"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11];
+		ParamDef->init("EnableStencilOpt", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Enable stencil optimization", true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=12, longName="StepScale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12];
+		ParamDef->init("StepScale", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Scale ray march step - e.g. 1.0 == voxel size, 0.5 == half voxel size", true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=13, longName="Density"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13];
+		ParamDef->init("Density", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Volume density [0, 1000.0]", true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=14, longName="EdgeFade"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14];
+		ParamDef->init("EdgeFade", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Edge fade distance [0, 1]", true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=15, longName="OpacityThreshold"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15];
+		ParamDef->init("OpacityThreshold", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Stop ray marching once opacity has reached this threshold [0, 1]", true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=16, longName="RayJitter"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16];
+		ParamDef->init("RayJitter", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Amount to jitter view rays [0, 1]", true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=17, longName="IsoValue"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17];
+		ParamDef->init("IsoValue", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Surface Isovalue for Isovalue render mode", true);
+		ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=18, longName="IsoValueSign"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18];
+		ParamDef->init("IsoValueSign", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Isovalue sign, density is multiplied by this value before comparison (usually 1.0 or -1.0)", true);
+		ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=19, longName="ShadowSamples"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19];
+		ParamDef->init("ShadowSamples", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(256), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(256), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Number of samples for shadows [0, 256]", true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=20, longName="ShadowDistance"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20];
+		ParamDef->init("ShadowDistance", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Distance to ray march shadows [0, 1]", true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=21, longName="ShadowDensity"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21];
+		ParamDef->init("ShadowDensity", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Shadow density [0, 1000]", true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=22, longName="ShadowJitter"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22];
+		ParamDef->init("ShadowJitter", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Amount to jitter shadow rays [0, 1]", true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=23, longName="ShadowAmount"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23];
+		ParamDef->init("ShadowAmount", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Amount of shadowing [0, 1]", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=24, longName="LightDir"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24];
+		ParamDef->init("LightDir", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Normalized light direction", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=25, longName="LightColor"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25];
+		ParamDef->init("LightColor", TYPE_VEC4, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The color to use for the 'light' on this volume render", true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=26, longName="BlockEmptyThreshold"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26];
+		ParamDef->init("BlockEmptyThreshold", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Threshold above which block is considered non-empty for empty space skipping (typically close to 0.0)", true);
+		ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=27, longName="ReadDepth"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27];
+		ParamDef->init("ReadDepth", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Read background depth during compositing", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=28, longName="ColorMapScale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28];
+		ParamDef->init("ColorMapScale", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Color map scale", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=29, longName="ColorMapOffset"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29];
+		ParamDef->init("ColorMapOffset", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Color map offset", true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=30, longName="ColorMap"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30];
+		ParamDef->init("ColorMap", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "''Fluid Density''", true);
+		HintTable[4].init("yAxisLabel", "''Alpha + Color''", true);
+		ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for color map", true);
+		HintTable[4].init("xAxisLabel", "''Fluid Density''", true);
+		HintTable[5].init("yAxisLabel", "''Alpha + Color''", true);
+		ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=31, longName="ColorMap[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31];
+		ParamDef->init("ColorMap", TYPE_STRUCT, "colorLifeStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "''Fluid Density''", true);
+		HintTable[4].init("yAxisLabel", "''Alpha + Color''", true);
+		ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for color map", true);
+		HintTable[4].init("xAxisLabel", "''Fluid Density''", true);
+		HintTable[5].init("yAxisLabel", "''Alpha + Color''", true);
+		ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=32, longName="ColorMap[].density"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[32];
+		ParamDef->init("density", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[32].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Density", true);
+		ParamDefTable[32].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=33, longName="ColorMap[].color"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[33];
+		ParamDef->init("color", TYPE_VEC4, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Color is formated x=R, y=G, z=B, w=A", true);
+		ParamDefTable[33].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=34, longName="TextureRangeMin"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[34];
+		ParamDef->init("TextureRangeMin", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(5000.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[34].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(5000.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "For APEX turbulence, controls the minimum density range to copy to the density texture", true);
+		ParamDefTable[34].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=35, longName="TextureRangeMax"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[35];
+		ParamDef->init("TextureRangeMax", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(5000.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[35].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(5000.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "For APEX turbulence, controls the maximum density range to copy to the density texture", true);
+		ParamDefTable[35].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[32];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+		Children[3] = PDEF_PTR(4);
+		Children[4] = PDEF_PTR(5);
+		Children[5] = PDEF_PTR(6);
+		Children[6] = PDEF_PTR(7);
+		Children[7] = PDEF_PTR(8);
+		Children[8] = PDEF_PTR(9);
+		Children[9] = PDEF_PTR(10);
+		Children[10] = PDEF_PTR(11);
+		Children[11] = PDEF_PTR(12);
+		Children[12] = PDEF_PTR(13);
+		Children[13] = PDEF_PTR(14);
+		Children[14] = PDEF_PTR(15);
+		Children[15] = PDEF_PTR(16);
+		Children[16] = PDEF_PTR(17);
+		Children[17] = PDEF_PTR(18);
+		Children[18] = PDEF_PTR(19);
+		Children[19] = PDEF_PTR(20);
+		Children[20] = PDEF_PTR(21);
+		Children[21] = PDEF_PTR(22);
+		Children[22] = PDEF_PTR(23);
+		Children[23] = PDEF_PTR(24);
+		Children[24] = PDEF_PTR(25);
+		Children[25] = PDEF_PTR(26);
+		Children[26] = PDEF_PTR(27);
+		Children[27] = PDEF_PTR(28);
+		Children[28] = PDEF_PTR(29);
+		Children[29] = PDEF_PTR(30);
+		Children[30] = PDEF_PTR(34);
+		Children[31] = PDEF_PTR(35);
+
+		ParamDefTable[0].setChildren(Children, 32);
+	}
+
+	// SetChildren for: nodeIndex=30, longName="ColorMap"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(31);
+
+		ParamDefTable[30].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=31, longName="ColorMap[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(32);
+		Children[1] = PDEF_PTR(33);
+
+		ParamDefTable[31].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void VolumeRenderMaterialData::initStrings(void)
+{
+	Name.isAllocated = false;
+	Name.buf = (const char*)"defaultVolumeRenderMaterial";
+	ApplicationMaterialName.isAllocated = true;
+	ApplicationMaterialName.buf = NULL;
+	UserProperties.isAllocated = true;
+	UserProperties.buf = NULL;
+}
+
+void VolumeRenderMaterialData::initDynamicArrays(void)
+{
+	ColorMap.buf = NULL;
+	ColorMap.isAllocated = true;
+	ColorMap.elementSize = sizeof(colorLifeStruct_Type);
+	ColorMap.arraySizes[0] = 0;
+}
+
+void VolumeRenderMaterialData::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	RenderMode = (const char*)"VOLUME";
+	RenderMethod = (const char*)"RAYCASTING";
+	ResolutionScale = (const char*)"NO_SCALE";
+	FillMode = (const char*)"SOLID";
+	GenerateShadows = bool(0);
+	BlurShadows = bool(1);
+	GenerateMipmaps = bool(0);
+	EnableStencilOpt = bool(0);
+	StepScale = float(0.500000000);
+	Density = float(50.000000000);
+	EdgeFade = float(0.100000001);
+	OpacityThreshold = float(0.990000010);
+	RayJitter = float(0.000000000);
+	IsoValue = float(0.500000000);
+	IsoValueSign = float(1.000000000);
+	ShadowSamples = uint32_t(4);
+	ShadowDistance = float(0.200000003);
+	ShadowDensity = float(20.000000000);
+	ShadowJitter = float(1.000000000);
+	ShadowAmount = float(1.000000000);
+	LightDir = physx::PxVec3(init(1.000000000,1.000000000,1.000000000));
+	LightColor = physx::PxVec4(initVec4(1.000000000,1.000000000,1.000000000,1.000000000));
+	BlockEmptyThreshold = float(0.000000000);
+	ReadDepth = bool(1);
+	ColorMapScale = float(1.000000000);
+	ColorMapOffset = float(0.000000000);
+	TextureRangeMin = float(0.000000000);
+	TextureRangeMax = float(500.000000000);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void VolumeRenderMaterialData::initReferences(void)
+{
+}
+
+void VolumeRenderMaterialData::freeDynamicArrays(void)
+{
+	if (ColorMap.isAllocated && ColorMap.buf)
+	{
+		mParameterizedTraits->free(ColorMap.buf);
+	}
+}
+
+void VolumeRenderMaterialData::freeStrings(void)
+{
+
+	if (Name.isAllocated && Name.buf)
+	{
+		mParameterizedTraits->strfree((char*)Name.buf);
+	}
+
+	if (ApplicationMaterialName.isAllocated && ApplicationMaterialName.buf)
+	{
+		mParameterizedTraits->strfree((char*)ApplicationMaterialName.buf);
+	}
+
+	if (UserProperties.isAllocated && UserProperties.buf)
+	{
+		mParameterizedTraits->strfree((char*)UserProperties.buf);
+	}
+}
+
+void VolumeRenderMaterialData::freeReferences(void)
+{
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/VortexFieldSamplerData.cpp b/APEX_1.4/module/particles/src/autogen/VortexFieldSamplerData.cpp
new file mode 100644
index 00000000..357e302d
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/VortexFieldSamplerData.cpp
@@ -0,0 +1,363 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "VortexFieldSamplerData.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace VortexFieldSamplerDataNS;
+
+const char* const VortexFieldSamplerDataFactory::vptr =
+    NvParameterized::getVptr<VortexFieldSamplerData, VortexFieldSamplerData::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->Name), NULL, 0 }, // Name
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->VortexFieldSampler), NULL, 0 }, // VortexFieldSampler
+};
+
+
+bool VortexFieldSamplerData::mBuiltFlag = false;
+NvParameterized::MutexType VortexFieldSamplerData::mBuiltFlagMutex;
+
+VortexFieldSamplerData::VortexFieldSamplerData(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &VortexFieldSamplerDataFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+VortexFieldSamplerData::~VortexFieldSamplerData()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void VortexFieldSamplerData::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~VortexFieldSamplerData();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* VortexFieldSamplerData::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* VortexFieldSamplerData::getParameterDefinitionTree(void) const
+{
+	VortexFieldSamplerData* tmpParam = const_cast<VortexFieldSamplerData*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType VortexFieldSamplerData::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType VortexFieldSamplerData::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void VortexFieldSamplerData::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<VortexFieldSamplerData::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void VortexFieldSamplerData::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void VortexFieldSamplerData::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the asset properties for this vortex field sampler", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="Name"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("Name", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Vortex FS Name", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="VortexFieldSampler"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("VortexFieldSampler", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Vortex FS properties", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "VortexFSAssetParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void VortexFieldSamplerData::initStrings(void)
+{
+	Name.isAllocated = false;
+	Name.buf = (const char*)"defaultVortexFieldSampler";
+}
+
+void VortexFieldSamplerData::initDynamicArrays(void)
+{
+}
+
+void VortexFieldSamplerData::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void VortexFieldSamplerData::initReferences(void)
+{
+	VortexFieldSampler = NULL;
+
+}
+
+void VortexFieldSamplerData::freeDynamicArrays(void)
+{
+}
+
+void VortexFieldSamplerData::freeStrings(void)
+{
+
+	if (Name.isAllocated && Name.buf)
+	{
+		mParameterizedTraits->strfree((char*)Name.buf);
+	}
+}
+
+void VortexFieldSamplerData::freeReferences(void)
+{
+	if (VortexFieldSampler)
+	{
+		VortexFieldSampler->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/VortexFieldSamplerEffect.cpp b/APEX_1.4/module/particles/src/autogen/VortexFieldSamplerEffect.cpp
new file mode 100644
index 00000000..06a3bf04
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/VortexFieldSamplerEffect.cpp
@@ -0,0 +1,1362 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "VortexFieldSamplerEffect.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace VortexFieldSamplerEffectNS;
+
+const char* const VortexFieldSamplerEffectFactory::vptr =
+    NvParameterized::getVptr<VortexFieldSamplerEffect, VortexFieldSamplerEffect::ClassAlignment>();
+
+const uint32_t NumParamDefs = 32;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 31, 2, 3, 4, 8, 12, 13, 14, 15, 16, 17, 5, 6, 7, 9, 10, 11, 18, 19, 20, 21, 23,
+	27, 22, 24, 25, 26, 28, 29, 30,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->EffectProperties), CHILDREN(2), 10 }, // EffectProperties
+	{ TYPE_STRING, false, (size_t)(&((EffectProperties_Type*)0)->UserString), NULL, 0 }, // EffectProperties.UserString
+	{ TYPE_BOOL, false, (size_t)(&((EffectProperties_Type*)0)->Enable), NULL, 0 }, // EffectProperties.Enable
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Position), CHILDREN(12), 3 }, // EffectProperties.Position
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateX), NULL, 0 }, // EffectProperties.Position.TranslateX
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateY), NULL, 0 }, // EffectProperties.Position.TranslateY
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateZ), NULL, 0 }, // EffectProperties.Position.TranslateZ
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Orientation), CHILDREN(15), 3 }, // EffectProperties.Orientation
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateX), NULL, 0 }, // EffectProperties.Orientation.RotateX
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateY), NULL, 0 }, // EffectProperties.Orientation.RotateY
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateZ), NULL, 0 }, // EffectProperties.Orientation.RotateZ
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->InitialDelayTime), NULL, 0 }, // EffectProperties.InitialDelayTime
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->Duration), NULL, 0 }, // EffectProperties.Duration
+	{ TYPE_U32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatCount), NULL, 0 }, // EffectProperties.RepeatCount
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatDelay), NULL, 0 }, // EffectProperties.RepeatDelay
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RandomizeRepeatTime), NULL, 0 }, // EffectProperties.RandomizeRepeatTime
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Path), CHILDREN(18), 6 }, // EffectProperties.Path
+	{ TYPE_ENUM, false, (size_t)(&((EffectPath_Type*)0)->PlaybackMode), NULL, 0 }, // EffectProperties.Path.PlaybackMode
+	{ TYPE_F32, false, (size_t)(&((EffectPath_Type*)0)->PathDuration), NULL, 0 }, // EffectProperties.Path.PathDuration
+	{ TYPE_U32, false, (size_t)(&((EffectPath_Type*)0)->LoopIndex), NULL, 0 }, // EffectProperties.Path.LoopIndex
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->ControlPoints), CHILDREN(24), 1 }, // EffectProperties.Path.ControlPoints
+	{ TYPE_TRANSFORM, false, 1 * sizeof(physx::PxTransform), NULL, 0 }, // EffectProperties.Path.ControlPoints[]
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Scale), CHILDREN(25), 1 }, // EffectProperties.Path.Scale
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(26), 2 }, // EffectProperties.Path.Scale[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Scale[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Scale[].y
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Speed), CHILDREN(28), 1 }, // EffectProperties.Path.Speed
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(29), 2 }, // EffectProperties.Path.Speed[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Speed[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Speed[].y
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->VortexFieldSampler), NULL, 0 }, // VortexFieldSampler
+};
+
+
+bool VortexFieldSamplerEffect::mBuiltFlag = false;
+NvParameterized::MutexType VortexFieldSamplerEffect::mBuiltFlagMutex;
+
+VortexFieldSamplerEffect::VortexFieldSamplerEffect(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &VortexFieldSamplerEffectFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+VortexFieldSamplerEffect::~VortexFieldSamplerEffect()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void VortexFieldSamplerEffect::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~VortexFieldSamplerEffect();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* VortexFieldSamplerEffect::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* VortexFieldSamplerEffect::getParameterDefinitionTree(void) const
+{
+	VortexFieldSamplerEffect* tmpParam = const_cast<VortexFieldSamplerEffect*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType VortexFieldSamplerEffect::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType VortexFieldSamplerEffect::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void VortexFieldSamplerEffect::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<VortexFieldSamplerEffect::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void VortexFieldSamplerEffect::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void VortexFieldSamplerEffect::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "A vortex field sampler effect", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="EffectProperties"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("EffectProperties", TYPE_STRUCT, "EffectProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Vortex FS Properties", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="EffectProperties.UserString"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("UserString", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An aribtrary user string that can be set by an artist/designer/programmer", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="EffectProperties.Enable"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("Enable", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Whether or not this effect is to be initially enabled on startup", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("Position", TYPE_STRUCT, "TranslateObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The position of this effect relative to the parent", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="EffectProperties.Position.TranslateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("TranslateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="EffectProperties.Position.TranslateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("TranslateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="EffectProperties.Position.TranslateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("TranslateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("Orientation", TYPE_STRUCT, "OrientObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The orientation of this effect, relative to the parent orientation", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="EffectProperties.Orientation.RotateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("RotateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the X axis (0-360 degrees)", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="EffectProperties.Orientation.RotateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("RotateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Y axis (0-360 degrees)", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=11, longName="EffectProperties.Orientation.RotateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11];
+		ParamDef->init("RotateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Z axis (0-360 degrees)", true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=12, longName="EffectProperties.InitialDelayTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12];
+		ParamDef->init("InitialDelayTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "Initial time to delay before spawning this effect", true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=13, longName="EffectProperties.Duration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13];
+		ParamDef->init("Duration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The duration of the effect in secontds", true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=14, longName="EffectProperties.RepeatCount"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14];
+		ParamDef->init("RepeatCount", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(1), true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The number of times to repeat the effect; 9999 means repeate forever", true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=15, longName="EffectProperties.RepeatDelay"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15];
+		ParamDef->init("RepeatDelay", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The time to delay activation each time the effect repeats in seconds; this can be different than the initial delay time", true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=16, longName="EffectProperties.RandomizeRepeatTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16];
+		ParamDef->init("RandomizeRepeatTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Amount of randomization to the repeat cycle; a value of zero (default) means no random and a value of one means completely random.", true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17];
+		ParamDef->init("Path", TYPE_STRUCT, "EffectPath", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An optional pre-defined path for this effect to travel on", true);
+		ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=18, longName="EffectProperties.Path.PlaybackMode"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18];
+		ParamDef->init("PlaybackMode", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The mode to play back the path", true);
+		ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "LOOP", "PLAY_ONCE", "PING_PONG" };
+		ParamDefTable[18].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=19, longName="EffectProperties.Path.PathDuration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19];
+		ParamDef->init("PathDuration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		HintTable[2].init("shortDescription", "The duration of the path if one is not otherwise provided", true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=20, longName="EffectProperties.Path.LoopIndex"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20];
+		ParamDef->init("LoopIndex", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "The array index to loop back to", true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21];
+		ParamDef->init("ControlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=22, longName="EffectProperties.Path.ControlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22];
+		ParamDef->init("ControlPoints", TYPE_TRANSFORM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23];
+		ParamDef->init("Scale", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24];
+		ParamDef->init("Scale", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=25, longName="EffectProperties.Path.Scale[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=26, longName="EffectProperties.Path.Scale[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27];
+		ParamDef->init("Speed", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28];
+		ParamDef->init("Speed", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=29, longName="EffectProperties.Path.Speed[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=30, longName="EffectProperties.Path.Speed[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=31, longName="VortexFieldSampler"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31];
+		ParamDef->init("VortexFieldSampler", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Vortex FS Asset", true);
+		ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "VortexFSAsset" };
+		ParamDefTable[31].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(31);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="EffectProperties"
+	{
+		static Definition* Children[10];
+		Children[0] = PDEF_PTR(2);
+		Children[1] = PDEF_PTR(3);
+		Children[2] = PDEF_PTR(4);
+		Children[3] = PDEF_PTR(8);
+		Children[4] = PDEF_PTR(12);
+		Children[5] = PDEF_PTR(13);
+		Children[6] = PDEF_PTR(14);
+		Children[7] = PDEF_PTR(15);
+		Children[8] = PDEF_PTR(16);
+		Children[9] = PDEF_PTR(17);
+
+		ParamDefTable[1].setChildren(Children, 10);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(5);
+		Children[1] = PDEF_PTR(6);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[4].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(9);
+		Children[1] = PDEF_PTR(10);
+		Children[2] = PDEF_PTR(11);
+
+		ParamDefTable[8].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		static Definition* Children[6];
+		Children[0] = PDEF_PTR(18);
+		Children[1] = PDEF_PTR(19);
+		Children[2] = PDEF_PTR(20);
+		Children[3] = PDEF_PTR(21);
+		Children[4] = PDEF_PTR(23);
+		Children[5] = PDEF_PTR(27);
+
+		ParamDefTable[17].setChildren(Children, 6);
+	}
+
+	// SetChildren for: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(22);
+
+		ParamDefTable[21].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(24);
+
+		ParamDefTable[23].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(25);
+		Children[1] = PDEF_PTR(26);
+
+		ParamDefTable[24].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(28);
+
+		ParamDefTable[27].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(29);
+		Children[1] = PDEF_PTR(30);
+
+		ParamDefTable[28].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void VortexFieldSamplerEffect::initStrings(void)
+{
+	EffectProperties.UserString.isAllocated = true;
+	EffectProperties.UserString.buf = NULL;
+}
+
+void VortexFieldSamplerEffect::initDynamicArrays(void)
+{
+	EffectProperties.Path.ControlPoints.buf = NULL;
+	EffectProperties.Path.ControlPoints.isAllocated = true;
+	EffectProperties.Path.ControlPoints.elementSize = sizeof(physx::PxTransform);
+	EffectProperties.Path.ControlPoints.arraySizes[0] = 0;
+	EffectProperties.Path.Scale.buf = NULL;
+	EffectProperties.Path.Scale.isAllocated = true;
+	EffectProperties.Path.Scale.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Scale.arraySizes[0] = 0;
+	EffectProperties.Path.Speed.buf = NULL;
+	EffectProperties.Path.Speed.isAllocated = true;
+	EffectProperties.Path.Speed.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Speed.arraySizes[0] = 0;
+}
+
+void VortexFieldSamplerEffect::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	EffectProperties.Enable = bool(1);
+	EffectProperties.Position.TranslateX = float(0.000000000);
+	EffectProperties.Position.TranslateY = float(0.000000000);
+	EffectProperties.Position.TranslateZ = float(0.000000000);
+	EffectProperties.Orientation.RotateX = float(0.000000000);
+	EffectProperties.Orientation.RotateY = float(0.000000000);
+	EffectProperties.Orientation.RotateZ = float(0.000000000);
+	EffectProperties.InitialDelayTime = float(0.000000000);
+	EffectProperties.Duration = float(0.000000000);
+	EffectProperties.RepeatCount = uint32_t(1);
+	EffectProperties.RepeatDelay = float(0.000000000);
+	EffectProperties.RandomizeRepeatTime = float(0.000000000);
+	EffectProperties.Path.PlaybackMode = (const char*)"LOOP";
+	EffectProperties.Path.PathDuration = float(4.000000000);
+	EffectProperties.Path.LoopIndex = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void VortexFieldSamplerEffect::initReferences(void)
+{
+	VortexFieldSampler = NULL;
+
+}
+
+void VortexFieldSamplerEffect::freeDynamicArrays(void)
+{
+	if (EffectProperties.Path.ControlPoints.isAllocated && EffectProperties.Path.ControlPoints.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.ControlPoints.buf);
+	}
+	if (EffectProperties.Path.Scale.isAllocated && EffectProperties.Path.Scale.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Scale.buf);
+	}
+	if (EffectProperties.Path.Speed.isAllocated && EffectProperties.Path.Speed.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Speed.buf);
+	}
+}
+
+void VortexFieldSamplerEffect::freeStrings(void)
+{
+
+	if (EffectProperties.UserString.isAllocated && EffectProperties.UserString.buf)
+	{
+		mParameterizedTraits->strfree((char*)EffectProperties.UserString.buf);
+	}
+}
+
+void VortexFieldSamplerEffect::freeReferences(void)
+{
+	if (VortexFieldSampler)
+	{
+		VortexFieldSampler->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/WindFieldSamplerData.cpp b/APEX_1.4/module/particles/src/autogen/WindFieldSamplerData.cpp
new file mode 100644
index 00000000..9d5308f7
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/WindFieldSamplerData.cpp
@@ -0,0 +1,363 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "WindFieldSamplerData.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace WindFieldSamplerDataNS;
+
+const char* const WindFieldSamplerDataFactory::vptr =
+    NvParameterized::getVptr<WindFieldSamplerData, WindFieldSamplerData::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->Name), NULL, 0 }, // Name
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->WindFieldSampler), NULL, 0 }, // WindFieldSampler
+};
+
+
+bool WindFieldSamplerData::mBuiltFlag = false;
+NvParameterized::MutexType WindFieldSamplerData::mBuiltFlagMutex;
+
+WindFieldSamplerData::WindFieldSamplerData(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &WindFieldSamplerDataFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+WindFieldSamplerData::~WindFieldSamplerData()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void WindFieldSamplerData::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~WindFieldSamplerData();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* WindFieldSamplerData::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* WindFieldSamplerData::getParameterDefinitionTree(void) const
+{
+	WindFieldSamplerData* tmpParam = const_cast<WindFieldSamplerData*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType WindFieldSamplerData::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType WindFieldSamplerData::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void WindFieldSamplerData::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<WindFieldSamplerData::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void WindFieldSamplerData::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void WindFieldSamplerData::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the asset properties for this wind field sampler", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="Name"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("Name", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Wind FS Name", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="WindFieldSampler"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("WindFieldSampler", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Wind FS properties", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "WindFSAssetParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void WindFieldSamplerData::initStrings(void)
+{
+	Name.isAllocated = false;
+	Name.buf = (const char*)"defaultWindFieldSampler";
+}
+
+void WindFieldSamplerData::initDynamicArrays(void)
+{
+}
+
+void WindFieldSamplerData::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void WindFieldSamplerData::initReferences(void)
+{
+	WindFieldSampler = NULL;
+
+}
+
+void WindFieldSamplerData::freeDynamicArrays(void)
+{
+}
+
+void WindFieldSamplerData::freeStrings(void)
+{
+
+	if (Name.isAllocated && Name.buf)
+	{
+		mParameterizedTraits->strfree((char*)Name.buf);
+	}
+}
+
+void WindFieldSamplerData::freeReferences(void)
+{
+	if (WindFieldSampler)
+	{
+		WindFieldSampler->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia
diff --git a/APEX_1.4/module/particles/src/autogen/WindFieldSamplerEffect.cpp b/APEX_1.4/module/particles/src/autogen/WindFieldSamplerEffect.cpp
new file mode 100644
index 00000000..f431ff3b
--- /dev/null
+++ b/APEX_1.4/module/particles/src/autogen/WindFieldSamplerEffect.cpp
@@ -0,0 +1,1362 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "WindFieldSamplerEffect.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace particles
+{
+
+using namespace WindFieldSamplerEffectNS;
+
+const char* const WindFieldSamplerEffectFactory::vptr =
+    NvParameterized::getVptr<WindFieldSamplerEffect, WindFieldSamplerEffect::ClassAlignment>();
+
+const uint32_t NumParamDefs = 32;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 31, 2, 3, 4, 8, 12, 13, 14, 15, 16, 17, 5, 6, 7, 9, 10, 11, 18, 19, 20, 21, 23,
+	27, 22, 24, 25, 26, 28, 29, 30,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->EffectProperties), CHILDREN(2), 10 }, // EffectProperties
+	{ TYPE_STRING, false, (size_t)(&((EffectProperties_Type*)0)->UserString), NULL, 0 }, // EffectProperties.UserString
+	{ TYPE_BOOL, false, (size_t)(&((EffectProperties_Type*)0)->Enable), NULL, 0 }, // EffectProperties.Enable
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Position), CHILDREN(12), 3 }, // EffectProperties.Position
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateX), NULL, 0 }, // EffectProperties.Position.TranslateX
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateY), NULL, 0 }, // EffectProperties.Position.TranslateY
+	{ TYPE_F32, false, (size_t)(&((TranslateObject_Type*)0)->TranslateZ), NULL, 0 }, // EffectProperties.Position.TranslateZ
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Orientation), CHILDREN(15), 3 }, // EffectProperties.Orientation
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateX), NULL, 0 }, // EffectProperties.Orientation.RotateX
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateY), NULL, 0 }, // EffectProperties.Orientation.RotateY
+	{ TYPE_F32, false, (size_t)(&((OrientObject_Type*)0)->RotateZ), NULL, 0 }, // EffectProperties.Orientation.RotateZ
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->InitialDelayTime), NULL, 0 }, // EffectProperties.InitialDelayTime
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->Duration), NULL, 0 }, // EffectProperties.Duration
+	{ TYPE_U32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatCount), NULL, 0 }, // EffectProperties.RepeatCount
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RepeatDelay), NULL, 0 }, // EffectProperties.RepeatDelay
+	{ TYPE_F32, false, (size_t)(&((EffectProperties_Type*)0)->RandomizeRepeatTime), NULL, 0 }, // EffectProperties.RandomizeRepeatTime
+	{ TYPE_STRUCT, false, (size_t)(&((EffectProperties_Type*)0)->Path), CHILDREN(18), 6 }, // EffectProperties.Path
+	{ TYPE_ENUM, false, (size_t)(&((EffectPath_Type*)0)->PlaybackMode), NULL, 0 }, // EffectProperties.Path.PlaybackMode
+	{ TYPE_F32, false, (size_t)(&((EffectPath_Type*)0)->PathDuration), NULL, 0 }, // EffectProperties.Path.PathDuration
+	{ TYPE_U32, false, (size_t)(&((EffectPath_Type*)0)->LoopIndex), NULL, 0 }, // EffectProperties.Path.LoopIndex
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->ControlPoints), CHILDREN(24), 1 }, // EffectProperties.Path.ControlPoints
+	{ TYPE_TRANSFORM, false, 1 * sizeof(physx::PxTransform), NULL, 0 }, // EffectProperties.Path.ControlPoints[]
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Scale), CHILDREN(25), 1 }, // EffectProperties.Path.Scale
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(26), 2 }, // EffectProperties.Path.Scale[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Scale[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Scale[].y
+	{ TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Speed), CHILDREN(28), 1 }, // EffectProperties.Path.Speed
+	{ TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(29), 2 }, // EffectProperties.Path.Speed[]
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // EffectProperties.Path.Speed[].x
+	{ TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // EffectProperties.Path.Speed[].y
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->WindFieldSampler), NULL, 0 }, // WindFieldSampler
+};
+
+
+bool WindFieldSamplerEffect::mBuiltFlag = false;
+NvParameterized::MutexType WindFieldSamplerEffect::mBuiltFlagMutex;
+
+WindFieldSamplerEffect::WindFieldSamplerEffect(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &WindFieldSamplerEffectFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+WindFieldSamplerEffect::~WindFieldSamplerEffect()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void WindFieldSamplerEffect::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~WindFieldSamplerEffect();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* WindFieldSamplerEffect::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* WindFieldSamplerEffect::getParameterDefinitionTree(void) const
+{
+	WindFieldSamplerEffect* tmpParam = const_cast<WindFieldSamplerEffect*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType WindFieldSamplerEffect::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType WindFieldSamplerEffect::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void WindFieldSamplerEffect::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<WindFieldSamplerEffect::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void WindFieldSamplerEffect::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void WindFieldSamplerEffect::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "A wind field sampler effect", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="EffectProperties"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("EffectProperties", TYPE_STRUCT, "EffectProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Wind FS Properties", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="EffectProperties.UserString"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("UserString", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An aribtrary user string that can be set by an artist/designer/programmer", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="EffectProperties.Enable"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("Enable", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Whether or not this effect is to be initially enabled on startup", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("Position", TYPE_STRUCT, "TranslateObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The position of this effect relative to the parent", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="EffectProperties.Position.TranslateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("TranslateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="EffectProperties.Position.TranslateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("TranslateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="EffectProperties.Position.TranslateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("TranslateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(500.000000000), true);
+		HintTable[2].init("min", double(-500.000000000), true);
+		HintTable[3].init("shortDescription", "Nudge up to +/- one meter in each direction", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("Orientation", TYPE_STRUCT, "OrientObject", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The orientation of this effect, relative to the parent orientation", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="EffectProperties.Orientation.RotateX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("RotateX", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the X axis (0-360 degrees)", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="EffectProperties.Orientation.RotateY"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("RotateY", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Y axis (0-360 degrees)", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=11, longName="EffectProperties.Orientation.RotateZ"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11];
+		ParamDef->init("RotateZ", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("READONLY", uint64_t(0), true);
+		HintTable[1].init("max", double(360.000000000), true);
+		HintTable[2].init("min", double(0.000000000), true);
+		HintTable[3].init("shortDescription", "Rotate on the Z axis (0-360 degrees)", true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=12, longName="EffectProperties.InitialDelayTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12];
+		ParamDef->init("InitialDelayTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "Initial time to delay before spawning this effect", true);
+		ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=13, longName="EffectProperties.Duration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13];
+		ParamDef->init("Duration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The duration of the effect in secontds", true);
+		ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=14, longName="EffectProperties.RepeatCount"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14];
+		ParamDef->init("RepeatCount", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(1), true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The number of times to repeat the effect; 9999 means repeate forever", true);
+		ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=15, longName="EffectProperties.RepeatDelay"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15];
+		ParamDef->init("RepeatDelay", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", double(0.000000000), true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", double(0.000000000), true);
+		HintTable[1].init("shortDescription", "The time to delay activation each time the effect repeats in seconds; this can be different than the initial delay time", true);
+		ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=16, longName="EffectProperties.RandomizeRepeatTime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16];
+		ParamDef->init("RandomizeRepeatTime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "Amount of randomization to the repeat cycle; a value of zero (default) means no random and a value of one means completely random.", true);
+		ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17];
+		ParamDef->init("Path", TYPE_STRUCT, "EffectPath", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An optional pre-defined path for this effect to travel on", true);
+		ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=18, longName="EffectProperties.Path.PlaybackMode"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18];
+		ParamDef->init("PlaybackMode", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The mode to play back the path", true);
+		ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "LOOP", "PLAY_ONCE", "PING_PONG" };
+		ParamDefTable[18].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=19, longName="EffectProperties.Path.PathDuration"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19];
+		ParamDef->init("PathDuration", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1000.000000000), true);
+		HintTable[1].init("min", double(0.000010000), true);
+		HintTable[2].init("shortDescription", "The duration of the path if one is not otherwise provided", true);
+		ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=20, longName="EffectProperties.Path.LoopIndex"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20];
+		ParamDef->init("LoopIndex", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "The array index to loop back to", true);
+		ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21];
+		ParamDef->init("ControlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=22, longName="EffectProperties.Path.ControlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22];
+		ParamDef->init("ControlPoints", TYPE_TRANSFORM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("editorCurve", uint64_t(1), true);
+		HintTable[2].init("pathEditor", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true);
+		ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23];
+		ParamDef->init("Scale", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24];
+		ParamDef->init("Scale", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of scale values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=25, longName="EffectProperties.Path.Scale[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=26, longName="EffectProperties.Path.Scale[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27];
+		ParamDef->init("Speed", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28];
+		ParamDef->init("Speed", TYPE_STRUCT, "ControlPoint", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Over Time", true);
+		HintTable[4].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true);
+		HintTable[1].init("UseSpline", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "The array of speed values over time", true);
+		HintTable[4].init("xAxisLabel", "Over Time", true);
+		HintTable[5].init("yAxisLabel", "Speed", true);
+		ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=29, longName="EffectProperties.Path.Speed[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", double(1.000000000), true);
+		HintTable[1].init("min", double(0.000000000), true);
+		HintTable[2].init("shortDescription", "The x-axis value for this vector", true);
+		ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=30, longName="EffectProperties.Path.Speed[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The y-axis value for this vector", true);
+		ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=31, longName="WindFieldSampler"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31];
+		ParamDef->init("WindFieldSampler", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Wind FS Asset", true);
+		ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "WindFSAsset" };
+		ParamDefTable[31].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(31);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="EffectProperties"
+	{
+		static Definition* Children[10];
+		Children[0] = PDEF_PTR(2);
+		Children[1] = PDEF_PTR(3);
+		Children[2] = PDEF_PTR(4);
+		Children[3] = PDEF_PTR(8);
+		Children[4] = PDEF_PTR(12);
+		Children[5] = PDEF_PTR(13);
+		Children[6] = PDEF_PTR(14);
+		Children[7] = PDEF_PTR(15);
+		Children[8] = PDEF_PTR(16);
+		Children[9] = PDEF_PTR(17);
+
+		ParamDefTable[1].setChildren(Children, 10);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="EffectProperties.Position"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(5);
+		Children[1] = PDEF_PTR(6);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[4].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=8, longName="EffectProperties.Orientation"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(9);
+		Children[1] = PDEF_PTR(10);
+		Children[2] = PDEF_PTR(11);
+
+		ParamDefTable[8].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=17, longName="EffectProperties.Path"
+	{
+		static Definition* Children[6];
+		Children[0] = PDEF_PTR(18);
+		Children[1] = PDEF_PTR(19);
+		Children[2] = PDEF_PTR(20);
+		Children[3] = PDEF_PTR(21);
+		Children[4] = PDEF_PTR(23);
+		Children[5] = PDEF_PTR(27);
+
+		ParamDefTable[17].setChildren(Children, 6);
+	}
+
+	// SetChildren for: nodeIndex=21, longName="EffectProperties.Path.ControlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(22);
+
+		ParamDefTable[21].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=23, longName="EffectProperties.Path.Scale"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(24);
+
+		ParamDefTable[23].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=24, longName="EffectProperties.Path.Scale[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(25);
+		Children[1] = PDEF_PTR(26);
+
+		ParamDefTable[24].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=27, longName="EffectProperties.Path.Speed"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(28);
+
+		ParamDefTable[27].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=28, longName="EffectProperties.Path.Speed[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(29);
+		Children[1] = PDEF_PTR(30);
+
+		ParamDefTable[28].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void WindFieldSamplerEffect::initStrings(void)
+{
+	EffectProperties.UserString.isAllocated = true;
+	EffectProperties.UserString.buf = NULL;
+}
+
+void WindFieldSamplerEffect::initDynamicArrays(void)
+{
+	EffectProperties.Path.ControlPoints.buf = NULL;
+	EffectProperties.Path.ControlPoints.isAllocated = true;
+	EffectProperties.Path.ControlPoints.elementSize = sizeof(physx::PxTransform);
+	EffectProperties.Path.ControlPoints.arraySizes[0] = 0;
+	EffectProperties.Path.Scale.buf = NULL;
+	EffectProperties.Path.Scale.isAllocated = true;
+	EffectProperties.Path.Scale.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Scale.arraySizes[0] = 0;
+	EffectProperties.Path.Speed.buf = NULL;
+	EffectProperties.Path.Speed.isAllocated = true;
+	EffectProperties.Path.Speed.elementSize = sizeof(ControlPoint_Type);
+	EffectProperties.Path.Speed.arraySizes[0] = 0;
+}
+
+void WindFieldSamplerEffect::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	EffectProperties.Enable = bool(1);
+	EffectProperties.Position.TranslateX = float(0.000000000);
+	EffectProperties.Position.TranslateY = float(0.000000000);
+	EffectProperties.Position.TranslateZ = float(0.000000000);
+	EffectProperties.Orientation.RotateX = float(0.000000000);
+	EffectProperties.Orientation.RotateY = float(0.000000000);
+	EffectProperties.Orientation.RotateZ = float(0.000000000);
+	EffectProperties.InitialDelayTime = float(0.000000000);
+	EffectProperties.Duration = float(0.000000000);
+	EffectProperties.RepeatCount = uint32_t(1);
+	EffectProperties.RepeatDelay = float(0.000000000);
+	EffectProperties.RandomizeRepeatTime = float(0.000000000);
+	EffectProperties.Path.PlaybackMode = (const char*)"LOOP";
+	EffectProperties.Path.PathDuration = float(4.000000000);
+	EffectProperties.Path.LoopIndex = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void WindFieldSamplerEffect::initReferences(void)
+{
+	WindFieldSampler = NULL;
+
+}
+
+void WindFieldSamplerEffect::freeDynamicArrays(void)
+{
+	if (EffectProperties.Path.ControlPoints.isAllocated && EffectProperties.Path.ControlPoints.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.ControlPoints.buf);
+	}
+	if (EffectProperties.Path.Scale.isAllocated && EffectProperties.Path.Scale.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Scale.buf);
+	}
+	if (EffectProperties.Path.Speed.isAllocated && EffectProperties.Path.Speed.buf)
+	{
+		mParameterizedTraits->free(EffectProperties.Path.Speed.buf);
+	}
+}
+
+void WindFieldSamplerEffect::freeStrings(void)
+{
+
+	if (EffectProperties.UserString.isAllocated && EffectProperties.UserString.buf)
+	{
+		mParameterizedTraits->strfree((char*)EffectProperties.UserString.buf);
+	}
+}
+
+void WindFieldSamplerEffect::freeReferences(void)
+{
+	if (WindFieldSampler)
+	{
+		WindFieldSampler->destroy();
+	}
+
+}
+
+} // namespace particles
+} // namespace nvidia