Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

52 files changed, 22865 insertions, 0 deletions

diff --git a/APEX_1.4/module/iofx/src/IofxActorCPU.cpp b/APEX_1.4/module/iofx/src/IofxActorCPU.cpp
new file mode 100644
index 00000000..25663b71
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/IofxActorCPU.cpp
@@ -0,0 +1,326 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "Apex.h"
+#include "SceneIntl.h"
+#include "Modifier.h"
+#include "IofxActor.h"
+#include "IofxActorCPU.h"
+#include "IofxAssetImpl.h"
+#include "IofxSceneCPU.h"
+#include "IosObjectData.h"
+
+#include "ModuleIofxImpl.h"
+
+#include "ARLSort.h"
+
+
+namespace nvidia
+{
+namespace iofx
+{
+
+void TaskModifiers::run()
+{
+	setProfileStat((uint16_t) mOwner.mWorkingRange.objectCount);
+	mOwner.updateBounds();
+	mOwner.runModifiers();
+}
+
+
+#pragma warning(disable: 4355) // 'this' : used in base member initializer list
+
+IofxActorCPU::IofxActorCPU(ResID renderResID, IofxScene* iscene, IofxManager& mgr)
+	: IofxActorImpl(renderResID, iscene, mgr)
+	, mModifierTask(*this)
+{
+}
+
+void IofxActorCPU::updateBounds()
+{
+	mWorkingBounds.setEmpty();
+
+	const IosObjectCpuData& objData = *static_cast<const IosObjectCpuData*>(mMgr.mWorkingIosData);
+
+	for (uint32_t id = 0; id < mWorkingRange.objectCount; id++)
+	{
+		uint32_t outputID = mWorkingRange.startIndex + id;
+
+		uint32_t stateID = objData.outputToState[ outputID ];
+		PX_ASSERT(stateID != IosBufferDescIntl::NOT_A_PARTICLE);
+		PX_ASSERT(stateID < objData.maxStateID);
+
+		uint32_t inputID = objData.pmaInStateToInput->get(stateID);
+		PX_ASSERT(inputID != IosBufferDescIntl::NOT_A_PARTICLE);
+		inputID &= ~IosBufferDescIntl::NEW_PARTICLE_FLAG;
+		PX_ASSERT(inputID < objData.maxInputCount);
+
+		// include particle in renderable bounds
+		mWorkingBounds.include(objData.pmaPositionMass->get(inputID).getXYZ());
+	}
+}
+
+PX_INLINE void MeshInput::load(const IosObjectBaseData& objData, uint32_t pos)
+{
+	position		= objData.pmaPositionMass->get(pos).getXYZ();
+	mass			= objData.pmaPositionMass->get(pos).w;
+	velocity		= objData.pmaVelocityLife->get(pos).getXYZ();
+	liferemain		= objData.pmaVelocityLife->get(pos).w;
+	density			= objData.pmaDensity ? objData.pmaDensity->get(pos) : 0;
+	collisionNormal	= objData.pmaCollisionNormalFlags ? objData.pmaCollisionNormalFlags->get(pos).getXYZ() : PxVec3(0.0f);
+	collisionFlags	= objData.pmaCollisionNormalFlags ? *(const uint32_t*)(&objData.pmaCollisionNormalFlags->get(pos).w) : 0;
+
+	userData		= objData.pmaUserData ? objData.pmaUserData->get(pos) : 0;
+}
+
+PX_INLINE void SpriteInput::load(const IosObjectBaseData& objData, uint32_t pos)
+{
+	position		= objData.pmaPositionMass->get(pos).getXYZ();
+	mass			= objData.pmaPositionMass->get(pos).w;
+	velocity		= objData.pmaVelocityLife->get(pos).getXYZ();
+	liferemain		= objData.pmaVelocityLife->get(pos).w;
+	density			= objData.pmaDensity ? objData.pmaDensity->get(pos) : 0;
+
+	userData		= objData.pmaUserData ? objData.pmaUserData->get(pos) : 0;
+}
+
+
+void IofxActorCPU::runModifiers()
+{
+	mWorkingVisibleCount = mWorkingRange.objectCount;
+
+	IosObjectCpuData* obj = DYNAMIC_CAST(IosObjectCpuData*)(mMgr.mWorkingIosData);
+	if (mMgr.mIsMesh)
+	{
+		IofxSharedRenderDataMeshImpl* meshRenderData = DYNAMIC_CAST(IofxSharedRenderDataMeshImpl*)(obj->renderData);
+		const IofxMeshRenderLayout& meshRenderLayout = meshRenderData->getRenderLayout();
+
+		MeshOutputLayout outputLayout;
+		PX_COMPILE_TIME_ASSERT(sizeof(outputLayout.offsets) == sizeof(meshRenderLayout.offsets));
+		::memcpy(outputLayout.offsets, meshRenderLayout.offsets, sizeof(outputLayout.offsets));	
+		outputLayout.stride = meshRenderLayout.stride;
+
+		updateParticles<MeshInput, MeshPublicState, MeshPrivateState>(*obj, 
+																	outputLayout,
+																	static_cast<uint8_t*>(meshRenderData->getBufferMappedPtr())
+																	);
+	}
+	else
+	{
+		if (mDistanceSortingEnabled)
+		{
+			const ObjectRange& range = mWorkingRange;
+
+			mWorkingVisibleCount = 0;
+			PX_ASSERT(obj->sortingKeys != NULL);
+			for (uint32_t outputId = range.startIndex; outputId < range.startIndex + range.objectCount ; outputId++)
+			{
+				uint32_t stateId = obj->outputToState[ outputId ];
+				PX_ASSERT(stateId != IosBufferDescIntl::NOT_A_PARTICLE);
+				uint32_t inputId = obj->pmaInStateToInput->get(stateId);
+				inputId &= ~IosBufferDescIntl::NEW_PARTICLE_FLAG;
+
+				const PxVec3 position = obj->pmaPositionMass->get(inputId).getXYZ();
+				float sortDistance = obj->zNear + (obj->eyePosition - position).dot(obj->eyeDirection);
+
+				//build uint key for radix sorting (flip float)
+				uint32_t key = *reinterpret_cast<const uint32_t*>(&sortDistance);
+				uint32_t mask = -int32_t(key >> 31) | 0x80000000;
+				key ^= mask;
+
+				obj->sortingKeys[ outputId ] = key;
+				if ((key & 0x80000000) == 0) ++mWorkingVisibleCount;
+			}
+
+			uint32_t* keys = obj->sortingKeys + range.startIndex;
+			uint32_t* values = obj->outputToState + range.startIndex;
+			iofx::ARLSort<uint32_t, uint32_t>::sort(keys, values, (int32_t)range.objectCount);
+
+			if (range.objectCount > 0)
+			{
+				PX_ASSERT(values[range.objectCount - 1] < obj->maxStateID);
+			}
+		}
+
+		IofxSharedRenderDataSpriteImpl* spriteRenderData = DYNAMIC_CAST(IofxSharedRenderDataSpriteImpl*)(obj->renderData);
+		const IofxSpriteRenderLayout& spriteRenderLayout = spriteRenderData->getRenderLayout();
+		if (spriteRenderLayout.surfaceCount > 0)
+		{
+			SpriteTextureOutputLayout outputLayout;
+			bool result = true;
+			for (uint32_t i = 0; i < spriteRenderLayout.surfaceCount; ++i)
+			{
+				UserRenderSurface::MappedInfo mappedInfo;
+				if (spriteRenderData->getSurfaceMappedInfo(i, mappedInfo))
+				{
+					const UserRenderSurfaceDesc& surfaceDesc = spriteRenderLayout.surfaceDescs[i];
+					outputLayout.textureData[i].layout = static_cast<uint16_t>(spriteRenderLayout.surfaceElements[i]);
+
+					outputLayout.texturePtr[i] = static_cast<uint8_t*>(mappedInfo.pData);
+
+					const uint32_t surfaceWidth = uint32_t(surfaceDesc.width);
+					const uint32_t surfacePitch = mappedInfo.rowPitch;
+
+					PX_ASSERT(isPowerOfTwo(surfaceWidth));
+					outputLayout.textureData[i].widthShift = static_cast<uint8_t>(highestSetBit(surfaceWidth));
+					PX_ASSERT(isPowerOfTwo(surfacePitch));
+					outputLayout.textureData[i].pitchShift = static_cast<uint8_t>(highestSetBit(surfacePitch));
+				}
+				else
+				{
+					result = false;
+					break;
+				}
+			}
+			outputLayout.textureCount = result ? spriteRenderLayout.surfaceCount : 0;
+
+			updateParticles<SpriteInput, SpritePublicState, SpritePrivateState>(*obj, outputLayout, NULL);
+		}
+		else
+		{
+			SpriteOutputLayout outputLayout;
+			/* Copy user-defined semantics offsets to output offsets */
+			PX_COMPILE_TIME_ASSERT(sizeof(outputLayout.offsets) == sizeof(spriteRenderLayout.offsets));
+			::memcpy(outputLayout.offsets, spriteRenderLayout.offsets, sizeof(outputLayout.offsets));
+			outputLayout.stride = spriteRenderLayout.stride;
+
+			updateParticles<SpriteInput, SpritePublicState, SpritePrivateState>(*obj, 
+																				outputLayout,
+																				static_cast<uint8_t*>(spriteRenderData->getBufferMappedPtr())
+																				);
+		}
+	}
+}
+
+class ModifierParamsMapperCPUimpl : public ModifierParamsMapperCPU
+{
+	template <typename T>
+	void _mapValue(size_t offset, T value)
+	{
+		if (mData != 0)
+		{
+			*(T*)(mData + mParamsOffset + offset) = value;
+		}
+	}
+
+public:
+	virtual void beginParams(void* , size_t size, size_t align, uint32_t)
+	{
+		mParamsOffset = (mTotalSize + (uint32_t)align - 1) & ~((uint32_t)align - 1);
+		mTotalSize = mParamsOffset + (uint32_t)size;
+	}
+	virtual void endParams()
+	{
+	}
+
+	virtual void mapValue(size_t offset, int32_t value)
+	{
+		_mapValue(offset, value);
+	}
+	virtual void mapValue(size_t offset, float value)
+	{
+		_mapValue(offset, value);
+	}
+	virtual void mapCurve(size_t offset, const nvidia::apex::Curve* curve)
+	{
+		_mapValue(offset, curve);
+	}
+
+	ModifierParamsMapperCPUimpl()
+	{
+		reset(0);
+	}
+
+	void reset(uint8_t* data)
+	{
+		mData = data;
+		mTotalSize = 0;
+		mParamsOffset = 0;
+	}
+
+	uint32_t getTotalSize() const
+	{
+		return mTotalSize;
+	}
+	uint32_t getParamsOffset() const
+	{
+		return mParamsOffset;
+	}
+
+private:
+	uint8_t*	mData;
+
+	uint32_t	mTotalSize;
+	uint32_t	mParamsOffset;
+};
+
+
+uint32_t IofxAssetSceneInstCPU::introspectModifiers(ModifierParamsMapperCPUimpl& introspector, ModifierInfo* list, const ModifierStack& stack, ModifierStage stage, uint32_t usageClass)
+{
+	uint32_t usageStage = ModifierUsageFromStage(stage);
+	uint32_t count = 0;
+	for (ModifierStack::ConstIterator it = stack.begin(); it != stack.end(); ++it)
+	{
+		//uint32_t type = (*it)->getModifierType();
+		uint32_t usage = (*it)->getModifierUsage();
+		if ((usage & usageStage) == usageStage && (usage & usageClass) == usageClass)
+		{
+			const ModifierImpl* modifier = ModifierImpl::castFrom(*it);
+			modifier->mapParamsCPU(introspector);
+			if (list != 0)
+			{
+				if (usageClass == ModifierUsage_Sprite)
+				{
+					list[count].updateSpriteFunc = modifier->getUpdateSpriteFunc(stage);
+				}
+				else
+				{
+					list[count].updateMeshFunc = modifier->getUpdateMeshFunc(stage);
+				}
+
+				list[count].paramsOffset = introspector.getParamsOffset();
+			}
+			++count;
+		}
+	}
+	return count;
+}
+
+IofxAssetSceneInstCPU::IofxAssetSceneInstCPU(IofxAssetImpl* asset, uint32_t semantics, IofxScene* scene)
+	: IofxAssetSceneInst(asset, semantics)
+{
+	PX_UNUSED(scene);
+
+	const ModifierStack& spawnModifiers = asset->getModifierStack(ModifierStage_Spawn);
+	const ModifierStack& continuousModifiers = asset->getModifierStack(ModifierStage_Continuous);
+
+	// set the particle buffer type here
+	uint32_t usageClass = (asset->getMeshAssetCount() > 0) ? ModifierUsage_Mesh : ModifierUsage_Sprite;
+
+	//collect params
+	ModifierParamsMapperCPUimpl paramsMapper;
+
+	uint32_t spawnModifierCount = introspectModifiers(paramsMapper, 0, spawnModifiers, ModifierStage_Spawn, usageClass);
+	uint32_t continuousModifierCount = introspectModifiers(paramsMapper, 0, continuousModifiers, ModifierStage_Continuous, usageClass);
+
+	mSpawnModifiersList.resize(spawnModifierCount);
+	mContinuousModifiersList.resize(continuousModifierCount);
+
+	mModifiersParamsBuffer.resize(paramsMapper.getTotalSize());
+
+	paramsMapper.reset(mModifiersParamsBuffer.begin());
+
+	introspectModifiers(paramsMapper, mSpawnModifiersList.begin(), spawnModifiers, ModifierStage_Spawn, usageClass);
+	introspectModifiers(paramsMapper, mContinuousModifiersList.begin(), continuousModifiers, ModifierStage_Continuous, usageClass);
+}
+
+}
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/IofxActorImpl.cpp b/APEX_1.4/module/iofx/src/IofxActorImpl.cpp
new file mode 100644
index 00000000..6996e880
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/IofxActorImpl.cpp
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "Apex.h"
+#include "ApexSDKIntl.h"
+#include "SceneIntl.h"
+#include "IofxActor.h"
+#include "IofxActorImpl.h"
+#include "IofxSceneCPU.h"
+#include "IofxSceneGPU.h"
+#include "RenderVolumeImpl.h"
+#include "IosObjectData.h"
+#include "IofxRenderData.h"
+
+#include "ModuleIofxImpl.h"
+
+namespace nvidia
+{
+namespace iofx
+{
+
+IofxActorImpl::IofxActorImpl(ResID renderResID, IofxScene* iscene, IofxManager& mgr)
+	: mRenderResID(renderResID)
+	, mIofxScene(iscene)
+	, mMgr(mgr)
+	, mRenderVolume(NULL) // IOS will set this after creation
+	, mSemantics(0)
+	, mActiveRenderable(NULL)
+{
+	//asset.add(*this);
+
+	mResultBounds.setEmpty();
+	mResultRange.startIndex = 0;
+	mResultRange.objectCount = 0;
+	mResultVisibleCount = 0;
+
+	addSelfToContext(*iscene->mApexScene->getApexContext());    // Add self to ApexScene
+	addSelfToContext(*iscene);							      // Add self to IofxScene
+}
+
+IofxActorImpl::~IofxActorImpl()
+{
+}
+
+void IofxActorImpl::getLodRange(float& min, float& max, bool& intOnly) const
+{
+	READ_ZONE();
+	PX_UNUSED(min);
+	PX_UNUSED(max);
+	PX_UNUSED(intOnly);
+	APEX_INVALID_OPERATION("not implemented");
+}
+
+
+float IofxActorImpl::getActiveLod() const
+{
+	READ_ZONE();
+	APEX_INVALID_OPERATION("BasicIosActor does not support this operation");
+	return -1.0f;
+}
+
+
+void IofxActorImpl::forceLod(float lod)
+{
+	WRITE_ZONE();
+	PX_UNUSED(lod);
+	APEX_INVALID_OPERATION("not implemented");
+}
+
+void IofxActorImpl::release()
+{
+	if (mInRelease)
+	{
+		return;
+	}
+	mInRelease = true;
+	destroy();
+}
+
+
+void IofxActorImpl::destroy()
+{
+	if (mRenderVolume)
+	{
+		mRenderVolume->removeIofxActor(*this);
+	}
+
+	// Removes self from scenes and IOFX manager
+	// should be called after mRenderVolume->removeIofxActor to avoid dead-lock!!!
+	ApexActor::destroy();
+
+	for (uint32_t i = 0 ; i < mRenderableArray.size() ; i++)
+	{
+		IofxRenderableImpl* renderable = mRenderableArray[i];
+		if (renderable != NULL)
+		{
+			renderable->release();
+		}
+	}
+	mRenderableArray.clear();
+
+	delete this;
+}
+
+bool IofxActorImpl::prepareRenderables(IosObjectBaseData* obj)
+{
+	if (mResultRange.objectCount > 0 && obj->renderData->checkSemantics(mSemantics))
+	{
+		const uint32_t instanceID = obj->renderData->getInstanceID();
+		if (mRenderableArray.size() <= instanceID)
+		{
+			mRenderableArray.resize(instanceID + 1, NULL);
+		}
+		mActiveRenderable = mRenderableArray[instanceID];
+		if (mActiveRenderable == NULL)
+		{
+			if (mMgr.mIsMesh)
+			{
+				mActiveRenderable = PX_NEW(IofxMeshRenderable)(mIofxScene, mRenderResID);
+			}
+			else
+			{
+				mActiveRenderable = PX_NEW(IofxSpriteRenderable)(mIofxScene, mRenderResID);
+			}
+			mRenderableArray[instanceID] = mActiveRenderable;
+		}
+
+		mActiveRenderable->update(obj->renderData, mResultBounds, mResultRange.startIndex, mResultRange.objectCount, mResultVisibleCount);
+		return true;
+	}
+	else
+	{
+		mActiveRenderable = NULL;
+		return false;
+	}
+}
+
+IofxRenderable* IofxActorImpl::acquireRenderableReference()
+{
+	return mActiveRenderable ? mActiveRenderable->incrementReferenceCount() : NULL;
+}
+
+
+}
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/IofxAssetImpl.cpp b/APEX_1.4/module/iofx/src/IofxAssetImpl.cpp
new file mode 100644
index 00000000..b04211a9
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/IofxAssetImpl.cpp
@@ -0,0 +1,1138 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "Apex.h"
+#include "ApexUsingNamespace.h"
+#include "IofxAssetImpl.h"
+#include "IofxActorImpl.h"
+#include "IofxScene.h"
+#include "ModuleIofxImpl.h"
+#include "Modifier.h"
+#include "ModifierImpl.h"
+#include "SceneIntl.h"
+#include "IofxManagerIntl.h"
+//#include "ApexSharedSerialization.h"
+#include "CurveImpl.h"
+
+namespace nvidia
+{
+namespace iofx
+{
+
+
+IofxAssetImpl::IofxAssetImpl(ModuleIofxImpl* module, ResourceList& list, const char* name) :
+	mRenderMeshAssetTracker(module->mSdk, RENDER_MESH_AUTHORING_TYPE_NAME),
+	mSpriteMaterialAssetTracker(module->mSdk),
+	mModule(module),
+	mName(name),
+	mSpriteSemanticBitmap(0),
+	mMeshSemanticBitmap(0)
+{
+	using namespace IofxAssetParametersNS;
+
+	NvParameterized::Traits* traits = GetInternalApexSDK()->getParameterizedTraits();
+	mParams = (IofxAssetParameters*)traits->createNvParameterized(IofxAssetParameters::staticClassName());
+
+	PX_ASSERT(mParams);
+
+	// LRR: Hmmmm, these will never be setup for authors, it's a good thing we can't create actors from authors!
+	mRenderMeshList = NULL;
+	mSpriteParams = NULL;
+
+	list.add(*this);
+}
+
+IofxAssetImpl::IofxAssetImpl(ModuleIofxImpl* module,
+                     ResourceList& list,
+                     NvParameterized::Interface* params,
+                     const char* name) :
+	mRenderMeshAssetTracker(module->mSdk, RENDER_MESH_AUTHORING_TYPE_NAME),
+	mSpriteMaterialAssetTracker(module->mSdk),
+	mParams((IofxAssetParameters*)params),
+	mSpriteParams(NULL),
+	mModule(module),
+	mName(name),
+	mSpriteSemanticBitmap(0),
+	mMeshSemanticBitmap(0)
+{
+	using namespace MeshIofxParametersNS;
+
+	if (mParams->iofxType &&
+	        !nvidia::strcmp(mParams->iofxType->className(), MeshIofxParameters::staticClassName()))
+	{
+		MeshIofxParameters* mIofxParams = static_cast<MeshIofxParameters*>(mParams->iofxType);
+
+		ParamDynamicArrayStruct* tmpStructPtr = (ParamDynamicArrayStruct*) & (mIofxParams->renderMeshList);
+		mRenderMeshList = PX_NEW(ParamArray<meshProperties_Type>)(mIofxParams, "renderMeshList", tmpStructPtr);
+	}
+	else
+	{
+		mRenderMeshList = NULL;
+	}
+
+	if (mParams->iofxType &&
+	        !nvidia::strcmp(mParams->iofxType->className(), SpriteIofxParameters::staticClassName()))
+	{
+		mSpriteParams = static_cast<SpriteIofxParameters*>(mParams->iofxType);
+	}
+
+
+	// call this now to "initialize" the asset
+	postDeserialize();
+
+	list.add(*this);
+}
+
+IofxAssetImpl::~IofxAssetImpl()
+{
+	for (uint32_t i = mSpawnModifierStack.size(); i--;)
+	{
+		delete mSpawnModifierStack[i];
+	}
+
+	for (uint32_t i = mContinuousModifierStack.size(); i--;)
+	{
+		delete mContinuousModifierStack[i];
+	}
+}
+
+void IofxAssetImpl::destroy()
+{
+	/* Assets that were forceloaded or loaded by actors will be automatically
+	 * released by the ApexAssetTracker member destructors.
+	 */
+	if (mParams)
+	{
+		mParams->destroy();
+		mParams = NULL;
+	}
+
+	if (mRenderMeshList)
+	{
+		PX_DELETE(mRenderMeshList);
+	}
+
+#if IOFX_SLOW_COMPOSITE_MODIFIERS
+	// destroy any color vs life params that we may have laying around
+	for (uint32_t i = 0; i < mCompositeParams.size(); i++)
+	{
+		mCompositeParams[i]->destroy();
+	}
+	mCompositeParams.clear();
+#endif
+
+	// this will release all of this asset's IOFX actors, which is necessary, otherwise
+	// the IOFX actors will have their APEX Render Meshes ripped out from underneath them
+	ResourceList::clear();
+
+	delete this;
+}
+
+void IofxAssetImpl::release()
+{
+	mModule->mSdk->releaseAsset(*this);
+}
+
+void IofxAssetImpl::removeAllActors()
+{
+	ApexContext::removeAllActors();
+}
+
+void IofxAssetImpl::addDependentActor(ApexActor* actor)
+{
+	WRITE_ZONE();
+	if (actor)
+	{
+		actor->addSelfToContext(*this);
+	}
+}
+
+
+
+void IofxAssetImpl::preSerialize(void* userData_)
+{
+	PX_UNUSED(userData_);
+}
+
+void IofxAssetImpl::postDeserialize(void* userData_)
+{
+	PX_UNUSED(userData_);
+
+	NvParameterized::Traits* traits = GetInternalApexSDK()->getParameterizedTraits();
+
+	PX_ASSERT(mParams->iofxType);
+	if (!mParams->iofxType)
+	{
+		return;
+	}
+
+	initializeAssetNameTable();
+
+	// destroy the old modifier stacks
+	for (uint32_t i = mSpawnModifierStack.size(); i--;)
+	{
+		delete mSpawnModifierStack[i];
+	}
+	mSpawnModifierStack.resize(0);
+
+	for (uint32_t i = mContinuousModifierStack.size(); i--;)
+	{
+		delete mContinuousModifierStack[i];
+	}
+	mContinuousModifierStack.resize(0);
+
+#if IOFX_SLOW_COMPOSITE_MODIFIERS
+	// destroy any color vs life params that we may have laying around
+	for (uint32_t i = 0; i < mCompositeParams.size(); i++)
+	{
+		mCompositeParams[i]->destroy();
+	}
+	mCompositeParams.clear();
+#endif
+
+	const char* handleNameList[] = { "spawnModifierList", "continuousModifierList" };
+
+// 'param' and 'newMod' are defined in the local scope where this macro is used
+#define _MODIFIER(Type) \
+	else if( !nvidia::strcmp(param->className(), #Type "ModifierParams") )	\
+	{																\
+		newMod = PX_NEW( Type##ModifierImpl )( (Type##ModifierParams *)param );	\
+	}
+
+	for (uint32_t i = 0; i < 2; i++)
+	{
+		NvParameterized::Handle h(*mParams->iofxType);
+		mParams->iofxType->getParameterHandle(handleNameList[i], h);
+		int listSize = 0;
+		h.getArraySize(listSize);
+
+		for (int j = 0; j < listSize; j++)
+		{
+			NvParameterized::Interface* param = 0;
+			NvParameterized::Handle ih(*mParams->iofxType);
+			Modifier* newMod = 0;
+
+			h.getChildHandle(j, ih);
+			ih.getParamRef(param);
+			PX_ASSERT(param);
+			if (!param)
+			{
+				continue;
+			}
+
+			if (newMod != 0)  //this'll never happen :-)
+				{}
+
+#include "ModifierList.h"
+
+#if IOFX_SLOW_COMPOSITE_MODIFIERS
+			// LRR: there is a better way to do this, but I don't have time at the moment to
+			// make this any cleaner
+
+			// special case, we don't currently have an initial color modifier, just insert
+			// a colorVsLife modifier for each color channel
+			else if (!nvidia::strcmp(param->className(), "InitialColorModifierParams"))
+			{
+				InitialColorModifierParams* icParams = (InitialColorModifierParams*)param;
+
+				for (uint32_t colorIdx = 0; colorIdx < 4; colorIdx++)
+				{
+					ColorVsLifeModifierParams* p = (ColorVsLifeModifierParams*)
+					                               traits->createNvParameterized(ColorVsLifeModifierParams::staticClassName());
+
+					// save these parameterized classes off for later, we'll need to destroy them
+					mCompositeParams.pushBack(p);
+
+					ColorVsLifeModifierImpl* cvlMod = PX_NEW(ColorVsLifeModifierImpl)(p);
+					PX_ASSERT(cvlMod);
+
+					// set the color channel
+					cvlMod->setColorChannel((ColorChannel)colorIdx);
+
+					// set the curve
+					CurveImpl curve;
+					curve.addControlPoint(Vec2R(0.0f, icParams->color[colorIdx]));
+					curve.addControlPoint(Vec2R(1.0f, icParams->color[colorIdx]));
+
+					cvlMod->setFunction(&curve);
+
+					// save which sprite render semantics this modifier will update
+					setSpriteSemanticsUsed(cvlMod->getModifierSpriteSemantics());
+					setMeshSemanticsUsed(cvlMod->getModifierMeshSemantics());
+					ModifierStack& activeStack = getModifierStack(i);
+					activeStack.pushBack(cvlMod);
+				}
+			}
+
+			else if (!nvidia::strcmp(param->className(), "ColorVsLifeCompositeModifierParams"))
+			{
+				// setup an array so we can get the control points easily
+				ColorVsLifeCompositeModifierParams* cParams = (ColorVsLifeCompositeModifierParams*)param;
+
+				if (cParams->controlPoints.arraySizes[0] == 0)
+				{
+					continue;
+				}
+
+				for (uint32_t colorIdx = 0; colorIdx < 4; colorIdx++)
+				{
+
+					ColorVsLifeModifierParams* p = (ColorVsLifeModifierParams*)
+					                               traits->createNvParameterized(ColorVsLifeModifierParams::staticClassName());
+
+					// save these parameterized classes off for later, we'll need to destroy them
+					mCompositeParams.pushBack(p);
+
+					ColorVsLifeModifierImpl* cvlMod = PX_NEW(ColorVsLifeModifierImpl)(p);
+					PX_ASSERT(cvlMod);
+
+					// set the color channel
+					cvlMod->setColorChannel((ColorChannel)colorIdx);
+
+					// set the curve
+					CurveImpl curve;
+					for (int32_t cpIdx = 0; cpIdx < cParams->controlPoints.arraySizes[0]; cpIdx++)
+					{
+
+						curve.addControlPoint(Vec2R(cParams->controlPoints.buf[cpIdx].lifeRemaining,
+						                              cParams->controlPoints.buf[cpIdx].color[colorIdx]));
+					}
+					cvlMod->setFunction(&curve);
+
+					// save which sprite render semantics this modifier will update
+					setSpriteSemanticsUsed(cvlMod->getModifierSpriteSemantics());
+					setMeshSemanticsUsed(cvlMod->getModifierMeshSemantics());
+					ModifierStack& activeStack = getModifierStack(i);
+					activeStack.pushBack(cvlMod);
+				}
+			}
+
+			else if (!nvidia::strcmp(param->className(), "ColorVsDensityCompositeModifierParams"))
+			{
+				ColorVsDensityCompositeModifierParams* cParams = (ColorVsDensityCompositeModifierParams*)param;
+
+				if (cParams->controlPoints.arraySizes[0] == 0)
+				{
+					continue;
+				}
+
+				for (uint32_t colorIdx = 0; colorIdx < 4; colorIdx++)
+				{
+
+					ColorVsDensityModifierParams* p = (ColorVsDensityModifierParams*)
+					                                  traits->createNvParameterized(ColorVsDensityModifierParams::staticClassName());
+
+					// save these parameterized classes off for later, we'll need to destroy them
+					mCompositeParams.pushBack(p);
+
+					ColorVsDensityModifierImpl* cvlMod = PX_NEW(ColorVsDensityModifierImpl)(p);
+					PX_ASSERT(cvlMod);
+
+					// set the color channel
+					cvlMod->setColorChannel((ColorChannel)colorIdx);
+
+					// set the curve
+					CurveImpl curve;
+					for (int32_t cpIdx = 0; cpIdx < cParams->controlPoints.arraySizes[0]; cpIdx++)
+					{
+						curve.addControlPoint(Vec2R(cParams->controlPoints.buf[cpIdx].density,
+						                              cParams->controlPoints.buf[cpIdx].color[colorIdx]));
+					}
+					cvlMod->setFunction(&curve);
+
+					// save which sprite render semantics this modifier will update
+					setSpriteSemanticsUsed(cvlMod->getModifierSpriteSemantics());
+					setMeshSemanticsUsed(cvlMod->getModifierMeshSemantics());
+					ModifierStack& activeStack = getModifierStack(i);
+					activeStack.pushBack(cvlMod);
+				}
+			}
+
+			else if (!nvidia::strcmp(param->className(), "ColorVsVelocityCompositeModifierParams"))
+			{
+				// setup an array so we can get the control points easily
+				ColorVsVelocityCompositeModifierParams* cParams = (ColorVsVelocityCompositeModifierParams*)param;
+
+				if (cParams->controlPoints.arraySizes[0] == 0)
+				{
+					continue;
+				}
+
+				for (uint32_t colorIdx = 0; colorIdx < 4; colorIdx++)
+				{
+
+					ColorVsVelocityModifierParams* p = (ColorVsVelocityModifierParams*)
+					                               traits->createNvParameterized(ColorVsVelocityModifierParams::staticClassName());
+
+					// save these parameterized classes off for later, we'll need to destroy them
+					mCompositeParams.pushBack(p);
+
+					ColorVsVelocityModifierImpl* cvlMod = PX_NEW(ColorVsVelocityModifierImpl)(p);
+					PX_ASSERT(cvlMod);
+
+					cvlMod->setVelocity0(cParams->velocity0);
+					cvlMod->setVelocity1(cParams->velocity1);
+
+					// set the color channel
+					cvlMod->setColorChannel((ColorChannel)colorIdx);
+
+					// set the curve
+					CurveImpl curve;
+					for (int32_t cpIdx = 0; cpIdx < cParams->controlPoints.arraySizes[0]; cpIdx++)
+					{
+
+						curve.addControlPoint(Vec2R(cParams->controlPoints.buf[cpIdx].velocity,
+						                              cParams->controlPoints.buf[cpIdx].color[colorIdx]));
+					}
+					cvlMod->setFunction(&curve);
+
+					// save which sprite render semantics this modifier will update
+					setSpriteSemanticsUsed(cvlMod->getModifierSpriteSemantics());
+					setMeshSemanticsUsed(cvlMod->getModifierMeshSemantics());
+					ModifierStack& activeStack = getModifierStack(i);
+					activeStack.pushBack(cvlMod);
+				}
+			}
+
+			else if (!nvidia::strcmp(param->className(), "ScaleVsLife2DModifierParams"))
+			{
+				// setup an array so we can get the control points easily
+				ScaleVsLife2DModifierParams* cParams = (ScaleVsLife2DModifierParams*)param;
+
+				if (cParams->controlPoints.arraySizes[0] == 0)
+				{
+					continue;
+				}
+
+				for (int32_t axisIdx = 0; axisIdx < 2; axisIdx++)
+				{
+					ScaleVsLifeModifierParams* p = (ScaleVsLifeModifierParams*)
+					                               traits->createNvParameterized(ScaleVsLifeModifierParams::staticClassName());
+
+					// save these parameterized classes off for later, we'll need to destroy them
+					mCompositeParams.pushBack(p);
+
+					ScaleVsLifeModifierImpl* cvlMod = PX_NEW(ScaleVsLifeModifierImpl)(p);
+					PX_ASSERT(cvlMod);
+
+					// set the scale axis
+					cvlMod->setScaleAxis((ScaleAxis)axisIdx);
+
+					// set the curve
+					CurveImpl curve;
+					for (int32_t cpIdx = 0; cpIdx < cParams->controlPoints.arraySizes[0]; cpIdx++)
+					{
+						curve.addControlPoint(Vec2R(cParams->controlPoints.buf[cpIdx].lifeRemaining,
+						                              cParams->controlPoints.buf[cpIdx].scale[axisIdx]));
+					}
+					cvlMod->setFunction(&curve);
+
+					// save which sprite render semantics this modifier will update
+					setSpriteSemanticsUsed(cvlMod->getModifierSpriteSemantics());
+					setMeshSemanticsUsed(cvlMod->getModifierMeshSemantics());
+					ModifierStack& activeStack = getModifierStack(i);
+					activeStack.pushBack(cvlMod);
+				}
+			}
+
+			else if (!nvidia::strcmp(param->className(), "ScaleVsLife3DModifierParams"))
+			{
+				// setup an array so we can get the control points easily
+				ScaleVsLife3DModifierParams* cParams = (ScaleVsLife3DModifierParams*)param;
+
+				if (cParams->controlPoints.arraySizes[0] == 0)
+				{
+					continue;
+				}
+
+				for (uint32_t axisIdx = 0; axisIdx < 3; axisIdx++)
+				{
+					ScaleVsLifeModifierParams* p = (ScaleVsLifeModifierParams*)
+					                               traits->createNvParameterized(ScaleVsLifeModifierParams::staticClassName());
+
+					// save these parameterized classes off for later, we'll need to destroy them
+					mCompositeParams.pushBack(p);
+
+					ScaleVsLifeModifierImpl* cvlMod = PX_NEW(ScaleVsLifeModifierImpl)(p);
+					PX_ASSERT(cvlMod);
+
+					// set the scale axis
+					cvlMod->setScaleAxis((ScaleAxis)axisIdx);
+
+					// set the curve
+					CurveImpl curve;
+					for (int32_t cpIdx = 0; cpIdx < cParams->controlPoints.arraySizes[0]; cpIdx++)
+					{
+						curve.addControlPoint(Vec2R(cParams->controlPoints.buf[cpIdx].lifeRemaining,
+						                              cParams->controlPoints.buf[cpIdx].scale[axisIdx]));
+					}
+					cvlMod->setFunction(&curve);
+
+					// save which sprite render semantics this modifier will update
+					setSpriteSemanticsUsed(cvlMod->getModifierSpriteSemantics());
+					setMeshSemanticsUsed(cvlMod->getModifierMeshSemantics());
+					ModifierStack& activeStack = getModifierStack(i);
+					activeStack.pushBack(cvlMod);
+				}
+			}
+
+			else if (!nvidia::strcmp(param->className(), "ScaleVsDensity2DModifierParams"))
+			{
+				// setup an array so we can get the control points easily
+				ScaleVsDensity2DModifierParams* cParams = (ScaleVsDensity2DModifierParams*)param;
+
+				if (cParams->controlPoints.arraySizes[0] == 0)
+				{
+					continue;
+				}
+
+				for (int32_t axisIdx = 0; axisIdx < 2; axisIdx++)
+				{
+					ScaleVsDensityModifierParams* p = (ScaleVsDensityModifierParams*)
+					                                  traits->createNvParameterized(ScaleVsDensityModifierParams::staticClassName());
+
+					// save these parameterized classes off for later, we'll need to destroy them
+					mCompositeParams.pushBack(p);
+
+					ScaleVsDensityModifierImpl* cvlMod = PX_NEW(ScaleVsDensityModifierImpl)(p);
+					PX_ASSERT(cvlMod);
+
+					// set the scale axis
+					cvlMod->setScaleAxis((ScaleAxis)axisIdx);
+
+					// set the curve
+					CurveImpl curve;
+					for (int32_t cpIdx = 0; cpIdx < cParams->controlPoints.arraySizes[0]; cpIdx++)
+					{
+						curve.addControlPoint(Vec2R(cParams->controlPoints.buf[cpIdx].density,
+						                              cParams->controlPoints.buf[cpIdx].scale[axisIdx]));
+					}
+					cvlMod->setFunction(&curve);
+
+					// save which sprite render semantics this modifier will update
+					setSpriteSemanticsUsed(cvlMod->getModifierSpriteSemantics());
+					setMeshSemanticsUsed(cvlMod->getModifierMeshSemantics());
+					ModifierStack& activeStack = getModifierStack(i);
+					activeStack.pushBack(cvlMod);
+				}
+			}
+
+			else if (!nvidia::strcmp(param->className(), "ScaleVsDensity3DModifierParams"))
+			{
+				// setup an array so we can get the control points easily
+				ScaleVsDensity3DModifierParams* cParams = (ScaleVsDensity3DModifierParams*)param;
+
+				if (cParams->controlPoints.arraySizes[0] == 0)
+				{
+					continue;
+				}
+
+				for (uint32_t axisIdx = 0; axisIdx < 3; axisIdx++)
+				{
+					ScaleVsDensityModifierParams* p = (ScaleVsDensityModifierParams*)
+					                                  traits->createNvParameterized(ScaleVsDensityModifierParams::staticClassName());
+
+					// save these parameterized classes off for later, we'll need to destroy them
+					mCompositeParams.pushBack(p);
+
+					ScaleVsDensityModifierImpl* cvlMod = PX_NEW(ScaleVsDensityModifierImpl)(p);
+					PX_ASSERT(cvlMod);
+
+					// set the scale axis
+					cvlMod->setScaleAxis((ScaleAxis)axisIdx);
+
+					// set the curve
+					CurveImpl curve;
+					for (int32_t cpIdx = 0; cpIdx < cParams->controlPoints.arraySizes[0]; cpIdx++)
+					{
+						curve.addControlPoint(Vec2R(cParams->controlPoints.buf[cpIdx].density,
+						                              cParams->controlPoints.buf[cpIdx].scale[axisIdx]));
+					}
+					cvlMod->setFunction(&curve);
+
+					// save which sprite render semantics this modifier will update
+					setSpriteSemanticsUsed(cvlMod->getModifierSpriteSemantics());
+					setMeshSemanticsUsed(cvlMod->getModifierMeshSemantics());
+					ModifierStack& activeStack = getModifierStack(i);
+					activeStack.pushBack(cvlMod);
+				}
+			}
+
+			else if (!nvidia::strcmp(param->className(), "ScaleVsCameraDistance2DModifierParams"))
+			{
+				// setup an array so we can get the control points easily
+				ScaleVsCameraDistance2DModifierParams* cParams = (ScaleVsCameraDistance2DModifierParams*)param;
+
+				if (cParams->controlPoints.arraySizes[0] == 0)
+				{
+					continue;
+				}
+
+				for (int32_t axisIdx = 0; axisIdx < 2; axisIdx++)
+				{
+					ScaleVsCameraDistanceModifierParams* p = (ScaleVsCameraDistanceModifierParams*)
+					        traits->createNvParameterized(ScaleVsCameraDistanceModifierParams::staticClassName());
+
+					// save these parameterized classes off for later, we'll need to destroy them
+					mCompositeParams.pushBack(p);
+
+					ScaleVsCameraDistanceModifierImpl* cvlMod = PX_NEW(ScaleVsCameraDistanceModifierImpl)(p);
+					PX_ASSERT(cvlMod);
+
+					// set the scale axis
+					cvlMod->setScaleAxis((ScaleAxis)axisIdx);
+
+					// set the curve
+					CurveImpl curve;
+					for (int32_t cpIdx = 0; cpIdx < cParams->controlPoints.arraySizes[0]; cpIdx++)
+					{
+						curve.addControlPoint(Vec2R(cParams->controlPoints.buf[cpIdx].cameraDistance,
+						                              cParams->controlPoints.buf[cpIdx].scale[axisIdx]));
+					}
+					cvlMod->setFunction(&curve);
+
+					// save which sprite render semantics this modifier will update
+					setSpriteSemanticsUsed(cvlMod->getModifierSpriteSemantics());
+					setMeshSemanticsUsed(cvlMod->getModifierMeshSemantics());
+					ModifierStack& activeStack = getModifierStack(i);
+					activeStack.pushBack(cvlMod);
+				}
+			}
+
+			else if (!nvidia::strcmp(param->className(), "ScaleVsCameraDistance3DModifierParams"))
+			{
+				// setup an array so we can get the control points easily
+				ScaleVsCameraDistance3DModifierParams* cParams = (ScaleVsCameraDistance3DModifierParams*)param;
+
+				if (cParams->controlPoints.arraySizes[0] == 0)
+				{
+					continue;
+				}
+
+				for (uint32_t axisIdx = 0; axisIdx < 3; axisIdx++)
+				{
+					ScaleVsCameraDistanceModifierParams* p = (ScaleVsCameraDistanceModifierParams*)
+					        traits->createNvParameterized(ScaleVsCameraDistanceModifierParams::staticClassName());
+
+					// save these parameterized classes off for later, we'll need to destroy them
+					mCompositeParams.pushBack(p);
+
+					ScaleVsCameraDistanceModifierImpl* cvlMod = PX_NEW(ScaleVsCameraDistanceModifierImpl)(p);
+					PX_ASSERT(cvlMod);
+
+					// set the scale axis
+					cvlMod->setScaleAxis((ScaleAxis)axisIdx);
+
+					// set the curve
+					CurveImpl curve;
+					for (int32_t cpIdx = 0; cpIdx < cParams->controlPoints.arraySizes[0]; cpIdx++)
+					{
+						curve.addControlPoint(Vec2R(cParams->controlPoints.buf[cpIdx].cameraDistance,
+						                              cParams->controlPoints.buf[cpIdx].scale[axisIdx]));
+					}
+					cvlMod->setFunction(&curve);
+
+					// save which sprite render semantics this modifier will update
+					setSpriteSemanticsUsed(cvlMod->getModifierSpriteSemantics());
+					setMeshSemanticsUsed(cvlMod->getModifierMeshSemantics());
+					ModifierStack& activeStack = getModifierStack(i);
+					activeStack.pushBack(cvlMod);
+				}
+			}
+#endif /* IOFX_SLOW_COMPOSITE_MODIFIERS */
+
+			if (newMod)
+			{
+				// save which sprite render semantics this modifier will update
+				setSpriteSemanticsUsed(newMod->getModifierSpriteSemantics());
+				setMeshSemanticsUsed(newMod->getModifierMeshSemantics());
+
+				ModifierStack& activeStack = getModifierStack(i);
+				activeStack.pushBack(newMod);
+			}
+
+		}
+	}
+
+	bool useFloat4Color = mParams->renderOutput.useFloat4Color;
+	if (!useFloat4Color)
+	{
+		//detect if some Color modifier has a color component value greater than 1
+		for (uint32_t modStage = 0; modStage < 2; modStage++)
+		{
+			const ModifierStack& activeStack = getModifierStack(modStage);
+
+			uint32_t modCount = activeStack.size();
+			for (uint32_t modIndex = 0; modIndex < modCount; modIndex++)
+			{
+				const nvidia::apex::Curve* pColorCurve = 0;
+
+				const Modifier* pModifier = activeStack[modIndex];
+				switch (pModifier->getModifierType())
+				{
+					case ModifierType_ColorVsLife:
+						pColorCurve = static_cast<const ColorVsLifeModifier*>(pModifier)->getFunction();
+						break;
+					case ModifierType_ColorVsDensity:
+						pColorCurve = static_cast<const ColorVsDensityModifier*>(pModifier)->getFunction();
+						break;
+					default:
+						break;
+				}
+
+				if (pColorCurve)
+				{
+					uint32_t pointsCount;
+					const Vec2R* pPoints = pColorCurve->getControlPoints(pointsCount);
+
+					for (uint32_t i = 0; i < pointsCount; i++)
+					{
+						if (pPoints[i].y > 1)
+						{
+							useFloat4Color = true;
+							break;
+						}
+					}
+				}
+				if (useFloat4Color)
+				{
+					break;
+				}
+			}
+			if (useFloat4Color)
+			{
+				break;
+			}
+		}
+	}
+
+	if (mParams->renderOutput.useUserSemantic)
+	{
+		mMeshSemanticBitmap |= (1 << IofxRenderSemantic::USER_DATA);
+		mSpriteSemanticBitmap |= (1 << IofxRenderSemantic::USER_DATA);
+	}
+}
+
+const char* IofxAssetImpl::getSpriteMaterialName() const
+{
+	READ_ZONE();
+	if (mSpriteParams &&
+	        mSpriteParams->spriteMaterialName &&
+	        mSpriteParams->spriteMaterialName->name() &&
+	        mSpriteParams->spriteMaterialName->name()[0])
+	{
+		return mSpriteParams->spriteMaterialName->name();
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+const char* IofxAssetImpl::getMeshAssetName(uint32_t index) const
+{
+	READ_ZONE();
+	if (mRenderMeshList && index < (*mRenderMeshList).size() && (*mRenderMeshList)[index].meshAssetName)
+	{
+		return (*mRenderMeshList)[index].meshAssetName->name();
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+uint32_t IofxAssetImpl::getMeshAssetWeight(uint32_t index) const
+{
+	READ_ZONE();
+	if (mRenderMeshList && index < (*mRenderMeshList).size())
+	{
+		return (*mRenderMeshList)[index].weight;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+bool IofxAssetImpl::isOpaqueMesh(uint32_t index) const
+{
+	if (mRenderMeshList && index < (*mRenderMeshList).size() && (*mRenderMeshList)[index].meshAssetName)
+	{
+		return nvidia::strcmp((*mRenderMeshList)[index].meshAssetName->className(), "ApexOpaqueMesh") == 0;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+uint32_t IofxAssetImpl::forceLoadAssets()
+{
+	WRITE_ZONE();
+	uint32_t assetLoadedCount = 0;
+
+	assetLoadedCount += mRenderMeshAssetTracker.forceLoadAssets();
+	assetLoadedCount += mSpriteMaterialAssetTracker.forceLoadAssets();
+
+	return assetLoadedCount;
+}
+
+void IofxAssetImpl::initializeAssetNameTable()
+{
+	// clean up asset tracker list
+	mRenderMeshAssetTracker.removeAllAssetNames();
+	mSpriteMaterialAssetTracker.removeAllAssetNames();
+
+	if (mRenderMeshList)
+	{
+		/* initialize the rendermesh asset name to resID tables */
+		for (uint32_t i = 0; i < (*mRenderMeshList).size(); i++)
+		{
+			const char* name = "";
+			if ((*mRenderMeshList)[i].meshAssetName)
+			{
+				name = (*mRenderMeshList)[i].meshAssetName->name();
+			}
+			mRenderMeshAssetTracker.addAssetName(name, isOpaqueMesh(i));
+		}
+	}
+	else
+	{
+		/* initialize the sprite material name to resID tables */
+		if (getSpriteMaterialName())
+		{
+			mSpriteMaterialAssetTracker.addAssetName(getSpriteMaterialName(), false);
+		}
+	}
+}
+
+void IofxAssetImpl::setSpriteSemanticsUsed(uint32_t spriteSemanticsBitmap)
+{
+	mSpriteSemanticBitmap |= spriteSemanticsBitmap;
+}
+void IofxAssetImpl::setMeshSemanticsUsed(uint32_t meshSemanticsBitmap)
+{
+	mMeshSemanticBitmap |= meshSemanticsBitmap;
+}
+
+uint32_t IofxAssetImpl::getPubStateSize() const
+{
+	return mSpriteParams ? sizeof(SpritePublicState) : sizeof(MeshPublicState);
+}
+
+uint32_t IofxAssetImpl::getPrivStateSize() const
+{
+	return mSpriteParams ? sizeof(SpritePrivateState) : sizeof(MeshPrivateState);
+}
+
+bool IofxAssetImpl::isSortingEnabled() const
+{
+	const ModifierStack& stack = getModifierStack(ModifierStage_Continuous);
+	for (ModifierStack::ConstIterator it = stack.begin(); it != stack.end(); ++it)
+	{
+		if ((*it)->getModifierType() == ModifierType_ViewDirectionSorting)
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+#ifndef WITHOUT_APEX_AUTHORING
+
+void IofxAssetAuthoringImpl::release()
+{
+	delete this;
+}
+
+const char* IofxAssetAuthoringImpl::getObjTypeName() const
+{
+	return IofxAssetImpl::getObjTypeName();
+}
+
+#if IOFX_AUTHORING_API_ENABLED
+
+void IofxAssetAuthoringImpl::setMeshAssetCount(const uint32_t meshCount)
+{
+	(*mRenderMeshList).resize(meshCount);
+}
+
+void IofxAssetAuthoringImpl::setSpriteMaterialName(const char* inSpriteMaterialName)
+{
+	if ((*mRenderMeshList).size())
+	{
+		APEX_INVALID_OPERATION("Unable to set Sprite Material Name (%s). Systems can be either Mesh or Sprite, but not both. This system is already a Mesh.", getSpriteMaterialName());
+		return;
+	}
+
+	NvParameterized::Handle h(*mParams);
+	NvParameterized::Interface* refParam;
+
+	mParams->getParameterHandle("spriteMaterialName", h);
+	mParams->initParamRef(h, NULL, true);
+	mParams->getParamRef(h, refParam);
+
+	PX_ASSERT(refParam);
+	if (refParam)
+	{
+		refParam->setName(inSpriteMaterialName);
+	}
+}
+
+void IofxAssetAuthoringImpl::setMeshAssetName(const char* meshAssetName, uint32_t meshIndex)
+{
+	if (getSpriteMaterialName())
+	{
+		APEX_INVALID_OPERATION("Unable to set Mesh Material Name (%s). Systems can be either Mesh or Sprite, but not both. This system is already a Sprite.", meshAssetName);
+		return;
+	}
+
+	PX_ASSERT(meshIndex < (*mRenderMeshList).size());
+
+	NvParameterized::Handle arrayHandle(*mParams), indexHandle(*mParams), childHandle(*mParams);
+	NvParameterized::Interface* refPtr;
+
+	mParams->getParameterHandle("renderMeshList", arrayHandle);
+	arrayHandle.getChildHandle(meshIndex, indexHandle);
+
+	indexHandle.getChildHandle(mParams, "meshAssetName", childHandle);
+	mParams->initParamRef(childHandle, NULL, true);
+	mParams->getParamRef(childHandle, refPtr);
+	PX_ASSERT(refPtr);
+	if (refPtr)
+	{
+		refPtr->setName(meshAssetName);
+	}
+}
+
+void IofxAssetAuthoringImpl::setMeshAssetWeight(const uint32_t weight, uint32_t meshIndex)
+{
+	if (getSpriteMaterialName())
+	{
+		APEX_INVALID_OPERATION("Unable to set Mesh Material Weight (%d). Systems can be either Mesh or Sprite, but not both. This system is already a Sprite.", weight);
+		return;
+	}
+
+	PX_ASSERT(meshIndex < (*mRenderMeshList).size());
+	(*mRenderMeshList)[meshIndex].weight = weight;
+}
+
+
+Modifier* IofxAssetAuthoringImpl::createModifier(uint32_t modStage, uint32_t modType)
+{
+	// create a modifier to go in this particular modifier stage
+	// we'll need a handle to the correct mod stage list, pass that and the Param Obj to CreateModifier,
+	// it will resize the array (+1), then pass the correct string to initParamRef()
+	// Then it can pass the new ref param to the mod constructor
+	NvParameterized::Handle h(*mParams), ih(*mParams);
+	int modStackSize = 0;
+
+	getModifierStack(modStage, h);
+
+	// resize the array
+	mParams->getArraySize(h, modStackSize);
+	mParams->resizeArray(h, ++modStackSize);
+
+	h.getChildHandle(modStackSize - 1, ih);
+
+	Modifier* retVal = CreateModifier((ModifierTypeEnum)modType, mParams, ih);
+
+	uint32_t assetTarget = getAssetTarget();
+	// We don't yet know what type this is, which is invalid.
+	if (assetTarget == 0)
+	{
+		// delete the new param ref and re-resize array
+		NvParameterized::Interface* refParam = 0;
+		mParams->getParamRef(ih, refParam);
+		PX_ASSERT(refParam);
+		if (refParam)
+		{
+			refParam->destroy();
+		}
+		mParams->resizeArray(h, modStackSize - 1);
+
+		delete retVal;
+		retVal = 0;
+		APEX_INVALID_OPERATION("Specifying modifiers before specifying the mesh or sprite asset is invalid");
+		return retVal;
+	}
+
+	// The modifier only supports certain semantics, so let's test those now.
+	const uint32_t supportedUsage = retVal->getModifierUsage();
+
+	if ((supportedUsage & assetTarget) != assetTarget)
+	{
+		// delete the new param ref and re-resize array
+		NvParameterized::Interface* refParam = 0;
+		mParams->getParamRef(ih, refParam);
+		PX_ASSERT(refParam);
+		if (refParam)
+		{
+			refParam->destroy();
+		}
+		mParams->resizeArray(h, modStackSize - 1);
+
+		delete retVal;
+		retVal = 0;
+		APEX_INVALID_OPERATION("The specified modifier doesn't work on that system type (e.g. Sprite ModifierImpl on a Mesh System or vice-versa).");
+		return retVal;
+	}
+
+	uint32_t stageBits = ModifierUsageFromStage(ModifierStage(modStage));
+	if ((supportedUsage & stageBits) != stageBits)
+	{
+		// delete the new param ref and re-resize array
+		NvParameterized::Interface* refParam = 0;
+		mParams->getParamRef(ih, refParam);
+		PX_ASSERT(refParam);
+		if (refParam)
+		{
+			refParam->destroy();
+		}
+		mParams->resizeArray(h, modStackSize - 1);
+
+		delete retVal;
+		retVal = 0;
+		APEX_INVALID_OPERATION("The specified modifier doesn't work in that stage.");
+		return retVal;
+	}
+
+	ModifierStack& activeStack = getModifierStack(modStage);
+
+	activeStack.pushBack(retVal);
+	return retVal;
+}
+
+void IofxAssetAuthoringImpl::removeModifier(uint32_t modStage, uint32_t position)
+{
+	if (modStage >= ModifierStage_Count)
+	{
+		APEX_INVALID_OPERATION("Invalid modifier stage");
+		return;
+	}
+
+	ModifierStack& activeStack = getModifierStack(modStage);
+
+	if (position >= activeStack.size())
+	{
+		APEX_INVALID_OPERATION("position %d is greater than modifier stack size: %d", position, activeStack.size());
+		return;
+	}
+
+	// remove from ModifierStack (runtime)
+	activeStack.replaceWithLast(position);
+
+	// remove from NvParameterized data
+	NvParameterized::Handle h(*mParams), ih(*mParams);
+	NvParameterized::Interface* modParams = 0;
+	int modStackSize = 0;
+
+	// 1. get the correct stack
+	getModifierStack(modStage, h);
+
+	// 2. get the NvParameterized::Interface* for the position
+	mParams->getArraySize(h, modStackSize);
+	h.getChildHandle(position, ih);
+	mParams->getParamRef(ih, modParams);
+	PX_ASSERT(modParams);
+
+	// 3. destroy it
+	modParams->destroy();
+
+	// 4. copy the last member of the stack to position
+	if (position != (uint32_t)modStackSize - 1)
+	{
+		NvParameterized::Handle lastH(*mParams);
+		h.getChildHandle(modStackSize - 1, lastH);
+		mParams->getParamRef(lastH, modParams);
+		mParams->setParamRef(ih, modParams);
+	}
+
+	// 5. resize the stack
+	mParams->resizeArray(h, modStackSize - 1);
+}
+
+uint32_t IofxAssetAuthoringImpl::getModifierCount(uint32_t modStage) const
+{
+	if (modStage >= ModifierStage_Count)
+	{
+		APEX_INVALID_OPERATION("Invalid modifier stage");
+		return 0;
+	}
+
+	const ModifierStack& activeStack = getModifierStack(modStage);
+	return activeStack.size();
+}
+
+uint32_t IofxAssetAuthoringImpl::findModifier(uint32_t modStage, Modifier* modifier)
+{
+	if (modStage >= ModifierStage_Count)
+	{
+		APEX_INVALID_OPERATION("Invalid modifier stage");
+		return 0;
+	}
+
+	const ModifierStack& activeStack = getModifierStack(modStage);
+
+	for (uint32_t i = 0; i < activeStack.size(); i++)
+	{
+		if (activeStack[i] == modifier)
+		{
+			return i;
+		}
+	}
+
+	return 0xffffffff;
+}
+
+Modifier* IofxAssetAuthoringImpl::getModifier(uint32_t modStage, uint32_t position) const
+{
+	if (modStage >= ModifierStage_Count)
+	{
+		APEX_INVALID_OPERATION("Invalid modifier stage");
+		return 0;
+	}
+
+	const ModifierStack& activeStack = getModifierStack(modStage);
+
+	if (position >= activeStack.size())
+	{
+		APEX_INVALID_OPERATION("position %d is greater than modifier stack size: %d", position, activeStack.size());
+		return 0;
+	}
+
+	// remove from ModifierStack (runtime)
+	return activeStack[ position ];
+}
+
+uint32_t IofxAssetAuthoringImpl::getAssetTarget() const
+{
+	uint32_t retVal = 0;
+	if (getSpriteMaterialName())
+	{
+		retVal |= ModifierUsage_Sprite;
+	}
+	else if ((*mRenderMeshList).size())
+	{
+		retVal |= ModifierUsage_Mesh;
+	}
+
+	return retVal;
+}
+
+#endif /* IOFX_AUTHORING_API_ENABLED */
+
+#endif
+
+}
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/IofxManager.cpp b/APEX_1.4/module/iofx/src/IofxManager.cpp
new file mode 100644
index 00000000..490fe3c7
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/IofxManager.cpp
@@ -0,0 +1,1291 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "Apex.h"
+#include "PsArray.h"
+#include "SceneIntl.h"
+#include "ModuleIofxImpl.h"
+#include "IofxManager.h"
+#include "IofxSceneCPU.h"
+#include "IofxAssetImpl.h"
+#include "IosObjectData.h"
+#include "IofxRenderData.h"
+
+#include "IofxActorCPU.h"
+
+#if APEX_CUDA_SUPPORT
+#include "ApexCuda.h" // APEX_CUDA_MEM_ALIGN_UP_32BIT
+#include "ApexMirroredArray.h"
+#if ENABLE_TEST
+#include "IofxTestManagerGPU.h"
+#define IOFX_MANAGER_GPU IofxTestManagerGPU
+#else
+#include "IofxManagerGPU.h"
+#define IOFX_MANAGER_GPU IofxManagerGPU
+#endif
+#endif
+
+#define BASE_SPRITE_SEMANTICS (1<<IofxRenderSemantic::POSITION) | \
+	(1<<IofxRenderSemantic::VELOCITY) | \
+	(1<<IofxRenderSemantic::LIFE_REMAIN)
+
+#define BASE_MESH_SEMANTICS   (1<<IofxRenderSemantic::POSITION) | \
+	(1<<IofxRenderSemantic::SCALE) | \
+	(1<<IofxRenderSemantic::ROTATION) | \
+	(1<<IofxRenderSemantic::VELOCITY) | \
+	(1<<IofxRenderSemantic::LIFE_REMAIN)
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#pragma warning(disable: 4355) // 'this' : used in base member initializer list
+
+
+IofxManager::IofxManager(IofxScene& scene, const IofxManagerDescIntl& desc, bool isMesh)
+	: mPostUpdateTaskID(0)
+	, mIofxScene(&scene)
+	, mIosAssetName(desc.iosAssetName)
+	, mWorkingIosData(NULL)
+	, mResultIosData(NULL)
+	, mStagingIosData(NULL)
+	, mTargetSemantics(0)
+	, mRenderState(RENDER_WAIT_FOR_DATA_ALLOC)
+	, mInteropFlags(RenderInteropFlags::NO_INTEROP)
+	, positionMass(*scene.mApexScene, PX_ALLOC_INFO("positionMass", PARTICLES))
+	, velocityLife(*scene.mApexScene, PX_ALLOC_INFO("velocityLife", PARTICLES))
+	, collisionNormalFlags(*scene.mApexScene, PX_ALLOC_INFO("collisionNormalFlags", PARTICLES))
+	, density(*scene.mApexScene, PX_ALLOC_INFO("density", PARTICLES))
+	, actorIdentifiers(*scene.mApexScene, PX_ALLOC_INFO("actorIdentifiers", PARTICLES))
+	, inStateToInput(*scene.mApexScene, PX_ALLOC_INFO("inStateToInput", PARTICLES))
+	, outStateToInput(*scene.mApexScene, PX_ALLOC_INFO("outStateToInput", PARTICLES))
+	, userData(*scene.mApexScene, PX_ALLOC_INFO("userData", PARTICLES))
+	, pubStateSize(0)
+	, privStateSize(0)
+	, mStateSwap(false)
+	, mTotalElapsedTime(0)
+	, mIsMesh(isMesh)
+	, mDistanceSortingEnabled(false)
+	, mCudaIos(desc.iosOutputsOnDevice)
+	, mCudaModifiers(false)
+	, mCudaPipeline(NULL)
+	, mSimulateTask(*this)
+#if APEX_CUDA_SUPPORT
+	, mCopyQueue(*scene.mApexScene->getTaskManager()->getGpuDispatcher())
+#endif
+	, mLastNumObjects(0)
+	, mLastMaxInputID(0)
+	, mOnStartCallback(NULL)
+	, mOnFinishCallback(NULL)
+{
+	scene.mActorManagers.add(*this);
+
+	mBounds.setEmpty();
+
+	mInStateOffset = 0;
+	mOutStateOffset = desc.maxObjectCount;
+
+	// The decision whether to use GPU IOFX Modifiers is separate from whether the IOS
+	// outputs will come from the GPU or not
+#if APEX_CUDA_SUPPORT
+	PxGpuDispatcher* gd = scene.mApexScene->getTaskManager()->getGpuDispatcher();
+	if (gd && gd->getCudaContextManager()->contextIsValid() && !scene.mModule->mCudaDisabled)
+	{
+		mCudaModifiers = true;
+		// detect interop
+		if (gd->getCudaContextManager()->getInteropMode() != PxCudaInteropMode::NO_INTEROP && !scene.mModule->mInteropDisabled)
+		{
+			mInteropFlags = RenderInteropFlags::CUDA_INTEROP;
+		}
+		const uint32_t dataCount = 3u;
+		for (uint32_t i = 0 ; i < dataCount ; i++)
+		{
+			IosObjectGpuData* gpuIosData = PX_NEW(IosObjectGpuData)(i);
+			mObjData.pushBack(gpuIosData);
+		}
+
+		mOutStateOffset = APEX_CUDA_MEM_ALIGN_UP_32BIT(desc.maxObjectCount);
+		mCudaPipeline = PX_NEW(IOFX_MANAGER_GPU)(*mIofxScene->mApexScene, desc, *this);
+	}
+	else
+#endif
+	{
+		const uint32_t dataCount = 3u;
+		for (uint32_t i = 0 ; i < dataCount ; i++)
+		{
+			IosObjectCpuData* cpuIosData = PX_NEW(IosObjectCpuData)(i);
+			mObjData.pushBack(cpuIosData);
+		}
+	}
+
+	mWorkingIosData = mObjData[0];
+	mResultIosData = mObjData[1];
+	mStagingIosData = mObjData[2];
+
+	// Create & Assign Shared Render Data
+	for (uint32_t i = 0 ; i < mObjData.size() ; i++)
+	{
+		if (mIsMesh)
+		{
+			mObjData[i]->renderData = PX_NEW(IofxSharedRenderDataMeshImpl)(i, mInteropFlags);
+		}
+		else
+		{
+			mObjData[i]->renderData = PX_NEW(IofxSharedRenderDataSpriteImpl)(i, mInteropFlags);
+		}
+	}
+
+	ApexMirroredPlace::Enum place = ApexMirroredPlace::CPU;
+#if APEX_CUDA_SUPPORT
+	if (mCudaIos || mCudaModifiers)
+	{
+		place =  ApexMirroredPlace::CPU_GPU;
+	}
+#endif
+	{
+		positionMass.setSize(desc.maxInputCount, place);
+		velocityLife.setSize(desc.maxInputCount, place);
+		if (desc.iosSupportsCollision)
+		{
+			collisionNormalFlags.setSize(desc.maxInputCount, place);
+		}
+		if (desc.iosSupportsDensity)
+		{
+			density.setSize(desc.maxInputCount, place);
+		}
+		actorIdentifiers.setSize(desc.maxInputCount, place);
+		inStateToInput.setSize(desc.maxInStateCount, place);
+		outStateToInput.setSize(desc.maxObjectCount, place);
+
+		if (desc.iosSupportsUserData)
+		{
+			userData.setSize(desc.maxInputCount, place);
+		}
+
+		mSimBuffers.pmaPositionMass = &positionMass;
+		mSimBuffers.pmaVelocityLife = &velocityLife;
+		mSimBuffers.pmaCollisionNormalFlags = desc.iosSupportsCollision ? &collisionNormalFlags : NULL;
+		mSimBuffers.pmaDensity = desc.iosSupportsDensity ? &density : NULL;
+		mSimBuffers.pmaActorIdentifiers = &actorIdentifiers;
+		mSimBuffers.pmaInStateToInput = &inStateToInput;
+		mSimBuffers.pmaOutStateToInput = &outStateToInput;
+		mSimBuffers.pmaUserData = desc.iosSupportsUserData ? &userData : NULL;
+	}
+
+	if (!mCudaModifiers)
+	{
+		mOutputToState.resize(desc.maxObjectCount);
+	}
+
+	/* Initialize IOS object data structures */
+	for (uint32_t i = 0 ; i < mObjData.size() ; i++)
+	{
+		mObjData[i]->pmaPositionMass = mSimBuffers.pmaPositionMass;
+		mObjData[i]->pmaVelocityLife = mSimBuffers.pmaVelocityLife;
+		mObjData[i]->pmaCollisionNormalFlags = mSimBuffers.pmaCollisionNormalFlags;
+		mObjData[i]->pmaDensity = mSimBuffers.pmaDensity;
+		mObjData[i]->pmaActorIdentifiers = mSimBuffers.pmaActorIdentifiers;
+		mObjData[i]->pmaInStateToInput = mSimBuffers.pmaInStateToInput;
+		mObjData[i]->pmaOutStateToInput = mSimBuffers.pmaOutStateToInput;
+		mObjData[i]->pmaUserData = mSimBuffers.pmaUserData;
+
+		mObjData[i]->iosAssetName = desc.iosAssetName;
+		mObjData[i]->iosOutputsOnDevice = desc.iosOutputsOnDevice;
+		mObjData[i]->iosSupportsDensity = desc.iosSupportsDensity;
+		mObjData[i]->iosSupportsCollision = desc.iosSupportsCollision;
+		mObjData[i]->iosSupportsUserData = desc.iosSupportsUserData;
+		mObjData[i]->maxObjectCount = desc.maxObjectCount;
+		mObjData[i]->maxInputCount = desc.maxInputCount;
+		mObjData[i]->maxInStateCount = desc.maxInStateCount;
+	}
+}
+
+IofxManager::~IofxManager()
+{
+	for (uint32_t i = 0; i < pubState.slices.size(); ++i)
+	{
+		delete pubState.slices[i];
+	}
+
+	for (uint32_t i = 0; i < privState.slices.size(); ++i)
+	{
+		delete privState.slices[i];
+	}
+}
+
+void IofxManager::destroy()
+{
+#if APEX_CUDA_SUPPORT
+	if (mCudaPipeline)
+	{
+		mCudaPipeline->release();
+	}
+#endif
+	for (uint32_t i = 0 ; i < mObjData.size() ; i++)
+	{
+		PX_DELETE(mObjData[i]);
+	}
+
+	delete this;
+}
+
+
+void IofxManager::release()
+{
+	mIofxScene->releaseIofxManager(this);
+}
+
+#if !APEX_CUDA_SUPPORT
+/* Stubs for console builds */
+void IofxManager::fillMapUnmapArraysForInterop(nvidia::Array<CUgraphicsResource> &, nvidia::Array<CUgraphicsResource> &) {}
+void IofxManager::mapBufferResultsForInterop(bool, bool) {}
+#endif
+
+void IofxManager::prepareRenderables()
+{
+	const uint32_t targetSemantics = mTargetSemantics;
+
+	switch (mRenderState)
+	{
+	case RENDER_READY:
+		//PX_ASSERT(mResultIosData->renderData->getBufferIsMapped() == true);
+		mResultIosData->renderData->unmap();
+
+		//PX_ASSERT(mStagingIosData->renderData->getBufferIsMapped() == false);
+		mStagingIosData->updateSemantics(*mIofxScene, targetSemantics);
+		mStagingIosData->renderData->map();
+
+		nvidia::swap(mStagingIosData, mResultIosData);
+
+		mRenderState = RENDER_WAIT_FOR_NEW;
+		break;
+	case RENDER_WAIT_FOR_DATA_ALLOC:
+		if (targetSemantics != 0)
+		{
+			mResultIosData->updateSemantics(*mIofxScene, targetSemantics);
+			mResultIosData->renderData->map();
+			mStagingIosData->updateSemantics(*mIofxScene, targetSemantics);
+			mStagingIosData->renderData->map();
+
+			mRenderState = RENDER_WAIT_FOR_FETCH_RESULT;
+		}
+		//go to default case here!
+	default:
+		return;
+	};
+
+	// mLiveRenderVolumesLock is allready locked in IofxScene::prepareRenderables
+	for (uint32_t i = 0 ; i < mIofxScene->mLiveRenderVolumes.size() ; i++)
+	{
+		RenderVolumeImpl* vol = mIofxScene->mLiveRenderVolumes[i];
+		// all render volumes are allready locked in IofxScene::prepareRenderables
+
+		uint32_t iofxActorCount;
+		IofxActor* const* iofxActorList = vol->lockIofxActorList(iofxActorCount);
+		for (uint32_t iofxActorIndex = 0; iofxActorIndex < iofxActorCount; ++iofxActorIndex)
+		{
+			IofxActorImpl* iofxActor = DYNAMIC_CAST(IofxActorImpl*)( iofxActorList[iofxActorIndex] );
+			if (&iofxActor->mMgr == this)
+			{
+				iofxActor->prepareRenderables(mStagingIosData);
+			}
+		}
+		vol->unlockIofxActorList();
+	}
+}
+
+float IofxManager::getObjectRadius() const
+{
+	return mObjData[0] ? mObjData[0]->radius : 0.0f;
+}
+
+void IofxManager::setSimulationParameters(float radius, const PxVec3& up, float gravity, float restDensity)
+{
+	/* Initialize IOS object data structures */
+	for (uint32_t i = 0 ; i < mObjData.size() ; i++)
+	{
+		mObjData[i]->radius = radius;
+		mObjData[i]->upVector = up;
+		mObjData[i]->gravity = gravity;
+		mObjData[i]->restDensity = restDensity;
+	}
+}
+
+void IofxManager::createSimulationBuffers(IosBufferDescIntl& outDesc)
+{
+	outDesc = mSimBuffers;
+}
+
+/* Called by owning IOS actor during simulation startup, only if
+ * the IOS is going to simulate this frame, so it is safe to submit
+ * tasks from here. postUpdateTaskID is the ID for an IOS task
+ * that should run after IOFX modifiers.  If the IOFX Manager adds
+ * no dependencies, postUpdateTaskID task will run right after
+ * updateEffectsData() returns.  If updateEffectsData() will be completely
+ * synchronous, it is safe to return (PxTaskID)0xFFFFFFFF here.
+ */
+PxTaskID IofxManager::getUpdateEffectsTaskID(PxTaskID postUpdateTaskID)
+{
+	PxTaskManager* tm = mIofxScene->mApexScene->getTaskManager();
+	mPostUpdateTaskID = postUpdateTaskID;
+	if (mCudaModifiers)
+	{
+		return mCudaPipeline->launchGpuTasks();
+	}
+	else
+	{
+		tm->submitUnnamedTask(mSimulateTask);
+		mSimulateTask.finishBefore(tm->getNamedTask(AST_PHYSX_FETCH_RESULTS));
+		return mSimulateTask.getTaskID();
+	}
+}
+
+
+void TaskUpdateEffects::run()
+{
+	setProfileStat((uint16_t) mOwner.mWorkingIosData->numParticles);
+	mOwner.cpuModifiers();
+}
+
+/// \brief Called by IOS actor before TaskUpdateEffects is scheduled to run
+void IofxManager::updateEffectsData(float deltaTime, uint32_t numObjects, uint32_t maxInputID, uint32_t maxStateID, void* extraData)
+{
+	PX_ASSERT(maxStateID >= maxInputID && maxInputID >= numObjects);
+
+	mLastNumObjects = numObjects;
+	mLastMaxInputID = maxInputID;
+
+	if (mCudaIos && !mCudaModifiers)
+	{
+#if APEX_CUDA_SUPPORT
+		/* Presumably, updateEffectsData() is being called from a DtoH GPU task */
+		mCopyQueue.reset(CUstream(extraData), 8);
+		positionMass.copyDeviceToHostQ(mCopyQueue, maxInputID);
+		velocityLife.copyDeviceToHostQ(mCopyQueue, maxInputID);
+		if (mWorkingIosData->iosSupportsCollision)
+		{
+			collisionNormalFlags.copyDeviceToHostQ(mCopyQueue, maxInputID);
+		}
+		if (mWorkingIosData->iosSupportsDensity)
+		{
+			density.copyDeviceToHostQ(mCopyQueue, maxInputID);
+		}
+		if (mWorkingIosData->iosSupportsUserData)
+		{
+			userData.copyDeviceToHostQ(mCopyQueue, maxInputID);
+		}
+		actorIdentifiers.copyDeviceToHostQ(mCopyQueue, maxInputID);
+		inStateToInput.copyDeviceToHostQ(mCopyQueue, maxStateID);
+		mCopyQueue.flushEnqueued();
+
+		mIofxScene->mApexScene->getTaskManager()->getGpuDispatcher()->addCompletionPrereq(mSimulateTask);
+#else
+		PX_UNUSED(extraData);
+		PX_ALWAYS_ASSERT();
+#endif
+	}
+
+	/* Data from the IOS */
+	mWorkingIosData->maxInputID = maxInputID;
+	mWorkingIosData->maxStateID = maxStateID;
+	mWorkingIosData->numParticles = numObjects;
+
+	/* Data from the scene */
+	mWorkingIosData->eyePosition = mIofxScene->mApexScene->getEyePosition();
+	mWorkingIosData->eyeDirection = mIofxScene->mApexScene->getEyeDirection();
+
+	PxMat44 viewMtx = mIofxScene->mApexScene->getViewMatrix();
+	PxMat44 projMtx = mIofxScene->mApexScene->getProjMatrix();
+	mWorkingIosData->eyeAxisX = PxVec3(viewMtx.column0.x, viewMtx.column1.x, viewMtx.column2.x);
+	mWorkingIosData->eyeAxisY = PxVec3(viewMtx.column0.y, viewMtx.column1.y, viewMtx.column2.y);
+	mWorkingIosData->zNear = PxAbs(projMtx.column3.z / projMtx.column2.z);
+
+	mWorkingIosData->deltaTime = deltaTime;
+	// TODO: Convert into uint32_t elapsed milliseconds
+	mTotalElapsedTime = numObjects ? mTotalElapsedTime + mWorkingIosData->deltaTime : 0;
+	mWorkingIosData->elapsedTime = mTotalElapsedTime;
+
+	/* IOFX data */
+	if (mCudaModifiers)
+	{
+		mCudaPipeline->launchPrep(); // calls allocOutputs
+	}
+}
+
+void IofxManager::cpuModifiers()
+{
+	if (!mCudaIos && mOnStartCallback)
+	{
+		(*mOnStartCallback)(NULL);
+	}
+	uint32_t maxInputID, maxStateID, numObjects;
+
+	maxInputID = mWorkingIosData->maxInputID;
+	maxStateID = mWorkingIosData->maxStateID;
+	numObjects = mWorkingIosData->numParticles;
+
+	PX_UNUSED(numObjects);
+
+	/* Swap state buffer pointers */
+
+	IosObjectCpuData* md = DYNAMIC_CAST(IosObjectCpuData*)(mWorkingIosData);
+
+	md->inPubState = mStateSwap ? &pubState.a[0] : &pubState.b[0];
+	md->outPubState = mStateSwap ? &pubState.b[0] : &pubState.a[0];
+
+	md->inPrivState = mStateSwap ? &privState.a[0] : &privState.b[0];
+	md->outPrivState = mStateSwap ? &privState.b[0] : &privState.a[0];
+
+	swapStates();
+
+	/* Sort sprites */
+
+	if (!mIsMesh)
+	{
+		DYNAMIC_CAST(IosObjectCpuData*)(mWorkingIosData)->sortingKeys =
+			mDistanceSortingEnabled ? &mSortingKeys.front() : NULL;
+	}
+
+	/* Volume Migration (1 pass) */
+
+	mCountPerActor.clear();
+	mCountPerActor.resize(mActorTable.size() * mVolumeTable.size(), 0);
+	for (uint32_t input = 0 ; input < maxInputID ; input++)
+	{
+		IofxActorIDIntl& id = mWorkingIosData->pmaActorIdentifiers->get(input);
+		if (id.getActorClassID() == IofxActorIDIntl::IPX_ACTOR || id.getActorClassID() >= mActorClassTable.size())
+		{
+			id.set(IofxActorIDIntl::NO_VOLUME, IofxActorIDIntl::IPX_ACTOR);
+		}
+		else
+		{
+			const PxVec3& pos = mWorkingIosData->pmaPositionMass->get(input).getXYZ();
+			uint32_t curPri = 0;
+			uint16_t curVID = IofxActorIDIntl::NO_VOLUME;
+
+			for (uint16_t i = 0 ; i < mVolumeTable.size() ; i++)
+			{
+				VolumeData& vd = mVolumeTable[ i ];
+				if (vd.vol == NULL)
+				{
+					continue;
+				}
+
+				const uint32_t bit = mActorClassTable.size() * i + id.getActorClassID();
+
+				// This volume owns this particle if:
+				//  1. The volume bounds contain the particle
+				//  2. The volume affects the particle's IOFX Asset
+				//  3. This volume has the highest priority or was the previous owner
+				if (vd.mBounds.contains(pos) &&
+				    (mVolumeActorClassBitmap[ bit >> 5 ] & (1u << (bit & 31))) &&
+				    (curVID == IofxActorIDIntl::NO_VOLUME || vd.mPri > curPri || (vd.mPri == curPri && id.getVolumeID() == i)))
+				{
+					curVID = i;
+					curPri = vd.mPri;
+				}
+			}
+
+			id.setVolumeID(curVID);
+		}
+
+		// Count particles in each actor
+		if (id.getVolumeID() != IofxActorIDIntl::NO_VOLUME)
+		{
+			const uint32_t actorID = mActorClassTable[ id.getActorClassID() ].actorID;
+			PX_ASSERT(actorID < mActorTable.size());
+			const uint32_t aid = id.getVolumeID() * mActorTable.size() + actorID;
+			++mCountPerActor[aid];
+		}
+	}
+
+	/* Prefix sum */
+	mStartPerActor.clear();
+	mStartPerActor.resize(mCountPerActor.size(), 0);
+	uint32_t sum = 0;
+	for (uint32_t i = 0 ; i < mStartPerActor.size() ; i++)
+	{
+		mStartPerActor[ i ] = sum;
+		sum += mCountPerActor[ i ];
+	}
+
+	IosObjectCpuData* objData = DYNAMIC_CAST(IosObjectCpuData*)(mWorkingIosData);
+	objData->outputToState = &mOutputToState.front();
+
+	/* Generate outputToState (1 pass) */
+	mBuildPerActor.clear();
+	mBuildPerActor.resize(mStartPerActor.size(), 0);
+	uint32_t homeless = 0;
+	for (uint32_t state = 0 ; state < maxStateID ; state++)
+	{
+		uint32_t input = objData->pmaInStateToInput->get(state);
+		if (input == IosBufferDescIntl::NOT_A_PARTICLE)
+		{
+			continue;
+		}
+
+		input &= ~IosBufferDescIntl::NEW_PARTICLE_FLAG;
+
+		const IofxActorIDIntl id = objData->pmaActorIdentifiers->get(input);
+		if (id.getVolumeID() == IofxActorIDIntl::NO_VOLUME)
+		{
+			objData->pmaOutStateToInput->get(sum + homeless) = input;
+			++homeless;
+		}
+		else
+		{
+			PX_ASSERT(id.getActorClassID() != IofxActorIDIntl::IPX_ACTOR && id.getActorClassID() < mActorClassTable.size());
+			const uint32_t actorID = mActorClassTable[ id.getActorClassID() ].actorID;
+			PX_ASSERT(actorID < mActorTable.size());
+			const uint32_t aid = id.getVolumeID() * mActorTable.size() + actorID;
+			objData->outputToState[ mStartPerActor[aid] + mBuildPerActor[ aid ]++ ] = state;
+		}
+	}
+
+	/* Step IOFX Actors */
+	uint32_t aid = 0;
+	PxTaskManager* tm = mIofxScene->mApexScene->getTaskManager();
+	for (uint32_t i = 0 ; i < mVolumeTable.size() ; i++)
+	{
+		VolumeData& d = mVolumeTable[ i ];
+		if (d.vol == 0)
+		{
+			aid += mActorTable.size();
+			continue;
+		}
+
+		for (uint32_t j = 0 ; j < mActorTable.size(); j++)
+		{
+			if (d.mActors[ j ] == DEFERRED_IOFX_ACTOR && mActorTable[ j ] != NULL &&
+			        (mIofxScene->mModule->mDeferredDisabled || mCountPerActor[ aid ]))
+			{
+				IofxActorImpl* iofxActor = PX_NEW(IofxActorCPU)(mActorTable[j]->getRenderResID(), mIofxScene, *this);
+				if (d.vol->addIofxActor(*iofxActor))
+				{
+					d.mActors[ j ] = iofxActor;
+
+					initIofxActor(iofxActor, j, d.vol);
+				}
+				else
+				{
+					iofxActor->release();
+				}
+			}
+
+			IofxActorCPU* cpuIofx = DYNAMIC_CAST(IofxActorCPU*)(d.mActors[ j ]);
+			if (cpuIofx && cpuIofx != DEFERRED_IOFX_ACTOR)
+			{
+				if (mCountPerActor[ aid ])
+				{
+					ObjectRange range;
+					range.objectCount = mCountPerActor[ aid ];
+					range.startIndex = mStartPerActor[ aid ];
+					PX_ASSERT(range.startIndex + range.objectCount <= numObjects);
+
+					cpuIofx->mWorkingRange = range;
+
+					cpuIofx->mModifierTask.setContinuation(*tm, tm->getTaskFromID(mPostUpdateTaskID));
+					cpuIofx->mModifierTask.removeReference();
+				}
+				else
+				{
+					cpuIofx->mWorkingVisibleCount = 0;
+					cpuIofx->mWorkingRange.objectCount = 0;
+					cpuIofx->mWorkingRange.startIndex = 0;
+					cpuIofx->mWorkingBounds.setEmpty();
+				}
+			}
+
+			aid++;
+		}
+	}
+
+	if (!mCudaIos && mOnFinishCallback)
+	{
+		(*mOnFinishCallback)(NULL);
+	}
+}
+
+void IofxManager::outputHostToDevice(PxGpuCopyDescQueue& copyQueue)
+{
+	if (mCudaIos && !mCudaModifiers)
+	{
+#if APEX_CUDA_SUPPORT
+		actorIdentifiers.copyHostToDeviceQ(copyQueue, mLastMaxInputID);
+		outStateToInput.copyHostToDeviceQ(copyQueue, mLastNumObjects);
+#else
+		PX_UNUSED(copyQueue);
+		PX_ALWAYS_ASSERT();
+#endif
+	}
+}
+
+
+void IofxManager::submitTasks()
+{
+	/* Discover new volumes, removed volumes */
+	for (uint32_t i = 0 ; i < mVolumeTable.size() ; i++)
+	{
+		mVolumeTable[ i ].mFlags = 0;
+	}
+
+	for (uint32_t i = 0 ; i < mIofxScene->mLiveRenderVolumes.size() ; i++)
+	{
+		getVolumeID(mIofxScene->mLiveRenderVolumes[ i ]);
+	}
+
+	for (uint32_t i = 0 ; i < mVolumeTable.size() ; i++)
+	{
+		if (mVolumeTable[ i ].mFlags == 0)
+		{
+			mVolumeTable[ i ].vol = 0;
+		}
+	}
+
+	/* Trim Volume, ActorID and ActorClassID tables */
+	while (mVolumeTable.size() && mVolumeTable.back().vol == 0)
+	{
+		mVolumeTable.popBack();
+	}
+
+	if (!mActorTable.empty())
+	{
+		int32_t lastValidID = -1;
+		for (int32_t cur = (int32_t)mActorTable.size() - 1; cur >= 0; --cur)
+		{
+			if (mActorTable[(uint32_t)cur] != NULL)
+			{
+				lastValidID = cur;
+				break;
+			}
+		}
+		if (lastValidID == -1)
+		{
+			mActorTable.clear();
+		}
+		else
+		{
+			mActorTable.resize((uint32_t)lastValidID + 1);
+		}
+	}
+
+	if (!mActorClassTable.empty())
+	{
+		int32_t lastValidID = -1;
+		for (uint32_t cur = 0; cur < mActorClassTable.size(); cur += mActorClassTable[ cur ].count)
+		{
+			if (mActorClassTable[ cur ].client != NULL)
+			{
+				lastValidID = (int32_t)cur;
+			}
+		}
+		if (lastValidID == -1)
+		{
+			mActorClassTable.clear();
+		}
+		else
+		{
+			mActorClassTable.resize((uint32_t)(lastValidID + mActorClassTable[ (uint32_t)lastValidID ].count));
+		}
+	}
+
+	const uint32_t volumeActorClassBitmapSize = (mVolumeTable.size() * mActorClassTable.size() + 31) >> 5;
+	mVolumeActorClassBitmap.resize(volumeActorClassBitmapSize);
+	for (uint32_t i = 0 ; i < volumeActorClassBitmapSize ; i++)
+	{
+		mVolumeActorClassBitmap[ i ] = 0;
+	}
+
+	/* Add new IofxActors as necessary */
+	for (uint32_t i = 0 ; i < mVolumeTable.size() ; i++)
+	{
+		VolumeData& d = mVolumeTable[ i ];
+
+		// First, ensure per-volume actor array can hold all ClassIDs
+		d.mActors.resize(mActorTable.size(), 0);
+
+		if (d.vol == NULL)
+		{
+			continue;
+		}
+
+		d.mBounds = d.vol->getOwnershipBounds();
+		d.mPri = d.vol->getPriority();
+
+		for (uint32_t cur = 0; cur < mActorTable.size(); ++cur)
+		{
+			if (mActorTable[ cur ] != NULL)
+			{
+				if (!d.mActors[ cur ])
+				{
+					d.mActors[ cur ] = DEFERRED_IOFX_ACTOR;
+				}
+			}
+		}
+
+		d.vol->lockReader(); // for safety during affectsIofxAsset() calls
+		for (uint32_t cur = 0; cur < mActorClassTable.size(); ++cur)
+		{
+			const ActorClassData& acd = mActorClassTable[ cur ];
+			if (acd.client != NULL && acd.actorID < mActorTable.size())
+			{
+				IofxAssetImpl* iofxAsset = acd.client->getAssetSceneInst()->getAsset();
+				if (iofxAsset && d.vol->affectsIofxAsset(*iofxAsset))
+				{
+					const uint32_t bit = mActorClassTable.size() * i + cur;
+					mVolumeActorClassBitmap[ bit >> 5 ] |= (1u << (bit & 31));
+				}
+			}
+		}
+		d.vol->unlockReader(); // for safety during affectsIofxAsset() calls
+	}
+
+	uint32_t targetSemantics = 0;
+	mDistanceSortingEnabled = false;
+	{
+		for (AssetHashMap_t::Iterator it = mAssetHashMap.getIterator(); !it.done(); ++it)
+		{
+			IofxAssetImpl* iofxAsset = it->first;
+			IofxAssetSceneInst* iofxAssetSceneInst = it->second;
+
+			targetSemantics |= iofxAssetSceneInst->getSemantics();
+			if (!mDistanceSortingEnabled && iofxAsset->isSortingEnabled())
+			{
+				mDistanceSortingEnabled = true;
+				if (!mCudaModifiers)
+				{
+					mSortingKeys.resize(mOutputToState.size());
+				}
+			}
+		}
+	}
+	mTargetSemantics = targetSemantics;
+
+	if (mCudaModifiers)
+	{
+		mCudaPipeline->submitTasks();
+	}
+
+	if (!addedAssets.empty())
+	{
+		/* Calculate state sizes required by new assets */
+		uint32_t newPubStateSize = 0, newPrivStateSize = 0;
+		for (uint32_t i = 0; i < addedAssets.size(); ++i)
+		{
+			newPubStateSize = PxMax(newPubStateSize, addedAssets[i]->getPubStateSize());
+			newPrivStateSize = PxMax(newPrivStateSize, addedAssets[i]->getPrivStateSize());
+		}
+
+		uint32_t maxObjectCount = outStateToInput.getSize(),
+			totalCount = mOutStateOffset + maxObjectCount;
+
+		// Allocate data for pubstates
+		while (newPubStateSize > pubStateSize)
+		{
+			pubStateSize += sizeof(IofxSlice);
+
+			SliceArray* slice = new SliceArray(*mIofxScene->mApexScene, PX_ALLOC_INFO("slice", PARTICLES));
+
+#if APEX_CUDA_SUPPORT
+			if (mCudaModifiers)
+			{
+				//slice->reserve(totalCount, ApexMirroredPlace::GPU); Recalculated on GPU
+			}
+			else
+#endif
+			{
+				slice->reserve(totalCount, ApexMirroredPlace::CPU);
+			}
+
+			pubState.slices.pushBack(slice);
+
+			IofxSlice* p;
+#if APEX_CUDA_SUPPORT
+			p = mCudaModifiers
+				? pubState.slices.back()->getGpuPtr()
+				: pubState.slices.back()->getPtr();
+#else
+			p = pubState.slices.back()->getPtr();
+#endif
+			pubState.a.pushBack(p + mInStateOffset);
+			pubState.b.pushBack(p + mOutStateOffset);
+		}
+
+		// Allocate data for privstates
+		while (newPrivStateSize > privStateSize)
+		{
+			privStateSize += sizeof(IofxSlice);
+
+			SliceArray* slice = new SliceArray(*mIofxScene->mApexScene, PX_ALLOC_INFO("slice", PARTICLES));
+
+#if APEX_CUDA_SUPPORT
+			if (mCudaModifiers)
+			{
+				slice->reserve(totalCount, ApexMirroredPlace::GPU);
+			}
+			else
+#endif
+			{
+				slice->reserve(totalCount, ApexMirroredPlace::CPU);
+			}
+
+			privState.slices.pushBack(slice);
+
+			IofxSlice* p;
+#if APEX_CUDA_SUPPORT
+			p = mCudaModifiers 
+				? privState.slices.back()->getGpuPtr()
+				: privState.slices.back()->getPtr();
+#else
+			p = privState.slices.back()->getPtr();
+#endif
+			privState.a.pushBack(p + mInStateOffset);
+			privState.b.pushBack(p + mOutStateOffset);
+		}
+
+		addedAssets.clear();
+	}
+}
+
+void IofxManager::swapStates()
+{
+	mStateSwap = !mStateSwap;
+	swap(mInStateOffset, mOutStateOffset);
+}
+
+void IofxManager::fetchResults()
+{
+	if (!mPostUpdateTaskID)
+	{
+		return;
+	}
+	mPostUpdateTaskID = 0;
+
+	if (mCudaModifiers)
+	{
+		mCudaPipeline->fetchResults();
+	}
+	else
+	{
+		for (uint32_t i = 0 ; i < mVolumeTable.size() ; i++)
+		{
+			VolumeData& d = mVolumeTable[ i ];
+			for (uint32_t j = 0 ; j < mActorTable.size() ; j++)
+			{
+				IofxActorCPU* cpuIofx = DYNAMIC_CAST(IofxActorCPU*)(d.mActors[ j ]);
+				if (cpuIofx && cpuIofx != DEFERRED_IOFX_ACTOR)
+				{
+					cpuIofx->mResultBounds = cpuIofx->mWorkingBounds;
+					cpuIofx->mResultRange = cpuIofx->mWorkingRange;
+					cpuIofx->mResultVisibleCount = cpuIofx->mWorkingVisibleCount;
+				}
+			}
+		}
+	}
+
+	//build bounds
+	{
+		mBounds.setEmpty();
+		for (uint32_t i = 0 ; i < mVolumeTable.size() ; i++)
+		{
+			VolumeData& d = mVolumeTable[ i ];
+			for (uint32_t j = 0 ; j < mActorTable.size() ; j++)
+			{
+				IofxActorImpl* iofx = d.mActors[ j ];
+				if (iofx && iofx != DEFERRED_IOFX_ACTOR)
+				{
+					mBounds.include(iofx->mResultBounds);
+				}
+			}
+		}
+	}
+
+	{
+		switch (mRenderState)
+		{
+		case RENDER_WAIT_FOR_DATA_ALLOC:
+			//just do nothing
+			break;
+		case RENDER_WAIT_FOR_FETCH_RESULT:
+			nvidia::swap(mStagingIosData, mWorkingIosData);
+			mRenderState = RENDER_WAIT_FOR_NEW;
+			break;
+		case RENDER_WAIT_FOR_NEW:
+		case RENDER_READY:
+			nvidia::swap(mResultIosData, mWorkingIosData);
+			mRenderState = RENDER_READY;
+			break;
+		default:
+			PX_ALWAYS_ASSERT();
+		};
+	}
+}
+
+PxBounds3 IofxManager::getBounds() const
+{
+	return mBounds;
+}
+
+uint32_t IofxManager::getActorID(IofxAssetSceneInst* assetSceneInst, uint16_t meshID)
+{
+	IofxAssetImpl* iofxAsset = assetSceneInst->getAsset();
+
+	ResID renderResID = INVALID_RESOURCE_ID;
+	if (mIsMesh)
+	{
+		const char* rmName = iofxAsset->getMeshAssetName(meshID);
+		bool isOpaqueMesh = iofxAsset->isOpaqueMesh(meshID);
+		renderResID = iofxAsset->mRenderMeshAssetTracker.getResourceIdFromName(rmName, isOpaqueMesh);
+		if (renderResID == INVALID_RESOURCE_ID)
+		{
+			APEX_INVALID_PARAMETER("IofxManager: Mesh Asset with name \"%s\" not found.", rmName);
+		}
+	}
+	else
+	{
+		const char* mtlName = iofxAsset->getSpriteMaterialName();
+		renderResID = iofxAsset->mSpriteMaterialAssetTracker.getResourceIdFromName(mtlName, false);
+		if (renderResID == INVALID_RESOURCE_ID)
+		{
+			APEX_INVALID_PARAMETER("IofxManager: Sprite Material with name \"%s\" not found.", mtlName);
+		}
+	}
+	uint32_t actorID = uint32_t(-1);
+	if (renderResID != INVALID_RESOURCE_ID)
+	{
+		for (uint32_t id = 0 ; id < mActorTable.size() ; id++)
+		{
+			if (mActorTable[id] != NULL)
+			{
+				if (mActorTable[id]->getRenderResID() == renderResID)
+				{
+					actorID = id;
+					break;
+				}
+			}
+			else if (actorID == uint32_t(-1))
+			{
+				actorID = id;
+			}
+		}
+		if (actorID == uint32_t(-1))
+		{
+			actorID = mActorTable.size();
+			mActorTable.resize(actorID + 1, NULL);
+		}
+
+		IofxActorSceneInst* &actorSceneInst = mActorTable[actorID];
+		if (actorSceneInst == NULL)
+		{
+			actorSceneInst = PX_NEW(IofxActorSceneInst)(renderResID);
+		}
+		actorSceneInst->addRef();
+
+		// only add iofxAsset one time, check refCount
+		if (assetSceneInst->getRefCount() == 1)
+		{
+			actorSceneInst->addAssetSceneInst(assetSceneInst);
+		}
+	}
+	return actorID;
+}
+void IofxManager::releaseActorID(IofxAssetSceneInst* assetSceneInst, uint32_t actorID)
+{
+	PX_ASSERT(actorID < mActorTable.size());
+	IofxActorSceneInst* &actorSceneInst = mActorTable[actorID];
+	if (actorSceneInst != NULL)
+	{
+		PX_ASSERT(actorSceneInst->getRefCount() > 0);
+		if (actorSceneInst->removeRef())
+		{
+			for (uint16_t j = 0 ; j < mVolumeTable.size() ; j++)
+			{
+				if (mVolumeTable[ j ].vol == NULL)
+				{
+					continue;
+				}
+
+				if (actorID < mVolumeTable[ j ].mActors.size())
+				{
+					IofxActorImpl* iofxActor = mVolumeTable[ j ].mActors[ actorID ];
+					if (iofxActor && iofxActor != DEFERRED_IOFX_ACTOR)
+					{
+						iofxActor->release();
+						//IofxManager::removeActorAtIndex should zero the actor in mActors
+						PX_ASSERT(mVolumeTable[ j ].mActors[ actorID ] == 0);
+					}
+					mVolumeTable[ j ].mActors[ actorID ] = 0;
+				}
+			}
+
+			PX_DELETE(actorSceneInst);
+			actorSceneInst = NULL;
+		}
+		else
+		{
+			// only remove iofxAsset one time, check refCount
+			if (assetSceneInst->getRefCount() == 1)
+			{
+				actorSceneInst->removeAssetSceneInst(assetSceneInst);
+			}
+		}
+	}
+}
+
+uint16_t IofxManager::getActorClassID(IofxManagerClientIntl* iofxClient, uint16_t meshID)
+{
+	IofxManagerClient* client = static_cast<IofxManagerClient*>(iofxClient);
+	if (client != 0)
+	{
+		const uint16_t actorClassID = uint16_t(client->getActorClassID() + meshID);
+		PX_ASSERT(actorClassID < mActorClassTable.size());
+		PX_ASSERT(mActorClassTable[actorClassID].client == client);
+		PX_ASSERT(meshID < mActorClassTable[actorClassID].count);
+
+		const uint32_t actorID = mActorClassTable[actorClassID].actorID;
+		if (actorID != uint32_t(-1))
+		{
+			return actorClassID;
+		}
+		else
+		{
+			APEX_DEBUG_WARNING("IofxManager: getActorClassID returned invalid actor.");
+			return IofxActorIDIntl::IPX_ACTOR;
+		}
+	}
+	else
+	{
+		APEX_INVALID_PARAMETER("IofxManager: getActorClassID was called with invalid client.");
+		return IofxActorIDIntl::IPX_ACTOR;
+	}
+}
+
+IofxManagerClientIntl* IofxManager::createClient(nvidia::apex::IofxAsset* asset, const IofxManagerClientIntl::Params& params)
+{
+	IofxAssetImpl* iofxAsset = static_cast<IofxAssetImpl*>(asset);
+
+	IofxAssetSceneInst* &assetSceneInst = mAssetHashMap[iofxAsset];
+	if (assetSceneInst == NULL)
+	{
+		assetSceneInst = createAssetSceneInst(iofxAsset);
+		// Update state sizes later in submitTasks
+		addedAssets.pushBack(iofxAsset);
+		// increase asset refCount
+		//ResourceProvider* nrp = GetInternalApexSDK()->getNamedResourceProvider();
+		//nrp->setResource(IOFX_AUTHORING_TYPE_NAME, asset->getName(), asset, true);
+	}
+	assetSceneInst->addRef();
+
+	//allocate actorClasses
+	uint16_t actorClassCount = uint16_t( PxMax(1u, iofxAsset->getMeshAssetCount()) );
+	uint32_t actorClassID = 0;
+	while (actorClassID < mActorClassTable.size())
+	{
+		ActorClassData& acd = mActorClassTable[ actorClassID ];
+
+		if (acd.client == NULL && actorClassCount <= acd.count)
+		{
+			/* Make a shim to conver remaining hole */
+			uint16_t remains = uint16_t(acd.count - actorClassCount);
+			for (uint16_t i = 0 ; i < remains ; i++)
+			{
+				ActorClassData& acd1 = mActorClassTable[ actorClassID + actorClassCount + i ];
+				acd1.client = 0;
+				acd1.meshid = i;
+				acd1.count = remains;
+				acd1.actorID = uint32_t(-1);
+			}
+			break;
+		}
+		actorClassID = actorClassID + acd.count;
+	}
+	if (actorClassID >= mActorClassTable.size())
+	{
+		/* Asset is not in table, append it */
+		actorClassID = mActorClassTable.size();
+		mActorClassTable.resize(actorClassID + actorClassCount);
+	}
+
+	IofxManagerClient* client = NULL;
+#if APEX_CUDA_SUPPORT
+	if (mCudaModifiers)
+	{
+		client = mCudaPipeline->createClient(assetSceneInst, actorClassID, params);
+	}
+	else
+#endif
+	{
+		client = PX_NEW(IofxManagerClient)(assetSceneInst, actorClassID, params);
+	}
+	PX_ASSERT(client != NULL);
+
+	for (uint16_t i = 0 ; i < actorClassCount ; i++)
+	{
+		ActorClassData& acd = mActorClassTable[ actorClassID + i ];
+		acd.client = client;
+		acd.meshid = i;
+		acd.count = actorClassCount;
+		acd.actorID = getActorID(assetSceneInst, i);
+	}
+
+	return static_cast<IofxManagerClientIntl*>(client);
+}
+
+void IofxManager::releaseClient(IofxManagerClientIntl* iofxClient)
+{
+	// TODO: free unused memory in states
+
+	IofxManagerClient* client = static_cast<IofxManagerClient*>(iofxClient);
+	if (client != 0)
+	{
+		IofxAssetSceneInst* assetSceneInst = client->getAssetSceneInst();
+		uint32_t actorClassID = uint16_t(client->getActorClassID());
+
+		if (actorClassID < mActorClassTable.size())
+		{
+			for (uint16_t i = 0 ; i < mActorClassTable[ actorClassID ].count ; i++)
+			{
+				uint32_t actorID = mActorClassTable[ actorClassID + i ].actorID;
+				if (actorID != uint32_t(-1))
+				{
+					releaseActorID(assetSceneInst, actorID);
+				}
+			}
+
+			// TODO: merge backward hole also
+			/* merge consecutive holes */
+			uint32_t next = actorClassID + mActorClassTable[ actorClassID ].count;
+			while (next < mActorClassTable.size() && mActorClassTable[ next ].client == NULL)
+			{
+				next = next + mActorClassTable[ next ].count;
+			}
+
+			uint16_t count = uint16_t(next - actorClassID);
+			for (uint16_t i = 0 ; i < count ; i++)
+			{
+				ActorClassData& acd = mActorClassTable[ actorClassID + i ];
+				acd.client = 0;
+				acd.meshid = i;
+				acd.count = count;
+				acd.actorID = uint32_t(-1);
+			}
+		}
+
+		PX_DELETE(client);
+
+		if (assetSceneInst->removeRef())
+		{
+			// decrease asset refCount
+			//ResourceProvider* nrp = GetInternalApexSDK()->getNamedResourceProvider();
+			//nrp->releaseResource(IOFX_AUTHORING_TYPE_NAME, ad.asset->getName());
+
+			IofxAssetImpl* iofxAsset = assetSceneInst->getAsset();
+			PX_DELETE(assetSceneInst);
+			assetSceneInst = NULL;
+
+			mAssetHashMap.erase(iofxAsset);
+		}
+	}
+}
+
+uint16_t IofxManager::getVolumeID(RenderVolume* vol)
+{
+	int32_t hole = -1;
+	for (uint16_t i = 0 ; i < mVolumeTable.size() ; i++)
+	{
+		if (vol == mVolumeTable[ i ].vol)
+		{
+			mVolumeTable[ i ].mFlags = 1;
+			return i;
+		}
+		else if (hole == -1 && !mVolumeTable[ i ].vol)
+		{
+			hole = (int32_t) i;
+		}
+	}
+	if (hole == -1)
+	{
+		mVolumeTable.insert();
+		hole = (int32_t)mVolumeTable.size() - 1;
+	}
+	VolumeData& d = mVolumeTable[ (uint32_t)hole ];
+	d.vol = DYNAMIC_CAST(RenderVolumeImpl*)(vol);
+	d.mFlags = 1;
+	d.mActors.clear(); //Iofx Actors are released in RenderVolumeImpl destructor!
+	return (uint16_t) hole;
+}
+
+
+void IofxManager::removeActorAtIndex(uint32_t index)
+{
+	IofxActorImpl* iofx = DYNAMIC_CAST(IofxActorImpl*)(mActorArray[ index ]);
+
+	for (uint32_t i = 0 ; i < mVolumeTable.size() ; i++)
+	{
+		if (mVolumeTable[ i ].vol == iofx->mRenderVolume)
+		{
+			PX_ASSERT(iofx == mVolumeTable[ i ].mActors[ iofx->mActorID ]);
+			mVolumeTable[ i ].mActors[ iofx->mActorID ] = 0;
+		}
+	}
+
+	ApexContext::removeActorAtIndex(index);
+}
+
+IofxAssetSceneInst* IofxManager::createAssetSceneInst(IofxAsset* nxAsset)
+{
+	IofxAssetImpl* asset = DYNAMIC_CAST(IofxAssetImpl*)( nxAsset );
+
+	uint32_t semantics = uint32_t(mIsMesh ? BASE_MESH_SEMANTICS : BASE_SPRITE_SEMANTICS);
+	if( mObjData[0]->iosSupportsDensity ) 
+	{
+		semantics |= (uint32_t)IofxRenderSemantic::DENSITY;
+	}
+	semantics |= mIsMesh ? asset->getMeshSemanticsBitmap() : asset->getSpriteSemanticsBitmap();
+
+	IofxAssetSceneInst* assetSceneInst = 0;
+#if APEX_CUDA_SUPPORT
+	if (mCudaModifiers)
+	{
+		assetSceneInst = mCudaPipeline->createAssetSceneInst(asset, semantics);
+	}
+	else
+#endif
+	{
+		assetSceneInst = PX_NEW(IofxAssetSceneInstCPU)(asset, semantics, mIofxScene);
+	}
+	PX_ASSERT(assetSceneInst != 0);
+	return assetSceneInst;
+}
+
+void IofxManager::initIofxActor(IofxActorImpl* iofxActor, uint32_t actorID, RenderVolumeImpl* renderVolume)
+{
+	iofxActor->addSelfToContext(*this);
+	iofxActor->mActorID = actorID;
+	iofxActor->mRenderVolume = renderVolume;
+	iofxActor->mSemantics = 0;
+	iofxActor->mDistanceSortingEnabled = false;
+
+	PX_ASSERT(mActorTable[actorID] != NULL);
+	const nvidia::Array<IofxAssetSceneInst*>& iofxAssets = mActorTable[actorID]->getAssetSceneInstArray();
+	for (uint32_t k = 0; k < iofxAssets.size(); ++k)
+	{
+		IofxAssetSceneInst* assetSceneInst = iofxAssets[k];
+
+		iofxActor->mSemantics |= assetSceneInst->getSemantics();
+		iofxActor->mDistanceSortingEnabled |= assetSceneInst->getAsset()->isSortingEnabled();
+	}
+
+}
+
+}
+} // end namespace nvidia::apex
diff --git a/APEX_1.4/module/iofx/src/IofxManagerGPU.cpp b/APEX_1.4/module/iofx/src/IofxManagerGPU.cpp
new file mode 100644
index 00000000..06d1209a
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/IofxManagerGPU.cpp
@@ -0,0 +1,1319 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "Apex.h"
+#include "ApexDefs.h"
+
+#if APEX_CUDA_SUPPORT
+
+#include "ApexSDKIntl.h"
+#include "SceneIntl.h"
+#include "ModifierImpl.h"
+#include "IofxActor.h"
+#include "IofxManagerGPU.h"
+#include "IofxAssetImpl.h"
+#include "IofxSceneGPU.h"
+
+#include "ModuleIofxImpl.h"
+#include "IofxActorGPU.h"
+
+#include "PxGpuTask.h"
+#include "ApexCutil.h"
+
+#include "RandStateHelpers.h"
+
+#include "IofxRenderData.h"
+
+#define CUDA_OBJ(name) SCENE_CUDA_OBJ(mIofxScene, name)
+
+namespace nvidia
+{
+namespace iofx
+{
+
+class IofxAssetSceneInstGPU : public IofxAssetSceneInst
+{
+public:
+	IofxAssetSceneInstGPU(IofxAssetImpl* asset, uint32_t semantics, IofxScene* scene)
+		: IofxAssetSceneInst(asset, semantics)
+		, _constMemGroup(SCENE_CUDA_OBJ(*scene, modifierStorage))
+	{
+		_totalRandomCount = 0;
+
+		APEX_CUDA_CONST_MEM_GROUP_SCOPE(_constMemGroup)
+
+		_storage_.alloc(_assetParamsHandle);
+		AssetParams assetParams;
+		buildModifierList(assetParams.spawnModifierList, _asset->mSpawnModifierStack);
+		buildModifierList(assetParams.continuousModifierList, _asset->mContinuousModifierStack);
+		_storage_.update(_assetParamsHandle, assetParams);
+	}
+	virtual ~IofxAssetSceneInstGPU() {}
+
+	InplaceHandle<AssetParams> getAssetParamsHandle() const
+	{
+		return _assetParamsHandle;
+	}
+
+private:
+
+	void buildModifierList(ModifierList& list, const ModifierStack& stack)
+	{
+		InplaceStorage& _storage_ = _constMemGroup.getStorage();
+
+		class Mapper : public ModifierParamsMapperGPU
+		{
+		public:
+			InplaceStorage* storage;
+
+			InplaceHandleBase paramsHandle;
+			uint32_t paramsRandomCount;
+
+			virtual InplaceStorage& getStorage()
+			{
+				return *storage;
+			}
+
+			virtual void  onParams(InplaceHandleBase handle, uint32_t randomCount)
+			{
+				paramsHandle = handle;
+				paramsRandomCount = randomCount;
+			}
+
+		} mapper;
+		mapper.storage = &_storage_;
+
+		list.resize(_storage_, stack.size());
+
+		uint32_t index = 0;
+		for (ModifierStack::ConstIterator it = stack.begin(); it != stack.end(); ++it)
+		{
+			uint32_t type = (*it)->getModifierType();
+			//NxU32 usage = (*it)->getModifierUsage();
+			//if ((usage & usageStage) == usageStage && (usage & usageClass) == usageClass)
+			{
+				const ModifierImpl* modifier = ModifierImpl::castFrom(*it);
+				modifier->mapParamsGPU(mapper);
+
+				ModifierListElem listElem;
+				listElem.type = type;
+				listElem.paramsHandle = mapper.paramsHandle;
+				list.updateElem(_storage_, listElem, index);
+
+				_totalRandomCount += mapper.paramsRandomCount;
+			}
+			++index;
+		}
+	}
+
+	ApexCudaConstMemGroup		_constMemGroup;
+	InplaceHandle<AssetParams>	_assetParamsHandle;
+	uint32_t				_totalRandomCount;
+};
+
+class IofxManagerClientGPU : public IofxManagerClient
+{
+public:
+	IofxManagerClientGPU(IofxAssetSceneInst* assetSceneInst, uint32_t actorClassID, const IofxManagerClientIntl::Params& params, IofxScene* scene)
+		: IofxManagerClient(assetSceneInst, actorClassID, params)
+		, _constMemGroup(SCENE_CUDA_OBJ(*scene, modifierStorage))
+	{
+		setParamsGPU();
+	}
+
+	InplaceHandle<ClientParams> getClientParamsHandle() const
+	{
+		return _clientParamsHandle;
+	}
+
+	// IofxManagerClientIntl interface
+	virtual void setParams(const IofxManagerClientIntl::Params& params)
+	{
+		IofxManagerClient::setParams(params);
+		setParamsGPU();
+	}
+
+private:
+	void setParamsGPU()
+	{
+		APEX_CUDA_CONST_MEM_GROUP_SCOPE(_constMemGroup)
+
+		ClientParams clientParams;
+		if (_clientParamsHandle.allocOrFetch(_storage_, clientParams))
+		{
+			clientParams.assetParamsHandle = static_cast<IofxAssetSceneInstGPU*>(_assetSceneInst)->getAssetParamsHandle();
+		}
+		clientParams.objectScale = _params.objectScale;
+		_clientParamsHandle.update(_storage_, clientParams);
+	}
+
+	ApexCudaConstMemGroup		_constMemGroup;
+	InplaceHandle<ClientParams>	_clientParamsHandle;
+};
+
+
+IofxManagerClient* IofxManagerGPU::createClient(IofxAssetSceneInst* assetSceneInst, uint32_t actorClassID, const IofxManagerClientIntl::Params& params)
+{
+	return PX_NEW(IofxManagerClientGPU)(assetSceneInst, actorClassID, params, &mIofxScene);
+}
+
+IofxAssetSceneInst* IofxManagerGPU::createAssetSceneInst(IofxAssetImpl* asset,uint32_t semantics)
+{
+	return PX_NEW(IofxAssetSceneInstGPU)(asset, semantics, &mIofxScene);
+}
+
+class IofxManagerLaunchTask : public PxGpuTask, public UserAllocated
+{
+public:
+	IofxManagerLaunchTask(IofxManagerGPU* actor) : mActor(actor) {}
+	const char* getName() const
+	{
+		return "IofxManagerLaunchTask";
+	}
+	void         run()
+	{
+		PX_ALWAYS_ASSERT();
+	}
+	bool         launchInstance(CUstream stream, int kernelIndex)
+	{
+		return mActor->cudaLaunch(stream, kernelIndex);
+	}
+	PxGpuTaskHint::Enum getTaskHint() const
+	{
+		return PxGpuTaskHint::Kernel;
+	}
+
+protected:
+	IofxManagerGPU* mActor;
+};
+
+IofxManagerGPU::IofxManagerGPU(SceneIntl& scene, const IofxManagerDescIntl& desc, IofxManager& mgr, const ApexMirroredPlace::Enum defaultPlace)
+	: mManager(mgr)
+	, mIofxScene(*mgr.mIofxScene)
+	, mCopyQueue(*scene.getTaskManager()->getGpuDispatcher())
+	, mDefaultPlace(defaultPlace)
+	, mCuSpawnScale(scene)
+	, mCuSpawnSeed(scene)
+	, mCuBlockPRNGs(scene)
+	, mCuSortedActorIDs(scene)
+	, mCuSortedStateIDs(scene)
+	, mCuSortTempKeys(scene)
+	, mCuSortTempValues(scene)
+	, mCuSortTemp(scene)
+	, mCuMinBounds(scene)
+	, mCuMaxBounds(scene)
+	, mCuTempMinBounds(scene)
+	, mCuTempMaxBounds(scene)
+	, mCuTempActorIDs(scene)
+	, mCuActorStart(scene)
+	, mCuActorEnd(scene)
+	, mCuActorVisibleEnd(scene)
+	, mCurSeed(0)
+	, mTargetBufDevPtr(NULL)
+	, mCountActorIDs(0)
+	, mNumberVolumes(0)
+	, mNumberActorClasses(0)
+	, mEmptySimulation(false)
+	, mVolumeConstMemGroup(CUDA_OBJ(migrationStorage))
+	, mRemapConstMemGroup(CUDA_OBJ(remapStorage))
+	, mModifierConstMemGroup(CUDA_OBJ(modifierStorage))
+{
+	mTaskLaunch = PX_NEW(IofxManagerLaunchTask)(this);
+
+	const uint32_t maxObjectCount = desc.maxObjectCount;
+	const uint32_t maxInStateCount = desc.maxInStateCount;
+	uint32_t usageClass = 0;
+	uint32_t blockSize = MAX_THREADS_PER_BLOCK;
+
+	if (mManager.mIsMesh)
+	{
+		usageClass = ModifierUsage_Mesh;
+		//blockSize = CUDA_OBJ(meshModifiersKernel).getBlockDim().x;
+	}
+	else
+	{
+		usageClass = ModifierUsage_Sprite;
+		//blockSize = CUDA_OBJ(spriteModifiersKernel).getBlockDim().x;
+	}
+
+	mCuSpawnScale.reserve(mManager.mOutStateOffset + maxObjectCount, ApexMirroredPlace::GPU);
+	mCuSpawnSeed.reserve(mManager.mOutStateOffset + maxObjectCount, ApexMirroredPlace::GPU);
+
+	mCuSortedActorIDs.reserve(maxInStateCount, defaultPlace);
+	mCuSortedStateIDs.reserve(maxInStateCount, defaultPlace);
+
+	mCuSortTempKeys.reserve(maxInStateCount, ApexMirroredPlace::GPU);
+	mCuSortTempValues.reserve(maxInStateCount, ApexMirroredPlace::GPU);
+	mCuSortTemp.reserve(MAX_BOUND_BLOCKS * NEW_SORT_KEY_DIGITS, ApexMirroredPlace::GPU);
+
+	mCuTempMinBounds.reserve(WARP_SIZE * 2, ApexMirroredPlace::GPU);
+	mCuTempMaxBounds.reserve(WARP_SIZE * 2, ApexMirroredPlace::GPU);
+	mCuTempActorIDs.reserve(WARP_SIZE * 2, ApexMirroredPlace::GPU);
+
+	// alloc volumeConstMem
+	{
+		APEX_CUDA_CONST_MEM_GROUP_SCOPE(mVolumeConstMemGroup)
+
+		mVolumeParamsArrayHandle.alloc(_storage_);
+		mActorClassIDBitmapArrayHandle.alloc(_storage_);
+	}
+
+	// alloc remapConstMem
+	{
+		APEX_CUDA_CONST_MEM_GROUP_SCOPE(mRemapConstMemGroup)
+
+		mActorIDRemapArrayHandle.alloc(_storage_);
+	}
+
+	// alloc modifierConstMem
+	{
+		APEX_CUDA_CONST_MEM_GROUP_SCOPE(mModifierConstMemGroup)
+
+		mClientParamsHandleArrayHandle.alloc(_storage_);
+
+		if (mManager.mIsMesh)
+		{
+			mMeshOutputLayoutHandle.alloc(_storage_);
+		}
+		else
+		{
+			mSpriteOutputLayoutHandle.alloc(_storage_);
+		}
+	}
+
+	InitDevicePRNGs(scene, blockSize, mRandThreadLeap, mRandGridLeap, mCuBlockPRNGs);
+}
+
+void IofxManagerGPU::release()
+{
+	delete this;
+}
+
+IofxManagerGPU::~IofxManagerGPU()
+{
+	delete mTaskLaunch;
+}
+
+
+void IofxManagerGPU::submitTasks()
+{
+	mNumberActorClasses = mManager.mActorClassTable.size();
+	mNumberVolumes = mManager.mVolumeTable.size();
+	mCountActorIDs = mManager.mActorTable.size() * mNumberVolumes;
+
+	// update volumeConstMem
+	if (mNumberVolumes)
+	{
+		APEX_CUDA_CONST_MEM_GROUP_SCOPE(mVolumeConstMemGroup)
+
+		VolumeParamsArray volumeParamsArray;
+		_storage_.fetch(mVolumeParamsArrayHandle, volumeParamsArray);
+		volumeParamsArray.resize(_storage_, mNumberVolumes);
+		_storage_.update(mVolumeParamsArrayHandle, volumeParamsArray);
+
+
+		ActorClassIDBitmapArray actorClassIDBitmapArray;
+		_storage_.fetch(mActorClassIDBitmapArrayHandle, actorClassIDBitmapArray);
+		actorClassIDBitmapArray.resize(_storage_, mManager.mVolumeActorClassBitmap.size());
+		_storage_.update(mActorClassIDBitmapArrayHandle, actorClassIDBitmapArray);
+
+		actorClassIDBitmapArray.updateRange(_storage_, &mManager.mVolumeActorClassBitmap.front(), actorClassIDBitmapArray.getSize());
+
+		for (uint32_t i = 0 ; i < mNumberVolumes ; i++)
+		{
+			VolumeParams volumeParams;
+			IofxManager::VolumeData& vd = mManager.mVolumeTable[ i ];
+			if (vd.vol)
+			{
+				volumeParams.bounds = vd.mBounds;
+				volumeParams.priority = vd.mPri;
+			}
+			else
+			{
+				volumeParams.bounds.setEmpty();
+				volumeParams.priority = 0;
+			}
+			volumeParamsArray.updateElem(_storage_, volumeParams, i);
+		}
+	}
+	else
+	{
+		APEX_DEBUG_WARNING("IofxManager: There is no render volume!");
+	}
+
+	// update remapConstMem
+	{
+		APEX_CUDA_CONST_MEM_GROUP_SCOPE(mRemapConstMemGroup)
+
+		ActorIDRemapArray actorIDRemapArray;
+		_storage_.fetch(mActorIDRemapArrayHandle, actorIDRemapArray);
+		actorIDRemapArray.resize(_storage_, mNumberActorClasses);
+		for (uint32_t i = 0 ; i < mNumberActorClasses ; ++i)
+		{
+			actorIDRemapArray.updateElem(_storage_, mManager.mActorClassTable[i].actorID, i);
+		}
+		_storage_.update(mActorIDRemapArrayHandle, actorIDRemapArray);
+	}
+
+	// update modifierConstMem
+	{
+		APEX_CUDA_CONST_MEM_GROUP_SCOPE(mModifierConstMemGroup)
+
+		ClientParamsHandleArray clientParamsHandleArray;
+		_storage_.fetch(mClientParamsHandleArrayHandle, clientParamsHandleArray);
+		clientParamsHandleArray.resize(_storage_, mNumberActorClasses);
+		for (uint32_t i = 0 ; i < mNumberActorClasses ; ++i)
+		{
+			InplaceHandle<ClientParams> clientParamsHandle;
+			IofxManagerClientGPU* clientGPU = static_cast<IofxManagerClientGPU*>(mManager.mActorClassTable[i].client);
+			if (clientGPU != NULL)
+			{
+				clientParamsHandle = clientGPU->getClientParamsHandle();
+			}
+			clientParamsHandleArray.updateElem(_storage_, clientParamsHandle, i);
+		}
+		_storage_.update(mClientParamsHandleArrayHandle, clientParamsHandleArray);
+
+		if (mManager.mIsMesh)
+		{
+			MeshOutputLayout meshOutputLayout;
+
+			IosObjectGpuData* mWorkingData = DYNAMIC_CAST(IosObjectGpuData*)(mManager.mWorkingIosData);
+			IofxSharedRenderDataMeshImpl* meshRenderData = DYNAMIC_CAST(IofxSharedRenderDataMeshImpl*)(mWorkingData->renderData);
+			const IofxMeshRenderLayout& meshRenderLayout = meshRenderData->getRenderLayout();
+
+			mOutputDWords = meshRenderLayout.stride >> 2;
+			meshOutputLayout.stride = meshRenderLayout.stride;
+			::memcpy(meshOutputLayout.offsets, meshRenderLayout.offsets, sizeof(meshOutputLayout.offsets));
+
+			_storage_.update(mMeshOutputLayoutHandle, meshOutputLayout);
+		}
+		else
+		{
+			SpriteOutputLayout spriteOutputLayout;
+
+			IosObjectGpuData* mWorkingData = DYNAMIC_CAST(IosObjectGpuData*)(mManager.mWorkingIosData);
+			IofxSharedRenderDataSpriteImpl* spriteRenderData = DYNAMIC_CAST(IofxSharedRenderDataSpriteImpl*)(mWorkingData->renderData);
+			const IofxSpriteRenderLayout& spriteRenderLayout = spriteRenderData->getRenderLayout();
+			
+			mOutputDWords = spriteRenderLayout.stride >> 2;
+			spriteOutputLayout.stride = spriteRenderLayout.stride;
+			::memcpy(spriteOutputLayout.offsets, spriteRenderLayout.offsets, sizeof(spriteOutputLayout.offsets));
+
+			_storage_.update(mSpriteOutputLayoutHandle, spriteOutputLayout);
+		}
+	}
+
+}
+
+
+#pragma warning(push)
+#pragma warning(disable:4312) // conversion from 'CUdeviceptr' to 'uint32_t *' of greater size
+
+PxTaskID IofxManagerGPU::launchGpuTasks()
+{
+	PxTaskManager* tm = mIofxScene.mApexScene->getTaskManager();
+	tm->submitUnnamedTask(*mTaskLaunch, PxTaskType::TT_GPU);
+	mTaskLaunch->finishBefore(mManager.mPostUpdateTaskID);
+	return mTaskLaunch->getTaskID();
+}
+
+void IofxManagerGPU::launchPrep()
+{
+	IosObjectGpuData* mWorkingData = DYNAMIC_CAST(IosObjectGpuData*)(mManager.mWorkingIosData);
+
+	if (!mWorkingData->numParticles)
+	{
+		mEmptySimulation = true;
+		return;
+	}
+
+	mCurSeed = static_cast<uint32_t>(mIofxScene.mApexScene->getSeed());
+
+	PxTaskManager* tm = mIofxScene.mApexScene->getTaskManager();
+	PxCudaContextManager* ctx = tm->getGpuDispatcher()->getCudaContextManager();
+	{
+		PxScopedCudaLock s(*ctx);
+
+		mTargetTextureCount = 0;
+		mTargetBufDevPtr = 0;
+		if (!mManager.mIsMesh)
+		{
+			IofxSharedRenderDataSpriteImpl* spriteRenderData = DYNAMIC_CAST(IofxSharedRenderDataSpriteImpl*)(mWorkingData->renderData);
+			const IofxSpriteRenderLayout& spriteRenderLayout = spriteRenderData->getRenderLayout();
+
+			mTargetTextureCount = spriteRenderLayout.surfaceCount;
+			for( uint32_t i = 0; i < mTargetTextureCount; ++i )
+			{
+				const CUarray cuArray = spriteRenderData->getSurfaceMappedCudaArray(i);
+				if (cuArray != NULL)
+				{
+					mTargetCudaArrayList[i].assign(cuArray, false);
+				}
+				else
+				{
+					CUarray_format format = CUarray_format(0);
+					uint32_t numChannels = 0;
+					switch (spriteRenderLayout.surfaceElements[i])
+					{
+					case IofxSpriteRenderLayoutSurfaceElement::POSITION_FLOAT4:
+					case IofxSpriteRenderLayoutSurfaceElement::SCALE_ORIENT_SUBTEX_FLOAT4:
+					case IofxSpriteRenderLayoutSurfaceElement::COLOR_FLOAT4:
+						format = CU_AD_FORMAT_FLOAT;
+						numChannels = 4;
+						break;
+					case IofxSpriteRenderLayoutSurfaceElement::COLOR_RGBA8:
+					case IofxSpriteRenderLayoutSurfaceElement::COLOR_BGRA8:
+						format = CU_AD_FORMAT_UNSIGNED_INT32;
+						numChannels = 1;
+					default:
+						PX_ALWAYS_ASSERT();
+						break;
+					}
+					const UserRenderSurfaceDesc& desc = spriteRenderLayout.surfaceDescs[i];
+					mTargetCudaArrayList[i].create(format, numChannels, uint32_t(desc.width), uint32_t(desc.height), 0, true);
+				}
+			}
+			for( uint32_t i = mTargetTextureCount; i < IofxSpriteRenderLayout::MAX_SURFACE_COUNT; ++i ) {
+				mTargetCudaArrayList[i].release();
+			}
+		}
+
+		if (mTargetTextureCount == 0)
+		{
+			const CUdeviceptr cudaPtr = mWorkingData->renderData->getBufferMappedCudaPtr();
+			if (cudaPtr != 0)
+			{
+				mTargetOutputBuffer.release();
+				mTargetBufDevPtr = reinterpret_cast<uint32_t*>(cudaPtr);
+			}
+			else
+			{
+				const size_t size = mWorkingData->renderData->getRenderBufferSize();
+				if (size > 0)
+				{
+					mTargetOutputBuffer.realloc(size, ctx);
+					mTargetBufDevPtr = static_cast<uint32_t*>( mTargetOutputBuffer.getGpuPtr() );
+				}
+			}
+		}
+	}
+
+	const uint32_t numActorIDValues = mCountActorIDs + 2;
+	mCuActorStart.setSize(numActorIDValues, ApexMirroredPlace::CPU_GPU);
+	mCuActorEnd.setSize(numActorIDValues, ApexMirroredPlace::CPU_GPU);
+	mCuActorVisibleEnd.setSize(numActorIDValues, ApexMirroredPlace::CPU_GPU);
+	mCuMinBounds.setSize(numActorIDValues, ApexMirroredPlace::CPU_GPU);
+	mCuMaxBounds.setSize(numActorIDValues, ApexMirroredPlace::CPU_GPU);
+
+	mCuSortedActorIDs.setSize(mWorkingData->maxStateID, mDefaultPlace);
+	mCuSortedStateIDs.setSize(mWorkingData->maxStateID, mDefaultPlace);
+
+	mManager.positionMass.setSize(mWorkingData->maxInputID, ApexMirroredPlace::CPU_GPU);
+	mManager.velocityLife.setSize(mWorkingData->maxInputID, ApexMirroredPlace::CPU_GPU);
+	mManager.actorIdentifiers.setSize(mWorkingData->maxInputID, ApexMirroredPlace::CPU_GPU);
+	mManager.inStateToInput.setSize(mWorkingData->maxStateID, ApexMirroredPlace::CPU_GPU);
+	mManager.outStateToInput.setSize(mWorkingData->numParticles, ApexMirroredPlace::CPU_GPU);
+	if (mWorkingData->iosSupportsCollision)
+	{
+		mManager.collisionNormalFlags.setSize(mWorkingData->maxInputID, ApexMirroredPlace::CPU_GPU);
+	}
+	if (mWorkingData->iosSupportsDensity)
+	{
+		mManager.density.setSize(mWorkingData->maxInputID, ApexMirroredPlace::CPU_GPU);
+	}
+	if (mWorkingData->iosSupportsUserData)
+	{
+		mManager.userData.setSize(mWorkingData->maxInputID, ApexMirroredPlace::CPU_GPU);
+	}
+
+	mEmptySimulation = false;
+}
+
+#pragma warning(pop)
+
+
+///
+PX_INLINE uint32_t getHighestBitShift(uint32_t x)
+{
+	PX_ASSERT(isPowerOfTwo(x));
+	return highestSetBit(x);
+}
+
+void IofxManagerGPU::cudaLaunchRadixSort(CUstream stream, unsigned int numElements, unsigned int keyBits, unsigned int startBit, bool useSyncKernels)
+{
+	if (useSyncKernels)
+	{
+		//we use OLD Radix Sort on Tesla (SM < 2), because it is faster
+		CUDA_OBJ(radixSortSyncKernel)(
+			stream, numElements,
+			mCuSortedActorIDs.getGpuPtr(), mCuSortedStateIDs.getGpuPtr(),
+			mCuSortTempKeys.getGpuPtr(), mCuSortTempValues.getGpuPtr(),
+			mCuSortTemp.getGpuPtr(), keyBits, startBit
+		);
+	}
+	else
+	{
+#if 1
+		//NEW Radix Sort
+		unsigned int totalThreads = (numElements + NEW_SORT_VECTOR_SIZE - 1) / NEW_SORT_VECTOR_SIZE;
+		if (CUDA_OBJ(newRadixSortBlockKernel).isSingleBlock(totalThreads))
+		{
+			//launch just a single block for small sizes
+			CUDA_OBJ(newRadixSortBlockKernel)(
+				stream, APEX_CUDA_SINGLE_BLOCK_LAUNCH,
+				numElements, keyBits, startBit,
+				mCuSortedActorIDs.getGpuPtr(), mCuSortedStateIDs.getGpuPtr()
+			);
+		}
+		else
+		{
+			for (unsigned int bit = startBit; bit < startBit + keyBits; bit += RADIX_SORT_NBITS)
+			{
+				uint32_t gridSize = 
+					CUDA_OBJ(newRadixSortStepKernel)(
+						stream, totalThreads,
+						numElements, bit,
+						mCuSortedActorIDs.getGpuPtr(), mCuSortedStateIDs.getGpuPtr(),
+						mCuSortTempKeys.getGpuPtr(), mCuSortTempValues.getGpuPtr(),
+						mCuSortTemp.getGpuPtr(),
+						1, 0
+					);
+
+				//launch just a single block
+				CUDA_OBJ(newRadixSortStepKernel)(
+					stream, APEX_CUDA_SINGLE_BLOCK_LAUNCH,
+					numElements, bit,
+					mCuSortedActorIDs.getGpuPtr(), mCuSortedStateIDs.getGpuPtr(),
+					mCuSortTempKeys.getGpuPtr(), mCuSortTempValues.getGpuPtr(),
+					mCuSortTemp.getGpuPtr(),
+					2, gridSize
+				);
+
+				CUDA_OBJ(newRadixSortStepKernel)(
+					stream, totalThreads,
+					numElements, bit,
+					mCuSortedActorIDs.getGpuPtr(), mCuSortedStateIDs.getGpuPtr(),
+					mCuSortTempKeys.getGpuPtr(), mCuSortTempValues.getGpuPtr(),
+					mCuSortTemp.getGpuPtr(),
+					3, 0
+				);
+
+				mCuSortedActorIDs.swapGpuPtr(mCuSortTempKeys);
+				mCuSortedStateIDs.swapGpuPtr(mCuSortTempValues);
+			}
+		}
+#else
+		//OLD Radix Sort
+		for (unsigned int startBit = 0; startBit < keyBits; startBit += RADIX_SORT_NBITS)
+		{
+			int gridSize = 
+				CUDA_OBJ(radixSortStep1Kernel)(
+					stream, numElements,
+					mCuSortedActorIDs.getGpuPtr(), mCuSortedStateIDs.getGpuPtr(),
+					mCuSortTempKeys.getGpuPtr(), mCuSortTempValues.getGpuPtr(),
+					mCuSortTemp.getGpuPtr(), startBit
+				);
+
+			//launch just 1 block
+			CUDA_OBJ(radixSortStep2Kernel)(
+				stream, CUDA_OBJ(radixSortStep2Kernel).getBlockDim().x,
+				mCuSortTemp.getGpuPtr(), gridSize
+			);
+
+			CUDA_OBJ(radixSortStep3Kernel)(
+				stream, numElements,
+				mCuSortedActorIDs.getGpuPtr(), mCuSortedStateIDs.getGpuPtr(),
+				mCuSortTempKeys.getGpuPtr(), mCuSortTempValues.getGpuPtr(),
+				mCuSortTemp.getGpuPtr(), startBit
+			);
+		}
+#endif
+	}
+}
+
+bool IofxManagerGPU::cudaLaunch(CUstream stream, int kernelIndex)
+{
+	PxTaskManager* tm = mIofxScene.mApexScene->getTaskManager();
+
+	if (mEmptySimulation)
+	{
+		return false;
+	}
+
+	const uint32_t numActorIDValues = mCountActorIDs + 2;
+	//value <  mCountActorIDs     - valid particle with volume
+	//value == mCountActorIDs     - homeless particle (no volume or invalid actor class)
+	//value == mCountActorIDs + 1 - NOT_A_PARTICLE
+
+
+	IofxSceneGPU* sceneGPU = static_cast<IofxSceneGPU*>(&mIofxScene);
+	bool useSyncKernels = !sceneGPU->getGpuDispatcher()->getCudaContextManager()->supportsArchSM20();
+
+	IosObjectGpuData* mWorkingData = DYNAMIC_CAST(IosObjectGpuData*)(mManager.mWorkingIosData);
+
+	switch (kernelIndex)
+	{
+	case 0:
+		if (mManager.mOnStartCallback)
+		{
+			(*mManager.mOnStartCallback)(stream);
+		}
+		mCopyQueue.reset(stream, 24);
+		if (!mManager.mCudaIos && mWorkingData->maxInputID > 0)
+		{
+			mManager.positionMass.copyHostToDeviceQ(mCopyQueue);
+			mManager.velocityLife.copyHostToDeviceQ(mCopyQueue);
+			mManager.actorIdentifiers.copyHostToDeviceQ(mCopyQueue);
+			mManager.inStateToInput.copyHostToDeviceQ(mCopyQueue);
+			if (mWorkingData->iosSupportsCollision)
+			{
+				mManager.collisionNormalFlags.copyHostToDeviceQ(mCopyQueue);
+			}
+			if (mWorkingData->iosSupportsDensity)
+			{
+				mManager.density.copyHostToDeviceQ(mCopyQueue);
+			}
+			if (mWorkingData->iosSupportsUserData)
+			{
+				mManager.userData.copyHostToDeviceQ(mCopyQueue);
+			}
+			mCopyQueue.flushEnqueued();
+		}
+		break;
+
+	case 1:
+		/* Volume Migration (input space) */
+		CUDA_OBJ(volumeMigrationKernel)(stream,
+		                                PxMax(mWorkingData->maxInputID, numActorIDValues),
+										mVolumeConstMemGroup.getStorage().mappedHandle(mVolumeParamsArrayHandle),
+		                                mVolumeConstMemGroup.getStorage().mappedHandle(mActorClassIDBitmapArrayHandle),
+		                                mNumberActorClasses, mNumberVolumes, numActorIDValues,
+		                                mManager.actorIdentifiers.getGpuPtr(), mWorkingData->maxInputID,
+		                                (const float4*)mManager.positionMass.getGpuPtr(),
+		                                mCuActorStart.getGpuPtr(), mCuActorEnd.getGpuPtr(), mCuActorVisibleEnd.getGpuPtr()
+		                               );
+		break;
+
+	case 2:
+		{
+			APEX_CUDA_TEXTURE_SCOPE_BIND(texRefRemapPositions,      mManager.positionMass)
+			APEX_CUDA_TEXTURE_SCOPE_BIND(texRefRemapActorIDs,       mManager.actorIdentifiers)
+			APEX_CUDA_TEXTURE_SCOPE_BIND(texRefRemapInStateToInput, mManager.inStateToInput)
+
+			/* if mDistanceSortingEnabled, sort on camera distance first, else directly make ActorID keys */
+			CUDA_OBJ(makeSortKeys)(stream, mWorkingData->maxStateID,
+								   mManager.inStateToInput.getGpuPtr(), mWorkingData->maxInputID,
+								   mManager.mActorTable.size(), mCountActorIDs,
+								   mRemapConstMemGroup.getStorage().mappedHandle(mActorIDRemapArrayHandle),
+								   (const float4*)mManager.positionMass.getGpuPtr(), mManager.mDistanceSortingEnabled,
+								   mWorkingData->eyePosition, mWorkingData->eyeDirection, mWorkingData->zNear,
+								   mCuSortedActorIDs.getGpuPtr(), mCuSortedStateIDs.getGpuPtr());
+
+			if (mManager.mDistanceSortingEnabled)
+			{
+				cudaLaunchRadixSort(stream, mWorkingData->maxStateID, 32, 0, useSyncKernels);
+
+				/* Generate ActorID sort keys, using distance sorted stateID values */
+				CUDA_OBJ(remapKernel)(stream, mWorkingData->maxStateID,
+									  mManager.inStateToInput.getGpuPtr(), mWorkingData->maxInputID,
+									  mManager.mActorTable.size(), mCountActorIDs,
+									  mRemapConstMemGroup.getStorage().mappedHandle(mActorIDRemapArrayHandle),
+									  mCuSortedStateIDs.getGpuPtr(), mCuSortedActorIDs.getGpuPtr());
+			}
+		}
+		break;
+
+	case 3:
+		/* ActorID Sort (output state space) */
+		// input: mCuSortedActorIDs == actorIDs, in distance sorted order
+		// input: mCuSortedStateIDs == stateIDs, in distance sorted order
+
+		// output: mCuSortedActorIDs == sorted ActorIDs
+		// output: mCuSortedStateIDs == output-to-input state
+		{
+			//SortedActorIDs could contain values from 0 to mCountActorIDs + 1 (included),
+			//so keybits should cover at least mCountActorIDs + 2 numbers
+			uint32_t keybits = 0;
+			while ((1U << keybits) < numActorIDValues)
+			{
+				++keybits;
+			}
+
+			cudaLaunchRadixSort(stream, mWorkingData->maxStateID, keybits, 0, useSyncKernels);
+		}
+		break;
+
+	case 4:
+		/* Per-IOFX actor particle range detection */
+		CUDA_OBJ(actorRangeKernel)(stream, mWorkingData->maxStateID,
+		                           mCuSortedActorIDs.getGpuPtr(), mCountActorIDs,
+		                           mCuActorStart.getGpuPtr(), mCuActorEnd.getGpuPtr(), mCuActorVisibleEnd.getGpuPtr(),
+								   mCuSortedStateIDs.getGpuPtr()
+		                          );
+		break;
+
+	case 5:
+		/* Modifiers (output state space) */
+		{
+			PX_PROFILE_ZONE("IofxManagerGPUModifiers", GetInternalApexSDK()->getContextId());
+			ModifierCommonParams commonParams = mWorkingData->getCommonParams();
+
+			APEX_CUDA_TEXTURE_SCOPE_BIND(texRefPositionMass,     mManager.positionMass)
+			APEX_CUDA_TEXTURE_SCOPE_BIND(texRefVelocityLife,     mManager.velocityLife)
+			APEX_CUDA_TEXTURE_SCOPE_BIND(texRefInStateToInput,   mManager.inStateToInput)
+			APEX_CUDA_TEXTURE_SCOPE_BIND(texRefStateSpawnSeed,   mCuSpawnSeed)
+			APEX_CUDA_TEXTURE_SCOPE_BIND(texRefStateSpawnScale,  mCuSpawnScale)
+
+			APEX_CUDA_TEXTURE_SCOPE_BIND(texRefActorIDs,         mManager.actorIdentifiers)
+
+			if (mWorkingData->iosSupportsCollision)
+			{
+				CUDA_OBJ(texRefCollisionNormalFlags).bindTo(mManager.collisionNormalFlags);
+			}
+			if (mWorkingData->iosSupportsDensity)
+			{
+				CUDA_OBJ(texRefDensity).bindTo(mManager.density);
+			}
+			if (mWorkingData->iosSupportsUserData)
+			{
+				CUDA_OBJ(texRefUserData).bindTo(mManager.userData);
+			}
+
+			PRNGInfo rand;
+			rand.g_stateSpawnSeed = mCuSpawnSeed.getGpuPtr();
+			rand.g_randBlock = mCuBlockPRNGs.getGpuPtr();
+			rand.randGrid = mRandGridLeap;
+			rand.randThread = mRandThreadLeap;
+			rand.seed = mCurSeed;
+
+			if (mManager.mIsMesh)
+			{
+				// 3x3 matrix => 9 float scalars => 3 slices
+
+				APEX_CUDA_TEXTURE_SCOPE_BIND(texRefMeshPrivState0, *mManager.privState.slices[0]);
+				APEX_CUDA_TEXTURE_SCOPE_BIND(texRefMeshPrivState1, *mManager.privState.slices[1]);
+				APEX_CUDA_TEXTURE_SCOPE_BIND(texRefMeshPrivState2, *mManager.privState.slices[2]);
+
+				MeshPrivateStateArgs meshPrivStateArgs;
+				meshPrivStateArgs.g_state[0] = mManager.privState.a[0];
+				meshPrivStateArgs.g_state[1] = mManager.privState.a[1];
+				meshPrivStateArgs.g_state[2] = mManager.privState.a[2];
+
+				CUDA_OBJ(meshModifiersKernel)(ApexKernelConfig(MAX_SMEM_BANKS * mOutputDWords, WARP_SIZE * PxMax<uint32_t>(mOutputDWords, 4)), 
+											  stream, mWorkingData->numParticles,
+											  mManager.mInStateOffset, mManager.mOutStateOffset,
+											  mModifierConstMemGroup.getStorage().mappedHandle(mClientParamsHandleArrayHandle),
+											  commonParams,
+											  mCuSortedActorIDs.getGpuPtr(), mCuSortedStateIDs.getGpuPtr(),
+											  mManager.outStateToInput.getGpuPtr(),
+											  meshPrivStateArgs, mCuSpawnScale.getGpuPtr(),
+											  rand, mTargetBufDevPtr,
+											  mModifierConstMemGroup.getStorage().mappedHandle(mMeshOutputLayoutHandle)
+											 );
+			}
+			else
+			{
+				// 1 float scalar => 1 slice
+
+				APEX_CUDA_TEXTURE_SCOPE_BIND(texRefSpritePrivState0, *mManager.privState.slices[0]);
+
+				SpritePrivateStateArgs spritePrivStateArgs;
+				spritePrivStateArgs.g_state[0] = mManager.privState.a[0];
+
+				IofxSharedRenderDataSpriteImpl* renderDataSprite = static_cast<IofxSharedRenderDataSpriteImpl*>(mWorkingData->renderData);
+				const IofxSpriteRenderLayout& spriteRenderLayout = renderDataSprite->getRenderLayout();
+
+				if (mTargetTextureCount > 0)
+				{
+					SpriteTextureOutputLayout outputLayout;
+					outputLayout.textureCount = mTargetTextureCount;
+					for (uint32_t i = 0; i < outputLayout.textureCount; ++i)
+					{
+						outputLayout.textureData[i].layout = static_cast<uint16_t>(spriteRenderLayout.surfaceElements[i]);
+
+						uint32_t width = mTargetCudaArrayList[i].getWidth();
+						//width should be a power of 2 and a multiply of WARP_SIZE
+						PX_ASSERT(isPowerOfTwo(width));
+						PX_ASSERT((width & (WARP_SIZE - 1)) == 0);
+						outputLayout.textureData[i].widthShift = static_cast<uint8_t>(highestSetBit(width));
+
+						outputLayout.textureData[i].pitchShift = 0; //unused in GPU mode!
+						outputLayout.texturePtr[i] = NULL; //unused in GPU mode!
+					}
+
+					if (0 < outputLayout.textureCount) APEX_CUDA_SURFACE_BIND(surfRefOutput0, mTargetCudaArrayList[0], ApexCudaMemFlags::OUT);
+					if (1 < outputLayout.textureCount) APEX_CUDA_SURFACE_BIND(surfRefOutput1, mTargetCudaArrayList[1], ApexCudaMemFlags::OUT);
+					if (2 < outputLayout.textureCount) APEX_CUDA_SURFACE_BIND(surfRefOutput2, mTargetCudaArrayList[2], ApexCudaMemFlags::OUT);
+					if (3 < outputLayout.textureCount) APEX_CUDA_SURFACE_BIND(surfRefOutput3, mTargetCudaArrayList[3], ApexCudaMemFlags::OUT);
+
+					CUDA_OBJ(spriteTextureModifiersKernel)(stream, mWorkingData->numParticles,
+														   mManager.mInStateOffset, mManager.mOutStateOffset,
+														   mModifierConstMemGroup.getStorage().mappedHandle(mClientParamsHandleArrayHandle),
+														   commonParams,
+														   mCuSortedActorIDs.getGpuPtr(), mCuSortedStateIDs.getGpuPtr(),
+														   mManager.outStateToInput.getGpuPtr(),
+														   spritePrivStateArgs, mCuSpawnScale.getGpuPtr(),
+														   rand, outputLayout
+														  );
+
+					if (0 < outputLayout.textureCount) APEX_CUDA_SURFACE_UNBIND(surfRefOutput0);
+					if (1 < outputLayout.textureCount) APEX_CUDA_SURFACE_UNBIND(surfRefOutput1);
+					if (2 < outputLayout.textureCount) APEX_CUDA_SURFACE_UNBIND(surfRefOutput2);
+					if (3 < outputLayout.textureCount) APEX_CUDA_SURFACE_UNBIND(surfRefOutput3);
+				}
+				else
+				{
+					CUDA_OBJ(spriteModifiersKernel)(ApexKernelConfig(MAX_SMEM_BANKS * mOutputDWords, WARP_SIZE * PxMax<uint32_t>(mOutputDWords, 4)),
+													stream, mWorkingData->numParticles,
+													mManager.mInStateOffset, mManager.mOutStateOffset,
+													mModifierConstMemGroup.getStorage().mappedHandle(mClientParamsHandleArrayHandle),
+													commonParams,
+													mCuSortedActorIDs.getGpuPtr(), mCuSortedStateIDs.getGpuPtr(),
+													mManager.outStateToInput.getGpuPtr(),
+													spritePrivStateArgs, mCuSpawnScale.getGpuPtr(),
+													rand, mTargetBufDevPtr,
+													mModifierConstMemGroup.getStorage().mappedHandle(mSpriteOutputLayoutHandle)
+												   );
+				}
+			}
+
+			if (mWorkingData->iosSupportsCollision)
+			{
+				CUDA_OBJ(texRefCollisionNormalFlags).unbind();
+			}
+			if (mWorkingData->iosSupportsDensity)
+			{
+				CUDA_OBJ(texRefDensity).unbind();
+			}
+			if (mWorkingData->iosSupportsUserData)
+			{
+				CUDA_OBJ(texRefUserData).unbind();
+			}
+		}
+		break;
+
+	case 6:
+		if (mCountActorIDs > 0)
+		{
+			/* Per-IOFX actor BBox generation */
+			APEX_CUDA_TEXTURE_SCOPE_BIND(texRefBBoxPositions, mManager.positionMass)
+
+			if (useSyncKernels)
+			{
+				CUDA_OBJ(bboxSyncKernel)(
+					stream, mWorkingData->numParticles,
+					mCuSortedActorIDs.getGpuPtr(),
+					mManager.outStateToInput.getGpuPtr(),
+					(const float4*)mManager.positionMass.getGpuPtr(),
+					(float4*)mCuMinBounds.getGpuPtr(), (float4*)mCuMaxBounds.getGpuPtr(),
+					mCuTempActorIDs.getGpuPtr(),
+					(float4*)mCuTempMinBounds.getGpuPtr(), (float4*)mCuTempMaxBounds.getGpuPtr()
+				);
+			}
+			else
+			{
+				uint32_t bboxGridSize =
+					CUDA_OBJ(bboxKernel)(
+						stream, mWorkingData->numParticles,
+						mCuSortedActorIDs.getGpuPtr(),
+						mManager.outStateToInput.getGpuPtr(),
+						(const float4*)mManager.positionMass.getGpuPtr(),
+						(float4*)mCuMinBounds.getGpuPtr(), (float4*)mCuMaxBounds.getGpuPtr(),
+						mCuTempActorIDs.getGpuPtr(),
+						(float4*)mCuTempMinBounds.getGpuPtr(), (float4*)mCuTempMaxBounds.getGpuPtr(),
+						1, 0
+					);
+
+				CUDA_OBJ(bboxKernel)(
+					stream, APEX_CUDA_SINGLE_BLOCK_LAUNCH,
+					mCuSortedActorIDs.getGpuPtr(),
+					mManager.outStateToInput.getGpuPtr(),
+					(const float4*)mManager.positionMass.getGpuPtr(),
+					(float4*)mCuMinBounds.getGpuPtr(), (float4*)mCuMaxBounds.getGpuPtr(),
+					mCuTempActorIDs.getGpuPtr(),
+					(float4*)mCuTempMinBounds.getGpuPtr(), (float4*)mCuTempMaxBounds.getGpuPtr(),
+					2, bboxGridSize
+				);
+			}
+		}
+		break;
+
+	case 7:
+		if (mTargetTextureCount > 0)
+		{
+			IofxSharedRenderDataSpriteImpl* spriteRenderData = DYNAMIC_CAST(IofxSharedRenderDataSpriteImpl*)(mWorkingData->renderData);
+			PX_ASSERT(spriteRenderData->getRenderLayout().surfaceCount == mTargetTextureCount);
+
+			for (uint32_t i = 0; i < mTargetTextureCount; ++i)
+			{
+				UserRenderSurface::MappedInfo mappedInfo;
+				if (spriteRenderData->getSurfaceMappedInfo(i, mappedInfo))
+				{
+					const size_t surfaceWidth = spriteRenderData->getRenderLayout().surfaceDescs[i].width;
+					size_t copyHeight = (mWorkingData->numParticles + surfaceWidth - 1) / surfaceWidth;
+					mTargetCudaArrayList[i].copyToHost(stream, mappedInfo.pData, mappedInfo.rowPitch, 0, 0, copyHeight);
+				}
+			}
+		}
+		else
+		{
+			void* mappedPtr = mWorkingData->renderData->getBufferMappedPtr();
+			if (mappedPtr)
+			{
+				size_t size = (mOutputDWords << 2) * mWorkingData->numParticles;
+				mTargetOutputBuffer.copyToHost(stream, mappedPtr, size);
+			}
+		}
+		if (mCountActorIDs > 0)
+		{
+			mCuMinBounds.copyDeviceToHostQ(mCopyQueue);
+			mCuMaxBounds.copyDeviceToHostQ(mCopyQueue);
+		}
+		mCuActorStart.copyDeviceToHostQ(mCopyQueue);
+		mCuActorEnd.copyDeviceToHostQ(mCopyQueue);
+		mCuActorVisibleEnd.copyDeviceToHostQ(mCopyQueue);
+
+
+		if (mCuSortedActorIDs.cpuPtrIsValid())
+		{
+			mManager.inStateToInput.copyDeviceToHostQ(mCopyQueue);
+			mManager.actorIdentifiers.copyDeviceToHostQ(mCopyQueue);
+			mManager.outStateToInput.copyDeviceToHostQ(mCopyQueue);
+			mManager.positionMass.copyDeviceToHostQ(mCopyQueue);
+
+			mCuSortedActorIDs.copyDeviceToHostQ(mCopyQueue);
+			mCuSortedStateIDs.copyDeviceToHostQ(mCopyQueue);
+		}
+		else if (!mManager.mCudaIos)
+		{
+			mManager.actorIdentifiers.copyDeviceToHostQ(mCopyQueue);
+			mManager.outStateToInput.copyDeviceToHostQ(mCopyQueue);
+		}
+
+		mCopyQueue.flushEnqueued();
+
+		if (mManager.mOnFinishCallback)
+		{
+			(*mManager.mOnFinishCallback)(stream);
+		}
+
+		tm->getGpuDispatcher()->addCompletionPrereq(*tm->getTaskFromID(mManager.mPostUpdateTaskID));
+		return false;
+
+	default:
+		PX_ALWAYS_ASSERT();
+		return false;
+	}
+
+	return true;
+}
+
+void IofxManagerGPU::fetchResults()
+{
+	IosObjectGpuData* mWorkingData = DYNAMIC_CAST(IosObjectGpuData*)(mManager.mWorkingIosData);
+	PX_UNUSED(mWorkingData);
+
+#if 0
+	{
+		ApexMirroredArray<uint32_t> actorID(*mIofxScene.mApexScene);
+		ApexMirroredArray<PxVec4> outMinBounds(*mIofxScene.mApexScene);
+		ApexMirroredArray<PxVec4> outMaxBounds(*mIofxScene.mApexScene);
+		ApexMirroredArray<PxVec4> outDebugInfo(*mIofxScene.mApexScene);
+		ApexMirroredArray<uint32_t> tmpLastActorID(*mIofxScene.mApexScene);
+		tmpLastActorID.setSize(64, ApexMirroredPlace::CPU_GPU);
+
+		const uint32_t NE = 2000;
+		actorID.setSize(NE, ApexMirroredPlace::CPU_GPU);
+
+		Array<uint32_t> actorCounts;
+		actorCounts.reserve(1000);
+
+		uint32_t NA = 0;
+		for (uint32_t ie = 0; ie < NE; ++NA)
+		{
+			uint32_t num_ie = rand(1, 100); // We need to use QDSRand here s.t. seed could be preset during tests!
+			uint32_t next_ie = PxMin(ie + num_ie, NE);
+
+			actorCounts.pushBack(next_ie - ie);
+
+			for (; ie < next_ie; ++ie)
+			{
+				actorID[ie] = NA;
+			}
+		}
+		outMinBounds.setSize(NA, ApexMirroredPlace::CPU_GPU);
+		outMaxBounds.setSize(NA, ApexMirroredPlace::CPU_GPU);
+		outDebugInfo.setSize(NA, ApexMirroredPlace::CPU_GPU);
+
+		for (uint32_t ia = 0; ia < NA; ++ia)
+		{
+			outMinBounds[ia].setZero();
+			outMaxBounds[ia].setZero();
+		}
+
+		PxTaskManager* tm = mIofxScene.mApexScene->getTaskManager();
+		PxCudaContextManager* ctx = tm->getGpuDispatcher()->getCudaContextManager();
+		PxScopedCudaLock s(*ctx);
+
+		mCopyQueue.reset(0, 4);
+
+		actorID.copyHostToDeviceQ(mCopyQueue);
+		outMinBounds.copyHostToDeviceQ(mCopyQueue);
+		outMaxBounds.copyHostToDeviceQ(mCopyQueue);
+		mCopyQueue.flushEnqueued();
+
+		CUDA_OBJ(bboxKernel2)(0, NE, actorID.getGpuPtr(), NULL, 0, (float4*)outDebugInfo.getGpuPtr(), (float4*)outMinBounds.getGpuPtr(), (float4*)outMaxBounds.getGpuPtr()/*, tmpLastActorID.getGpuPtr()*/);
+
+		outMinBounds.copyDeviceToHostQ(mCopyQueue);
+		outMaxBounds.copyDeviceToHostQ(mCopyQueue);
+		outDebugInfo.copyDeviceToHostQ(mCopyQueue);
+		tmpLastActorID.copyDeviceToHostQ(mCopyQueue);
+		mCopyQueue.flushEnqueued();
+
+		CUT_SAFE_CALL(cuCtxSynchronize());
+
+		uint32_t errors = 0;
+		float totCount = 0;
+		for (uint32_t ie = 0; ie < NE; ++ie)
+		{
+			uint32_t id = actorID[ie];
+			if (ie == 0 || actorID[ie - 1] != id)
+			{
+				uint32_t count = actorCounts[id];
+				const PxVec4& bounds = outMinBounds[id];
+				if (bounds.x != count)
+				{
+					++errors;
+				}
+				if (bounds.y != count * 2)
+				{
+					++errors;
+				}
+				if (bounds.z != count * 3)
+				{
+					++errors;
+				}
+				totCount += count;
+			}
+		}
+
+	}
+#endif
+
+#if 0
+	{
+		PxTaskManager* tm = mIofxScene.mApexScene->getTaskManager();
+		PxCudaContextManager* ctx = tm->getGpuDispatcher()->getCudaContextManager();
+
+		PxScopedCudaLock s(*ctx);
+
+		CUT_SAFE_CALL(cuCtxSynchronize());
+	}
+#endif
+#if DEBUG_GPU
+	{
+		nvidia::Array<int> valuesCounters(mWorkingData->maxStateID, 0);
+		uint32_t lastKey = uint32_t(-1);
+		for (uint32_t i = 0; i < mWorkingData->maxStateID; ++i)
+		{
+			uint32_t currKey = mCuSortedActorIDs.get(i);
+			PX_ASSERT(currKey < mCountActorIDs + 2);
+			if (lastKey != uint32_t(-1))
+			{
+				PX_ASSERT(lastKey <= currKey);
+			}
+			if (lastKey != currKey)
+			{
+				if (mCuActorStart[currKey] != i)
+				{
+					int temp = 0;
+					temp++;
+				}
+				PX_ASSERT(mCuActorStart[currKey] == i);
+				if (lastKey != uint32_t(-1))
+				{
+					if (mCuActorEnd[lastKey] != i)
+					{
+						int temp = 0;
+						temp++;
+					}
+					PX_ASSERT(mCuActorEnd[lastKey] == i);
+				}
+			}
+			lastKey = currKey;
+
+			uint32_t currValue = (mCuSortedStateIDs.get(i) & STATE_ID_MASK);
+			PX_ASSERT(currValue < mWorkingData->maxStateID);
+			if (currValue < mWorkingData->maxStateID)
+			{
+				valuesCounters[currValue] += 1;
+			}
+		}
+		if (lastKey != uint32_t(-1))
+		{
+			PX_ASSERT(mCuActorEnd[lastKey] == mWorkingData->maxStateID);
+		}
+		for (uint32_t i = 0; i < mWorkingData->maxStateID; ++i)
+		{
+			PX_ASSERT(valuesCounters[i] == 1);
+		}
+	}
+#endif
+
+	/* Swap input/output state offsets */
+	mManager.swapStates();
+
+	if (mEmptySimulation)
+	{
+		for (uint32_t i = 0 ; i < mNumberVolumes ; i++)
+		{
+			IofxManager::VolumeData& d = mManager.mVolumeTable[ i ];
+			if (d.vol == 0)
+			{
+				continue;
+			}
+
+			for (uint32_t j = 0 ; j < mManager.mActorTable.size() ; j++)
+			{
+				IofxActorImpl* iofx = d.mActors[ j ];
+				if (iofx && iofx != DEFERRED_IOFX_ACTOR)
+				{
+					iofx->mResultBounds.setEmpty();
+					iofx->mResultRange.startIndex = 0;
+					iofx->mResultRange.objectCount = 0;
+					iofx->mResultVisibleCount = 0;
+				}
+			}
+		}
+	}
+	else
+	{
+		PX_ASSERT(mCuActorStart.cpuPtrIsValid() && mCuActorEnd.cpuPtrIsValid());
+		if (!mCuActorStart.cpuPtrIsValid() || !mCuActorEnd.cpuPtrIsValid())
+		{
+			// Workaround for issue seen by a customer
+			APEX_INTERNAL_ERROR("Bad cpuPtr in IofxManagerGPU::fetchResults");
+			return;
+		}
+#ifndef NDEBUG
+		//check Actor Ranges
+		{
+			uint32_t totalCount = 0;
+			//range with the last index (= mCountActorIDs) contains homeless particles!
+			for (uint32_t i = 0 ; i <= mCountActorIDs ; i++)
+			{
+				const uint32_t rangeStart = mCuActorStart[ i ];
+				const uint32_t rangeEnd = mCuActorEnd[ i ];
+				const uint32_t rangeVisibleEnd = mCuActorVisibleEnd[ i ];
+
+				PX_ASSERT(rangeStart < mWorkingData->numParticles);
+				PX_ASSERT(rangeEnd <= mWorkingData->numParticles);
+				PX_ASSERT(rangeStart <= rangeEnd);
+				PX_ASSERT(rangeStart <= rangeVisibleEnd && rangeVisibleEnd <= rangeEnd);
+				PX_UNUSED(rangeVisibleEnd);
+
+				const uint32_t rangeCount = rangeEnd - rangeStart;
+				totalCount += rangeCount;
+			}
+			PX_ASSERT(totalCount == mWorkingData->numParticles);
+		}
+#endif
+
+		uint32_t aid = 0;
+		for (uint32_t i = 0 ; i < mNumberVolumes ; i++)
+		{
+			IofxManager::VolumeData& d = mManager.mVolumeTable[ i ];
+			if (d.vol == 0)
+			{
+				aid += mManager.mActorTable.size();
+				continue;
+			}
+
+			for (uint32_t j = 0 ; j < mManager.mActorTable.size() ; j++)
+			{
+				const uint32_t rangeStart = mCuActorStart[ aid ];
+				const uint32_t rangeEnd = mCuActorEnd[ aid ];
+				const uint32_t rangeVisibleEnd = mCuActorVisibleEnd[ aid ];
+
+				const uint32_t rangeCount = rangeEnd - rangeStart;
+				const uint32_t visibleCount = rangeVisibleEnd - rangeStart;
+
+				if (d.mActors[ j ] == DEFERRED_IOFX_ACTOR && mManager.mActorTable[ j ] != NULL &&
+				        (mIofxScene.mModule->mDeferredDisabled || rangeCount))
+				{
+					IofxActorImpl* iofxActor = PX_NEW(IofxActorGPU)(mManager.mActorTable[j]->getRenderResID(), &mIofxScene, mManager);
+					if (d.vol->addIofxActor(*iofxActor))
+					{
+						d.mActors[ j ] = iofxActor;
+
+						mManager.initIofxActor(iofxActor, j, d.vol);
+
+						// lock this renderable because the APEX scene will unlock it after this method is called
+						iofxActor->renderDataLock();
+					}
+					else
+					{
+						iofxActor->release();
+					}
+				}
+
+				IofxActorImpl* iofxActor = d.mActors[ j ];
+				if (iofxActor && iofxActor != DEFERRED_IOFX_ACTOR)
+				{
+					iofxActor->mResultBounds.setEmpty();
+					if (rangeCount > 0)
+					{
+						iofxActor->mResultBounds.minimum = mCuMinBounds[ aid ].getXYZ();
+						iofxActor->mResultBounds.maximum = mCuMaxBounds[ aid ].getXYZ();
+					}
+					PX_ASSERT(iofxActor->mRenderBounds.isFinite());
+					iofxActor->mResultRange.startIndex = rangeStart;
+					iofxActor->mResultRange.objectCount = rangeCount;
+					iofxActor->mResultVisibleCount = visibleCount;
+				}
+
+				aid++;
+			}
+		}
+	}
+
+}
+
+
+/**
+ * Called from render thread context, just before renderer calls update/dispatch on any IOFX
+ * actors.  Map/Unmap render resources as required.  "Mapped" means the graphics buffer has been
+ * mapped into our CUDA context where our kernels can write directly into it.
+ */
+void IofxManager::fillMapUnmapArraysForInterop(nvidia::Array<CUgraphicsResource> &toMapArray, nvidia::Array<CUgraphicsResource> &toUnmapArray)
+{
+	if (mInteropFlags == RenderInteropFlags::CUDA_INTEROP)
+	{
+		mResultIosData->renderData->fillMapUnmapArraysForInterop(toMapArray, toUnmapArray);
+		mStagingIosData->renderData->fillMapUnmapArraysForInterop(toMapArray, toUnmapArray);
+	}
+}
+
+
+void IofxManager::mapBufferResultsForInterop(bool mapSuccess, bool unmapSuccess)
+{
+	if (mInteropFlags == RenderInteropFlags::CUDA_INTEROP)
+	{
+		mResultIosData->renderData->mapBufferResultsForInterop(mapSuccess, unmapSuccess);
+		mStagingIosData->renderData->mapBufferResultsForInterop(mapSuccess, unmapSuccess);
+	}
+}
+
+}
+} // namespace nvidia
+
+#endif
diff --git a/APEX_1.4/module/iofx/src/IofxRenderDataMesh.cpp b/APEX_1.4/module/iofx/src/IofxRenderDataMesh.cpp
new file mode 100644
index 00000000..a3603f06
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/IofxRenderDataMesh.cpp
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "Apex.h"
+#include "IofxSceneCPU.h"
+#include "IofxSceneGPU.h"
+#include "IosObjectData.h"
+#include "IofxRenderData.h"
+#include "IofxActorImpl.h"
+
+namespace nvidia
+{
+namespace iofx
+{
+
+
+
+bool IofxSharedRenderDataMeshImpl::createRenderLayout(IofxScene& iofxScene, uint32_t semantics, uint32_t maxObjectCount, RenderLayout_t& renderLayout)
+{
+	bool bIsUserDefinedLayout = false;
+	IofxRenderCallback* renderCallback = iofxScene.getIofxRenderCallback();
+	if (renderCallback)
+	{
+		if (renderCallback->getIofxMeshRenderLayout(renderLayout, maxObjectCount, semantics, mInteropFlags))
+		{
+			bIsUserDefinedLayout = renderLayout.isValid();
+		}
+	}
+	if (!bIsUserDefinedLayout)
+	{
+		//make default layout for given set of semantics
+		uint32_t offset = 0;
+		{
+			IofxMeshRenderLayoutElement::Enum element = IofxMeshRenderLayoutElement::POSITION_FLOAT3;
+			renderLayout.offsets[element] = offset;
+			offset += RenderDataFormat::getFormatDataSize(IofxMeshRenderLayoutElement::getFormat(element));
+		}
+		{
+			IofxMeshRenderLayoutElement::Enum element = IofxMeshRenderLayoutElement::ROTATION_SCALE_FLOAT3x3;
+			renderLayout.offsets[element] = offset;
+			offset += RenderDataFormat::getFormatDataSize(IofxMeshRenderLayoutElement::getFormat(element));
+		}
+		if (semantics & (1 << IofxRenderSemantic::COLOR))
+		{
+			IofxMeshRenderLayoutElement::Enum element = IofxMeshRenderLayoutElement::COLOR_FLOAT4;
+			renderLayout.offsets[element] = offset;
+			offset += RenderDataFormat::getFormatDataSize(IofxMeshRenderLayoutElement::getFormat(element));
+		}
+		if (semantics & (1 << IofxRenderSemantic::DENSITY))
+		{
+			IofxMeshRenderLayoutElement::Enum element = IofxMeshRenderLayoutElement::DENSITY_FLOAT1;
+			renderLayout.offsets[element] = offset;
+			offset += RenderDataFormat::getFormatDataSize(IofxMeshRenderLayoutElement::getFormat(element));
+		}
+		if (semantics & (1 << IofxRenderSemantic::USER_DATA))
+		{
+			IofxMeshRenderLayoutElement::Enum element = IofxMeshRenderLayoutElement::USER_DATA_UINT1;
+			renderLayout.offsets[element] = offset;
+			offset += RenderDataFormat::getFormatDataSize(IofxMeshRenderLayoutElement::getFormat(element));
+		}
+		renderLayout.stride = offset;
+
+		renderLayout.bufferDesc.setDefaults();
+		renderLayout.bufferDesc.size = maxObjectCount * renderLayout.stride;
+		renderLayout.bufferDesc.interopFlags = mInteropFlags;
+	}
+	PX_ASSERT((renderLayout.stride & 0x03) == 0);
+	return bIsUserDefinedLayout;
+}
+
+void IofxSharedRenderDataMeshImpl::freeAllRenderStorage()
+{
+	if (mSharedRenderData.meshRenderBuffer != NULL)
+	{
+		mSharedRenderData.meshRenderBuffer->release();
+		mSharedRenderData.meshRenderBuffer = NULL;
+	}
+}
+
+bool IofxSharedRenderDataMeshImpl::allocAllRenderStorage(const RenderLayout_t& newRenderLayout, IofxRenderCallback* iofxRenderCallback)
+{
+	mSharedRenderData.meshRenderBuffer = iofxRenderCallback->createRenderBuffer(newRenderLayout.bufferDesc);
+	return (mSharedRenderData.meshRenderBuffer != NULL);
+}
+
+}
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/IofxRenderDataSprite.cpp b/APEX_1.4/module/iofx/src/IofxRenderDataSprite.cpp
new file mode 100644
index 00000000..c2fb9318
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/IofxRenderDataSprite.cpp
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "Apex.h"
+#include "IofxSceneCPU.h"
+#include "IofxSceneGPU.h"
+#include "IosObjectData.h"
+#include "IofxRenderData.h"
+#include "IofxActorImpl.h"
+
+namespace nvidia
+{
+namespace iofx
+{
+
+bool IofxSharedRenderDataSpriteImpl::createRenderLayout(IofxScene& iofxScene, uint32_t semantics, uint32_t maxObjectCount, RenderLayout_t& renderLayout)
+{
+	bool bIsUserDefinedLayout = false;
+	IofxRenderCallback* renderCallback = iofxScene.getIofxRenderCallback();
+	if (renderCallback)
+	{
+		if (renderCallback->getIofxSpriteRenderLayout(renderLayout, maxObjectCount, semantics, mInteropFlags))
+		{
+			bIsUserDefinedLayout = renderLayout.isValid();
+		}
+	}
+	if (!bIsUserDefinedLayout)
+	{
+		uint32_t offset = 0;
+		if (semantics & (1 << IofxRenderSemantic::POSITION))
+		{
+			IofxSpriteRenderLayoutElement::Enum element = IofxSpriteRenderLayoutElement::POSITION_FLOAT3;
+			renderLayout.offsets[element] = offset;
+			offset += RenderDataFormat::getFormatDataSize(IofxSpriteRenderLayoutElement::getFormat(element));
+		}
+		if (semantics & (1 << IofxRenderSemantic::COLOR))
+		{
+			IofxSpriteRenderLayoutElement::Enum element = IofxSpriteRenderLayoutElement::COLOR_FLOAT4;
+			renderLayout.offsets[element] = offset;
+			offset += RenderDataFormat::getFormatDataSize(IofxSpriteRenderLayoutElement::getFormat(element));
+		}
+		if (semantics & (1 << IofxRenderSemantic::VELOCITY))
+		{
+			IofxSpriteRenderLayoutElement::Enum element = IofxSpriteRenderLayoutElement::VELOCITY_FLOAT3;
+			renderLayout.offsets[element] = offset;
+			offset += RenderDataFormat::getFormatDataSize(IofxSpriteRenderLayoutElement::getFormat(element));
+		}
+		if (semantics & (1 << IofxRenderSemantic::SCALE))
+		{
+			IofxSpriteRenderLayoutElement::Enum element = IofxSpriteRenderLayoutElement::SCALE_FLOAT2;
+			renderLayout.offsets[element] = offset;
+			offset += RenderDataFormat::getFormatDataSize(IofxSpriteRenderLayoutElement::getFormat(element));
+		}
+		if (semantics & (1 << IofxRenderSemantic::LIFE_REMAIN))
+		{
+			IofxSpriteRenderLayoutElement::Enum element = IofxSpriteRenderLayoutElement::LIFE_REMAIN_FLOAT1;
+			renderLayout.offsets[element] = offset;
+			offset += RenderDataFormat::getFormatDataSize(IofxSpriteRenderLayoutElement::getFormat(element));
+		}
+		if (semantics & (1 << IofxRenderSemantic::DENSITY))
+		{
+			IofxSpriteRenderLayoutElement::Enum element = IofxSpriteRenderLayoutElement::DENSITY_FLOAT1;
+			renderLayout.offsets[element] = offset;
+			offset += RenderDataFormat::getFormatDataSize(IofxSpriteRenderLayoutElement::getFormat(element));
+		}
+		if (semantics & (1 << IofxRenderSemantic::SUBTEXTURE))
+		{
+			IofxSpriteRenderLayoutElement::Enum element = IofxSpriteRenderLayoutElement::SUBTEXTURE_FLOAT1;
+			renderLayout.offsets[element] = offset;
+			offset += RenderDataFormat::getFormatDataSize(IofxSpriteRenderLayoutElement::getFormat(element));
+		}
+		if (semantics & (1 << IofxRenderSemantic::ORIENTATION))
+		{
+			IofxSpriteRenderLayoutElement::Enum element = IofxSpriteRenderLayoutElement::ORIENTATION_FLOAT1;
+			renderLayout.offsets[element] = offset;
+			offset += RenderDataFormat::getFormatDataSize(IofxSpriteRenderLayoutElement::getFormat(element));
+		}
+		if (semantics & (1 << IofxRenderSemantic::USER_DATA))
+		{
+			IofxSpriteRenderLayoutElement::Enum element = IofxSpriteRenderLayoutElement::USER_DATA_UINT1;
+			renderLayout.offsets[element] = offset;
+			offset += RenderDataFormat::getFormatDataSize(IofxSpriteRenderLayoutElement::getFormat(element));
+		}
+		renderLayout.stride = offset;
+		renderLayout.surfaceCount = 0;
+
+		renderLayout.bufferDesc.setDefaults();
+		renderLayout.bufferDesc.size = maxObjectCount * renderLayout.stride;
+		renderLayout.bufferDesc.interopFlags = mInteropFlags;
+	}
+	PX_ASSERT((renderLayout.stride & 0x03) == 0);
+	return bIsUserDefinedLayout;
+}
+
+void IofxSharedRenderDataSpriteImpl::freeAllRenderStorage()
+{
+	if (mSharedRenderData.spriteRenderBuffer != NULL)
+	{
+		mSharedRenderData.spriteRenderBuffer->release();
+		mSharedRenderData.spriteRenderBuffer = NULL;
+	}
+
+	for (uint32_t i = 0; i < IofxSpriteRenderLayout::MAX_SURFACE_COUNT; ++i)
+	{
+		if (mSharedRenderData.spriteRenderSurfaces[i] != NULL)
+		{
+			mSharedRenderData.spriteRenderSurfaces[i]->release();
+			mSharedRenderData.spriteRenderSurfaces[i] = NULL;
+		}
+	}
+}
+
+bool IofxSharedRenderDataSpriteImpl::allocAllRenderStorage(const RenderLayout_t& newRenderLayout, IofxRenderCallback* iofxRenderCallback)
+{
+	bool result = false;
+	if (newRenderLayout.surfaceCount > 0)
+	{
+		result = true;
+		for (uint32_t i = 0; result && i < newRenderLayout.surfaceCount; ++i)
+		{
+			mSharedRenderData.spriteRenderSurfaces[i] = iofxRenderCallback->createRenderSurface(newRenderLayout.surfaceDescs[i]);
+			result &= (mSharedRenderData.spriteRenderSurfaces[i] != NULL);
+		}
+		if (!result)
+		{
+			for (uint32_t i = 0; i < newRenderLayout.surfaceCount; ++i)
+			{
+				if (mSharedRenderData.spriteRenderSurfaces[i] != NULL)
+				{
+					mSharedRenderData.spriteRenderSurfaces[i]->release();
+					mSharedRenderData.spriteRenderSurfaces[i] = NULL;
+				}
+			}
+		}
+	}
+	else
+	{
+		mSharedRenderData.spriteRenderBuffer = iofxRenderCallback->createRenderBuffer(newRenderLayout.bufferDesc);
+		result = (mSharedRenderData.spriteRenderBuffer != NULL);
+	}
+	return result;
+}
+
+}
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/IofxScene.cpp b/APEX_1.4/module/iofx/src/IofxScene.cpp
new file mode 100644
index 00000000..400fca10
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/IofxScene.cpp
@@ -0,0 +1,527 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "Apex.h"
+#include "ApexUsingNamespace.h"
+#include "ModuleIofxImpl.h"
+#include "IofxSceneCPU.h"
+#include "IofxSceneGPU.h"
+#include "IofxAssetImpl.h"
+#include "IofxActorImpl.h"
+#include "IofxActorCPU.h"
+#include "IofxDebugRenderParams.h"
+#include "DebugRenderParams.h"
+#include "RenderVolumeImpl.h"
+#include "SceneIntl.h"
+#include "ModulePerfScope.h"
+#include "RenderDebugInterface.h"
+
+#if APEX_CUDA_SUPPORT
+#include <cuda.h>
+#include "ApexCutil.h"
+#include "IofxActorGPU.h"
+
+#include "ApexCudaSource.h"
+#endif
+
+#include "Lock.h"
+
+namespace nvidia
+{
+namespace iofx
+{
+
+IofxRenderable* IofxRenderableIteratorImpl::findNextInActorList()
+{
+	for (; mActorIndex < mActorCount; ++mActorIndex)
+	{
+		IofxRenderable* result = mActorList[mActorIndex]->acquireRenderableReference();
+		if (result != NULL)
+		{
+			return result;
+		}
+	}
+	mIofxScene.mLiveRenderVolumes[mVolumeIndex]->unlockIofxActorList();
+	return NULL;
+}
+
+IofxRenderable* IofxRenderableIteratorImpl::findFirstInNotEmptyVolume()
+{
+	for (; mVolumeIndex < mVolumeCount; ++mVolumeIndex)
+	{
+		mActorList = mIofxScene.mLiveRenderVolumes[mVolumeIndex]->lockIofxActorList(mActorCount);
+		mActorIndex = 0;
+		IofxRenderable* result = findNextInActorList();
+		if (result != NULL)
+		{
+			return result;
+		}
+	}
+	mIofxScene.mLiveRenderVolumesLock.unlockReader();
+	return NULL;
+}
+
+IofxRenderable* IofxRenderableIteratorImpl::getFirst()
+{
+	mIofxScene.mLiveRenderVolumesLock.lockReader();
+	mVolumeCount = mIofxScene.mLiveRenderVolumes.size();
+	mVolumeIndex = 0;
+	return findFirstInNotEmptyVolume();
+}
+
+IofxRenderable* IofxRenderableIteratorImpl::getNext()
+{
+	if (mVolumeIndex < mVolumeCount)
+	{
+		PX_ASSERT(mActorIndex < mActorCount);
+		++mActorIndex;
+		IofxRenderable* result = findNextInActorList();
+		if (result != NULL)
+		{
+			return result;
+		}
+		++mVolumeIndex;
+		return findFirstInNotEmptyVolume();
+	}
+	return NULL;
+}
+
+
+static StatsInfo IOFXStatsData[] =
+{
+	{"IOFX: SimulatedSpriteParticlesCount",	StatDataType::INT,   {{0}} },
+	{"IOFX: SimulatedMeshParticlesCount",	StatDataType::INT,   {{0}} }
+};
+
+IofxScene::IofxScene(ModuleIofxImpl& module, SceneIntl& scene, RenderDebugInterface* debugRender, ResourceList& list)
+	: mModule(&module)
+	, mApexScene(&scene)
+	, mDebugRender(debugRender)
+	, mPrevTotalSimulatedSpriteParticles(0)
+	, mPrevTotalSimulatedMeshParticles(0)
+	, mRenderCallback(NULL)
+{
+	list.add(*this);		// Add self to module's list of IofxScenes
+
+	/* Initialize reference to IofxDebugRenderParams */
+	{
+		WRITE_LOCK(*mApexScene);
+		mDebugRenderParams = DYNAMIC_CAST(DebugRenderParams*)(mApexScene->getDebugRenderParams());
+	}
+	PX_ASSERT(mDebugRenderParams);
+	NvParameterized::Handle handle(*mDebugRenderParams), memberHandle(*mDebugRenderParams);
+	int size;
+
+	if (mDebugRenderParams->getParameterHandle("moduleName", handle) == NvParameterized::ERROR_NONE)
+	{
+		handle.getArraySize(size, 0);
+		handle.resizeArray(size + 1);
+		if (handle.getChildHandle(size, memberHandle) == NvParameterized::ERROR_NONE)
+		{
+			memberHandle.initParamRef(IofxDebugRenderParams::staticClassName(), true);
+		}
+	}
+
+	/* Load reference to IofxDebugRenderParams */
+	NvParameterized::Interface* refPtr = NULL;
+	memberHandle.getParamRef(refPtr);
+	mIofxDebugRenderParams = DYNAMIC_CAST(IofxDebugRenderParams*)(refPtr);
+	PX_ASSERT(mIofxDebugRenderParams);
+
+	createModuleStats();
+}
+
+IofxScene::~IofxScene()
+{
+	destroyModuleStats();
+}
+
+Module* IofxScene::getModule()
+{
+	return mModule;
+}
+
+void IofxScene::release()
+{
+	mModule->releaseModuleSceneIntl(*this);
+}
+
+IofxManager* IofxScene::createIofxManager(const IofxAsset& asset, const IofxManagerDescIntl& desc)
+{
+	mManagersLock.lockWriter();
+
+	IofxManager* iofxManager = PX_NEW(IofxManager)(*this, desc, asset.getMeshAssetCount() > 0);
+
+	mManagersLock.unlockWriter();
+
+	return iofxManager;
+}
+
+void IofxScene::releaseIofxManager(IofxManager* manager)
+{
+	mManagersLock.lockWriter();
+
+	manager->destroy();
+
+	mManagersLock.unlockWriter();
+}
+
+void IofxScene::createModuleStats(void)
+{
+	mModuleSceneStats.numApexStats		= NumberOfStats;
+	mModuleSceneStats.ApexStatsInfoPtr	= (StatsInfo*)PX_ALLOC(sizeof(StatsInfo) * NumberOfStats, PX_DEBUG_EXP("StatsInfo"));
+
+	for (uint32_t i = 0; i < NumberOfStats; i++)
+	{
+		mModuleSceneStats.ApexStatsInfoPtr[i] = IOFXStatsData[i];
+	}
+}
+
+void IofxScene::destroyModuleStats(void)
+{
+	mModuleSceneStats.numApexStats = 0;
+	if (mModuleSceneStats.ApexStatsInfoPtr)
+	{
+		PX_FREE_AND_RESET(mModuleSceneStats.ApexStatsInfoPtr);
+	}
+}
+
+void IofxScene::setStatValue(StatsDataEnum index, StatValue dataVal)
+{
+	if (mModuleSceneStats.ApexStatsInfoPtr)
+	{
+		mModuleSceneStats.ApexStatsInfoPtr[index].StatCurrentValue = dataVal;
+	}
+}
+
+void IofxScene::visualize()
+{
+#ifndef WITHOUT_DEBUG_VISUALIZE
+	if (!mIofxDebugRenderParams->VISUALIZE_IOFX_ACTOR)
+	{
+		return;
+	}
+
+	PxMat44 cameraFacingPose((mApexScene->getViewMatrix(0)).inverseRT());
+
+	const physx::PxMat44& savedPose = *RENDER_DEBUG_IFACE(mDebugRender)->getPoseTyped();
+	RENDER_DEBUG_IFACE(mDebugRender)->setIdentityPose();
+	RENDER_DEBUG_IFACE(mDebugRender)->pushRenderState();
+	RENDER_DEBUG_IFACE(mDebugRender)->setCurrentTextScale(3.0f);
+
+	// iofx current bounding volume
+	// there is a bug with setting the color. it can change under certain circumstances. use default color for now
+	//RENDER_DEBUG_IFACE(mDebugRender)->setCurrentColor(RENDER_DEBUG_IFACE(mDebugRender)->getDebugColor(DebugColors::LightBlue));
+	for (uint32_t i = 0 ; i < mActorArray.size() ; i++)
+	{
+		IofxActorImpl* actor = DYNAMIC_CAST(IofxActorImpl*)(mActorArray[ i ]);
+		if (mIofxDebugRenderParams->VISUALIZE_IOFX_ACTOR_NAME)
+		{
+			PxVec3 textLocation = actor->getBounds().maximum;
+			cameraFacingPose.setPosition(textLocation);
+			if(actor->getOwner() != NULL)
+			{
+				RENDER_DEBUG_IFACE(mDebugRender)->debugText(textLocation, " %s %s", actor->getOwner()->getObjTypeName(), actor->getOwner()->getName());
+			}
+		}
+		if (mIofxDebugRenderParams->VISUALIZE_IOFX_BOUNDING_BOX)
+		{
+			RENDER_DEBUG_IFACE(mDebugRender)->debugBound(actor->getBounds());
+		}
+	}
+
+	// iofx max bounding volume
+	// there is a bug with setting the color. it can change under certain circumstances. use default color for now
+	//RENDER_DEBUG_IFACE(mDebugRender)->setCurrentColor(RENDER_DEBUG_IFACE(mDebugRender)->getDebugColor(DebugColors::Orange));
+	mLiveRenderVolumesLock.lockReader();
+	for (uint32_t i = 0 ; i < mLiveRenderVolumes.size() ; i++)
+	{
+		if (mIofxDebugRenderParams->VISUALIZE_IOFX_BOUNDING_BOX)
+		{
+			PxVec3 textLocation = mLiveRenderVolumes[i]->getOwnershipBounds().maximum;
+			cameraFacingPose.setPosition(textLocation);
+			RENDER_DEBUG_IFACE(mDebugRender)->debugText(textLocation, " Max Render Volume %d", i);
+			RENDER_DEBUG_IFACE(mDebugRender)->debugBound(mLiveRenderVolumes[i]->getOwnershipBounds());
+		}
+	}
+	mLiveRenderVolumesLock.unlockReader();
+
+	RENDER_DEBUG_IFACE(mDebugRender)->setPose(savedPose);
+	RENDER_DEBUG_IFACE(mDebugRender)->popRenderState();
+#endif
+}
+
+void IofxScene::destroy()
+{
+	removeAllActors();
+	mApexScene->moduleReleased(*this);
+
+	{
+		mLiveRenderVolumesLock.lockWriter();
+
+		/* Handle deferred insertions/deletions of ApexRenderVolumes */
+		processDeferredRenderVolumes();
+
+		/* Delete all Live ApexRenderVolumes */
+		for (uint32_t i = 0 ; i < mLiveRenderVolumes.size() ; i++)
+		{
+			RenderVolumeImpl* arv = mLiveRenderVolumes[ i ];
+			PX_DELETE(arv);
+		}
+		mLiveRenderVolumes.clear();
+
+		mLiveRenderVolumesLock.unlockWriter();
+	}
+	delete this;
+}
+
+void IofxScene::setModulePhysXScene(PxScene* nxScene)
+{
+	if (nxScene)
+	{
+		for (uint32_t i = 0 ; i < mActorArray.size() ; i++)
+		{
+			IofxActorImpl* actor = DYNAMIC_CAST(IofxActorImpl*)(mActorArray[ i ]);
+			actor->setPhysXScene(nxScene);
+		}
+	}
+	else
+	{
+		for (uint32_t i = 0 ; i < mActorArray.size() ; i++)
+		{
+			IofxActorImpl* actor = DYNAMIC_CAST(IofxActorImpl*)(mActorArray[ i ]);
+			actor->setPhysXScene(NULL);
+		}
+	}
+
+	mPhysXScene = nxScene;
+}
+
+void IofxScene::processDeferredRenderVolumes()
+{
+	mAddedRenderVolumesLock.lock();
+	while (mAddedRenderVolumes.size())
+	{
+		RenderVolumeImpl* arv = mAddedRenderVolumes.popBack();
+		mLiveRenderVolumes.pushBack(arv);
+	}
+	mAddedRenderVolumesLock.unlock();
+
+	mDeletedRenderVolumesLock.lock();
+	while (mDeletedRenderVolumes.size())
+	{
+		RenderVolumeImpl* arv = mDeletedRenderVolumes.popBack();
+		mLiveRenderVolumes.findAndReplaceWithLast(arv);
+		PX_DELETE(arv);
+	}
+	mDeletedRenderVolumesLock.unlock();
+}
+
+void IofxScene::submitTasks(float /*elapsedTime*/, float /*substepSize*/, uint32_t /*numSubSteps*/)
+{
+	{
+		mLiveRenderVolumesLock.lockWriter();
+
+		/* Handle deferred insertions/deletions of ApexRenderVolumes */
+		processDeferredRenderVolumes();
+
+		mLiveRenderVolumesLock.unlockWriter();
+	}
+
+	mManagersLock.lockReader();
+
+	//IofxManager::submitTasks reads mLiveRenderVolumes so we lock it here and unlock later
+	mLiveRenderVolumesLock.lockReader();
+	for (uint32_t i = 0; i < mActorManagers.getSize(); ++i)
+	{
+		IofxManager* mgr = DYNAMIC_CAST(IofxManager*)(mActorManagers.getResource(i));
+		mgr->submitTasks();
+	}
+	mLiveRenderVolumesLock.unlockReader();
+
+	mManagersLock.unlockReader();
+}
+
+void IofxScene::fetchResults()
+{
+	mManagersLock.lockReader();
+
+	mFetchResultsLock.lock();
+
+	uint32_t totalSimulatedSpriteParticles = 0,
+				totalSimulatedMeshParticles = 0;
+	for (uint32_t i = 0; i < mActorManagers.getSize(); ++i)
+	{
+		IofxManager* mgr = DYNAMIC_CAST(IofxManager*)(mActorManagers.getResource(i));
+		mgr->fetchResults();
+
+		if(mgr->isMesh())
+			totalSimulatedMeshParticles += mgr->getSimulatedParticlesCount();
+		else
+			totalSimulatedSpriteParticles += mgr->getSimulatedParticlesCount();
+	}
+
+	StatValue dataVal;
+	dataVal.Int = int32_t(totalSimulatedSpriteParticles - mPrevTotalSimulatedSpriteParticles);
+	setStatValue(SimulatedSpriteParticlesCount, dataVal);
+	mPrevTotalSimulatedSpriteParticles = totalSimulatedSpriteParticles;
+	dataVal.Int = int32_t(totalSimulatedMeshParticles - mPrevTotalSimulatedMeshParticles);
+	setStatValue(SimulatedMeshParticlesCount, dataVal);
+	mPrevTotalSimulatedMeshParticles = totalSimulatedMeshParticles;
+
+	mFetchResultsLock.unlock();
+
+	mManagersLock.unlockReader();
+}
+
+void IofxScene::prepareRenderables()
+{
+	mManagersLock.lockReader();
+
+	lockLiveRenderVolumes();
+	mFetchResultsLock.lock();
+
+	for (uint32_t i = 0; i < mActorManagers.getSize(); ++i)
+	{
+		IofxManager* mgr = DYNAMIC_CAST(IofxManager*)(mActorManagers.getResource(i));
+		mgr->prepareRenderables();
+	}
+
+	mFetchResultsLock.unlock();
+	unlockLiveRenderVolumes();
+
+	mManagersLock.unlockReader();
+}
+
+
+void IofxScene::lockLiveRenderVolumes()
+{
+	mLiveRenderVolumesLock.lockReader();
+	//for (uint32_t i = 0 ; i < mLiveRenderVolumes.size() ; i++)
+	//{
+	//	mLiveRenderVolumes[ i ]->lockReader();
+	//}
+}
+
+void IofxScene::unlockLiveRenderVolumes()
+{
+	//for (uint32_t i = 0 ; i < mLiveRenderVolumes.size() ; i++)
+	//{
+	//	mLiveRenderVolumes[ i ]->unlockReader();
+	//}
+	mLiveRenderVolumesLock.unlockReader();
+}
+
+/******************************** CPU Version ********************************/
+
+IofxSceneCPU::IofxSceneCPU(ModuleIofxImpl& module, SceneIntl& scene, RenderDebugInterface* debugRender, ResourceList& list) 
+	: IOFX_SCENE(module, scene, debugRender, list)
+{
+}
+
+/******************************** GPU Version ********************************/
+
+#if APEX_CUDA_SUPPORT
+IofxSceneGPU::IofxSceneGPU(ModuleIofxImpl& module, SceneIntl& scene, RenderDebugInterface* debugRender, ResourceList& list) :
+	IOFX_SCENE(module, scene, debugRender, list),
+	CudaModuleScene(scene, *mModule, APEX_CUDA_TO_STR(APEX_CUDA_MODULE_PREFIX)),
+	mContextManager(scene.getTaskManager()->getGpuDispatcher()->getCudaContextManager())
+{
+	PxGpuDispatcher* gd = scene.getTaskManager()->getGpuDispatcher();
+	PX_ASSERT(gd != NULL);
+	PxScopedCudaLock _lock_(*gd->getCudaContextManager());
+
+//CUDA module objects
+#include "../cuda/include/moduleList.h"
+}
+
+IofxSceneGPU::~IofxSceneGPU()
+{
+	PxScopedCudaLock s(*mContextManager);
+	CudaModuleScene::destroy(*mApexScene);
+}
+
+void IofxSceneGPU::submitTasks(float elapsedTime, float substepSize, uint32_t numSubSteps)
+{
+	IofxScene::submitTasks(elapsedTime, substepSize, numSubSteps);
+
+	{
+		PxScopedCudaLock _lock_(*mContextManager);
+
+		APEX_CUDA_OBJ_NAME(migrationStorage).copyToDevice(mContextManager, 0);
+		APEX_CUDA_OBJ_NAME(remapStorage).copyToDevice(mContextManager, 0);
+		APEX_CUDA_OBJ_NAME(modifierStorage).copyToDevice(mContextManager, 0);
+	}
+}
+
+
+void IofxSceneGPU::prepareRenderables()
+{
+	mManagersLock.lockReader();
+
+	lockLiveRenderVolumes();
+	mFetchResultsLock.lock();
+
+	for (uint32_t i = 0; i < mActorManagers.getSize(); ++i)
+	{
+		IofxManager* mgr = DYNAMIC_CAST(IofxManager*)(mActorManagers.getResource(i));
+		mgr->prepareRenderables();
+	}
+
+	if (mContextManager->getInteropMode() != PxCudaInteropMode::NO_INTEROP)
+	{
+		mToMapArray.clear();
+		mToUnmapArray.clear();
+
+		for (uint32_t i = 0; i < mActorManagers.getSize(); ++i)
+		{
+			IofxManager* mgr = DYNAMIC_CAST(IofxManager*)(mActorManagers.getResource(i));
+			mgr->fillMapUnmapArraysForInterop(mToMapArray, mToUnmapArray);
+		}
+
+		bool mapSuccess = true;
+		bool unmapSuccess = true;
+		{
+			PxScopedCudaLock s(*mContextManager);
+
+			if (!mToMapArray.empty())
+			{
+				for (uint32_t i = 0; i < mToMapArray.size(); ++i)
+				{
+					cuGraphicsResourceSetMapFlags( mToMapArray[i], CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD );
+				}
+				CUresult res = cuGraphicsMapResources(mToMapArray.size(), &mToMapArray.front(), 0);
+				mapSuccess = (res == CUDA_SUCCESS || res == CUDA_ERROR_ALREADY_MAPPED);
+			}
+			if (!mToUnmapArray.empty())
+			{
+				CUresult res = cuGraphicsUnmapResources(mToUnmapArray.size(), &mToUnmapArray.front(), 0);
+				unmapSuccess = (res == CUDA_SUCCESS || res == CUDA_ERROR_NOT_MAPPED);
+			}
+		}
+
+		for (uint32_t i = 0; i < mActorManagers.getSize(); ++i)
+		{
+			IofxManager* mgr = DYNAMIC_CAST(IofxManager*)(mActorManagers.getResource(i));
+			mgr->mapBufferResultsForInterop(mapSuccess, unmapSuccess);
+		}
+	}
+
+	mFetchResultsLock.unlock();
+	unlockLiveRenderVolumes();
+
+	mManagersLock.unlockReader();
+}
+
+#endif
+
+}
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/ModifierCPU.cpp b/APEX_1.4/module/iofx/src/ModifierCPU.cpp
new file mode 100644
index 00000000..572e8ac2
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/ModifierCPU.cpp
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "ModifierImpl.h"
+
+#pragma warning (disable : 4127)
+
+#include "ModifierData.h"
+
+namespace nvidia
+{
+namespace apex
+{
+
+#define MODIFIER_DECL
+#define CURVE_TYPE const nvidia::apex::Curve*
+#define EVAL_CURVE(curve, value) curve->evaluate(value)
+#define PARAMS_NAME(name) name ## ParamsCPU
+
+#include "ModifierSrc.h"
+
+#undef MODIFIER_DECL
+#undef CURVE_TYPE
+#undef EVAL_CURVE
+#undef PARAMS_NAME
+
+}
+
+namespace iofx
+{
+
+#define _MODIFIER(name) \
+	void name ## ModifierImpl :: mapParamsCPU(ModifierParamsMapperCPU& mapper) const \
+	{ \
+		mapParams(mapper, (name ## ParamsCPU *)NULL); \
+	} \
+	 
+#define _MODIFIER_SPRITE(name) \
+	void updateSprite_##name (const void* params, const SpriteInput& input, SpritePublicState& pubState, SpritePrivateState& privState, const ModifierCommonParams& common, RandState& randState) \
+	{ \
+		modifier##name <void, false, ModifierUsage_Sprite> (*static_cast<const name##ParamsCPU *>(params), input, pubState, privState, common, randState); \
+	} \
+	void updateSpriteOnSpawn_##name (const void* params, const SpriteInput& input, SpritePublicState& pubState, SpritePrivateState& privState, const ModifierCommonParams& common, RandState& randState) \
+	{ \
+		modifier##name <void, true, ModifierUsage_Sprite> (*static_cast<const name##ParamsCPU *>(params), input, pubState, privState, common, randState); \
+	} \
+	ModifierImpl::updateSpriteFunc name##ModifierImpl :: getUpdateSpriteFunc(ModifierStage stage) const \
+	{ \
+		switch (stage) { \
+		case ModifierStage_Spawn: return &updateSpriteOnSpawn_##name; \
+		case ModifierStage_Continuous: return &updateSprite_##name; \
+		default: \
+			PX_ALWAYS_ASSERT(); \
+			return 0; \
+		} \
+	}
+
+#define _MODIFIER_MESH(name) \
+	void updateMesh_##name (const void* params, const MeshInput& input, MeshPublicState& pubState, MeshPrivateState& privState, const ModifierCommonParams& common, RandState& randState) \
+	{ \
+		modifier##name <void, false, ModifierUsage_Mesh> (*static_cast<const name##ParamsCPU *>(params), input, pubState, privState, common, randState); \
+	} \
+	void updateMeshOnSpawn_##name (const void* params, const MeshInput& input, MeshPublicState& pubState, MeshPrivateState& privState, const ModifierCommonParams& common, RandState& randState) \
+	{ \
+		modifier##name <void, true, ModifierUsage_Mesh> (*static_cast<const name##ParamsCPU *>(params), input, pubState, privState, common, randState); \
+	} \
+	ModifierImpl::updateMeshFunc name##ModifierImpl :: getUpdateMeshFunc(ModifierStage stage) const \
+	{ \
+		switch (stage) { \
+		case ModifierStage_Spawn: return &updateMeshOnSpawn_##name; \
+		case ModifierStage_Continuous: return &updateMesh_##name; \
+		default: \
+			PX_ALWAYS_ASSERT(); \
+			return 0; \
+		} \
+	}
+
+#include "ModifierList.h"
+
+}
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/ModifierGPU.cpp b/APEX_1.4/module/iofx/src/ModifierGPU.cpp
new file mode 100644
index 00000000..55cae513
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/ModifierGPU.cpp
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "ModifierImpl.h"
+
+#if APEX_CUDA_SUPPORT
+
+#include "ApexCudaWrapper.h"
+
+#include "ModifierData.h"
+
+namespace nvidia
+{
+namespace apex
+{
+
+#define MODIFIER_DECL
+#define CURVE_TYPE nvidia::iofx::Curve
+#define EVAL_CURVE(curve, value) 0
+#define PARAMS_NAME(name) name ## ParamsGPU
+
+#include "ModifierSrc.h"
+
+#undef MODIFIER_DECL
+#undef CURVE_TYPE
+#undef EVAL_CURVE
+//#undef PARAMS_NAME
+}
+namespace iofx
+{
+
+class ModifierParamsMapperGPU_Adapter
+{
+private:
+	ModifierParamsMapperGPU_Adapter& operator=(const ModifierParamsMapperGPU_Adapter&);
+
+	ModifierParamsMapperGPU& _mapper;
+	InplaceStorage& _storage;
+	uint8_t* _params;
+
+public:
+	ModifierParamsMapperGPU_Adapter(ModifierParamsMapperGPU& mapper)
+		: _mapper(mapper), _storage(mapper.getStorage()), _params(0) {}
+
+	PX_INLINE InplaceStorage& getStorage()
+	{
+		return _storage;
+	}
+
+	PX_INLINE void beginParams(void* params, size_t , size_t , uint32_t)
+	{
+		_params = (uint8_t*)params;
+	}
+	PX_INLINE void endParams()
+	{
+		_params = 0;
+	}
+
+	template <typename T>
+	PX_INLINE void mapValue(size_t offset, T value)
+	{
+		PX_ASSERT(_params != 0);
+		*(T*)(_params + offset) = value;
+	}
+
+	PX_INLINE void mapCurve(size_t offset, const nvidia::apex::Curve* nxCurve)
+	{
+		PX_ASSERT(_params != 0);
+		Curve& curve = *(Curve*)(_params + offset);
+
+		uint32_t numPoints;
+		const Vec2R* nxPoints = nxCurve->getControlPoints(numPoints);
+
+		curve.resize(_storage, numPoints);
+		for (uint32_t i = 0; i < numPoints; ++i)
+		{
+			const Vec2R& nxPoint = nxPoints[i];
+			curve.setPoint(_storage, CurvePoint(nxPoint.x, nxPoint.y), i);
+		}
+	}
+};
+
+#define _MODIFIER(name) \
+	void name ## ModifierImpl :: mapParamsGPU(ModifierParamsMapperGPU& mapper) const \
+	{ \
+		ModifierParamsMapperGPU_Adapter adapter(mapper); \
+		InplaceHandle< PARAMS_NAME(name) > paramsHandle; \
+		paramsHandle.alloc( adapter.getStorage() ); \
+		PARAMS_NAME(name) params; \
+		mapParams( adapter, &params ); \
+		paramsHandle.update( adapter.getStorage(), params ); \
+		mapper.onParams( paramsHandle, PARAMS_NAME(name)::RANDOM_COUNT ); \
+	} \
+	 
+#include "ModifierList.h"
+
+}
+} // namespace nvidia
+
+#endif
diff --git a/APEX_1.4/module/iofx/src/ModifierImpl.cpp b/APEX_1.4/module/iofx/src/ModifierImpl.cpp
new file mode 100644
index 00000000..897364e7
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/ModifierImpl.cpp
@@ -0,0 +1,415 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+
+#include "ModifierImpl.h"
+
+#include "ApexSDKHelpers.h"
+#include "ApexSharedUtils.h"
+//#include "ApexSharedSerialization.h"
+#include "InstancedObjectSimulationIntl.h"
+#include "IofxActor.h"
+#include "ParamArray.h"
+#include "IofxAssetImpl.h"
+
+
+namespace nvidia
+{
+namespace iofx
+{
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+RotationModifierImpl::RotationModifierImpl(RotationModifierParams* params) :
+	mParams(params),
+	mRollType(ApexMeshParticleRollType::SPHERICAL),
+	mRollAxis(0),
+	mRollSign(0),
+	mLastUpdateTime(0.0f)
+{
+	NvParameterized::Handle h(*mParams);
+	mParams->getParameterHandle("rollType", h);
+	setRollType((ApexMeshParticleRollType::Enum) h.parameterDefinition()->enumValIndex(mParams->rollType));
+}
+
+// ------------------------------------------------------------------------------------------------
+void RotationModifierImpl::setRollType(ApexMeshParticleRollType::Enum rollType)
+{
+	PX_ASSERT(rollType < ApexMeshParticleRollType::COUNT);
+	mRollType = rollType;
+
+	NvParameterized::Handle h(*mParams);
+	mParams->getParameterHandle("rollType", h);
+	mParams->setParamEnum(h, h.parameterDefinition()->enumVal((int)rollType));
+
+	switch (mRollType)
+	{
+	default:
+		mRollSign = 1.0f;
+		mRollAxis = -1;
+		break;
+	case ApexMeshParticleRollType::FLAT_X:
+		mRollSign = 1.0f;
+		mRollAxis = 0;
+		break;
+	case ApexMeshParticleRollType::FLAT_Y:
+		mRollSign = 1.0f;
+		mRollAxis = 1;
+		break;
+	case ApexMeshParticleRollType::FLAT_Z:
+		mRollSign = 1.0f;
+		mRollAxis = 2;
+		break;
+	case ApexMeshParticleRollType::LONG_X:
+		mRollSign = -1.0f;
+		mRollAxis = 0;
+		break;
+	case ApexMeshParticleRollType::LONG_Y:
+		mRollSign = -1.0f;
+		mRollAxis = 1;
+		break;
+	case ApexMeshParticleRollType::LONG_Z:
+		mRollSign = -1.0f;
+		mRollAxis = 2;
+		break;
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+SimpleScaleModifierImpl::SimpleScaleModifierImpl(SimpleScaleModifierParams* params) :
+	mParams(params)
+{ }
+
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+RandomScaleModifierImpl::RandomScaleModifierImpl(RandomScaleModifierParams* param) :
+	mParams(param)
+{ }
+
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+ScaleByMassModifierImpl::ScaleByMassModifierImpl(ScaleByMassModifierParams* params) :
+	mParams(params)
+{ }
+
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+ColorVsLifeModifierImpl::ColorVsLifeModifierImpl(ColorVsLifeModifierParams* params) :
+	mParams(params)
+{
+	NvParameterized::Handle h(*mParams);
+	mParams->getParameterHandle("colorChannel", h);
+
+	mColorChannel = (ColorChannel)(h.parameterDefinition()->enumValIndex(mParams->colorChannel));
+
+	//do this in the Curve constructor... (for inplace stuff)
+	ParamArray<Vec2R> cp(mParams, "controlPoints", (ParamDynamicArrayStruct*)&mParams->controlPoints);
+	for (uint32_t i = 0; i < cp.size(); i++)
+	{
+		mCurveFunction.addControlPoint(cp[i]);
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void ColorVsLifeModifierImpl::setColorChannel(ColorChannel colorChannel)
+{
+	mColorChannel = colorChannel;
+
+	NvParameterized::Handle h(*mParams);
+	mParams->getParameterHandle("colorChannel", h);
+	mParams->setParamEnum(h, h.parameterDefinition()->enumVal((int)colorChannel));
+}
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+ColorVsDensityModifierImpl::ColorVsDensityModifierImpl(ColorVsDensityModifierParams* params) :
+	mParams(params)
+{
+	NvParameterized::Handle h(*mParams);
+	mParams->getParameterHandle("colorChannel", h);
+
+	mColorChannel = (ColorChannel)(h.parameterDefinition()->enumValIndex(mParams->colorChannel));
+
+	//do this in the Curve constructor... (for inplace stuff)
+	ParamArray<Vec2R> cp(mParams, "controlPoints", (ParamDynamicArrayStruct*)&mParams->controlPoints);
+	for (uint32_t i = 0; i < cp.size(); i++)
+	{
+		mCurveFunction.addControlPoint(cp[i]);
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void ColorVsDensityModifierImpl::setColorChannel(ColorChannel colorChannel)
+{
+	mColorChannel = colorChannel;
+
+	NvParameterized::Handle h(*mParams);
+	mParams->getParameterHandle("colorChannel", h);
+	mParams->setParamEnum(h, h.parameterDefinition()->enumVal((int)colorChannel));
+}
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+ColorVsVelocityModifierImpl::ColorVsVelocityModifierImpl(ColorVsVelocityModifierParams* params) :
+	mParams(params)
+{
+	NvParameterized::Handle h(*mParams);
+	mParams->getParameterHandle("colorChannel", h);
+
+	mColorChannel = (ColorChannel)(h.parameterDefinition()->enumValIndex(mParams->colorChannel));
+
+	//do this in the Curve constructor... (for inplace stuff)
+	ParamArray<Vec2R> cp(mParams, "controlPoints", (ParamDynamicArrayStruct*)&mParams->controlPoints);
+	for (uint32_t i = 0; i < cp.size(); i++)
+	{
+		mCurveFunction.addControlPoint(cp[i]);
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void ColorVsVelocityModifierImpl::setColorChannel(ColorChannel colorChannel)
+{
+	mColorChannel = colorChannel;
+
+	NvParameterized::Handle h(*mParams);
+	mParams->getParameterHandle("colorChannel", h);
+	mParams->setParamEnum(h, h.parameterDefinition()->enumVal((int)colorChannel));
+}
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+SubtextureVsLifeModifierImpl::SubtextureVsLifeModifierImpl(SubtextureVsLifeModifierParams* params) :
+	mParams(params)
+{
+	//do this in the Curve constructor... (for inplace stuff)
+	ParamArray<Vec2R> cp(mParams, "controlPoints", (ParamDynamicArrayStruct*)&mParams->controlPoints);
+	for (uint32_t i = 0; i < cp.size(); i++)
+	{
+		mCurveFunction.addControlPoint(cp[i]);
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+OrientAlongVelocityModifierImpl::OrientAlongVelocityModifierImpl(OrientAlongVelocityModifierParams* params) :
+	mParams(params)
+{ }
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+ScaleAlongVelocityModifierImpl::ScaleAlongVelocityModifierImpl(ScaleAlongVelocityModifierParams* params) :
+	mParams(params)
+{ }
+
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+RandomSubtextureModifierImpl::RandomSubtextureModifierImpl(RandomSubtextureModifierParams* params) :
+	mParams(params)
+{}
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+RandomRotationModifierImpl::RandomRotationModifierImpl(RandomRotationModifierParams* params) :
+	mParams(params)
+{}
+
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+ScaleVsLifeModifierImpl::ScaleVsLifeModifierImpl(ScaleVsLifeModifierParams* params) :
+	mParams(params)
+{
+	NvParameterized::Handle h(*mParams);
+	mParams->getParameterHandle("scaleAxis", h);
+
+	mScaleAxis = (ScaleAxis)(h.parameterDefinition()->enumValIndex(mParams->scaleAxis));
+
+	//do this in the Curve constructor... (for inplace stuff)
+	ParamArray<Vec2R> cp(mParams, "controlPoints", (ParamDynamicArrayStruct*)&mParams->controlPoints);
+	for (uint32_t i = 0; i < cp.size(); i++)
+	{
+		mCurveFunction.addControlPoint(cp[i]);
+	}
+}
+
+void ScaleVsLifeModifierImpl::setScaleAxis(ScaleAxis a)
+{
+	mScaleAxis = a;
+
+	NvParameterized::Handle h(*mParams);
+	mParams->getParameterHandle("scaleAxis", h);
+	mParams->setParamEnum(h, h.parameterDefinition()->enumVal((int)a));
+}
+
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+ScaleVsDensityModifierImpl::ScaleVsDensityModifierImpl(ScaleVsDensityModifierParams* params) :
+	mParams(params)
+{
+	NvParameterized::Handle h(*mParams);
+	mParams->getParameterHandle("scaleAxis", h);
+
+	mScaleAxis = (ScaleAxis)(h.parameterDefinition()->enumValIndex(mParams->scaleAxis));
+
+	//do this in the Curve constructor... (for inplace stuff)
+	ParamArray<Vec2R> cp(mParams, "controlPoints", (ParamDynamicArrayStruct*)&mParams->controlPoints);
+	for (uint32_t i = 0; i < cp.size(); i++)
+	{
+		mCurveFunction.addControlPoint(cp[i]);
+	}
+}
+
+void ScaleVsDensityModifierImpl::setScaleAxis(ScaleAxis a)
+{
+	mScaleAxis = a;
+
+	NvParameterized::Handle h(*mParams);
+	mParams->getParameterHandle("scaleAxis", h);
+	mParams->setParamEnum(h, h.parameterDefinition()->enumVal((int)a));
+}
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+ScaleVsCameraDistanceModifierImpl::ScaleVsCameraDistanceModifierImpl(ScaleVsCameraDistanceModifierParams* params) :
+	mParams(params)
+{
+	NvParameterized::Handle h(*mParams);
+	mParams->getParameterHandle("scaleAxis", h);
+
+	mScaleAxis = (ScaleAxis)(h.parameterDefinition()->enumValIndex(mParams->scaleAxis));
+
+	//do this in the Curve constructor... (for inplace stuff)
+	ParamArray<Vec2R> cp(mParams, "controlPoints", (ParamDynamicArrayStruct*)&mParams->controlPoints);
+	for (uint32_t i = 0; i < cp.size(); i++)
+	{
+		mCurveFunction.addControlPoint(cp[i]);
+	}
+}
+
+void ScaleVsCameraDistanceModifierImpl::setScaleAxis(ScaleAxis a)
+{
+	mScaleAxis = a;
+
+	NvParameterized::Handle h(*mParams);
+	mParams->getParameterHandle("scaleAxis", h);
+	mParams->setParamEnum(h, h.parameterDefinition()->enumVal((int)a));
+}
+
+
+
+ViewDirectionSortingModifierImpl::ViewDirectionSortingModifierImpl(ViewDirectionSortingModifierParams* params)
+	: mParams(params)
+{
+}
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+RotationRateModifierImpl::RotationRateModifierImpl(RotationRateModifierParams* params) :
+	mParams(params)
+{
+}
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+RotationRateVsLifeModifierImpl::RotationRateVsLifeModifierImpl(RotationRateVsLifeModifierParams* params) :
+	mParams(params)
+{
+	//do this in the Curve constructor... (for inplace stuff)
+	ParamArray<Vec2R> cp(mParams, "controlPoints", (ParamDynamicArrayStruct*)&mParams->controlPoints);
+	for (uint32_t i = 0; i < cp.size(); i++)
+	{
+		mCurveFunction.addControlPoint(cp[i]);
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+OrientScaleAlongScreenVelocityModifierImpl::OrientScaleAlongScreenVelocityModifierImpl(OrientScaleAlongScreenVelocityModifierParams* params) :
+	mParams(params)
+{
+}
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+Modifier* CreateModifier(ModifierTypeEnum modifierType, NvParameterized::Interface* objParam, NvParameterized::Handle& h)
+{
+	PX_UNUSED(objParam);
+	PX_ASSERT(objParam == h.getConstInterface());
+
+#define _MODIFIER(Type) \
+case ModifierType_##Type: \
+	h.initParamRef(#Type "ModifierParams", true); \
+	h.getParamRef(refParam); \
+	return PX_NEW(Type##ModifierImpl)((Type##ModifierParams*)refParam); \
+	 
+	NvParameterized::Interface* refParam = 0;
+
+	// TODO: This should go to an actual factory which can be used to extend modifiers.
+	switch (modifierType)
+	{
+#include "ModifierList.h"
+
+	default:
+		PX_ALWAYS_ASSERT();
+	}
+	return 0;
+}
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+
+const ModifierImpl* ModifierImpl::castFrom(const Modifier* modifier)
+{
+#define _MODIFIER(Type) \
+case ModifierType_##Type: \
+	return static_cast<const ModifierImpl*>( static_cast<const Type ## ModifierImpl *>(modifier) ); \
+	 
+	ModifierTypeEnum modifierType = modifier->getModifierType();
+	switch (modifierType)
+	{
+#include "ModifierList.h"
+
+	default:
+		PX_ALWAYS_ASSERT();
+		return 0;
+	}
+}
+
+}
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/ModuleIofxImpl.cpp b/APEX_1.4/module/iofx/src/ModuleIofxImpl.cpp
new file mode 100644
index 00000000..95df8b7c
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/ModuleIofxImpl.cpp
@@ -0,0 +1,412 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "Apex.h"
+#include "ApexUsingNamespace.h"
+#include "ApexSDKIntl.h"
+#include "ModuleIofxImpl.h"
+#include "ModuleIofxRegistration.h"
+#include "IofxAssetImpl.h"
+#include "SceneIntl.h"
+#include "PsMemoryBuffer.h"
+#include "IofxSceneCPU.h"
+#include "IofxSceneGPU.h"
+#include "IofxActorImpl.h"
+#include "RenderVolumeImpl.h"
+
+#include "ModulePerfScope.h"
+using namespace iofx;
+
+#include "Lock.h"
+
+namespace nvidia
+{
+namespace apex
+{
+
+#if defined(_USRDLL)
+
+/* Modules don't have to link against the framework, they keep their own */
+ApexSDKIntl* gApexSdk = 0;
+ApexSDK* GetApexSDK()
+{
+	return gApexSdk;
+}
+ApexSDKIntl* GetInternalApexSDK()
+{
+	return gApexSdk;
+}
+
+APEX_API Module*  CALL_CONV createModule(
+    ApexSDKIntl* inSdk,
+    ModuleIntl** niRef,
+    uint32_t APEXsdkVersion,
+    uint32_t PhysXsdkVersion,
+    ApexCreateError* errorCode)
+{
+	if (APEXsdkVersion != APEX_SDK_VERSION)
+	{
+		if (errorCode)
+		{
+			*errorCode = APEX_CE_WRONG_VERSION;
+		}
+		return NULL;
+	}
+
+	if (PhysXsdkVersion != PX_PHYSICS_VERSION)
+	{
+		if (errorCode)
+		{
+			*errorCode = APEX_CE_WRONG_VERSION;
+		}
+		return NULL;
+	}
+
+	/* Setup common module global variables */
+	gApexSdk = inSdk;
+	ModuleIofxImpl* impl = PX_NEW(ModuleIofx)(inSdk);
+	*niRef  = (ModuleIntl*) impl;
+	return (Module*) impl;
+}
+#else
+/* Statically linking entry function */
+void instantiateModuleIofx()
+{
+	ApexSDKIntl* sdk = GetInternalApexSDK();
+	iofx::ModuleIofxImpl* impl = PX_NEW(iofx::ModuleIofxImpl)(sdk);
+	sdk->registerExternalModule((Module*) impl, (ModuleIntl*) impl);
+}
+#endif
+}
+
+namespace iofx
+{
+/* =================== ModuleIofxImpl =================== */
+
+
+AuthObjTypeID IofxAssetImpl::mAssetTypeID;
+#ifdef WITHOUT_APEX_AUTHORING
+
+class IofxAssetDummyAuthoring : public AssetAuthoring, public UserAllocated
+{
+public:
+	IofxAssetDummyAuthoring(ModuleIofxImpl* module, ResourceList& list, NvParameterized::Interface* params, const char* name)
+	{
+		PX_UNUSED(module);
+		PX_UNUSED(list);
+		PX_UNUSED(params);
+		PX_UNUSED(name);
+	}
+
+	IofxAssetDummyAuthoring(ModuleIofxImpl* module, ResourceList& list, const char* name)
+	{
+		PX_UNUSED(module);
+		PX_UNUSED(list);
+		PX_UNUSED(name);
+	}
+
+	IofxAssetDummyAuthoring(ModuleIofxImpl* module, ResourceList& list)
+	{
+		PX_UNUSED(module);
+		PX_UNUSED(list);
+	}
+
+	virtual void setToolString(const char* /*toolName*/, const char* /*toolVersion*/, uint32_t /*toolChangelist*/)
+	{
+
+	}
+
+
+	virtual void release()
+	{
+		destroy();
+	}
+
+	// internal
+	void destroy()
+	{
+		delete this;
+	}
+
+	/**
+	* \brief Returns the name of this APEX authorable object type
+	*/
+	virtual const char* getObjTypeName() const
+	{
+		return IOFX_AUTHORING_TYPE_NAME;
+	}
+
+	/**
+	 * \brief Prepares a fully authored Asset Authoring object for a specified platform
+	 */
+	virtual bool prepareForPlatform(nvidia::apex::PlatformTag)
+	{
+		PX_ASSERT(0);
+		return false;
+	}
+
+	const char* getName(void) const
+	{
+		return NULL;
+	}
+
+	/**
+	* \brief Save asset's NvParameterized interface, may return NULL
+	*/
+	virtual NvParameterized::Interface* getNvParameterized() const
+	{
+		PX_ASSERT(0);
+		return NULL;
+	}
+
+	virtual NvParameterized::Interface* releaseAndReturnNvParameterizedInterface(void)
+	{
+		PX_ALWAYS_ASSERT();
+		return NULL;
+	}
+};
+
+typedef ApexAuthorableObject<ModuleIofxImpl, IofxAssetImpl, IofxAssetDummyAuthoring> IofxAO;
+
+#else
+typedef ApexAuthorableObject<ModuleIofxImpl, IofxAssetImpl, IofxAssetAuthoringImpl> IofxAO;
+#endif
+
+ModuleIofxImpl::ModuleIofxImpl(ApexSDKIntl* sdk)
+{
+	mSdk = sdk;
+	mApiProxy = this;
+	mName = "IOFX";
+	mModuleParams = NULL;
+	mInteropDisabled = false;
+	mCudaDisabled = false;
+	mDeferredDisabled = false;
+
+	/* Register this module's authorable object types and create their namespaces */
+	const char* pName = IofxAssetParameters::staticClassName();
+	IofxAO* AO = PX_NEW(IofxAO)(this, mAuthorableObjects, pName);
+	IofxAssetImpl::mAssetTypeID = AO->getResID();
+
+	/* Register the NvParameterized factories */
+	NvParameterized::Traits* traits = mSdk->getParameterizedTraits();
+	ModuleIofxRegistration::invokeRegistration(traits);
+}
+
+AuthObjTypeID ModuleIofxImpl::getModuleID() const
+{
+	READ_ZONE();
+	return IofxAssetImpl::mAssetTypeID;
+}
+
+ModuleIofxImpl::~ModuleIofxImpl()
+{
+}
+
+void ModuleIofxImpl::destroy()
+{
+	/* Remove the NvParameterized factories */
+	NvParameterized::Traits* traits = mSdk->getParameterizedTraits();
+
+	if (mModuleParams)
+	{
+		mModuleParams->destroy();
+		mModuleParams = NULL;
+	}
+
+	ModuleBase::destroy();
+
+	if (traits)
+	{
+		ModuleIofxRegistration::invokeUnregistration(traits);
+	}
+	delete this;
+}
+
+NvParameterized::Interface* ModuleIofxImpl::getDefaultModuleDesc()
+{
+	READ_ZONE();
+	NvParameterized::Traits* traits = mSdk->getParameterizedTraits();
+
+	if (!mModuleParams)
+	{
+		mModuleParams = DYNAMIC_CAST(IofxModuleParameters*)
+		                (traits->createNvParameterized("IofxModuleParameters"));
+		PX_ASSERT(mModuleParams);
+	}
+	else
+	{
+		mModuleParams->initDefaults();
+	}
+
+	return mModuleParams;
+}
+
+void ModuleIofxImpl::init(const ModuleIofxDesc&)
+{
+	WRITE_ZONE();
+}
+
+uint32_t ModuleIofxImpl::forceLoadAssets()
+{
+	uint32_t loadedAssetCount = 0;
+
+	for (uint32_t i = 0; i < mAuthorableObjects.getSize(); i++)
+	{
+		AuthorableObjectIntl* ao = static_cast<AuthorableObjectIntl*>(mAuthorableObjects.getResource(i));
+		loadedAssetCount += ao->forceLoadAssets();
+	}
+	return loadedAssetCount;
+}
+
+ModuleSceneIntl* ModuleIofxImpl::createInternalModuleScene(SceneIntl& scene, RenderDebugInterface* debugRender)
+{
+	IofxScene* res = NULL;
+#if APEX_CUDA_SUPPORT
+	PxGpuDispatcher* gd;
+	{
+		READ_LOCK(scene);
+		gd = scene.getTaskManager()->getGpuDispatcher();
+	}
+
+	if (gd && gd->getCudaContextManager()->contextIsValid())
+	{
+		res = PX_NEW(IofxSceneGPU)(*this, scene, debugRender, mIofxScenes);
+	}
+	else
+#endif
+	{
+		res = PX_NEW(IofxSceneCPU)(*this, scene, debugRender, mIofxScenes);
+	}
+	return res;
+}
+
+void ModuleIofxImpl::releaseModuleSceneIntl(ModuleSceneIntl& scene)
+{
+	IofxScene* is = DYNAMIC_CAST(IofxScene*)(&scene);
+	is->destroy();
+}
+
+IofxScene* ModuleIofxImpl::getIofxScene(const Scene& apexScene)
+{
+	for (uint32_t i = 0 ; i < mIofxScenes.getSize() ; i++)
+	{
+		IofxScene* is = DYNAMIC_CAST(IofxScene*)(mIofxScenes.getResource(i));
+		if (is->mApexScene == &apexScene)
+		{
+			return is;
+		}
+	}
+
+	PX_ASSERT(!"Unable to locate an appropriate IofxScene");
+	return NULL;
+}
+
+const IofxScene* ModuleIofxImpl::getIofxScene(const Scene& apexScene) const
+{
+	for (uint32_t i = 0 ; i < mIofxScenes.getSize() ; i++)
+	{
+		IofxScene* is = DYNAMIC_CAST(IofxScene*)(mIofxScenes.getResource(i));
+		if (is->mApexScene == &apexScene)
+		{
+			return is;
+		}
+	}
+
+	PX_ASSERT(!"Unable to locate an appropriate IofxScene");
+	return NULL;
+}
+
+RenderVolume* ModuleIofxImpl::createRenderVolume(const Scene& apexScene, const PxBounds3& b, uint32_t priority, bool allIofx)
+{
+	WRITE_ZONE();
+	IofxScene* is = getIofxScene(apexScene);
+	if (is)
+	{
+		return PX_NEW(RenderVolumeImpl)(*is, b, priority, allIofx);
+	}
+
+	return NULL;
+}
+
+void ModuleIofxImpl::releaseRenderVolume(RenderVolume& volume)
+{
+	WRITE_ZONE();
+	RenderVolumeImpl* arv = DYNAMIC_CAST(RenderVolumeImpl*)(&volume);
+	arv->destroy();
+}
+
+
+IofxManagerIntl* ModuleIofxImpl::createActorManager(const Scene& scene, const IofxAsset& asset, const IofxManagerDescIntl& desc)
+{
+	WRITE_ZONE();
+	IofxScene* is = getIofxScene(scene);
+	return is ? is->createIofxManager(asset, desc) : NULL;
+}
+
+const TestBase* ModuleIofxImpl::getTestBase(Scene* apexScene) const
+{
+#if ENABLE_TEST
+	const IofxScene* scene = getIofxScene(*apexScene);
+	return static_cast<const TestBase*>(DYNAMIC_CAST(const IofxTestScene*)(scene));
+#else
+	PX_UNUSED(apexScene);
+	return 0;
+#endif
+}
+
+bool ModuleIofxImpl::setIofxRenderCallback(const Scene& apexScene, IofxRenderCallback* callback)
+{
+	WRITE_ZONE();
+	IofxScene* is = getIofxScene(apexScene);
+	if (is)
+	{
+		is->setIofxRenderCallback(callback);
+		return true;
+	}
+	return false;
+}
+
+IofxRenderCallback* ModuleIofxImpl::getIofxRenderCallback(const Scene& apexScene) const
+{
+	READ_ZONE();
+	const IofxScene* is = getIofxScene(apexScene);
+	if (is)
+	{
+		return is->getIofxRenderCallback();
+	}
+	return NULL;
+}
+
+IofxRenderableIterator* ModuleIofxImpl::createIofxRenderableIterator(const Scene& apexScene)
+{
+	WRITE_ZONE();
+	IofxScene* is = getIofxScene(apexScene);
+	if (is)
+	{
+		return is->createIofxRenderableIterator();
+	}
+
+	return NULL;
+}
+
+void ModuleIofxImpl::prepareRenderables(const Scene& apexScene)
+{
+	WRITE_ZONE();
+	URR_SCOPE;
+	IofxScene* is = getIofxScene(apexScene);
+	if (is)
+	{
+		is->prepareRenderables();
+	}
+}
+
+}
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/RenderVolumeImpl.cpp b/APEX_1.4/module/iofx/src/RenderVolumeImpl.cpp
new file mode 100644
index 00000000..4138d30e
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/RenderVolumeImpl.cpp
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "Apex.h"
+
+#include "RenderVolumeImpl.h"
+#include "ModuleIofxImpl.h"
+#include "IofxAssetImpl.h"
+#include "IofxActorImpl.h"
+#include "IofxScene.h"
+#include "SceneIntl.h"
+
+#include "PsArray.h"
+
+namespace nvidia
+{
+namespace iofx
+{
+
+RenderVolumeImpl::RenderVolumeImpl(IofxScene& scene, const PxBounds3& b, uint32_t priority, bool allIofx)
+	: mPriority(priority)
+	, mAllIofx(allIofx)
+	, mPendingDelete(false)
+	, mScene(scene)
+{
+	setOwnershipBounds(b);
+
+	mScene.mAddedRenderVolumesLock.lock();
+	mScene.mAddedRenderVolumes.pushBack(this);
+	mScene.mAddedRenderVolumesLock.unlock();
+}
+
+RenderVolumeImpl::~RenderVolumeImpl()
+{
+	mLock.lockWriter();
+	while (mIofxActors.size())
+	{
+		IofxActor* iofx = mIofxActors.popBack();
+		iofx->release();
+	}
+	mLock.unlockWriter();
+}
+
+void RenderVolumeImpl::destroy()
+{
+	if (!mPendingDelete)
+	{
+		mPendingDelete = true;
+
+		mScene.mDeletedRenderVolumesLock.lock();
+		mScene.mDeletedRenderVolumes.pushBack(this);
+		mScene.mDeletedRenderVolumesLock.unlock();
+	}
+}
+
+void RenderVolumeImpl::release()
+{
+	if (!mPendingDelete)
+	{
+		mScene.mModule->releaseRenderVolume(*this);
+	}
+}
+
+bool RenderVolumeImpl::addIofxAsset(IofxAsset& iofx)
+{
+	WRITE_ZONE();
+	if (mAllIofx || mPendingDelete)
+	{
+		return false;
+	}
+
+	mLock.lockWriter();
+	mIofxAssets.pushBack(&iofx);
+	mLock.unlockWriter();
+	return true;
+}
+
+bool RenderVolumeImpl::addIofxActor(IofxActor& iofx)
+{
+	if (mPendingDelete)
+	{
+		return false;
+	}
+
+	mLock.lockWriter();
+	mIofxActors.pushBack(&iofx);
+	mLock.unlockWriter();
+	return true;
+}
+
+bool RenderVolumeImpl::removeIofxActor(const IofxActor& iofx)
+{
+	bool res = false;
+	mLock.lockWriter();
+	for (uint32_t i = 0 ; i < mIofxActors.size() ; i++)
+	{
+		if (mIofxActors[ i ] == &iofx)
+		{
+			mIofxActors.replaceWithLast(i);
+			res = true;
+			break;
+		}
+	}
+	mLock.unlockWriter();
+	return res;
+}
+
+void RenderVolumeImpl::setPosition(const PxVec3& pos)
+{
+	WRITE_ZONE();
+	PxVec3 ext = mOwnershipBounds.getExtents();
+	mOwnershipBounds = physx::PxBounds3(pos - ext, pos + ext);
+}
+
+PxBounds3 RenderVolumeImpl::getBounds() const
+{
+	READ_ZONE();
+	if (mPendingDelete)
+	{
+		return PxBounds3::empty();
+	}
+
+	PxBounds3 b = PxBounds3::empty();
+	nvidia::Array<IofxActor*>::ConstIterator i;
+	for (i = mIofxActors.begin() ; i != mIofxActors.end() ; i++)
+	{
+		b.include((*i)->getBounds());
+	}
+
+	return b;
+}
+
+// Callers must acquire render lock for thread safety
+bool RenderVolumeImpl::affectsIofxAsset(const IofxAsset& iofx) const
+{
+	READ_ZONE();
+	if (mPendingDelete)
+	{
+		return false;
+	}
+
+	if (mAllIofx)
+	{
+		return true;
+	}
+
+	nvidia::Array<IofxAsset*>::ConstIterator i;
+	for (i = mIofxAssets.begin() ; i != mIofxAssets.end() ; i++)
+	{
+		if (&iofx == *i)
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+}
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ColorVsDensityCompositeModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ColorVsDensityCompositeModifierParams.cpp
new file mode 100644
index 00000000..aa12bd3b
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ColorVsDensityCompositeModifierParams.cpp
@@ -0,0 +1,459 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ColorVsDensityCompositeModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ColorVsDensityCompositeModifierParamsNS;
+
+const char* const ColorVsDensityCompositeModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ColorVsDensityCompositeModifierParams, ColorVsDensityCompositeModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(colorDensityStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((colorDensityStruct_Type*)0)->density), NULL, 0 }, // controlPoints[].density
+	{ TYPE_VEC4, false, (size_t)(&((colorDensityStruct_Type*)0)->color), NULL, 0 }, // controlPoints[].color
+};
+
+
+bool ColorVsDensityCompositeModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ColorVsDensityCompositeModifierParams::mBuiltFlagMutex;
+
+ColorVsDensityCompositeModifierParams::ColorVsDensityCompositeModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ColorVsDensityCompositeModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ColorVsDensityCompositeModifierParams::~ColorVsDensityCompositeModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ColorVsDensityCompositeModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ColorVsDensityCompositeModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsDensityCompositeModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsDensityCompositeModifierParams::getParameterDefinitionTree(void) const
+{
+	ColorVsDensityCompositeModifierParams* tmpParam = const_cast<ColorVsDensityCompositeModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ColorVsDensityCompositeModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ColorVsDensityCompositeModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ColorVsDensityCompositeModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ColorVsDensityCompositeModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ColorVsDensityCompositeModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ColorVsDensityCompositeModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ColorVsDensityComposite modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Density", true);
+		HintTable[5].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite color vs density curve", true);
+		HintTable[5].init("xAxisLabel", "Density", true);
+		HintTable[6].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "colorDensityStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Density", true);
+		HintTable[5].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite color vs density curve", true);
+		HintTable[5].init("xAxisLabel", "Density", true);
+		HintTable[6].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].density"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("density", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Density", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].color"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("color", TYPE_VEC4, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max", uint64_t(16), true);
+		HintTable[2].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max", uint64_t(16), true);
+		HintTable[2].init("min", uint64_t(0), true);
+		HintTable[3].init("shortDescription", "Color is formatted x=R, y=G, z=B, w=A", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ColorVsDensityCompositeModifierParams::initStrings(void)
+{
+}
+
+void ColorVsDensityCompositeModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(colorDensityStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ColorVsDensityCompositeModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ColorVsDensityCompositeModifierParams::initReferences(void)
+{
+}
+
+void ColorVsDensityCompositeModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ColorVsDensityCompositeModifierParams::freeStrings(void)
+{
+}
+
+void ColorVsDensityCompositeModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ColorVsDensityModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ColorVsDensityModifierParams.cpp
new file mode 100644
index 00000000..168f45c0
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ColorVsDensityModifierParams.cpp
@@ -0,0 +1,478 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ColorVsDensityModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ColorVsDensityModifierParamsNS;
+
+const char* const ColorVsDensityModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ColorVsDensityModifierParams, ColorVsDensityModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->colorChannel), NULL, 0 }, // colorChannel
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(2), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(3), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool ColorVsDensityModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ColorVsDensityModifierParams::mBuiltFlagMutex;
+
+ColorVsDensityModifierParams::ColorVsDensityModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ColorVsDensityModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ColorVsDensityModifierParams::~ColorVsDensityModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ColorVsDensityModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ColorVsDensityModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsDensityModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsDensityModifierParams::getParameterDefinitionTree(void) const
+{
+	ColorVsDensityModifierParams* tmpParam = const_cast<ColorVsDensityModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ColorVsDensityModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ColorVsDensityModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ColorVsDensityModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ColorVsDensityModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ColorVsDensityModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ColorVsDensityModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ColorVsDensity modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="colorChannel"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("colorChannel", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "alpha", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "alpha", true);
+		HintTable[1].init("shortDescription", "Color channel", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "red", "green", "blue", "alpha" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 4);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Density", true);
+		HintTable[5].init("yAxisLabel", "Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[5].init("shortDescription", "Control points for a curve", true);
+		HintTable[6].init("xAxisLabel", "Density", true);
+		HintTable[7].init("yAxisLabel", "Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Density", true);
+		HintTable[5].init("yAxisLabel", "Color", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[5].init("shortDescription", "Control points for a curve", true);
+		HintTable[6].init("xAxisLabel", "Density", true);
+		HintTable[7].init("yAxisLabel", "Color", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Density", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Color", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(4);
+		Children[1] = PDEF_PTR(5);
+
+		ParamDefTable[3].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ColorVsDensityModifierParams::initStrings(void)
+{
+}
+
+void ColorVsDensityModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ColorVsDensityModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	colorChannel = (const char*)"alpha";
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ColorVsDensityModifierParams::initReferences(void)
+{
+}
+
+void ColorVsDensityModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ColorVsDensityModifierParams::freeStrings(void)
+{
+}
+
+void ColorVsDensityModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ColorVsLifeCompositeModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ColorVsLifeCompositeModifierParams.cpp
new file mode 100644
index 00000000..fbd9c761
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ColorVsLifeCompositeModifierParams.cpp
@@ -0,0 +1,471 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ColorVsLifeCompositeModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ColorVsLifeCompositeModifierParamsNS;
+
+const char* const ColorVsLifeCompositeModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ColorVsLifeCompositeModifierParams, ColorVsLifeCompositeModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(colorLifeStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((colorLifeStruct_Type*)0)->lifeRemaining), NULL, 0 }, // controlPoints[].lifeRemaining
+	{ TYPE_VEC4, false, (size_t)(&((colorLifeStruct_Type*)0)->color), NULL, 0 }, // controlPoints[].color
+};
+
+
+bool ColorVsLifeCompositeModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ColorVsLifeCompositeModifierParams::mBuiltFlagMutex;
+
+ColorVsLifeCompositeModifierParams::ColorVsLifeCompositeModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ColorVsLifeCompositeModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ColorVsLifeCompositeModifierParams::~ColorVsLifeCompositeModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ColorVsLifeCompositeModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ColorVsLifeCompositeModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsLifeCompositeModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsLifeCompositeModifierParams::getParameterDefinitionTree(void) const
+{
+	ColorVsLifeCompositeModifierParams* tmpParam = const_cast<ColorVsLifeCompositeModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ColorVsLifeCompositeModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ColorVsLifeCompositeModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ColorVsLifeCompositeModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ColorVsLifeCompositeModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ColorVsLifeCompositeModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ColorVsLifeCompositeModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ColorVsLifeComposite modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Life Time", true);
+		HintTable[5].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite color vs life curve", true);
+		HintTable[5].init("xAxisLabel", "Life Time", true);
+		HintTable[6].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "colorLifeStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Life Time", true);
+		HintTable[5].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite color vs life curve", true);
+		HintTable[5].init("xAxisLabel", "Life Time", true);
+		HintTable[6].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].lifeRemaining"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("lifeRemaining", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Life remaining", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].color"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("color", TYPE_VEC4, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max_w", uint64_t(8), true);
+		HintTable[2].init("max_x", uint64_t(8), true);
+		HintTable[3].init("max_y", uint64_t(8), true);
+		HintTable[4].init("min_w", uint64_t(0), true);
+		HintTable[5].init("min_x", uint64_t(0), true);
+		HintTable[6].init("min_y", uint64_t(0), true);
+		HintTable[7].init("min_z", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#else
+
+		static HintImpl HintTable[9];
+		static Hint* HintPtrTable[9] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], &HintTable[8], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max_w", uint64_t(8), true);
+		HintTable[2].init("max_x", uint64_t(8), true);
+		HintTable[3].init("max_y", uint64_t(8), true);
+		HintTable[4].init("min_w", uint64_t(0), true);
+		HintTable[5].init("min_x", uint64_t(0), true);
+		HintTable[6].init("min_y", uint64_t(0), true);
+		HintTable[7].init("min_z", uint64_t(0), true);
+		HintTable[8].init("shortDescription", "Color is formatted x=R, y=G, z=B, w=A", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 9);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ColorVsLifeCompositeModifierParams::initStrings(void)
+{
+}
+
+void ColorVsLifeCompositeModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(colorLifeStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ColorVsLifeCompositeModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ColorVsLifeCompositeModifierParams::initReferences(void)
+{
+}
+
+void ColorVsLifeCompositeModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ColorVsLifeCompositeModifierParams::freeStrings(void)
+{
+}
+
+void ColorVsLifeCompositeModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ColorVsLifeModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ColorVsLifeModifierParams.cpp
new file mode 100644
index 00000000..801c5209
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ColorVsLifeModifierParams.cpp
@@ -0,0 +1,474 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ColorVsLifeModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ColorVsLifeModifierParamsNS;
+
+const char* const ColorVsLifeModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ColorVsLifeModifierParams, ColorVsLifeModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->colorChannel), NULL, 0 }, // colorChannel
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(2), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(3), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool ColorVsLifeModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ColorVsLifeModifierParams::mBuiltFlagMutex;
+
+ColorVsLifeModifierParams::ColorVsLifeModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ColorVsLifeModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ColorVsLifeModifierParams::~ColorVsLifeModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ColorVsLifeModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ColorVsLifeModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsLifeModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsLifeModifierParams::getParameterDefinitionTree(void) const
+{
+	ColorVsLifeModifierParams* tmpParam = const_cast<ColorVsLifeModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ColorVsLifeModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ColorVsLifeModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ColorVsLifeModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ColorVsLifeModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ColorVsLifeModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ColorVsLifeModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ColorVsLife modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="colorChannel"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("colorChannel", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "alpha", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "alpha", true);
+		HintTable[1].init("shortDescription", "Color channel", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "red", "green", "blue", "alpha" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 4);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Life Time", true);
+		HintTable[2].init("yAxisLabel", "Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Life Time", true);
+		HintTable[2].init("yAxisLabel", "Color", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Color", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Life", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Color", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(4);
+		Children[1] = PDEF_PTR(5);
+
+		ParamDefTable[3].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ColorVsLifeModifierParams::initStrings(void)
+{
+}
+
+void ColorVsLifeModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ColorVsLifeModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	colorChannel = (const char*)"alpha";
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ColorVsLifeModifierParams::initReferences(void)
+{
+}
+
+void ColorVsLifeModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ColorVsLifeModifierParams::freeStrings(void)
+{
+}
+
+void ColorVsLifeModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ColorVsTemperatureCompositeModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ColorVsTemperatureCompositeModifierParams.cpp
new file mode 100644
index 00000000..388930f9
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ColorVsTemperatureCompositeModifierParams.cpp
@@ -0,0 +1,455 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ColorVsTemperatureCompositeModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ColorVsTemperatureCompositeModifierParamsNS;
+
+const char* const ColorVsTemperatureCompositeModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ColorVsTemperatureCompositeModifierParams, ColorVsTemperatureCompositeModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(colorTemperatureStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((colorTemperatureStruct_Type*)0)->temperature), NULL, 0 }, // controlPoints[].temperature
+	{ TYPE_VEC4, false, (size_t)(&((colorTemperatureStruct_Type*)0)->color), NULL, 0 }, // controlPoints[].color
+};
+
+
+bool ColorVsTemperatureCompositeModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ColorVsTemperatureCompositeModifierParams::mBuiltFlagMutex;
+
+ColorVsTemperatureCompositeModifierParams::ColorVsTemperatureCompositeModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ColorVsTemperatureCompositeModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ColorVsTemperatureCompositeModifierParams::~ColorVsTemperatureCompositeModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ColorVsTemperatureCompositeModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ColorVsTemperatureCompositeModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsTemperatureCompositeModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsTemperatureCompositeModifierParams::getParameterDefinitionTree(void) const
+{
+	ColorVsTemperatureCompositeModifierParams* tmpParam = const_cast<ColorVsTemperatureCompositeModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ColorVsTemperatureCompositeModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ColorVsTemperatureCompositeModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ColorVsTemperatureCompositeModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ColorVsTemperatureCompositeModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ColorVsTemperatureCompositeModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ColorVsTemperatureCompositeModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ColorVsTemperatureComposite modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Temperature", true);
+		HintTable[4].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite color vs Temperature curve", true);
+		HintTable[4].init("xAxisLabel", "Temperature", true);
+		HintTable[5].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "colorTemperatureStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Temperature", true);
+		HintTable[4].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite color vs Temperature curve", true);
+		HintTable[4].init("xAxisLabel", "Temperature", true);
+		HintTable[5].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].temperature"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("temperature", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Temperature", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].color"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("color", TYPE_VEC4, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max", uint64_t(16), true);
+		HintTable[2].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max", uint64_t(16), true);
+		HintTable[2].init("min", uint64_t(0), true);
+		HintTable[3].init("shortDescription", "Color is formatted x=R, y=G, z=B, w=A", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ColorVsTemperatureCompositeModifierParams::initStrings(void)
+{
+}
+
+void ColorVsTemperatureCompositeModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(colorTemperatureStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ColorVsTemperatureCompositeModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ColorVsTemperatureCompositeModifierParams::initReferences(void)
+{
+}
+
+void ColorVsTemperatureCompositeModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ColorVsTemperatureCompositeModifierParams::freeStrings(void)
+{
+}
+
+void ColorVsTemperatureCompositeModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ColorVsTemperatureModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ColorVsTemperatureModifierParams.cpp
new file mode 100644
index 00000000..3efec478
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ColorVsTemperatureModifierParams.cpp
@@ -0,0 +1,478 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ColorVsTemperatureModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ColorVsTemperatureModifierParamsNS;
+
+const char* const ColorVsTemperatureModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ColorVsTemperatureModifierParams, ColorVsTemperatureModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->colorChannel), NULL, 0 }, // colorChannel
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(2), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(3), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool ColorVsTemperatureModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ColorVsTemperatureModifierParams::mBuiltFlagMutex;
+
+ColorVsTemperatureModifierParams::ColorVsTemperatureModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ColorVsTemperatureModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ColorVsTemperatureModifierParams::~ColorVsTemperatureModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ColorVsTemperatureModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ColorVsTemperatureModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsTemperatureModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsTemperatureModifierParams::getParameterDefinitionTree(void) const
+{
+	ColorVsTemperatureModifierParams* tmpParam = const_cast<ColorVsTemperatureModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ColorVsTemperatureModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ColorVsTemperatureModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ColorVsTemperatureModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ColorVsTemperatureModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ColorVsTemperatureModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ColorVsTemperatureModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ColorVsTemperature modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="colorChannel"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("colorChannel", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "alpha", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "alpha", true);
+		HintTable[1].init("shortDescription", "Color channel", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "red", "green", "blue", "alpha" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 4);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Temperature", true);
+		HintTable[5].init("yAxisLabel", "Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[5].init("shortDescription", "Control points for a curve", true);
+		HintTable[6].init("xAxisLabel", "Temperature", true);
+		HintTable[7].init("yAxisLabel", "Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Temperature", true);
+		HintTable[5].init("yAxisLabel", "Color", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[5].init("shortDescription", "Control points for a curve", true);
+		HintTable[6].init("xAxisLabel", "Temperature", true);
+		HintTable[7].init("yAxisLabel", "Color", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Temperature", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Color", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(4);
+		Children[1] = PDEF_PTR(5);
+
+		ParamDefTable[3].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ColorVsTemperatureModifierParams::initStrings(void)
+{
+}
+
+void ColorVsTemperatureModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ColorVsTemperatureModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	colorChannel = (const char*)"alpha";
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ColorVsTemperatureModifierParams::initReferences(void)
+{
+}
+
+void ColorVsTemperatureModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ColorVsTemperatureModifierParams::freeStrings(void)
+{
+}
+
+void ColorVsTemperatureModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ColorVsVelocityCompositeModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ColorVsVelocityCompositeModifierParams.cpp
new file mode 100644
index 00000000..9745d6dc
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ColorVsVelocityCompositeModifierParams.cpp
@@ -0,0 +1,533 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ColorVsVelocityCompositeModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ColorVsVelocityCompositeModifierParamsNS;
+
+const char* const ColorVsVelocityCompositeModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ColorVsVelocityCompositeModifierParams, ColorVsVelocityCompositeModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 7;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5, 6,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->velocity0), NULL, 0 }, // velocity0
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->velocity1), NULL, 0 }, // velocity1
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(3), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(colorVelocityStruct_Type), CHILDREN(4), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((colorVelocityStruct_Type*)0)->velocity), NULL, 0 }, // controlPoints[].velocity
+	{ TYPE_VEC4, false, (size_t)(&((colorVelocityStruct_Type*)0)->color), NULL, 0 }, // controlPoints[].color
+};
+
+
+bool ColorVsVelocityCompositeModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ColorVsVelocityCompositeModifierParams::mBuiltFlagMutex;
+
+ColorVsVelocityCompositeModifierParams::ColorVsVelocityCompositeModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ColorVsVelocityCompositeModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ColorVsVelocityCompositeModifierParams::~ColorVsVelocityCompositeModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ColorVsVelocityCompositeModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ColorVsVelocityCompositeModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsVelocityCompositeModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsVelocityCompositeModifierParams::getParameterDefinitionTree(void) const
+{
+	ColorVsVelocityCompositeModifierParams* tmpParam = const_cast<ColorVsVelocityCompositeModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ColorVsVelocityCompositeModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ColorVsVelocityCompositeModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ColorVsVelocityCompositeModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ColorVsVelocityCompositeModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ColorVsVelocityCompositeModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ColorVsVelocityCompositeModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ColorVsVelocityComposite modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="velocity0"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("velocity0", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("gameScale", "true", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("gameScale", "true", true);
+		HintTable[1].init("shortDescription", "First velocity point", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="velocity1"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("velocity1", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("gameScale", "true", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("gameScale", "true", true);
+		HintTable[1].init("shortDescription", "Second velocity point", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Velocity", true);
+		HintTable[5].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite color vs velocity curve", true);
+		HintTable[5].init("xAxisLabel", "Velocity", true);
+		HintTable[6].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "colorVelocityStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Velocity", true);
+		HintTable[5].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite color vs velocity curve", true);
+		HintTable[5].init("xAxisLabel", "Velocity", true);
+		HintTable[6].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="controlPoints[].velocity"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("velocity", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Velocity", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="controlPoints[].color"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("color", TYPE_VEC4, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max_w", uint64_t(8), true);
+		HintTable[2].init("max_x", uint64_t(8), true);
+		HintTable[3].init("max_y", uint64_t(8), true);
+		HintTable[4].init("min_w", uint64_t(0), true);
+		HintTable[5].init("min_x", uint64_t(0), true);
+		HintTable[6].init("min_y", uint64_t(0), true);
+		HintTable[7].init("min_z", uint64_t(0), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#else
+
+		static HintImpl HintTable[9];
+		static Hint* HintPtrTable[9] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], &HintTable[8], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max_w", uint64_t(8), true);
+		HintTable[2].init("max_x", uint64_t(8), true);
+		HintTable[3].init("max_y", uint64_t(8), true);
+		HintTable[4].init("min_w", uint64_t(0), true);
+		HintTable[5].init("min_x", uint64_t(0), true);
+		HintTable[6].init("min_y", uint64_t(0), true);
+		HintTable[7].init("min_z", uint64_t(0), true);
+		HintTable[8].init("shortDescription", "Color is formatted x=R, y=G, z=B, w=A", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 9);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(4);
+
+		ParamDefTable[3].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(5);
+		Children[1] = PDEF_PTR(6);
+
+		ParamDefTable[4].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ColorVsVelocityCompositeModifierParams::initStrings(void)
+{
+}
+
+void ColorVsVelocityCompositeModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(colorVelocityStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ColorVsVelocityCompositeModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	velocity0 = float(0);
+	velocity1 = float(1);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ColorVsVelocityCompositeModifierParams::initReferences(void)
+{
+}
+
+void ColorVsVelocityCompositeModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ColorVsVelocityCompositeModifierParams::freeStrings(void)
+{
+}
+
+void ColorVsVelocityCompositeModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ColorVsVelocityModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ColorVsVelocityModifierParams.cpp
new file mode 100644
index 00000000..5b593de8
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ColorVsVelocityModifierParams.cpp
@@ -0,0 +1,524 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ColorVsVelocityModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ColorVsVelocityModifierParamsNS;
+
+const char* const ColorVsVelocityModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ColorVsVelocityModifierParams, ColorVsVelocityModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 8;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5, 6, 7,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 4 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->colorChannel), NULL, 0 }, // colorChannel
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->velocity0), NULL, 0 }, // velocity0
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->velocity1), NULL, 0 }, // velocity1
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(4), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(5), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool ColorVsVelocityModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ColorVsVelocityModifierParams::mBuiltFlagMutex;
+
+ColorVsVelocityModifierParams::ColorVsVelocityModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ColorVsVelocityModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ColorVsVelocityModifierParams::~ColorVsVelocityModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ColorVsVelocityModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ColorVsVelocityModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsVelocityModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsVelocityModifierParams::getParameterDefinitionTree(void) const
+{
+	ColorVsVelocityModifierParams* tmpParam = const_cast<ColorVsVelocityModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ColorVsVelocityModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ColorVsVelocityModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ColorVsVelocityModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ColorVsVelocityModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ColorVsVelocityModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ColorVsVelocityModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ColorVsVelocity modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="colorChannel"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("colorChannel", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "alpha", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "alpha", true);
+		HintTable[1].init("shortDescription", "Color channel", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "red", "green", "blue", "alpha" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 4);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="velocity0"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("velocity0", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Helpful documentation goes here", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="velocity1"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("velocity1", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Helpful documentation goes here", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Velocity", true);
+		HintTable[2].init("yAxisLabel", "Color", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Velocity", true);
+		HintTable[4].init("yAxisLabel", "Color", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Velocity", true);
+		HintTable[2].init("yAxisLabel", "Color", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Velocity", true);
+		HintTable[4].init("yAxisLabel", "Color", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Velocity", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Color", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[4];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+		Children[3] = PDEF_PTR(4);
+
+		ParamDefTable[0].setChildren(Children, 4);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(5);
+
+		ParamDefTable[4].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=5, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(6);
+		Children[1] = PDEF_PTR(7);
+
+		ParamDefTable[5].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ColorVsVelocityModifierParams::initStrings(void)
+{
+}
+
+void ColorVsVelocityModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ColorVsVelocityModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	colorChannel = (const char*)"alpha";
+	velocity0 = float(0);
+	velocity1 = float(1);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ColorVsVelocityModifierParams::initReferences(void)
+{
+}
+
+void ColorVsVelocityModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ColorVsVelocityModifierParams::freeStrings(void)
+{
+}
+
+void ColorVsVelocityModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/InitialColorModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/InitialColorModifierParams.cpp
new file mode 100644
index 00000000..58ca122d
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/InitialColorModifierParams.cpp
@@ -0,0 +1,328 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "InitialColorModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace InitialColorModifierParamsNS;
+
+const char* const InitialColorModifierParamsFactory::vptr =
+    NvParameterized::getVptr<InitialColorModifierParams, InitialColorModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_VEC4, false, (size_t)(&((ParametersStruct*)0)->color), NULL, 0 }, // color
+};
+
+
+bool InitialColorModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType InitialColorModifierParams::mBuiltFlagMutex;
+
+InitialColorModifierParams::InitialColorModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &InitialColorModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+InitialColorModifierParams::~InitialColorModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void InitialColorModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~InitialColorModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* InitialColorModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* InitialColorModifierParams::getParameterDefinitionTree(void) const
+{
+	InitialColorModifierParams* tmpParam = const_cast<InitialColorModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType InitialColorModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType InitialColorModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void InitialColorModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<InitialColorModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void InitialColorModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void InitialColorModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "InitialColor modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="color"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("color", TYPE_VEC4, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max", uint64_t(1), true);
+		HintTable[2].init("min", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max", uint64_t(1), true);
+		HintTable[2].init("min", uint64_t(0), true);
+		HintTable[3].init("shortDescription", "Color is formatted x=R, y=G, z=B, w=A", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void InitialColorModifierParams::initStrings(void)
+{
+}
+
+void InitialColorModifierParams::initDynamicArrays(void)
+{
+}
+
+void InitialColorModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	color = physx::PxVec4(initVec4(1, 1, 1, 1));
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void InitialColorModifierParams::initReferences(void)
+{
+}
+
+void InitialColorModifierParams::freeDynamicArrays(void)
+{
+}
+
+void InitialColorModifierParams::freeStrings(void)
+{
+}
+
+void InitialColorModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/IofxAssetParameters.cpp b/APEX_1.4/module/iofx/src/autogen/IofxAssetParameters.cpp
new file mode 100644
index 00000000..5d29be2d
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/IofxAssetParameters.cpp
@@ -0,0 +1,425 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "IofxAssetParameters.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace IofxAssetParametersNS;
+
+const char* const IofxAssetParametersFactory::vptr =
+    NvParameterized::getVptr<IofxAssetParameters, IofxAssetParameters::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->iofxType), NULL, 0 }, // iofxType
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->renderOutput), CHILDREN(2), 2 }, // renderOutput
+	{ TYPE_BOOL, false, (size_t)(&((outputProperties_Type*)0)->useUserSemantic), NULL, 0 }, // renderOutput.useUserSemantic
+	{ TYPE_BOOL, false, (size_t)(&((outputProperties_Type*)0)->useFloat4Color), NULL, 0 }, // renderOutput.useFloat4Color
+};
+
+
+bool IofxAssetParameters::mBuiltFlag = false;
+NvParameterized::MutexType IofxAssetParameters::mBuiltFlagMutex;
+
+IofxAssetParameters::IofxAssetParameters(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &IofxAssetParametersFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+IofxAssetParameters::~IofxAssetParameters()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void IofxAssetParameters::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~IofxAssetParameters();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* IofxAssetParameters::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* IofxAssetParameters::getParameterDefinitionTree(void) const
+{
+	IofxAssetParameters* tmpParam = const_cast<IofxAssetParameters*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType IofxAssetParameters::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType IofxAssetParameters::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void IofxAssetParameters::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<IofxAssetParameters::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void IofxAssetParameters::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void IofxAssetParameters::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the asset properties for an IOFX", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="iofxType"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("iofxType", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Contains the mesh or sprite IOFX parameters, only one may be selected", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "MeshIofxParameters", "SpriteIofxParameters" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 2);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="renderOutput"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("renderOutput", TYPE_STRUCT, "outputProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "render output properties", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="renderOutput.useUserSemantic"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("useUserSemantic", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "use user semantic in render output", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="renderOutput.useFloat4Color"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("useFloat4Color", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "use float4 color in render output", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="renderOutput"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void IofxAssetParameters::initStrings(void)
+{
+}
+
+void IofxAssetParameters::initDynamicArrays(void)
+{
+}
+
+void IofxAssetParameters::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	renderOutput.useUserSemantic = bool(false);
+	renderOutput.useFloat4Color = bool(false);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void IofxAssetParameters::initReferences(void)
+{
+	iofxType = NULL;
+
+}
+
+void IofxAssetParameters::freeDynamicArrays(void)
+{
+}
+
+void IofxAssetParameters::freeStrings(void)
+{
+}
+
+void IofxAssetParameters::freeReferences(void)
+{
+	if (iofxType)
+	{
+		iofxType->destroy();
+	}
+
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/IofxDebugRenderParams.cpp b/APEX_1.4/module/iofx/src/autogen/IofxDebugRenderParams.cpp
new file mode 100644
index 00000000..73271f70
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/IofxDebugRenderParams.cpp
@@ -0,0 +1,358 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "IofxDebugRenderParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace IofxDebugRenderParamsNS;
+
+const char* const IofxDebugRenderParamsFactory::vptr =
+    NvParameterized::getVptr<IofxDebugRenderParams, IofxDebugRenderParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 4;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->VISUALIZE_IOFX_ACTOR), NULL, 0 }, // VISUALIZE_IOFX_ACTOR
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->VISUALIZE_IOFX_BOUNDING_BOX), NULL, 0 }, // VISUALIZE_IOFX_BOUNDING_BOX
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->VISUALIZE_IOFX_ACTOR_NAME), NULL, 0 }, // VISUALIZE_IOFX_ACTOR_NAME
+};
+
+
+bool IofxDebugRenderParams::mBuiltFlag = false;
+NvParameterized::MutexType IofxDebugRenderParams::mBuiltFlagMutex;
+
+IofxDebugRenderParams::IofxDebugRenderParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &IofxDebugRenderParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+IofxDebugRenderParams::~IofxDebugRenderParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void IofxDebugRenderParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~IofxDebugRenderParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* IofxDebugRenderParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* IofxDebugRenderParams::getParameterDefinitionTree(void) const
+{
+	IofxDebugRenderParams* tmpParam = const_cast<IofxDebugRenderParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType IofxDebugRenderParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType IofxDebugRenderParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void IofxDebugRenderParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<IofxDebugRenderParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void IofxDebugRenderParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void IofxDebugRenderParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="VISUALIZE_IOFX_ACTOR"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("VISUALIZE_IOFX_ACTOR", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Render IOFX actor in view window", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="VISUALIZE_IOFX_BOUNDING_BOX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("VISUALIZE_IOFX_BOUNDING_BOX", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Render IOFX bounding box in view window", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="VISUALIZE_IOFX_ACTOR_NAME"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("VISUALIZE_IOFX_ACTOR_NAME", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Render IOFX actor name in view window", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	mBuiltFlag = true;
+
+}
+void IofxDebugRenderParams::initStrings(void)
+{
+}
+
+void IofxDebugRenderParams::initDynamicArrays(void)
+{
+}
+
+void IofxDebugRenderParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	VISUALIZE_IOFX_ACTOR = bool(false);
+	VISUALIZE_IOFX_BOUNDING_BOX = bool(true);
+	VISUALIZE_IOFX_ACTOR_NAME = bool(true);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void IofxDebugRenderParams::initReferences(void)
+{
+}
+
+void IofxDebugRenderParams::freeDynamicArrays(void)
+{
+}
+
+void IofxDebugRenderParams::freeStrings(void)
+{
+}
+
+void IofxDebugRenderParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/IofxModuleParameters.cpp b/APEX_1.4/module/iofx/src/autogen/IofxModuleParameters.cpp
new file mode 100644
index 00000000..4bae7ae3
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/IofxModuleParameters.cpp
@@ -0,0 +1,318 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "IofxModuleParameters.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace IofxModuleParametersNS;
+
+const char* const IofxModuleParametersFactory::vptr =
+    NvParameterized::getVptr<IofxModuleParameters, IofxModuleParameters::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->unused), NULL, 0 }, // unused
+};
+
+
+bool IofxModuleParameters::mBuiltFlag = false;
+NvParameterized::MutexType IofxModuleParameters::mBuiltFlagMutex;
+
+IofxModuleParameters::IofxModuleParameters(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &IofxModuleParametersFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+IofxModuleParameters::~IofxModuleParameters()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void IofxModuleParameters::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~IofxModuleParameters();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* IofxModuleParameters::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* IofxModuleParameters::getParameterDefinitionTree(void) const
+{
+	IofxModuleParameters* tmpParam = const_cast<IofxModuleParameters*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType IofxModuleParameters::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType IofxModuleParameters::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void IofxModuleParameters::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<IofxModuleParameters::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void IofxModuleParameters::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void IofxModuleParameters::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "This class is used for initializing the ModuleIofx.", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="unused"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("unused", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "No parameters necessary", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void IofxModuleParameters::initStrings(void)
+{
+}
+
+void IofxModuleParameters::initDynamicArrays(void)
+{
+}
+
+void IofxModuleParameters::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	unused = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void IofxModuleParameters::initReferences(void)
+{
+}
+
+void IofxModuleParameters::freeDynamicArrays(void)
+{
+}
+
+void IofxModuleParameters::freeStrings(void)
+{
+}
+
+void IofxModuleParameters::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/MeshIofxParameters.cpp b/APEX_1.4/module/iofx/src/autogen/MeshIofxParameters.cpp
new file mode 100644
index 00000000..05fd8458
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/MeshIofxParameters.cpp
@@ -0,0 +1,623 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "MeshIofxParameters.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace MeshIofxParametersNS;
+
+const char* const MeshIofxParametersFactory::vptr =
+    NvParameterized::getVptr<MeshIofxParameters, MeshIofxParameters::ClassAlignment>();
+
+const uint32_t NumParamDefs = 9;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 5, 7, 2, 3, 4, 6, 8,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->renderMeshList), CHILDREN(3), 1 }, // renderMeshList
+	{ TYPE_STRUCT, false, 1 * sizeof(meshProperties_Type), CHILDREN(4), 2 }, // renderMeshList[]
+	{ TYPE_REF, false, (size_t)(&((meshProperties_Type*)0)->meshAssetName), NULL, 0 }, // renderMeshList[].meshAssetName
+	{ TYPE_U32, false, (size_t)(&((meshProperties_Type*)0)->weight), NULL, 0 }, // renderMeshList[].weight
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->spawnModifierList), CHILDREN(6), 1 }, // spawnModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // spawnModifierList[]
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->continuousModifierList), CHILDREN(7), 1 }, // continuousModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // continuousModifierList[]
+};
+
+
+bool MeshIofxParameters::mBuiltFlag = false;
+NvParameterized::MutexType MeshIofxParameters::mBuiltFlagMutex;
+
+MeshIofxParameters::MeshIofxParameters(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &MeshIofxParametersFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+MeshIofxParameters::~MeshIofxParameters()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void MeshIofxParameters::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~MeshIofxParameters();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* MeshIofxParameters::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* MeshIofxParameters::getParameterDefinitionTree(void) const
+{
+	MeshIofxParameters* tmpParam = const_cast<MeshIofxParameters*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType MeshIofxParameters::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType MeshIofxParameters::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void MeshIofxParameters::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<MeshIofxParameters::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [1,0] - renderMeshList.meshAssetName */
+/* [0] - spawnModifierList (not an array of structs) */
+/* [0] - continuousModifierList (not an array of structs) */
+
+void MeshIofxParameters::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void MeshIofxParameters::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="renderMeshList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("renderMeshList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An array of mesh asset names with their respective weights (if this is a render mesh IOFX)", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[2] = { 1, 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 2);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="renderMeshList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("renderMeshList", TYPE_STRUCT, "meshProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An array of mesh asset names with their respective weights (if this is a render mesh IOFX)", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="renderMeshList[].meshAssetName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("meshAssetName", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The render mesh asset name or opaque mesh name", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ApexRenderMesh", "ApexOpaqueMesh" };
+		ParamDefTable[3].setRefVariantVals((const char**)RefVariantVals, 2);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="renderMeshList[].weight"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("weight", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The weight for this mesh (weighed against other meshes)", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="spawnModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("spawnModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "These modifiers are applied to the instanced objects at object creation.", true);
+		HintTable[2].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "ScaleByMassModifierParams" };
+		ParamDefTable[5].setRefVariantVals((const char**)RefVariantVals, 5);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="spawnModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("spawnModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "These modifiers are applied to the instanced objects at object creation.", true);
+		HintTable[2].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "ScaleByMassModifierParams" };
+		ParamDefTable[6].setRefVariantVals((const char**)RefVariantVals, 5);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="continuousModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("continuousModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsTemperatureModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsTemperatureModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		HintTable[5].init("longDescription", "These modifiers are applied to the instanced objects every frame.", true);
+		HintTable[6].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "ScaleVsLife3DModifierParams", "ScaleVsDensity3DModifierParams", "ScaleVsTemperature3DModifierParams", "ScaleVsCameraDistance3DModifierParams", "OrientAlongVelocityModifierParams", "ScaleAlongVelocityModifierParams", "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ColorVsTemperatureCompositeModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsTemperatureModifierParams", "ScaleVsCameraDistanceModifierParams", "ColorVsVelocityCompositeModifierParams" };
+		ParamDefTable[7].setRefVariantVals((const char**)RefVariantVals, 15);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="continuousModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("continuousModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsTemperatureModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsTemperatureModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		HintTable[5].init("longDescription", "These modifiers are applied to the instanced objects every frame.", true);
+		HintTable[6].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "ScaleVsLife3DModifierParams", "ScaleVsDensity3DModifierParams", "ScaleVsTemperature3DModifierParams", "ScaleVsCameraDistance3DModifierParams", "OrientAlongVelocityModifierParams", "ScaleAlongVelocityModifierParams", "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ColorVsTemperatureCompositeModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsTemperatureModifierParams", "ScaleVsCameraDistanceModifierParams", "ColorVsVelocityCompositeModifierParams" };
+		ParamDefTable[8].setRefVariantVals((const char**)RefVariantVals, 15);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(5);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="renderMeshList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="renderMeshList[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=5, longName="spawnModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(6);
+
+		ParamDefTable[5].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=7, longName="continuousModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(8);
+
+		ParamDefTable[7].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void MeshIofxParameters::initStrings(void)
+{
+}
+
+void MeshIofxParameters::initDynamicArrays(void)
+{
+	renderMeshList.buf = NULL;
+	renderMeshList.isAllocated = true;
+	renderMeshList.elementSize = sizeof(meshProperties_Type);
+	renderMeshList.arraySizes[0] = 0;
+	spawnModifierList.buf = NULL;
+	spawnModifierList.isAllocated = true;
+	spawnModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	spawnModifierList.arraySizes[0] = 0;
+	continuousModifierList.buf = NULL;
+	continuousModifierList.isAllocated = true;
+	continuousModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	continuousModifierList.arraySizes[0] = 0;
+}
+
+void MeshIofxParameters::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void MeshIofxParameters::initReferences(void)
+{
+}
+
+void MeshIofxParameters::freeDynamicArrays(void)
+{
+	if (renderMeshList.isAllocated && renderMeshList.buf)
+	{
+		mParameterizedTraits->free(renderMeshList.buf);
+	}
+	if (spawnModifierList.isAllocated && spawnModifierList.buf)
+	{
+		mParameterizedTraits->free(spawnModifierList.buf);
+	}
+	if (continuousModifierList.isAllocated && continuousModifierList.buf)
+	{
+		mParameterizedTraits->free(continuousModifierList.buf);
+	}
+}
+
+void MeshIofxParameters::freeStrings(void)
+{
+}
+
+void MeshIofxParameters::freeReferences(void)
+{
+
+	for (int i = 0; i < renderMeshList.arraySizes[0]; i++)
+	{
+		if (renderMeshList.buf[i].meshAssetName)
+		{
+			renderMeshList.buf[i].meshAssetName->destroy();
+		}
+	}
+
+	for (int i = 0; i < spawnModifierList.arraySizes[0]; ++i)
+	{
+		if (spawnModifierList.buf[i])
+		{
+			spawnModifierList.buf[i]->destroy();
+		}
+	}
+
+	for (int i = 0; i < continuousModifierList.arraySizes[0]; ++i)
+	{
+		if (continuousModifierList.buf[i])
+		{
+			continuousModifierList.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/OrientAlongVelocityModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/OrientAlongVelocityModifierParams.cpp
new file mode 100644
index 00000000..e2e456b5
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/OrientAlongVelocityModifierParams.cpp
@@ -0,0 +1,318 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "OrientAlongVelocityModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace OrientAlongVelocityModifierParamsNS;
+
+const char* const OrientAlongVelocityModifierParamsFactory::vptr =
+    NvParameterized::getVptr<OrientAlongVelocityModifierParams, OrientAlongVelocityModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_VEC3, false, (size_t)(&((ParametersStruct*)0)->modelForward), NULL, 0 }, // modelForward
+};
+
+
+bool OrientAlongVelocityModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType OrientAlongVelocityModifierParams::mBuiltFlagMutex;
+
+OrientAlongVelocityModifierParams::OrientAlongVelocityModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &OrientAlongVelocityModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+OrientAlongVelocityModifierParams::~OrientAlongVelocityModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void OrientAlongVelocityModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~OrientAlongVelocityModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* OrientAlongVelocityModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* OrientAlongVelocityModifierParams::getParameterDefinitionTree(void) const
+{
+	OrientAlongVelocityModifierParams* tmpParam = const_cast<OrientAlongVelocityModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType OrientAlongVelocityModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType OrientAlongVelocityModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void OrientAlongVelocityModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<OrientAlongVelocityModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void OrientAlongVelocityModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void OrientAlongVelocityModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "OrientAlongVelocity modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="modelForward"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("modelForward", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Model forward", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void OrientAlongVelocityModifierParams::initStrings(void)
+{
+}
+
+void OrientAlongVelocityModifierParams::initDynamicArrays(void)
+{
+}
+
+void OrientAlongVelocityModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	modelForward = physx::PxVec3(init(0, 1, 0));
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void OrientAlongVelocityModifierParams::initReferences(void)
+{
+}
+
+void OrientAlongVelocityModifierParams::freeDynamicArrays(void)
+{
+}
+
+void OrientAlongVelocityModifierParams::freeStrings(void)
+{
+}
+
+void OrientAlongVelocityModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/OrientScaleAlongScreenVelocityModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/OrientScaleAlongScreenVelocityModifierParams.cpp
new file mode 100644
index 00000000..e18ecf54
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/OrientScaleAlongScreenVelocityModifierParams.cpp
@@ -0,0 +1,395 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "OrientScaleAlongScreenVelocityModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace OrientScaleAlongScreenVelocityModifierParamsNS;
+
+const char* const OrientScaleAlongScreenVelocityModifierParamsFactory::vptr =
+    NvParameterized::getVptr<OrientScaleAlongScreenVelocityModifierParams, OrientScaleAlongScreenVelocityModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 4;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->scalePerVelocity), NULL, 0 }, // scalePerVelocity
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->scaleChangeLimit), NULL, 0 }, // scaleChangeLimit
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->scaleChangeDelay), NULL, 0 }, // scaleChangeDelay
+};
+
+
+bool OrientScaleAlongScreenVelocityModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType OrientScaleAlongScreenVelocityModifierParams::mBuiltFlagMutex;
+
+OrientScaleAlongScreenVelocityModifierParams::OrientScaleAlongScreenVelocityModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &OrientScaleAlongScreenVelocityModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+OrientScaleAlongScreenVelocityModifierParams::~OrientScaleAlongScreenVelocityModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void OrientScaleAlongScreenVelocityModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~OrientScaleAlongScreenVelocityModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* OrientScaleAlongScreenVelocityModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* OrientScaleAlongScreenVelocityModifierParams::getParameterDefinitionTree(void) const
+{
+	OrientScaleAlongScreenVelocityModifierParams* tmpParam = const_cast<OrientScaleAlongScreenVelocityModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType OrientScaleAlongScreenVelocityModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType OrientScaleAlongScreenVelocityModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void OrientScaleAlongScreenVelocityModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<OrientScaleAlongScreenVelocityModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void OrientScaleAlongScreenVelocityModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void OrientScaleAlongScreenVelocityModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "OrientScaleAlongScreenVelocity modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="scalePerVelocity"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("scalePerVelocity", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("longDescription", "Scale(Velocity) = 1 + |Velocity| * scalePerVelocity", true);
+		HintTable[2].init("min", uint64_t(0), true);
+		HintTable[3].init("shortDescription", "Scale per velocity", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="scaleChangeLimit"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("scaleChangeLimit", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("longDescription", "This value limits the scale change per unit time, set to 0 to disable the limit", true);
+		HintTable[2].init("min", uint64_t(0), true);
+		HintTable[3].init("shortDescription", "Scale change limimt", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="scaleChangeDelay"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("scaleChangeDelay", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("longDescription", "This value is proportional to a delay in time of the scale change, set to 0 to disable the delay", true);
+		HintTable[2].init("min", uint64_t(0), true);
+		HintTable[3].init("shortDescription", "Scale change delay", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	mBuiltFlag = true;
+
+}
+void OrientScaleAlongScreenVelocityModifierParams::initStrings(void)
+{
+}
+
+void OrientScaleAlongScreenVelocityModifierParams::initDynamicArrays(void)
+{
+}
+
+void OrientScaleAlongScreenVelocityModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	scalePerVelocity = float(0.0f);
+	scaleChangeLimit = float(0.0f);
+	scaleChangeDelay = float(0.0f);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void OrientScaleAlongScreenVelocityModifierParams::initReferences(void)
+{
+}
+
+void OrientScaleAlongScreenVelocityModifierParams::freeDynamicArrays(void)
+{
+}
+
+void OrientScaleAlongScreenVelocityModifierParams::freeStrings(void)
+{
+}
+
+void OrientScaleAlongScreenVelocityModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/RandomRotationModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/RandomRotationModifierParams.cpp
new file mode 100644
index 00000000..0f0fe9d5
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/RandomRotationModifierParams.cpp
@@ -0,0 +1,355 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "RandomRotationModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace RandomRotationModifierParamsNS;
+
+const char* const RandomRotationModifierParamsFactory::vptr =
+    NvParameterized::getVptr<RandomRotationModifierParams, RandomRotationModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->minRotation), NULL, 0 }, // minRotation
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->maxRotation), NULL, 0 }, // maxRotation
+};
+
+
+bool RandomRotationModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType RandomRotationModifierParams::mBuiltFlagMutex;
+
+RandomRotationModifierParams::RandomRotationModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &RandomRotationModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+RandomRotationModifierParams::~RandomRotationModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void RandomRotationModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~RandomRotationModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* RandomRotationModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* RandomRotationModifierParams::getParameterDefinitionTree(void) const
+{
+	RandomRotationModifierParams* tmpParam = const_cast<RandomRotationModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType RandomRotationModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType RandomRotationModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void RandomRotationModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<RandomRotationModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void RandomRotationModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void RandomRotationModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "RandomRotation modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="minRotation"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("minRotation", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Minimum rotation in degrees", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="maxRotation"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("maxRotation", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Maximum rotation in degrees", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void RandomRotationModifierParams::initStrings(void)
+{
+}
+
+void RandomRotationModifierParams::initDynamicArrays(void)
+{
+}
+
+void RandomRotationModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	minRotation = float(0.0f);
+	maxRotation = float(0.0f);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void RandomRotationModifierParams::initReferences(void)
+{
+}
+
+void RandomRotationModifierParams::freeDynamicArrays(void)
+{
+}
+
+void RandomRotationModifierParams::freeStrings(void)
+{
+}
+
+void RandomRotationModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/RandomScaleModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/RandomScaleModifierParams.cpp
new file mode 100644
index 00000000..9403c5a3
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/RandomScaleModifierParams.cpp
@@ -0,0 +1,355 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "RandomScaleModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace RandomScaleModifierParamsNS;
+
+const char* const RandomScaleModifierParamsFactory::vptr =
+    NvParameterized::getVptr<RandomScaleModifierParams, RandomScaleModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->minScaleFactor), NULL, 0 }, // minScaleFactor
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->maxScaleFactor), NULL, 0 }, // maxScaleFactor
+};
+
+
+bool RandomScaleModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType RandomScaleModifierParams::mBuiltFlagMutex;
+
+RandomScaleModifierParams::RandomScaleModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &RandomScaleModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+RandomScaleModifierParams::~RandomScaleModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void RandomScaleModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~RandomScaleModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* RandomScaleModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* RandomScaleModifierParams::getParameterDefinitionTree(void) const
+{
+	RandomScaleModifierParams* tmpParam = const_cast<RandomScaleModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType RandomScaleModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType RandomScaleModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void RandomScaleModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<RandomScaleModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void RandomScaleModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void RandomScaleModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "RandomScale modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="minScaleFactor"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("minScaleFactor", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Scale factor", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="maxScaleFactor"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("maxScaleFactor", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Scale factor", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void RandomScaleModifierParams::initStrings(void)
+{
+}
+
+void RandomScaleModifierParams::initDynamicArrays(void)
+{
+}
+
+void RandomScaleModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	minScaleFactor = float(1.0f);
+	maxScaleFactor = float(1.0f);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void RandomScaleModifierParams::initReferences(void)
+{
+}
+
+void RandomScaleModifierParams::freeDynamicArrays(void)
+{
+}
+
+void RandomScaleModifierParams::freeStrings(void)
+{
+}
+
+void RandomScaleModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/RandomSubtextureModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/RandomSubtextureModifierParams.cpp
new file mode 100644
index 00000000..624d925b
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/RandomSubtextureModifierParams.cpp
@@ -0,0 +1,355 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "RandomSubtextureModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace RandomSubtextureModifierParamsNS;
+
+const char* const RandomSubtextureModifierParamsFactory::vptr =
+    NvParameterized::getVptr<RandomSubtextureModifierParams, RandomSubtextureModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->minSubtexture), NULL, 0 }, // minSubtexture
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->maxSubtexture), NULL, 0 }, // maxSubtexture
+};
+
+
+bool RandomSubtextureModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType RandomSubtextureModifierParams::mBuiltFlagMutex;
+
+RandomSubtextureModifierParams::RandomSubtextureModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &RandomSubtextureModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+RandomSubtextureModifierParams::~RandomSubtextureModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void RandomSubtextureModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~RandomSubtextureModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* RandomSubtextureModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* RandomSubtextureModifierParams::getParameterDefinitionTree(void) const
+{
+	RandomSubtextureModifierParams* tmpParam = const_cast<RandomSubtextureModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType RandomSubtextureModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType RandomSubtextureModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void RandomSubtextureModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<RandomSubtextureModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void RandomSubtextureModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void RandomSubtextureModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "RandomSubtexture modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="minSubtexture"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("minSubtexture", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Minimum subtexture index", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="maxSubtexture"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("maxSubtexture", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Maximum subtexture index", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void RandomSubtextureModifierParams::initStrings(void)
+{
+}
+
+void RandomSubtextureModifierParams::initDynamicArrays(void)
+{
+}
+
+void RandomSubtextureModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	minSubtexture = float(0.0f);
+	maxSubtexture = float(0.0f);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void RandomSubtextureModifierParams::initReferences(void)
+{
+}
+
+void RandomSubtextureModifierParams::freeDynamicArrays(void)
+{
+}
+
+void RandomSubtextureModifierParams::freeStrings(void)
+{
+}
+
+void RandomSubtextureModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/RotationModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/RotationModifierParams.cpp
new file mode 100644
index 00000000..6c363524
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/RotationModifierParams.cpp
@@ -0,0 +1,481 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "RotationModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace RotationModifierParamsNS;
+
+const char* const RotationModifierParamsFactory::vptr =
+    NvParameterized::getVptr<RotationModifierParams, RotationModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 7;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5, 6,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 6 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->rollType), NULL, 0 }, // rollType
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->maxRotationRatePerSec), NULL, 0 }, // maxRotationRatePerSec
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->maxSettleRatePerSec), NULL, 0 }, // maxSettleRatePerSec
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->inAirRotationMultiplier), NULL, 0 }, // inAirRotationMultiplier
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->collisionRotationMultiplier), NULL, 0 }, // collisionRotationMultiplier
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->includeVerticalDirection), NULL, 0 }, // includeVerticalDirection
+};
+
+
+bool RotationModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType RotationModifierParams::mBuiltFlagMutex;
+
+RotationModifierParams::RotationModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &RotationModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+RotationModifierParams::~RotationModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void RotationModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~RotationModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* RotationModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* RotationModifierParams::getParameterDefinitionTree(void) const
+{
+	RotationModifierParams* tmpParam = const_cast<RotationModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType RotationModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType RotationModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void RotationModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<RotationModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void RotationModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void RotationModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Rotation modifier parameters.", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="rollType"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("rollType", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "SPHERICAL", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "SPHERICAL", true);
+		HintTable[1].init("shortDescription", "Roll type", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "SPHERICAL", "CUBIC", "FLAT_X", "FLAT_Y", "FLAT_Z", "LONG_X", "LONG_Y", "LONG_Z" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 8);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="maxRotationRatePerSec"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("maxRotationRatePerSec", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Maximum rotation rate for instanced mesh objects", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="maxSettleRatePerSec"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("maxSettleRatePerSec", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Maximum settle rate for instanced mesh objects", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="inAirRotationMultiplier"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("inAirRotationMultiplier", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "This value is multiplied by the rotation delta to increase or decrease rotations/frame if there are no particle collisions", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="collisionRotationMultiplier"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("collisionRotationMultiplier", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "This value is multiplied by the rotation delta to increase or decrease rotations/frame while colliding objects", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="includeVerticalDirection"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("includeVerticalDirection", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "false", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "false", true);
+		HintTable[1].init("shortDescription", "If false, the vertical speed of the object does not affect the rotation", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[6];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+		Children[3] = PDEF_PTR(4);
+		Children[4] = PDEF_PTR(5);
+		Children[5] = PDEF_PTR(6);
+
+		ParamDefTable[0].setChildren(Children, 6);
+	}
+
+	mBuiltFlag = true;
+
+}
+void RotationModifierParams::initStrings(void)
+{
+}
+
+void RotationModifierParams::initDynamicArrays(void)
+{
+}
+
+void RotationModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	rollType = (const char*)"SPHERICAL";
+	maxRotationRatePerSec = float(0.0f);
+	maxSettleRatePerSec = float(1.0f);
+	inAirRotationMultiplier = float(1.0f);
+	collisionRotationMultiplier = float(1.0f);
+	includeVerticalDirection = bool(false);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void RotationModifierParams::initReferences(void)
+{
+}
+
+void RotationModifierParams::freeDynamicArrays(void)
+{
+}
+
+void RotationModifierParams::freeStrings(void)
+{
+}
+
+void RotationModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/RotationRateModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/RotationRateModifierParams.cpp
new file mode 100644
index 00000000..7d2ea83d
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/RotationRateModifierParams.cpp
@@ -0,0 +1,324 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "RotationRateModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace RotationRateModifierParamsNS;
+
+const char* const RotationRateModifierParamsFactory::vptr =
+    NvParameterized::getVptr<RotationRateModifierParams, RotationRateModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->rotationRate), NULL, 0 }, // rotationRate
+};
+
+
+bool RotationRateModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType RotationRateModifierParams::mBuiltFlagMutex;
+
+RotationRateModifierParams::RotationRateModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &RotationRateModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+RotationRateModifierParams::~RotationRateModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void RotationRateModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~RotationRateModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* RotationRateModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* RotationRateModifierParams::getParameterDefinitionTree(void) const
+{
+	RotationRateModifierParams* tmpParam = const_cast<RotationRateModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType RotationRateModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType RotationRateModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void RotationRateModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<RotationRateModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void RotationRateModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void RotationRateModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "RotationRate modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="rotationRate"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("rotationRate", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Rotation Rate (revs/sec) for sprite objects", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void RotationRateModifierParams::initStrings(void)
+{
+}
+
+void RotationRateModifierParams::initDynamicArrays(void)
+{
+}
+
+void RotationRateModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	rotationRate = float(0.0f);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void RotationRateModifierParams::initReferences(void)
+{
+}
+
+void RotationRateModifierParams::freeDynamicArrays(void)
+{
+}
+
+void RotationRateModifierParams::freeStrings(void)
+{
+}
+
+void RotationRateModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/RotationRateVsLifeModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/RotationRateVsLifeModifierParams.cpp
new file mode 100644
index 00000000..47a3142b
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/RotationRateVsLifeModifierParams.cpp
@@ -0,0 +1,441 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "RotationRateVsLifeModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace RotationRateVsLifeModifierParamsNS;
+
+const char* const RotationRateVsLifeModifierParamsFactory::vptr =
+    NvParameterized::getVptr<RotationRateVsLifeModifierParams, RotationRateVsLifeModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool RotationRateVsLifeModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType RotationRateVsLifeModifierParams::mBuiltFlagMutex;
+
+RotationRateVsLifeModifierParams::RotationRateVsLifeModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &RotationRateVsLifeModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+RotationRateVsLifeModifierParams::~RotationRateVsLifeModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void RotationRateVsLifeModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~RotationRateVsLifeModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* RotationRateVsLifeModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* RotationRateVsLifeModifierParams::getParameterDefinitionTree(void) const
+{
+	RotationRateVsLifeModifierParams* tmpParam = const_cast<RotationRateVsLifeModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType RotationRateVsLifeModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType RotationRateVsLifeModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void RotationRateVsLifeModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<RotationRateVsLifeModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void RotationRateVsLifeModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void RotationRateVsLifeModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "RotationRateVsLife modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(16), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Rotation Rate (revs/sec)", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(16), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[4].init("shortDescription", "Control points for a curve", true);
+		HintTable[5].init("xAxisLabel", "Life Time", true);
+		HintTable[6].init("yAxisLabel", "Rotation Rate (revs/sec)", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(16), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Rotation Rate (revs/sec)", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(16), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[4].init("shortDescription", "Control points for a curve", true);
+		HintTable[5].init("xAxisLabel", "Life Time", true);
+		HintTable[6].init("yAxisLabel", "Rotation Rate (revs/sec)", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Life time", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Rotation rate (revs/sec)", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void RotationRateVsLifeModifierParams::initStrings(void)
+{
+}
+
+void RotationRateVsLifeModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void RotationRateVsLifeModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void RotationRateVsLifeModifierParams::initReferences(void)
+{
+}
+
+void RotationRateVsLifeModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void RotationRateVsLifeModifierParams::freeStrings(void)
+{
+}
+
+void RotationRateVsLifeModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ScaleAlongVelocityModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ScaleAlongVelocityModifierParams.cpp
new file mode 100644
index 00000000..89e034e4
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ScaleAlongVelocityModifierParams.cpp
@@ -0,0 +1,324 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ScaleAlongVelocityModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ScaleAlongVelocityModifierParamsNS;
+
+const char* const ScaleAlongVelocityModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ScaleAlongVelocityModifierParams, ScaleAlongVelocityModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->scaleFactor), NULL, 0 }, // scaleFactor
+};
+
+
+bool ScaleAlongVelocityModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ScaleAlongVelocityModifierParams::mBuiltFlagMutex;
+
+ScaleAlongVelocityModifierParams::ScaleAlongVelocityModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleAlongVelocityModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleAlongVelocityModifierParams::~ScaleAlongVelocityModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleAlongVelocityModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleAlongVelocityModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleAlongVelocityModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleAlongVelocityModifierParams::getParameterDefinitionTree(void) const
+{
+	ScaleAlongVelocityModifierParams* tmpParam = const_cast<ScaleAlongVelocityModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleAlongVelocityModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleAlongVelocityModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleAlongVelocityModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleAlongVelocityModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleAlongVelocityModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleAlongVelocityModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleAlongVelocity modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="scaleFactor"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("scaleFactor", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Scale factor", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleAlongVelocityModifierParams::initStrings(void)
+{
+}
+
+void ScaleAlongVelocityModifierParams::initDynamicArrays(void)
+{
+}
+
+void ScaleAlongVelocityModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	scaleFactor = float(1.0f);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleAlongVelocityModifierParams::initReferences(void)
+{
+}
+
+void ScaleAlongVelocityModifierParams::freeDynamicArrays(void)
+{
+}
+
+void ScaleAlongVelocityModifierParams::freeStrings(void)
+{
+}
+
+void ScaleAlongVelocityModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ScaleByMassModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ScaleByMassModifierParams.cpp
new file mode 100644
index 00000000..a0e5f01c
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ScaleByMassModifierParams.cpp
@@ -0,0 +1,280 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ScaleByMassModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ScaleByMassModifierParamsNS;
+
+const char* const ScaleByMassModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ScaleByMassModifierParams, ScaleByMassModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 1;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, NULL, 0 },
+};
+
+
+bool ScaleByMassModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ScaleByMassModifierParams::mBuiltFlagMutex;
+
+ScaleByMassModifierParams::ScaleByMassModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleByMassModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleByMassModifierParams::~ScaleByMassModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleByMassModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleByMassModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleByMassModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleByMassModifierParams::getParameterDefinitionTree(void) const
+{
+	ScaleByMassModifierParams* tmpParam = const_cast<ScaleByMassModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleByMassModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleByMassModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleByMassModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleByMassModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleByMassModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleByMassModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleByMass modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleByMassModifierParams::initStrings(void)
+{
+}
+
+void ScaleByMassModifierParams::initDynamicArrays(void)
+{
+}
+
+void ScaleByMassModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleByMassModifierParams::initReferences(void)
+{
+}
+
+void ScaleByMassModifierParams::freeDynamicArrays(void)
+{
+}
+
+void ScaleByMassModifierParams::freeStrings(void)
+{
+}
+
+void ScaleByMassModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ScaleVsCameraDistance2DModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ScaleVsCameraDistance2DModifierParams.cpp
new file mode 100644
index 00000000..c30f2a94
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ScaleVsCameraDistance2DModifierParams.cpp
@@ -0,0 +1,451 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ScaleVsCameraDistance2DModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ScaleVsCameraDistance2DModifierParamsNS;
+
+const char* const ScaleVsCameraDistance2DModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ScaleVsCameraDistance2DModifierParams, ScaleVsCameraDistance2DModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(scaleCameraDistanceStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((scaleCameraDistanceStruct_Type*)0)->cameraDistance), NULL, 0 }, // controlPoints[].cameraDistance
+	{ TYPE_VEC2, false, (size_t)(&((scaleCameraDistanceStruct_Type*)0)->scale), NULL, 0 }, // controlPoints[].scale
+};
+
+
+bool ScaleVsCameraDistance2DModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsCameraDistance2DModifierParams::mBuiltFlagMutex;
+
+ScaleVsCameraDistance2DModifierParams::ScaleVsCameraDistance2DModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsCameraDistance2DModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsCameraDistance2DModifierParams::~ScaleVsCameraDistance2DModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsCameraDistance2DModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsCameraDistance2DModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsCameraDistance2DModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsCameraDistance2DModifierParams::getParameterDefinitionTree(void) const
+{
+	ScaleVsCameraDistance2DModifierParams* tmpParam = const_cast<ScaleVsCameraDistance2DModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsCameraDistance2DModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsCameraDistance2DModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsCameraDistance2DModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsCameraDistance2DModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsCameraDistance2DModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsCameraDistance2DModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsCameraDistance2D modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Camera Distance", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite 2D scale vs camera distance curve", true);
+		HintTable[4].init("xAxisLabel", "Camera Distance", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "scaleCameraDistanceStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Camera Distance", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite 2D scale vs camera distance curve", true);
+		HintTable[4].init("xAxisLabel", "Camera Distance", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].cameraDistance"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("cameraDistance", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Camera distance", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("scale", TYPE_VEC2, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Scale", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsCameraDistance2DModifierParams::initStrings(void)
+{
+}
+
+void ScaleVsCameraDistance2DModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(scaleCameraDistanceStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsCameraDistance2DModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsCameraDistance2DModifierParams::initReferences(void)
+{
+}
+
+void ScaleVsCameraDistance2DModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsCameraDistance2DModifierParams::freeStrings(void)
+{
+}
+
+void ScaleVsCameraDistance2DModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ScaleVsCameraDistance3DModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ScaleVsCameraDistance3DModifierParams.cpp
new file mode 100644
index 00000000..87ea4207
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ScaleVsCameraDistance3DModifierParams.cpp
@@ -0,0 +1,451 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ScaleVsCameraDistance3DModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ScaleVsCameraDistance3DModifierParamsNS;
+
+const char* const ScaleVsCameraDistance3DModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ScaleVsCameraDistance3DModifierParams, ScaleVsCameraDistance3DModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(scaleCameraDistanceStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((scaleCameraDistanceStruct_Type*)0)->cameraDistance), NULL, 0 }, // controlPoints[].cameraDistance
+	{ TYPE_VEC3, false, (size_t)(&((scaleCameraDistanceStruct_Type*)0)->scale), NULL, 0 }, // controlPoints[].scale
+};
+
+
+bool ScaleVsCameraDistance3DModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsCameraDistance3DModifierParams::mBuiltFlagMutex;
+
+ScaleVsCameraDistance3DModifierParams::ScaleVsCameraDistance3DModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsCameraDistance3DModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsCameraDistance3DModifierParams::~ScaleVsCameraDistance3DModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsCameraDistance3DModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsCameraDistance3DModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsCameraDistance3DModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsCameraDistance3DModifierParams::getParameterDefinitionTree(void) const
+{
+	ScaleVsCameraDistance3DModifierParams* tmpParam = const_cast<ScaleVsCameraDistance3DModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsCameraDistance3DModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsCameraDistance3DModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsCameraDistance3DModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsCameraDistance3DModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsCameraDistance3DModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsCameraDistance3DModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsCameraDistance3D modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Camera Distance", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite 3D scale vs camera distance curve", true);
+		HintTable[4].init("xAxisLabel", "Camera Distance", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "scaleCameraDistanceStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Camera Distance", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite 3D scale vs camera distance curve", true);
+		HintTable[4].init("xAxisLabel", "Camera Distance", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].cameraDistance"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("cameraDistance", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Camera distance", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("scale", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Scale", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsCameraDistance3DModifierParams::initStrings(void)
+{
+}
+
+void ScaleVsCameraDistance3DModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(scaleCameraDistanceStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsCameraDistance3DModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsCameraDistance3DModifierParams::initReferences(void)
+{
+}
+
+void ScaleVsCameraDistance3DModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsCameraDistance3DModifierParams::freeStrings(void)
+{
+}
+
+void ScaleVsCameraDistance3DModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ScaleVsCameraDistanceModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ScaleVsCameraDistanceModifierParams.cpp
new file mode 100644
index 00000000..b3c69217
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ScaleVsCameraDistanceModifierParams.cpp
@@ -0,0 +1,466 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ScaleVsCameraDistanceModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ScaleVsCameraDistanceModifierParamsNS;
+
+const char* const ScaleVsCameraDistanceModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ScaleVsCameraDistanceModifierParams, ScaleVsCameraDistanceModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->scaleAxis), NULL, 0 }, // scaleAxis
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(2), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(3), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool ScaleVsCameraDistanceModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsCameraDistanceModifierParams::mBuiltFlagMutex;
+
+ScaleVsCameraDistanceModifierParams::ScaleVsCameraDistanceModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsCameraDistanceModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsCameraDistanceModifierParams::~ScaleVsCameraDistanceModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsCameraDistanceModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsCameraDistanceModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsCameraDistanceModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsCameraDistanceModifierParams::getParameterDefinitionTree(void) const
+{
+	ScaleVsCameraDistanceModifierParams* tmpParam = const_cast<ScaleVsCameraDistanceModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsCameraDistanceModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsCameraDistanceModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsCameraDistanceModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsCameraDistanceModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsCameraDistanceModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsCameraDistanceModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsCameraDistance modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="scaleAxis"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("scaleAxis", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "xAxis", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "xAxis", true);
+		HintTable[1].init("shortDescription", "Scale axis to which the curve will be applied", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "xAxis", "yAxis", "zAxis" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Camera Distance", true);
+		HintTable[2].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Camera Distance", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Camera Distance", true);
+		HintTable[2].init("yAxisLabel", "Scale", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Camera Distance", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Camera distance", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Scale", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(4);
+		Children[1] = PDEF_PTR(5);
+
+		ParamDefTable[3].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsCameraDistanceModifierParams::initStrings(void)
+{
+}
+
+void ScaleVsCameraDistanceModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsCameraDistanceModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	scaleAxis = (const char*)"xAxis";
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsCameraDistanceModifierParams::initReferences(void)
+{
+}
+
+void ScaleVsCameraDistanceModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsCameraDistanceModifierParams::freeStrings(void)
+{
+}
+
+void ScaleVsCameraDistanceModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ScaleVsDensity2DModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ScaleVsDensity2DModifierParams.cpp
new file mode 100644
index 00000000..13191419
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ScaleVsDensity2DModifierParams.cpp
@@ -0,0 +1,455 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ScaleVsDensity2DModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ScaleVsDensity2DModifierParamsNS;
+
+const char* const ScaleVsDensity2DModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ScaleVsDensity2DModifierParams, ScaleVsDensity2DModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(scaleDensityStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((scaleDensityStruct_Type*)0)->density), NULL, 0 }, // controlPoints[].density
+	{ TYPE_VEC2, false, (size_t)(&((scaleDensityStruct_Type*)0)->scale), NULL, 0 }, // controlPoints[].scale
+};
+
+
+bool ScaleVsDensity2DModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsDensity2DModifierParams::mBuiltFlagMutex;
+
+ScaleVsDensity2DModifierParams::ScaleVsDensity2DModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsDensity2DModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsDensity2DModifierParams::~ScaleVsDensity2DModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsDensity2DModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsDensity2DModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsDensity2DModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsDensity2DModifierParams::getParameterDefinitionTree(void) const
+{
+	ScaleVsDensity2DModifierParams* tmpParam = const_cast<ScaleVsDensity2DModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsDensity2DModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsDensity2DModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsDensity2DModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsDensity2DModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsDensity2DModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsDensity2DModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsDensity2D modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Density", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite 2D scale vs density curve", true);
+		HintTable[5].init("xAxisLabel", "Density", true);
+		HintTable[6].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "scaleDensityStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Density", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite 2D scale vs density curve", true);
+		HintTable[5].init("xAxisLabel", "Density", true);
+		HintTable[6].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].density"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("density", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Density", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("scale", TYPE_VEC2, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Scale", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsDensity2DModifierParams::initStrings(void)
+{
+}
+
+void ScaleVsDensity2DModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(scaleDensityStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsDensity2DModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsDensity2DModifierParams::initReferences(void)
+{
+}
+
+void ScaleVsDensity2DModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsDensity2DModifierParams::freeStrings(void)
+{
+}
+
+void ScaleVsDensity2DModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ScaleVsDensity3DModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ScaleVsDensity3DModifierParams.cpp
new file mode 100644
index 00000000..5f1852ef
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ScaleVsDensity3DModifierParams.cpp
@@ -0,0 +1,455 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ScaleVsDensity3DModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ScaleVsDensity3DModifierParamsNS;
+
+const char* const ScaleVsDensity3DModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ScaleVsDensity3DModifierParams, ScaleVsDensity3DModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(scaleDensityStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((scaleDensityStruct_Type*)0)->density), NULL, 0 }, // controlPoints[].density
+	{ TYPE_VEC3, false, (size_t)(&((scaleDensityStruct_Type*)0)->scale), NULL, 0 }, // controlPoints[].scale
+};
+
+
+bool ScaleVsDensity3DModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsDensity3DModifierParams::mBuiltFlagMutex;
+
+ScaleVsDensity3DModifierParams::ScaleVsDensity3DModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsDensity3DModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsDensity3DModifierParams::~ScaleVsDensity3DModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsDensity3DModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsDensity3DModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsDensity3DModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsDensity3DModifierParams::getParameterDefinitionTree(void) const
+{
+	ScaleVsDensity3DModifierParams* tmpParam = const_cast<ScaleVsDensity3DModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsDensity3DModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsDensity3DModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsDensity3DModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsDensity3DModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsDensity3DModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsDensity3DModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsDensity3D modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Density", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite 3D scale vs density curve", true);
+		HintTable[5].init("xAxisLabel", "Density", true);
+		HintTable[6].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "scaleDensityStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Density", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite 3D scale vs density curve", true);
+		HintTable[5].init("xAxisLabel", "Density", true);
+		HintTable[6].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].density"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("density", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Density", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("scale", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Scale", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsDensity3DModifierParams::initStrings(void)
+{
+}
+
+void ScaleVsDensity3DModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(scaleDensityStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsDensity3DModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsDensity3DModifierParams::initReferences(void)
+{
+}
+
+void ScaleVsDensity3DModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsDensity3DModifierParams::freeStrings(void)
+{
+}
+
+void ScaleVsDensity3DModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ScaleVsDensityModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ScaleVsDensityModifierParams.cpp
new file mode 100644
index 00000000..e451646a
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ScaleVsDensityModifierParams.cpp
@@ -0,0 +1,466 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ScaleVsDensityModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ScaleVsDensityModifierParamsNS;
+
+const char* const ScaleVsDensityModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ScaleVsDensityModifierParams, ScaleVsDensityModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->scaleAxis), NULL, 0 }, // scaleAxis
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(2), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(3), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool ScaleVsDensityModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsDensityModifierParams::mBuiltFlagMutex;
+
+ScaleVsDensityModifierParams::ScaleVsDensityModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsDensityModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsDensityModifierParams::~ScaleVsDensityModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsDensityModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsDensityModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsDensityModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsDensityModifierParams::getParameterDefinitionTree(void) const
+{
+	ScaleVsDensityModifierParams* tmpParam = const_cast<ScaleVsDensityModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsDensityModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsDensityModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsDensityModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsDensityModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsDensityModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsDensityModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsDensity modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="scaleAxis"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("scaleAxis", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "xAxis", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "xAxis", true);
+		HintTable[1].init("shortDescription", "Scale axis to which the curve will be applied", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "xAxis", "yAxis", "zAxis" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Density", true);
+		HintTable[2].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Density", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Density", true);
+		HintTable[2].init("yAxisLabel", "Scale", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Density", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Density", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Scale", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(4);
+		Children[1] = PDEF_PTR(5);
+
+		ParamDefTable[3].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsDensityModifierParams::initStrings(void)
+{
+}
+
+void ScaleVsDensityModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsDensityModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	scaleAxis = (const char*)"xAxis";
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsDensityModifierParams::initReferences(void)
+{
+}
+
+void ScaleVsDensityModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsDensityModifierParams::freeStrings(void)
+{
+}
+
+void ScaleVsDensityModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ScaleVsLife2DModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ScaleVsLife2DModifierParams.cpp
new file mode 100644
index 00000000..f4166d50
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ScaleVsLife2DModifierParams.cpp
@@ -0,0 +1,453 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ScaleVsLife2DModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ScaleVsLife2DModifierParamsNS;
+
+const char* const ScaleVsLife2DModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ScaleVsLife2DModifierParams, ScaleVsLife2DModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(scaleLifeStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((scaleLifeStruct_Type*)0)->lifeRemaining), NULL, 0 }, // controlPoints[].lifeRemaining
+	{ TYPE_VEC2, false, (size_t)(&((scaleLifeStruct_Type*)0)->scale), NULL, 0 }, // controlPoints[].scale
+};
+
+
+bool ScaleVsLife2DModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsLife2DModifierParams::mBuiltFlagMutex;
+
+ScaleVsLife2DModifierParams::ScaleVsLife2DModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsLife2DModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsLife2DModifierParams::~ScaleVsLife2DModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsLife2DModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsLife2DModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsLife2DModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsLife2DModifierParams::getParameterDefinitionTree(void) const
+{
+	ScaleVsLife2DModifierParams* tmpParam = const_cast<ScaleVsLife2DModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsLife2DModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsLife2DModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsLife2DModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsLife2DModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsLife2DModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsLife2DModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsLife2D modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite scale vs life curve", true);
+		HintTable[4].init("xAxisLabel", "Life Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "scaleLifeStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite scale vs life curve", true);
+		HintTable[4].init("xAxisLabel", "Life Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].lifeRemaining"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("lifeRemaining", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Life remaining", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("scale", TYPE_VEC2, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Scale", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsLife2DModifierParams::initStrings(void)
+{
+}
+
+void ScaleVsLife2DModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(scaleLifeStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsLife2DModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsLife2DModifierParams::initReferences(void)
+{
+}
+
+void ScaleVsLife2DModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsLife2DModifierParams::freeStrings(void)
+{
+}
+
+void ScaleVsLife2DModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ScaleVsLife3DModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ScaleVsLife3DModifierParams.cpp
new file mode 100644
index 00000000..a53da682
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ScaleVsLife3DModifierParams.cpp
@@ -0,0 +1,453 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ScaleVsLife3DModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ScaleVsLife3DModifierParamsNS;
+
+const char* const ScaleVsLife3DModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ScaleVsLife3DModifierParams, ScaleVsLife3DModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(scaleLifeStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((scaleLifeStruct_Type*)0)->lifeRemaining), NULL, 0 }, // controlPoints[].lifeRemaining
+	{ TYPE_VEC3, false, (size_t)(&((scaleLifeStruct_Type*)0)->scale), NULL, 0 }, // controlPoints[].scale
+};
+
+
+bool ScaleVsLife3DModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsLife3DModifierParams::mBuiltFlagMutex;
+
+ScaleVsLife3DModifierParams::ScaleVsLife3DModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsLife3DModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsLife3DModifierParams::~ScaleVsLife3DModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsLife3DModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsLife3DModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsLife3DModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsLife3DModifierParams::getParameterDefinitionTree(void) const
+{
+	ScaleVsLife3DModifierParams* tmpParam = const_cast<ScaleVsLife3DModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsLife3DModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsLife3DModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsLife3DModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsLife3DModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsLife3DModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsLife3DModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsLife3D modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite scale vs life curve", true);
+		HintTable[4].init("xAxisLabel", "Life Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "scaleLifeStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite scale vs life curve", true);
+		HintTable[4].init("xAxisLabel", "Life Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].lifeRemaining"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("lifeRemaining", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Life remaining", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("scale", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Scale", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsLife3DModifierParams::initStrings(void)
+{
+}
+
+void ScaleVsLife3DModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(scaleLifeStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsLife3DModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsLife3DModifierParams::initReferences(void)
+{
+}
+
+void ScaleVsLife3DModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsLife3DModifierParams::freeStrings(void)
+{
+}
+
+void ScaleVsLife3DModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ScaleVsLifeModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ScaleVsLifeModifierParams.cpp
new file mode 100644
index 00000000..364cded7
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ScaleVsLifeModifierParams.cpp
@@ -0,0 +1,474 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ScaleVsLifeModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ScaleVsLifeModifierParamsNS;
+
+const char* const ScaleVsLifeModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ScaleVsLifeModifierParams, ScaleVsLifeModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->scaleAxis), NULL, 0 }, // scaleAxis
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(2), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(3), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool ScaleVsLifeModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsLifeModifierParams::mBuiltFlagMutex;
+
+ScaleVsLifeModifierParams::ScaleVsLifeModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsLifeModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsLifeModifierParams::~ScaleVsLifeModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsLifeModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsLifeModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsLifeModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsLifeModifierParams::getParameterDefinitionTree(void) const
+{
+	ScaleVsLifeModifierParams* tmpParam = const_cast<ScaleVsLifeModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsLifeModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsLifeModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsLifeModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsLifeModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsLifeModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsLifeModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsLife modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="scaleAxis"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("scaleAxis", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "xAxis", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "xAxis", true);
+		HintTable[1].init("shortDescription", "Scale axis to which the curve will be applied", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "xAxis", "yAxis", "zAxis" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Life Time", true);
+		HintTable[2].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Life Time", true);
+		HintTable[2].init("yAxisLabel", "Scale", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Life", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Scale", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(4);
+		Children[1] = PDEF_PTR(5);
+
+		ParamDefTable[3].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsLifeModifierParams::initStrings(void)
+{
+}
+
+void ScaleVsLifeModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsLifeModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	scaleAxis = (const char*)"xAxis";
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsLifeModifierParams::initReferences(void)
+{
+}
+
+void ScaleVsLifeModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsLifeModifierParams::freeStrings(void)
+{
+}
+
+void ScaleVsLifeModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ScaleVsTemperature2DModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ScaleVsTemperature2DModifierParams.cpp
new file mode 100644
index 00000000..d5c70695
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ScaleVsTemperature2DModifierParams.cpp
@@ -0,0 +1,451 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ScaleVsTemperature2DModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ScaleVsTemperature2DModifierParamsNS;
+
+const char* const ScaleVsTemperature2DModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ScaleVsTemperature2DModifierParams, ScaleVsTemperature2DModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(scaleTemperatureStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((scaleTemperatureStruct_Type*)0)->temperature), NULL, 0 }, // controlPoints[].temperature
+	{ TYPE_VEC2, false, (size_t)(&((scaleTemperatureStruct_Type*)0)->scale), NULL, 0 }, // controlPoints[].scale
+};
+
+
+bool ScaleVsTemperature2DModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsTemperature2DModifierParams::mBuiltFlagMutex;
+
+ScaleVsTemperature2DModifierParams::ScaleVsTemperature2DModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsTemperature2DModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsTemperature2DModifierParams::~ScaleVsTemperature2DModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsTemperature2DModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsTemperature2DModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsTemperature2DModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsTemperature2DModifierParams::getParameterDefinitionTree(void) const
+{
+	ScaleVsTemperature2DModifierParams* tmpParam = const_cast<ScaleVsTemperature2DModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsTemperature2DModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsTemperature2DModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsTemperature2DModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsTemperature2DModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsTemperature2DModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsTemperature2DModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsTemperature2D modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Temperature", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite 2D scale vs Temperature curve", true);
+		HintTable[4].init("xAxisLabel", "Temperature", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "scaleTemperatureStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Temperature", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite 2D scale vs Temperature curve", true);
+		HintTable[4].init("xAxisLabel", "Temperature", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].temperature"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("temperature", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Temperature", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("scale", TYPE_VEC2, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Scale", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsTemperature2DModifierParams::initStrings(void)
+{
+}
+
+void ScaleVsTemperature2DModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(scaleTemperatureStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsTemperature2DModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsTemperature2DModifierParams::initReferences(void)
+{
+}
+
+void ScaleVsTemperature2DModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsTemperature2DModifierParams::freeStrings(void)
+{
+}
+
+void ScaleVsTemperature2DModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ScaleVsTemperature3DModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ScaleVsTemperature3DModifierParams.cpp
new file mode 100644
index 00000000..f66a52e7
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ScaleVsTemperature3DModifierParams.cpp
@@ -0,0 +1,451 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ScaleVsTemperature3DModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ScaleVsTemperature3DModifierParamsNS;
+
+const char* const ScaleVsTemperature3DModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ScaleVsTemperature3DModifierParams, ScaleVsTemperature3DModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(scaleTemperatureStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((scaleTemperatureStruct_Type*)0)->temperature), NULL, 0 }, // controlPoints[].temperature
+	{ TYPE_VEC3, false, (size_t)(&((scaleTemperatureStruct_Type*)0)->scale), NULL, 0 }, // controlPoints[].scale
+};
+
+
+bool ScaleVsTemperature3DModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsTemperature3DModifierParams::mBuiltFlagMutex;
+
+ScaleVsTemperature3DModifierParams::ScaleVsTemperature3DModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsTemperature3DModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsTemperature3DModifierParams::~ScaleVsTemperature3DModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsTemperature3DModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsTemperature3DModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsTemperature3DModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsTemperature3DModifierParams::getParameterDefinitionTree(void) const
+{
+	ScaleVsTemperature3DModifierParams* tmpParam = const_cast<ScaleVsTemperature3DModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsTemperature3DModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsTemperature3DModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsTemperature3DModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsTemperature3DModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsTemperature3DModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsTemperature3DModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsTemperature3D modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Temperature", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite 3D scale vs Temperature curve", true);
+		HintTable[4].init("xAxisLabel", "Temperature", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "scaleTemperatureStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Temperature", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite 3D scale vs Temperature curve", true);
+		HintTable[4].init("xAxisLabel", "Temperature", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].temperature"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("temperature", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Temperature", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("scale", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Scale", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsTemperature3DModifierParams::initStrings(void)
+{
+}
+
+void ScaleVsTemperature3DModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(scaleTemperatureStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsTemperature3DModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsTemperature3DModifierParams::initReferences(void)
+{
+}
+
+void ScaleVsTemperature3DModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsTemperature3DModifierParams::freeStrings(void)
+{
+}
+
+void ScaleVsTemperature3DModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ScaleVsTemperatureModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ScaleVsTemperatureModifierParams.cpp
new file mode 100644
index 00000000..cea69421
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ScaleVsTemperatureModifierParams.cpp
@@ -0,0 +1,466 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ScaleVsTemperatureModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ScaleVsTemperatureModifierParamsNS;
+
+const char* const ScaleVsTemperatureModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ScaleVsTemperatureModifierParams, ScaleVsTemperatureModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->scaleAxis), NULL, 0 }, // scaleAxis
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(2), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(3), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool ScaleVsTemperatureModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsTemperatureModifierParams::mBuiltFlagMutex;
+
+ScaleVsTemperatureModifierParams::ScaleVsTemperatureModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsTemperatureModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsTemperatureModifierParams::~ScaleVsTemperatureModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsTemperatureModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsTemperatureModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsTemperatureModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsTemperatureModifierParams::getParameterDefinitionTree(void) const
+{
+	ScaleVsTemperatureModifierParams* tmpParam = const_cast<ScaleVsTemperatureModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsTemperatureModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsTemperatureModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsTemperatureModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsTemperatureModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsTemperatureModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsTemperatureModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsTemperature modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="scaleAxis"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("scaleAxis", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "xAxis", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "xAxis", true);
+		HintTable[1].init("shortDescription", "Scale axis to which the curve will be applied", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "xAxis", "yAxis", "zAxis" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Temperature", true);
+		HintTable[2].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Temperature", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Temperature", true);
+		HintTable[2].init("yAxisLabel", "Scale", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Temperature", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Temperature", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Scale", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(4);
+		Children[1] = PDEF_PTR(5);
+
+		ParamDefTable[3].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsTemperatureModifierParams::initStrings(void)
+{
+}
+
+void ScaleVsTemperatureModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsTemperatureModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	scaleAxis = (const char*)"xAxis";
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsTemperatureModifierParams::initReferences(void)
+{
+}
+
+void ScaleVsTemperatureModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsTemperatureModifierParams::freeStrings(void)
+{
+}
+
+void ScaleVsTemperatureModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/SimpleScaleModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/SimpleScaleModifierParams.cpp
new file mode 100644
index 00000000..d6071a72
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/SimpleScaleModifierParams.cpp
@@ -0,0 +1,318 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "SimpleScaleModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace SimpleScaleModifierParamsNS;
+
+const char* const SimpleScaleModifierParamsFactory::vptr =
+    NvParameterized::getVptr<SimpleScaleModifierParams, SimpleScaleModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_VEC3, false, (size_t)(&((ParametersStruct*)0)->scaleFactor), NULL, 0 }, // scaleFactor
+};
+
+
+bool SimpleScaleModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType SimpleScaleModifierParams::mBuiltFlagMutex;
+
+SimpleScaleModifierParams::SimpleScaleModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &SimpleScaleModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+SimpleScaleModifierParams::~SimpleScaleModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void SimpleScaleModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~SimpleScaleModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* SimpleScaleModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* SimpleScaleModifierParams::getParameterDefinitionTree(void) const
+{
+	SimpleScaleModifierParams* tmpParam = const_cast<SimpleScaleModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType SimpleScaleModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType SimpleScaleModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void SimpleScaleModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<SimpleScaleModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void SimpleScaleModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void SimpleScaleModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "SimpleScale modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="scaleFactor"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("scaleFactor", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Scale factor", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void SimpleScaleModifierParams::initStrings(void)
+{
+}
+
+void SimpleScaleModifierParams::initDynamicArrays(void)
+{
+}
+
+void SimpleScaleModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	scaleFactor = physx::PxVec3(init(1, 1, 1));
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void SimpleScaleModifierParams::initReferences(void)
+{
+}
+
+void SimpleScaleModifierParams::freeDynamicArrays(void)
+{
+}
+
+void SimpleScaleModifierParams::freeStrings(void)
+{
+}
+
+void SimpleScaleModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/SpriteIofxParameters.cpp b/APEX_1.4/module/iofx/src/autogen/SpriteIofxParameters.cpp
new file mode 100644
index 00000000..99c3c81b
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/SpriteIofxParameters.cpp
@@ -0,0 +1,534 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "SpriteIofxParameters.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace SpriteIofxParametersNS;
+
+const char* const SpriteIofxParametersFactory::vptr =
+    NvParameterized::getVptr<SpriteIofxParameters, SpriteIofxParameters::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 4, 3, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->spriteMaterialName), NULL, 0 }, // spriteMaterialName
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->spawnModifierList), CHILDREN(3), 1 }, // spawnModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // spawnModifierList[]
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->continuousModifierList), CHILDREN(4), 1 }, // continuousModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // continuousModifierList[]
+};
+
+
+bool SpriteIofxParameters::mBuiltFlag = false;
+NvParameterized::MutexType SpriteIofxParameters::mBuiltFlagMutex;
+
+SpriteIofxParameters::SpriteIofxParameters(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &SpriteIofxParametersFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+SpriteIofxParameters::~SpriteIofxParameters()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void SpriteIofxParameters::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~SpriteIofxParameters();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* SpriteIofxParameters::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* SpriteIofxParameters::getParameterDefinitionTree(void) const
+{
+	SpriteIofxParameters* tmpParam = const_cast<SpriteIofxParameters*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType SpriteIofxParameters::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType SpriteIofxParameters::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void SpriteIofxParameters::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<SpriteIofxParameters::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [0] - spawnModifierList (not an array of structs) */
+/* [0] - continuousModifierList (not an array of structs) */
+
+void SpriteIofxParameters::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void SpriteIofxParameters::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="spriteMaterialName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("spriteMaterialName", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The sprite material name (if this is a sprite IOFX)", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ApexMaterials" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="spawnModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("spawnModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		HintTable[2].init("longDescription", "These modifiers are applied to the instanced objects at object creation. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[3].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "RandomSubtextureModifierParams", "RandomRotationModifierParams", "ColorVsLifeModifierParams", "ScaleByMassModifierParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 7);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="spawnModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("spawnModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		HintTable[2].init("longDescription", "These modifiers are applied to the instanced objects at object creation. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[3].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "RandomSubtextureModifierParams", "RandomRotationModifierParams", "ColorVsLifeModifierParams", "ScaleByMassModifierParams" };
+		ParamDefTable[3].setRefVariantVals((const char**)RefVariantVals, 7);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="continuousModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("continuousModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("HIDE_CLASS6", "ColorVsTemperatureModifierParams", true);
+		HintTable[6].init("HIDE_CLASS7", "ScaleVsTemperatureModifierParams", true);
+		HintTable[7].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#else
+
+		static HintImpl HintTable[10];
+		static Hint* HintPtrTable[10] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], &HintTable[8], &HintTable[9], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("HIDE_CLASS6", "ColorVsTemperatureModifierParams", true);
+		HintTable[6].init("HIDE_CLASS7", "ScaleVsTemperatureModifierParams", true);
+		HintTable[7].init("INCLUDED", uint64_t(1), true);
+		HintTable[8].init("longDescription", "These modifiers are applied to the instanced objects every frame. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[9].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 10);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ColorVsTemperatureCompositeModifierParams", "ScaleVsLife2DModifierParams", "ScaleVsDensity2DModifierParams", "ScaleVsTemperature2DModifierParams", "ScaleVsCameraDistance2DModifierParams", "SubtextureVsLifeModifierParams", "ViewDirectionSortingModifierParams", "ColorVsLifeModifierParams", "ColorVsDensityModifierParams", "ColorVsTemperatureModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsTemperatureModifierParams", "ScaleVsCameraDistanceModifierParams", "RotationRateModifierParams", "RotationRateVsLifeModifierParams", "OrientScaleAlongScreenVelocityModifierParams", "ColorVsVelocityCompositeModifierParams" };
+		ParamDefTable[4].setRefVariantVals((const char**)RefVariantVals, 20);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="continuousModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("continuousModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("HIDE_CLASS6", "ColorVsTemperatureModifierParams", true);
+		HintTable[6].init("HIDE_CLASS7", "ScaleVsTemperatureModifierParams", true);
+		HintTable[7].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#else
+
+		static HintImpl HintTable[10];
+		static Hint* HintPtrTable[10] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], &HintTable[8], &HintTable[9], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("HIDE_CLASS6", "ColorVsTemperatureModifierParams", true);
+		HintTable[6].init("HIDE_CLASS7", "ScaleVsTemperatureModifierParams", true);
+		HintTable[7].init("INCLUDED", uint64_t(1), true);
+		HintTable[8].init("longDescription", "These modifiers are applied to the instanced objects every frame. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[9].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 10);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ColorVsTemperatureCompositeModifierParams", "ScaleVsLife2DModifierParams", "ScaleVsDensity2DModifierParams", "ScaleVsTemperature2DModifierParams", "ScaleVsCameraDistance2DModifierParams", "SubtextureVsLifeModifierParams", "ViewDirectionSortingModifierParams", "ColorVsLifeModifierParams", "ColorVsDensityModifierParams", "ColorVsTemperatureModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsTemperatureModifierParams", "ScaleVsCameraDistanceModifierParams", "RotationRateModifierParams", "RotationRateVsLifeModifierParams", "OrientScaleAlongScreenVelocityModifierParams", "ColorVsVelocityCompositeModifierParams" };
+		ParamDefTable[5].setRefVariantVals((const char**)RefVariantVals, 20);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(4);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="spawnModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="continuousModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(5);
+
+		ParamDefTable[4].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void SpriteIofxParameters::initStrings(void)
+{
+}
+
+void SpriteIofxParameters::initDynamicArrays(void)
+{
+	spawnModifierList.buf = NULL;
+	spawnModifierList.isAllocated = true;
+	spawnModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	spawnModifierList.arraySizes[0] = 0;
+	continuousModifierList.buf = NULL;
+	continuousModifierList.isAllocated = true;
+	continuousModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	continuousModifierList.arraySizes[0] = 0;
+}
+
+void SpriteIofxParameters::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void SpriteIofxParameters::initReferences(void)
+{
+	spriteMaterialName = NULL;
+
+}
+
+void SpriteIofxParameters::freeDynamicArrays(void)
+{
+	if (spawnModifierList.isAllocated && spawnModifierList.buf)
+	{
+		mParameterizedTraits->free(spawnModifierList.buf);
+	}
+	if (continuousModifierList.isAllocated && continuousModifierList.buf)
+	{
+		mParameterizedTraits->free(continuousModifierList.buf);
+	}
+}
+
+void SpriteIofxParameters::freeStrings(void)
+{
+}
+
+void SpriteIofxParameters::freeReferences(void)
+{
+	if (spriteMaterialName)
+	{
+		spriteMaterialName->destroy();
+	}
+
+
+	for (int i = 0; i < spawnModifierList.arraySizes[0]; ++i)
+	{
+		if (spawnModifierList.buf[i])
+		{
+			spawnModifierList.buf[i]->destroy();
+		}
+	}
+
+	for (int i = 0; i < continuousModifierList.arraySizes[0]; ++i)
+	{
+		if (continuousModifierList.buf[i])
+		{
+			continuousModifierList.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/SubtextureVsLifeModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/SubtextureVsLifeModifierParams.cpp
new file mode 100644
index 00000000..95d8e868
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/SubtextureVsLifeModifierParams.cpp
@@ -0,0 +1,449 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "SubtextureVsLifeModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace SubtextureVsLifeModifierParamsNS;
+
+const char* const SubtextureVsLifeModifierParamsFactory::vptr =
+    NvParameterized::getVptr<SubtextureVsLifeModifierParams, SubtextureVsLifeModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool SubtextureVsLifeModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType SubtextureVsLifeModifierParams::mBuiltFlagMutex;
+
+SubtextureVsLifeModifierParams::SubtextureVsLifeModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &SubtextureVsLifeModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+SubtextureVsLifeModifierParams::~SubtextureVsLifeModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void SubtextureVsLifeModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~SubtextureVsLifeModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* SubtextureVsLifeModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* SubtextureVsLifeModifierParams::getParameterDefinitionTree(void) const
+{
+	SubtextureVsLifeModifierParams* tmpParam = const_cast<SubtextureVsLifeModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType SubtextureVsLifeModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType SubtextureVsLifeModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void SubtextureVsLifeModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<SubtextureVsLifeModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void SubtextureVsLifeModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void SubtextureVsLifeModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "SubtextureVsLife modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(16), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "SubTexture", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(16), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[4].init("shortDescription", "Control points for a curve", true);
+		HintTable[5].init("xAxisLabel", "Life Time", true);
+		HintTable[6].init("yAxisLabel", "SubTexture", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(16), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "SubTexture", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(16), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[4].init("shortDescription", "Control points for a curve", true);
+		HintTable[5].init("xAxisLabel", "Life Time", true);
+		HintTable[6].init("yAxisLabel", "SubTexture", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Life time", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Subtexture id", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void SubtextureVsLifeModifierParams::initStrings(void)
+{
+}
+
+void SubtextureVsLifeModifierParams::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void SubtextureVsLifeModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void SubtextureVsLifeModifierParams::initReferences(void)
+{
+}
+
+void SubtextureVsLifeModifierParams::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void SubtextureVsLifeModifierParams::freeStrings(void)
+{
+}
+
+void SubtextureVsLifeModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx/src/autogen/ViewDirectionSortingModifierParams.cpp b/APEX_1.4/module/iofx/src/autogen/ViewDirectionSortingModifierParams.cpp
new file mode 100644
index 00000000..528175bb
--- /dev/null
+++ b/APEX_1.4/module/iofx/src/autogen/ViewDirectionSortingModifierParams.cpp
@@ -0,0 +1,326 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ViewDirectionSortingModifierParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace iofx
+{
+
+using namespace ViewDirectionSortingModifierParamsNS;
+
+const char* const ViewDirectionSortingModifierParamsFactory::vptr =
+    NvParameterized::getVptr<ViewDirectionSortingModifierParams, ViewDirectionSortingModifierParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->sortType), NULL, 0 }, // sortType
+};
+
+
+bool ViewDirectionSortingModifierParams::mBuiltFlag = false;
+NvParameterized::MutexType ViewDirectionSortingModifierParams::mBuiltFlagMutex;
+
+ViewDirectionSortingModifierParams::ViewDirectionSortingModifierParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ViewDirectionSortingModifierParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ViewDirectionSortingModifierParams::~ViewDirectionSortingModifierParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ViewDirectionSortingModifierParams::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ViewDirectionSortingModifierParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ViewDirectionSortingModifierParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ViewDirectionSortingModifierParams::getParameterDefinitionTree(void) const
+{
+	ViewDirectionSortingModifierParams* tmpParam = const_cast<ViewDirectionSortingModifierParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ViewDirectionSortingModifierParams::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ViewDirectionSortingModifierParams::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ViewDirectionSortingModifierParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ViewDirectionSortingModifierParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ViewDirectionSortingModifierParams::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ViewDirectionSortingModifierParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ViewDirectionSorting modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="sortType"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("sortType", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "default", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "default", true);
+		HintTable[1].init("shortDescription", "Sort type", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "default" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 1);
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ViewDirectionSortingModifierParams::initStrings(void)
+{
+}
+
+void ViewDirectionSortingModifierParams::initDynamicArrays(void)
+{
+}
+
+void ViewDirectionSortingModifierParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	sortType = (const char*)"default";
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ViewDirectionSortingModifierParams::initReferences(void)
+{
+}
+
+void ViewDirectionSortingModifierParams::freeDynamicArrays(void)
+{
+}
+
+void ViewDirectionSortingModifierParams::freeStrings(void)
+{
+}
+
+void ViewDirectionSortingModifierParams::freeReferences(void)
+{
+}
+
+} // namespace iofx
+} // namespace nvidia