Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

40 files changed, 9570 insertions, 0 deletions

diff --git a/APEX_1.4/module/iofx/include/autogen/ColorVsDensityCompositeModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ColorVsDensityCompositeModifierParams.h
new file mode 100644
index 00000000..2f505954
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ColorVsDensityCompositeModifierParams.h
@@ -0,0 +1,244 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ColorVsDensityCompositeModifierParams_h
+#define HEADER_ColorVsDensityCompositeModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ColorVsDensityCompositeModifierParamsNS
+{
+
+struct colorDensityStruct_Type;
+
+struct colorDensityStruct_DynamicArray1D_Type
+{
+	colorDensityStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct colorDensityStruct_Type
+{
+	float density;
+	physx::PxVec4 color;
+};
+
+struct ParametersStruct
+{
+
+	colorDensityStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x6ee7f5a0, 0xedd1e5d5, 0x6169ab3c, 0x868306ec, };
+
+} // namespace ColorVsDensityCompositeModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ColorVsDensityCompositeModifierParams : public NvParameterized::NvParameters, public ColorVsDensityCompositeModifierParamsNS::ParametersStruct
+{
+public:
+	ColorVsDensityCompositeModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ColorVsDensityCompositeModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ColorVsDensityCompositeModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ColorVsDensityCompositeModifierParamsNS::checksum);
+		return ColorVsDensityCompositeModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ColorVsDensityCompositeModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ColorVsDensityCompositeModifierParams* tmpThis = const_cast<ColorVsDensityCompositeModifierParams*>(this);
+		return *(static_cast<ColorVsDensityCompositeModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ColorVsDensityCompositeModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ColorVsDensityCompositeModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ColorVsDensityCompositeModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ColorVsDensityCompositeModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ColorVsDensityCompositeModifierParams), ColorVsDensityCompositeModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ColorVsDensityCompositeModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsDensityCompositeModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ColorVsDensityCompositeModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ColorVsDensityCompositeModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ColorVsDensityCompositeModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ColorVsDensityCompositeModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsDensityCompositeModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ColorVsDensityCompositeModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ColorVsDensityCompositeModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ColorVsDensityCompositeModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ColorVsDensityCompositeModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ColorVsDensityCompositeModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ColorVsDensityCompositeModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ColorVsDensityModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ColorVsDensityModifierParams.h
new file mode 100644
index 00000000..5386b7c5
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ColorVsDensityModifierParams.h
@@ -0,0 +1,245 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ColorVsDensityModifierParams_h
+#define HEADER_ColorVsDensityModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ColorVsDensityModifierParamsNS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	const char* colorChannel;
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0xbd1ead31, 0x79bc4460, 0x6a89ef07, 0xbbe13350, };
+
+} // namespace ColorVsDensityModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ColorVsDensityModifierParams : public NvParameterized::NvParameters, public ColorVsDensityModifierParamsNS::ParametersStruct
+{
+public:
+	ColorVsDensityModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ColorVsDensityModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ColorVsDensityModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ColorVsDensityModifierParamsNS::checksum);
+		return ColorVsDensityModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ColorVsDensityModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ColorVsDensityModifierParams* tmpThis = const_cast<ColorVsDensityModifierParams*>(this);
+		return *(static_cast<ColorVsDensityModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ColorVsDensityModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ColorVsDensityModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ColorVsDensityModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ColorVsDensityModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ColorVsDensityModifierParams), ColorVsDensityModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ColorVsDensityModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsDensityModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ColorVsDensityModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ColorVsDensityModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ColorVsDensityModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ColorVsDensityModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsDensityModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ColorVsDensityModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ColorVsDensityModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ColorVsDensityModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ColorVsDensityModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ColorVsDensityModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ColorVsDensityModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ColorVsLifeCompositeModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ColorVsLifeCompositeModifierParams.h
new file mode 100644
index 00000000..9a8111ee
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ColorVsLifeCompositeModifierParams.h
@@ -0,0 +1,244 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ColorVsLifeCompositeModifierParams_h
+#define HEADER_ColorVsLifeCompositeModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ColorVsLifeCompositeModifierParamsNS
+{
+
+struct colorLifeStruct_Type;
+
+struct colorLifeStruct_DynamicArray1D_Type
+{
+	colorLifeStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct colorLifeStruct_Type
+{
+	float lifeRemaining;
+	physx::PxVec4 color;
+};
+
+struct ParametersStruct
+{
+
+	colorLifeStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x2ee279f3, 0x6440bf5b, 0x26d89b02, 0xc90fa659, };
+
+} // namespace ColorVsLifeCompositeModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ColorVsLifeCompositeModifierParams : public NvParameterized::NvParameters, public ColorVsLifeCompositeModifierParamsNS::ParametersStruct
+{
+public:
+	ColorVsLifeCompositeModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ColorVsLifeCompositeModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ColorVsLifeCompositeModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ColorVsLifeCompositeModifierParamsNS::checksum);
+		return ColorVsLifeCompositeModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ColorVsLifeCompositeModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ColorVsLifeCompositeModifierParams* tmpThis = const_cast<ColorVsLifeCompositeModifierParams*>(this);
+		return *(static_cast<ColorVsLifeCompositeModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ColorVsLifeCompositeModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ColorVsLifeCompositeModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ColorVsLifeCompositeModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ColorVsLifeCompositeModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ColorVsLifeCompositeModifierParams), ColorVsLifeCompositeModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ColorVsLifeCompositeModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsLifeCompositeModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ColorVsLifeCompositeModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ColorVsLifeCompositeModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ColorVsLifeCompositeModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ColorVsLifeCompositeModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsLifeCompositeModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ColorVsLifeCompositeModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ColorVsLifeCompositeModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ColorVsLifeCompositeModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ColorVsLifeCompositeModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ColorVsLifeCompositeModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ColorVsLifeCompositeModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ColorVsLifeModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ColorVsLifeModifierParams.h
new file mode 100644
index 00000000..c146c48d
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ColorVsLifeModifierParams.h
@@ -0,0 +1,245 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ColorVsLifeModifierParams_h
+#define HEADER_ColorVsLifeModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ColorVsLifeModifierParamsNS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	const char* colorChannel;
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x6273c5a3, 0xe1a0df26, 0x77f5af16, 0x6a54d1e7, };
+
+} // namespace ColorVsLifeModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ColorVsLifeModifierParams : public NvParameterized::NvParameters, public ColorVsLifeModifierParamsNS::ParametersStruct
+{
+public:
+	ColorVsLifeModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ColorVsLifeModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ColorVsLifeModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ColorVsLifeModifierParamsNS::checksum);
+		return ColorVsLifeModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ColorVsLifeModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ColorVsLifeModifierParams* tmpThis = const_cast<ColorVsLifeModifierParams*>(this);
+		return *(static_cast<ColorVsLifeModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ColorVsLifeModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ColorVsLifeModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ColorVsLifeModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ColorVsLifeModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ColorVsLifeModifierParams), ColorVsLifeModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ColorVsLifeModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsLifeModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ColorVsLifeModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ColorVsLifeModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ColorVsLifeModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ColorVsLifeModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsLifeModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ColorVsLifeModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ColorVsLifeModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ColorVsLifeModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ColorVsLifeModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ColorVsLifeModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ColorVsLifeModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ColorVsTemperatureCompositeModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ColorVsTemperatureCompositeModifierParams.h
new file mode 100644
index 00000000..e3e84894
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ColorVsTemperatureCompositeModifierParams.h
@@ -0,0 +1,244 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ColorVsTemperatureCompositeModifierParams_h
+#define HEADER_ColorVsTemperatureCompositeModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ColorVsTemperatureCompositeModifierParamsNS
+{
+
+struct colorTemperatureStruct_Type;
+
+struct colorTemperatureStruct_DynamicArray1D_Type
+{
+	colorTemperatureStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct colorTemperatureStruct_Type
+{
+	float temperature;
+	physx::PxVec4 color;
+};
+
+struct ParametersStruct
+{
+
+	colorTemperatureStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0xb5bad295, 0x1bbde1e7, 0xb10b2dc3, 0xde67581e, };
+
+} // namespace ColorVsTemperatureCompositeModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ColorVsTemperatureCompositeModifierParams : public NvParameterized::NvParameters, public ColorVsTemperatureCompositeModifierParamsNS::ParametersStruct
+{
+public:
+	ColorVsTemperatureCompositeModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ColorVsTemperatureCompositeModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ColorVsTemperatureCompositeModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ColorVsTemperatureCompositeModifierParamsNS::checksum);
+		return ColorVsTemperatureCompositeModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ColorVsTemperatureCompositeModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ColorVsTemperatureCompositeModifierParams* tmpThis = const_cast<ColorVsTemperatureCompositeModifierParams*>(this);
+		return *(static_cast<ColorVsTemperatureCompositeModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ColorVsTemperatureCompositeModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ColorVsTemperatureCompositeModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ColorVsTemperatureCompositeModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ColorVsTemperatureCompositeModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ColorVsTemperatureCompositeModifierParams), ColorVsTemperatureCompositeModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ColorVsTemperatureCompositeModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsTemperatureCompositeModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ColorVsTemperatureCompositeModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ColorVsTemperatureCompositeModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ColorVsTemperatureCompositeModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ColorVsTemperatureCompositeModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsTemperatureCompositeModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ColorVsTemperatureCompositeModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ColorVsTemperatureCompositeModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ColorVsTemperatureCompositeModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ColorVsTemperatureCompositeModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ColorVsTemperatureCompositeModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ColorVsTemperatureCompositeModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ColorVsTemperatureModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ColorVsTemperatureModifierParams.h
new file mode 100644
index 00000000..135dc951
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ColorVsTemperatureModifierParams.h
@@ -0,0 +1,245 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ColorVsTemperatureModifierParams_h
+#define HEADER_ColorVsTemperatureModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ColorVsTemperatureModifierParamsNS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	const char* colorChannel;
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0xe539a2ca, 0x44cf1564, 0xa6a2c047, 0xec15660d, };
+
+} // namespace ColorVsTemperatureModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ColorVsTemperatureModifierParams : public NvParameterized::NvParameters, public ColorVsTemperatureModifierParamsNS::ParametersStruct
+{
+public:
+	ColorVsTemperatureModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ColorVsTemperatureModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ColorVsTemperatureModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ColorVsTemperatureModifierParamsNS::checksum);
+		return ColorVsTemperatureModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ColorVsTemperatureModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ColorVsTemperatureModifierParams* tmpThis = const_cast<ColorVsTemperatureModifierParams*>(this);
+		return *(static_cast<ColorVsTemperatureModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ColorVsTemperatureModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ColorVsTemperatureModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ColorVsTemperatureModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ColorVsTemperatureModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ColorVsTemperatureModifierParams), ColorVsTemperatureModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ColorVsTemperatureModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsTemperatureModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ColorVsTemperatureModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ColorVsTemperatureModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ColorVsTemperatureModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ColorVsTemperatureModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsTemperatureModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ColorVsTemperatureModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ColorVsTemperatureModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ColorVsTemperatureModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ColorVsTemperatureModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ColorVsTemperatureModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ColorVsTemperatureModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ColorVsVelocityCompositeModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ColorVsVelocityCompositeModifierParams.h
new file mode 100644
index 00000000..2815ecbf
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ColorVsVelocityCompositeModifierParams.h
@@ -0,0 +1,246 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ColorVsVelocityCompositeModifierParams_h
+#define HEADER_ColorVsVelocityCompositeModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ColorVsVelocityCompositeModifierParamsNS
+{
+
+struct colorVelocityStruct_Type;
+
+struct colorVelocityStruct_DynamicArray1D_Type
+{
+	colorVelocityStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct colorVelocityStruct_Type
+{
+	float velocity;
+	physx::PxVec4 color;
+};
+
+struct ParametersStruct
+{
+
+	float velocity0;
+	float velocity1;
+	colorVelocityStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x85918a9e, 0x651f465d, 0x179721b9, 0x3bbd630d, };
+
+} // namespace ColorVsVelocityCompositeModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ColorVsVelocityCompositeModifierParams : public NvParameterized::NvParameters, public ColorVsVelocityCompositeModifierParamsNS::ParametersStruct
+{
+public:
+	ColorVsVelocityCompositeModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ColorVsVelocityCompositeModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ColorVsVelocityCompositeModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ColorVsVelocityCompositeModifierParamsNS::checksum);
+		return ColorVsVelocityCompositeModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ColorVsVelocityCompositeModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ColorVsVelocityCompositeModifierParams* tmpThis = const_cast<ColorVsVelocityCompositeModifierParams*>(this);
+		return *(static_cast<ColorVsVelocityCompositeModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ColorVsVelocityCompositeModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ColorVsVelocityCompositeModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ColorVsVelocityCompositeModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ColorVsVelocityCompositeModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ColorVsVelocityCompositeModifierParams), ColorVsVelocityCompositeModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ColorVsVelocityCompositeModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsVelocityCompositeModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ColorVsVelocityCompositeModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ColorVsVelocityCompositeModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ColorVsVelocityCompositeModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ColorVsVelocityCompositeModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsVelocityCompositeModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ColorVsVelocityCompositeModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ColorVsVelocityCompositeModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ColorVsVelocityCompositeModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ColorVsVelocityCompositeModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ColorVsVelocityCompositeModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ColorVsVelocityCompositeModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ColorVsVelocityModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ColorVsVelocityModifierParams.h
new file mode 100644
index 00000000..376c875c
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ColorVsVelocityModifierParams.h
@@ -0,0 +1,247 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ColorVsVelocityModifierParams_h
+#define HEADER_ColorVsVelocityModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ColorVsVelocityModifierParamsNS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	const char* colorChannel;
+	float velocity0;
+	float velocity1;
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x4c79c470, 0xac91d48e, 0xa4578ba1, 0x9c1ae2f2, };
+
+} // namespace ColorVsVelocityModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ColorVsVelocityModifierParams : public NvParameterized::NvParameters, public ColorVsVelocityModifierParamsNS::ParametersStruct
+{
+public:
+	ColorVsVelocityModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ColorVsVelocityModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ColorVsVelocityModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ColorVsVelocityModifierParamsNS::checksum);
+		return ColorVsVelocityModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ColorVsVelocityModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ColorVsVelocityModifierParams* tmpThis = const_cast<ColorVsVelocityModifierParams*>(this);
+		return *(static_cast<ColorVsVelocityModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ColorVsVelocityModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ColorVsVelocityModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ColorVsVelocityModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ColorVsVelocityModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ColorVsVelocityModifierParams), ColorVsVelocityModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ColorVsVelocityModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsVelocityModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ColorVsVelocityModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ColorVsVelocityModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ColorVsVelocityModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ColorVsVelocityModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsVelocityModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ColorVsVelocityModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ColorVsVelocityModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ColorVsVelocityModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ColorVsVelocityModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ColorVsVelocityModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ColorVsVelocityModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/InitialColorModifierParams.h b/APEX_1.4/module/iofx/include/autogen/InitialColorModifierParams.h
new file mode 100644
index 00000000..49ba52b0
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/InitialColorModifierParams.h
@@ -0,0 +1,230 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_InitialColorModifierParams_h
+#define HEADER_InitialColorModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace InitialColorModifierParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxVec4 color;
+
+};
+
+static const uint32_t checksum[] = { 0xeede1183, 0x3f1f709f, 0x0957a3e8, 0x4a27910f, };
+
+} // namespace InitialColorModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class InitialColorModifierParams : public NvParameterized::NvParameters, public InitialColorModifierParamsNS::ParametersStruct
+{
+public:
+	InitialColorModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~InitialColorModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("InitialColorModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(InitialColorModifierParamsNS::checksum);
+		return InitialColorModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const InitialColorModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		InitialColorModifierParams* tmpThis = const_cast<InitialColorModifierParams*>(this);
+		return *(static_cast<InitialColorModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	InitialColorModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<InitialColorModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class InitialColorModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		InitialColorModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(InitialColorModifierParams), InitialColorModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, InitialColorModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class InitialColorModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(InitialColorModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, InitialColorModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, InitialColorModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, InitialColorModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class InitialColorModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of InitialColorModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (InitialColorModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (InitialColorModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (InitialColorModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (InitialColorModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (InitialColorModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/IofxAssetParameters.h b/APEX_1.4/module/iofx/include/autogen/IofxAssetParameters.h
new file mode 100644
index 00000000..77557890
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/IofxAssetParameters.h
@@ -0,0 +1,237 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_IofxAssetParameters_h
+#define HEADER_IofxAssetParameters_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace IofxAssetParametersNS
+{
+
+struct outputProperties_Type;
+
+struct outputProperties_Type
+{
+	bool useUserSemantic;
+	bool useFloat4Color;
+};
+
+struct ParametersStruct
+{
+
+	NvParameterized::Interface* iofxType;
+	outputProperties_Type renderOutput;
+
+};
+
+static const uint32_t checksum[] = { 0xbb5add57, 0xf771d298, 0xcd7c3bc3, 0x921baa57, };
+
+} // namespace IofxAssetParametersNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class IofxAssetParameters : public NvParameterized::NvParameters, public IofxAssetParametersNS::ParametersStruct
+{
+public:
+	IofxAssetParameters(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~IofxAssetParameters();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("IofxAssetParameters");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)2;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(IofxAssetParametersNS::checksum);
+		return IofxAssetParametersNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const IofxAssetParametersNS::ParametersStruct& parameters(void) const
+	{
+		IofxAssetParameters* tmpThis = const_cast<IofxAssetParameters*>(this);
+		return *(static_cast<IofxAssetParametersNS::ParametersStruct*>(tmpThis));
+	}
+
+	IofxAssetParametersNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<IofxAssetParametersNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class IofxAssetParametersFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		IofxAssetParameters::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(IofxAssetParameters), IofxAssetParameters::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, IofxAssetParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class IofxAssetParameters");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(IofxAssetParameters)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, IofxAssetParameters)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, IofxAssetParameters::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, IofxAssetParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class IofxAssetParameters");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of IofxAssetParameters here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (IofxAssetParameters*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (IofxAssetParameters::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (IofxAssetParameters::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (IofxAssetParameters::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (IofxAssetParameters::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/IofxDebugRenderParams.h b/APEX_1.4/module/iofx/include/autogen/IofxDebugRenderParams.h
new file mode 100644
index 00000000..a26652f3
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/IofxDebugRenderParams.h
@@ -0,0 +1,232 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_IofxDebugRenderParams_h
+#define HEADER_IofxDebugRenderParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace IofxDebugRenderParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	bool VISUALIZE_IOFX_ACTOR;
+	bool VISUALIZE_IOFX_BOUNDING_BOX;
+	bool VISUALIZE_IOFX_ACTOR_NAME;
+
+};
+
+static const uint32_t checksum[] = { 0xa907935c, 0x197f0683, 0x47c3ea05, 0x61985bda, };
+
+} // namespace IofxDebugRenderParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class IofxDebugRenderParams : public NvParameterized::NvParameters, public IofxDebugRenderParamsNS::ParametersStruct
+{
+public:
+	IofxDebugRenderParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~IofxDebugRenderParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("IofxDebugRenderParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(IofxDebugRenderParamsNS::checksum);
+		return IofxDebugRenderParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const IofxDebugRenderParamsNS::ParametersStruct& parameters(void) const
+	{
+		IofxDebugRenderParams* tmpThis = const_cast<IofxDebugRenderParams*>(this);
+		return *(static_cast<IofxDebugRenderParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	IofxDebugRenderParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<IofxDebugRenderParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class IofxDebugRenderParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		IofxDebugRenderParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(IofxDebugRenderParams), IofxDebugRenderParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, IofxDebugRenderParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class IofxDebugRenderParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(IofxDebugRenderParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, IofxDebugRenderParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, IofxDebugRenderParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, IofxDebugRenderParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class IofxDebugRenderParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of IofxDebugRenderParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (IofxDebugRenderParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (IofxDebugRenderParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (IofxDebugRenderParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (IofxDebugRenderParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (IofxDebugRenderParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/IofxModuleParameters.h b/APEX_1.4/module/iofx/include/autogen/IofxModuleParameters.h
new file mode 100644
index 00000000..eee1c73f
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/IofxModuleParameters.h
@@ -0,0 +1,230 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_IofxModuleParameters_h
+#define HEADER_IofxModuleParameters_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace IofxModuleParametersNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	uint32_t unused;
+
+};
+
+static const uint32_t checksum[] = { 0x70f85d6f, 0xc44790e5, 0x2f3cd6fd, 0x9d4a542b, };
+
+} // namespace IofxModuleParametersNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class IofxModuleParameters : public NvParameterized::NvParameters, public IofxModuleParametersNS::ParametersStruct
+{
+public:
+	IofxModuleParameters(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~IofxModuleParameters();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("IofxModuleParameters");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(IofxModuleParametersNS::checksum);
+		return IofxModuleParametersNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const IofxModuleParametersNS::ParametersStruct& parameters(void) const
+	{
+		IofxModuleParameters* tmpThis = const_cast<IofxModuleParameters*>(this);
+		return *(static_cast<IofxModuleParametersNS::ParametersStruct*>(tmpThis));
+	}
+
+	IofxModuleParametersNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<IofxModuleParametersNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class IofxModuleParametersFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		IofxModuleParameters::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(IofxModuleParameters), IofxModuleParameters::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, IofxModuleParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class IofxModuleParameters");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(IofxModuleParameters)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, IofxModuleParameters)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, IofxModuleParameters::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, IofxModuleParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class IofxModuleParameters");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of IofxModuleParameters here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (IofxModuleParameters*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (IofxModuleParameters::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (IofxModuleParameters::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (IofxModuleParameters::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (IofxModuleParameters::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/MeshIofxParameters.h b/APEX_1.4/module/iofx/include/autogen/MeshIofxParameters.h
new file mode 100644
index 00000000..8bac4572
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/MeshIofxParameters.h
@@ -0,0 +1,254 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_MeshIofxParameters_h
+#define HEADER_MeshIofxParameters_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace MeshIofxParametersNS
+{
+
+struct meshProperties_Type;
+
+struct meshProperties_DynamicArray1D_Type
+{
+	meshProperties_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct meshProperties_Type
+{
+	NvParameterized::Interface* meshAssetName;
+	uint32_t weight;
+};
+
+struct ParametersStruct
+{
+
+	meshProperties_DynamicArray1D_Type renderMeshList;
+	REF_DynamicArray1D_Type spawnModifierList;
+	REF_DynamicArray1D_Type continuousModifierList;
+
+};
+
+static const uint32_t checksum[] = { 0x823a573c, 0xd18e2215, 0x6fc4db63, 0x3df0022a, };
+
+} // namespace MeshIofxParametersNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class MeshIofxParameters : public NvParameterized::NvParameters, public MeshIofxParametersNS::ParametersStruct
+{
+public:
+	MeshIofxParameters(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~MeshIofxParameters();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("MeshIofxParameters");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)4;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(MeshIofxParametersNS::checksum);
+		return MeshIofxParametersNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const MeshIofxParametersNS::ParametersStruct& parameters(void) const
+	{
+		MeshIofxParameters* tmpThis = const_cast<MeshIofxParameters*>(this);
+		return *(static_cast<MeshIofxParametersNS::ParametersStruct*>(tmpThis));
+	}
+
+	MeshIofxParametersNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<MeshIofxParametersNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class MeshIofxParametersFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		MeshIofxParameters::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(MeshIofxParameters), MeshIofxParameters::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, MeshIofxParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class MeshIofxParameters");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(MeshIofxParameters)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, MeshIofxParameters)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, MeshIofxParameters::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, MeshIofxParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class MeshIofxParameters");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of MeshIofxParameters here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (MeshIofxParameters*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (MeshIofxParameters::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (MeshIofxParameters::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (MeshIofxParameters::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (MeshIofxParameters::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ModuleIofxRegistration.h b/APEX_1.4/module/iofx/include/autogen/ModuleIofxRegistration.h
new file mode 100644
index 00000000..db457b97
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ModuleIofxRegistration.h
@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+#ifndef MODULE_MODULEIOFXREGISTRATIONH_H
+#define MODULE_MODULEIOFXREGISTRATIONH_H
+
+#include "PsAllocator.h"
+#include "NvRegistrationsForTraitsBase.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "PxAssert.h"
+#include <stdint.h>
+
+// INCLUDE GENERATED FACTORIES
+#include "IofxDebugRenderParams.h"
+#include "IofxAssetParameters.h"
+#include "MeshIofxParameters.h"
+#include "SpriteIofxParameters.h"
+#include "RotationModifierParams.h"
+#include "SimpleScaleModifierParams.h"
+#include "ScaleByMassModifierParams.h"
+#include "RandomScaleModifierParams.h"
+#include "ColorVsLifeModifierParams.h"
+#include "ColorVsLifeCompositeModifierParams.h"
+#include "InitialColorModifierParams.h"
+#include "ScaleVsLifeModifierParams.h"
+#include "ScaleVsLife3DModifierParams.h"
+#include "ScaleVsLife2DModifierParams.h"
+#include "ScaleVsDensityModifierParams.h"
+#include "ScaleVsDensity3DModifierParams.h"
+#include "ScaleVsDensity2DModifierParams.h"
+#include "ScaleVsCameraDistanceModifierParams.h"
+#include "ScaleVsCameraDistance3DModifierParams.h"
+#include "ScaleVsCameraDistance2DModifierParams.h"
+#include "ColorVsDensityModifierParams.h"
+#include "ColorVsDensityCompositeModifierParams.h"
+#include "SubtextureVsLifeModifierParams.h"
+#include "OrientAlongVelocityModifierParams.h"
+#include "ScaleAlongVelocityModifierParams.h"
+#include "RandomSubtextureModifierParams.h"
+#include "RandomRotationModifierParams.h"
+#include "ViewDirectionSortingModifierParams.h"
+#include "RotationRateModifierParams.h"
+#include "RotationRateVsLifeModifierParams.h"
+#include "OrientScaleAlongScreenVelocityModifierParams.h"
+#include "ColorVsVelocityModifierParams.h"
+#include "ColorVsVelocityCompositeModifierParams.h"
+#include "ColorVsTemperatureModifierParams.h"
+#include "ColorVsTemperatureCompositeModifierParams.h"
+#include "ScaleVsTemperatureModifierParams.h"
+#include "ScaleVsTemperature3DModifierParams.h"
+#include "ScaleVsTemperature2DModifierParams.h"
+#include "IofxModuleParameters.h"
+
+
+// INCLUDE GENERATED CONVERSION
+
+
+namespace nvidia {
+namespace iofx {
+
+
+class ModuleIofxRegistration : public NvParameterized::RegistrationsForTraitsBase
+{
+public:
+	static void invokeRegistration(NvParameterized::Traits* parameterizedTraits)
+	{
+		if (parameterizedTraits)
+		{
+			ModuleIofxRegistration().registerAll(*parameterizedTraits);
+		}
+	}
+
+	static void invokeUnregistration(NvParameterized::Traits* parameterizedTraits)
+	{
+		if (parameterizedTraits)
+		{
+			ModuleIofxRegistration().unregisterAll(*parameterizedTraits);
+		}
+	}
+
+	void registerAvailableFactories(NvParameterized::Traits& parameterizedTraits)
+	{
+		::NvParameterized::Factory* factoriesToRegister[] = {
+// REGISTER GENERATED FACTORIES
+			new nvidia::iofx::IofxDebugRenderParamsFactory(),
+			new nvidia::iofx::IofxAssetParametersFactory(),
+			new nvidia::iofx::MeshIofxParametersFactory(),
+			new nvidia::iofx::SpriteIofxParametersFactory(),
+			new nvidia::iofx::RotationModifierParamsFactory(),
+			new nvidia::iofx::SimpleScaleModifierParamsFactory(),
+			new nvidia::iofx::ScaleByMassModifierParamsFactory(),
+			new nvidia::iofx::RandomScaleModifierParamsFactory(),
+			new nvidia::iofx::ColorVsLifeModifierParamsFactory(),
+			new nvidia::iofx::ColorVsLifeCompositeModifierParamsFactory(),
+			new nvidia::iofx::InitialColorModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsLifeModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsLife3DModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsLife2DModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsDensityModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsDensity3DModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsDensity2DModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsCameraDistanceModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsCameraDistance3DModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsCameraDistance2DModifierParamsFactory(),
+			new nvidia::iofx::ColorVsDensityModifierParamsFactory(),
+			new nvidia::iofx::ColorVsDensityCompositeModifierParamsFactory(),
+			new nvidia::iofx::SubtextureVsLifeModifierParamsFactory(),
+			new nvidia::iofx::OrientAlongVelocityModifierParamsFactory(),
+			new nvidia::iofx::ScaleAlongVelocityModifierParamsFactory(),
+			new nvidia::iofx::RandomSubtextureModifierParamsFactory(),
+			new nvidia::iofx::RandomRotationModifierParamsFactory(),
+			new nvidia::iofx::ViewDirectionSortingModifierParamsFactory(),
+			new nvidia::iofx::RotationRateModifierParamsFactory(),
+			new nvidia::iofx::RotationRateVsLifeModifierParamsFactory(),
+			new nvidia::iofx::OrientScaleAlongScreenVelocityModifierParamsFactory(),
+			new nvidia::iofx::ColorVsVelocityModifierParamsFactory(),
+			new nvidia::iofx::ColorVsVelocityCompositeModifierParamsFactory(),
+			new nvidia::iofx::ColorVsTemperatureModifierParamsFactory(),
+			new nvidia::iofx::ColorVsTemperatureCompositeModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsTemperatureModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsTemperature3DModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsTemperature2DModifierParamsFactory(),
+			new nvidia::iofx::IofxModuleParametersFactory(),
+
+		};
+
+		for (size_t i = 0; i < sizeof(factoriesToRegister)/sizeof(factoriesToRegister[0]); ++i)
+		{
+			parameterizedTraits.registerFactory(*factoriesToRegister[i]);
+		}
+	}
+
+	virtual void registerAvailableConverters(NvParameterized::Traits& parameterizedTraits)
+	{
+// REGISTER GENERATED CONVERSION
+PX_UNUSED(parameterizedTraits);
+
+	}
+
+	void unregisterAvailableFactories(NvParameterized::Traits& parameterizedTraits)
+	{
+		struct FactoryDesc
+		{
+			const char* name;
+			uint32_t version;
+		};
+
+		::NvParameterized::Factory* factoriesToUnregister[] = {
+// UNREGISTER GENERATED FACTORIES
+			new nvidia::iofx::IofxDebugRenderParamsFactory(),
+			new nvidia::iofx::IofxAssetParametersFactory(),
+			new nvidia::iofx::MeshIofxParametersFactory(),
+			new nvidia::iofx::SpriteIofxParametersFactory(),
+			new nvidia::iofx::RotationModifierParamsFactory(),
+			new nvidia::iofx::SimpleScaleModifierParamsFactory(),
+			new nvidia::iofx::ScaleByMassModifierParamsFactory(),
+			new nvidia::iofx::RandomScaleModifierParamsFactory(),
+			new nvidia::iofx::ColorVsLifeModifierParamsFactory(),
+			new nvidia::iofx::ColorVsLifeCompositeModifierParamsFactory(),
+			new nvidia::iofx::InitialColorModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsLifeModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsLife3DModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsLife2DModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsDensityModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsDensity3DModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsDensity2DModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsCameraDistanceModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsCameraDistance3DModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsCameraDistance2DModifierParamsFactory(),
+			new nvidia::iofx::ColorVsDensityModifierParamsFactory(),
+			new nvidia::iofx::ColorVsDensityCompositeModifierParamsFactory(),
+			new nvidia::iofx::SubtextureVsLifeModifierParamsFactory(),
+			new nvidia::iofx::OrientAlongVelocityModifierParamsFactory(),
+			new nvidia::iofx::ScaleAlongVelocityModifierParamsFactory(),
+			new nvidia::iofx::RandomSubtextureModifierParamsFactory(),
+			new nvidia::iofx::RandomRotationModifierParamsFactory(),
+			new nvidia::iofx::ViewDirectionSortingModifierParamsFactory(),
+			new nvidia::iofx::RotationRateModifierParamsFactory(),
+			new nvidia::iofx::RotationRateVsLifeModifierParamsFactory(),
+			new nvidia::iofx::OrientScaleAlongScreenVelocityModifierParamsFactory(),
+			new nvidia::iofx::ColorVsVelocityModifierParamsFactory(),
+			new nvidia::iofx::ColorVsVelocityCompositeModifierParamsFactory(),
+			new nvidia::iofx::ColorVsTemperatureModifierParamsFactory(),
+			new nvidia::iofx::ColorVsTemperatureCompositeModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsTemperatureModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsTemperature3DModifierParamsFactory(),
+			new nvidia::iofx::ScaleVsTemperature2DModifierParamsFactory(),
+			new nvidia::iofx::IofxModuleParametersFactory(),
+
+		};
+
+		for (size_t i = 0; i < sizeof(factoriesToUnregister)/sizeof(factoriesToUnregister[0]); ++i)
+		{
+			::NvParameterized::Factory* removedFactory = parameterizedTraits.removeFactory(factoriesToUnregister[i]->getClassName(), factoriesToUnregister[i]->getVersion());
+			if (!removedFactory) 
+			{
+				PX_ASSERT_WITH_MESSAGE(0, "Factory can not be removed!");
+			}
+			else
+			{
+				removedFactory->freeParameterDefinitionTable(&parameterizedTraits);
+				delete removedFactory;
+				delete factoriesToUnregister[i];
+			}
+		}
+	}
+
+	virtual void unregisterAvailableConverters(NvParameterized::Traits& parameterizedTraits)
+	{
+// UNREGISTER GENERATED CONVERSION
+PX_UNUSED(parameterizedTraits);
+
+	}
+
+};
+
+
+}
+} //nvidia::iofx
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/OrientAlongVelocityModifierParams.h b/APEX_1.4/module/iofx/include/autogen/OrientAlongVelocityModifierParams.h
new file mode 100644
index 00000000..b1769c54
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/OrientAlongVelocityModifierParams.h
@@ -0,0 +1,230 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_OrientAlongVelocityModifierParams_h
+#define HEADER_OrientAlongVelocityModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace OrientAlongVelocityModifierParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxVec3 modelForward;
+
+};
+
+static const uint32_t checksum[] = { 0xbec07bae, 0xf99a7cd3, 0xa819cd23, 0xe75ba471, };
+
+} // namespace OrientAlongVelocityModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class OrientAlongVelocityModifierParams : public NvParameterized::NvParameters, public OrientAlongVelocityModifierParamsNS::ParametersStruct
+{
+public:
+	OrientAlongVelocityModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~OrientAlongVelocityModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("OrientAlongVelocityModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(OrientAlongVelocityModifierParamsNS::checksum);
+		return OrientAlongVelocityModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const OrientAlongVelocityModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		OrientAlongVelocityModifierParams* tmpThis = const_cast<OrientAlongVelocityModifierParams*>(this);
+		return *(static_cast<OrientAlongVelocityModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	OrientAlongVelocityModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<OrientAlongVelocityModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class OrientAlongVelocityModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		OrientAlongVelocityModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(OrientAlongVelocityModifierParams), OrientAlongVelocityModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, OrientAlongVelocityModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class OrientAlongVelocityModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(OrientAlongVelocityModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, OrientAlongVelocityModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, OrientAlongVelocityModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, OrientAlongVelocityModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class OrientAlongVelocityModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of OrientAlongVelocityModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (OrientAlongVelocityModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (OrientAlongVelocityModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (OrientAlongVelocityModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (OrientAlongVelocityModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (OrientAlongVelocityModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/OrientScaleAlongScreenVelocityModifierParams.h b/APEX_1.4/module/iofx/include/autogen/OrientScaleAlongScreenVelocityModifierParams.h
new file mode 100644
index 00000000..2cb0cdea
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/OrientScaleAlongScreenVelocityModifierParams.h
@@ -0,0 +1,232 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_OrientScaleAlongScreenVelocityModifierParams_h
+#define HEADER_OrientScaleAlongScreenVelocityModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace OrientScaleAlongScreenVelocityModifierParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float scalePerVelocity;
+	float scaleChangeLimit;
+	float scaleChangeDelay;
+
+};
+
+static const uint32_t checksum[] = { 0x2a151b3c, 0x4a3faff3, 0xb9e6ebc2, 0x6ec77c7c, };
+
+} // namespace OrientScaleAlongScreenVelocityModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class OrientScaleAlongScreenVelocityModifierParams : public NvParameterized::NvParameters, public OrientScaleAlongScreenVelocityModifierParamsNS::ParametersStruct
+{
+public:
+	OrientScaleAlongScreenVelocityModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~OrientScaleAlongScreenVelocityModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("OrientScaleAlongScreenVelocityModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)1;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(OrientScaleAlongScreenVelocityModifierParamsNS::checksum);
+		return OrientScaleAlongScreenVelocityModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const OrientScaleAlongScreenVelocityModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		OrientScaleAlongScreenVelocityModifierParams* tmpThis = const_cast<OrientScaleAlongScreenVelocityModifierParams*>(this);
+		return *(static_cast<OrientScaleAlongScreenVelocityModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	OrientScaleAlongScreenVelocityModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<OrientScaleAlongScreenVelocityModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class OrientScaleAlongScreenVelocityModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		OrientScaleAlongScreenVelocityModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(OrientScaleAlongScreenVelocityModifierParams), OrientScaleAlongScreenVelocityModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, OrientScaleAlongScreenVelocityModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class OrientScaleAlongScreenVelocityModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(OrientScaleAlongScreenVelocityModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, OrientScaleAlongScreenVelocityModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, OrientScaleAlongScreenVelocityModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, OrientScaleAlongScreenVelocityModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class OrientScaleAlongScreenVelocityModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of OrientScaleAlongScreenVelocityModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (OrientScaleAlongScreenVelocityModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (OrientScaleAlongScreenVelocityModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (OrientScaleAlongScreenVelocityModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (OrientScaleAlongScreenVelocityModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (OrientScaleAlongScreenVelocityModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/RandomRotationModifierParams.h b/APEX_1.4/module/iofx/include/autogen/RandomRotationModifierParams.h
new file mode 100644
index 00000000..ee380621
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/RandomRotationModifierParams.h
@@ -0,0 +1,231 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_RandomRotationModifierParams_h
+#define HEADER_RandomRotationModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace RandomRotationModifierParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float minRotation;
+	float maxRotation;
+
+};
+
+static const uint32_t checksum[] = { 0xa4b51fa4, 0x02427ca9, 0xff6c9fc0, 0xe34b89b6, };
+
+} // namespace RandomRotationModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class RandomRotationModifierParams : public NvParameterized::NvParameters, public RandomRotationModifierParamsNS::ParametersStruct
+{
+public:
+	RandomRotationModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~RandomRotationModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("RandomRotationModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(RandomRotationModifierParamsNS::checksum);
+		return RandomRotationModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const RandomRotationModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		RandomRotationModifierParams* tmpThis = const_cast<RandomRotationModifierParams*>(this);
+		return *(static_cast<RandomRotationModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	RandomRotationModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<RandomRotationModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class RandomRotationModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		RandomRotationModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(RandomRotationModifierParams), RandomRotationModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, RandomRotationModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RandomRotationModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(RandomRotationModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, RandomRotationModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, RandomRotationModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, RandomRotationModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RandomRotationModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of RandomRotationModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (RandomRotationModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (RandomRotationModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (RandomRotationModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (RandomRotationModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (RandomRotationModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/RandomScaleModifierParams.h b/APEX_1.4/module/iofx/include/autogen/RandomScaleModifierParams.h
new file mode 100644
index 00000000..1463126a
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/RandomScaleModifierParams.h
@@ -0,0 +1,231 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_RandomScaleModifierParams_h
+#define HEADER_RandomScaleModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace RandomScaleModifierParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float minScaleFactor;
+	float maxScaleFactor;
+
+};
+
+static const uint32_t checksum[] = { 0x393214a5, 0x3920927a, 0x6b466949, 0x38714cd7, };
+
+} // namespace RandomScaleModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class RandomScaleModifierParams : public NvParameterized::NvParameters, public RandomScaleModifierParamsNS::ParametersStruct
+{
+public:
+	RandomScaleModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~RandomScaleModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("RandomScaleModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(RandomScaleModifierParamsNS::checksum);
+		return RandomScaleModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const RandomScaleModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		RandomScaleModifierParams* tmpThis = const_cast<RandomScaleModifierParams*>(this);
+		return *(static_cast<RandomScaleModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	RandomScaleModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<RandomScaleModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class RandomScaleModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		RandomScaleModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(RandomScaleModifierParams), RandomScaleModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, RandomScaleModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RandomScaleModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(RandomScaleModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, RandomScaleModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, RandomScaleModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, RandomScaleModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RandomScaleModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of RandomScaleModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (RandomScaleModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (RandomScaleModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (RandomScaleModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (RandomScaleModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (RandomScaleModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/RandomSubtextureModifierParams.h b/APEX_1.4/module/iofx/include/autogen/RandomSubtextureModifierParams.h
new file mode 100644
index 00000000..78afe359
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/RandomSubtextureModifierParams.h
@@ -0,0 +1,231 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_RandomSubtextureModifierParams_h
+#define HEADER_RandomSubtextureModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace RandomSubtextureModifierParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float minSubtexture;
+	float maxSubtexture;
+
+};
+
+static const uint32_t checksum[] = { 0x08f8796a, 0xa2e2f9c5, 0x8997cd3a, 0xc27f7e3a, };
+
+} // namespace RandomSubtextureModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class RandomSubtextureModifierParams : public NvParameterized::NvParameters, public RandomSubtextureModifierParamsNS::ParametersStruct
+{
+public:
+	RandomSubtextureModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~RandomSubtextureModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("RandomSubtextureModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(RandomSubtextureModifierParamsNS::checksum);
+		return RandomSubtextureModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const RandomSubtextureModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		RandomSubtextureModifierParams* tmpThis = const_cast<RandomSubtextureModifierParams*>(this);
+		return *(static_cast<RandomSubtextureModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	RandomSubtextureModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<RandomSubtextureModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class RandomSubtextureModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		RandomSubtextureModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(RandomSubtextureModifierParams), RandomSubtextureModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, RandomSubtextureModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RandomSubtextureModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(RandomSubtextureModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, RandomSubtextureModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, RandomSubtextureModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, RandomSubtextureModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RandomSubtextureModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of RandomSubtextureModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (RandomSubtextureModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (RandomSubtextureModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (RandomSubtextureModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (RandomSubtextureModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (RandomSubtextureModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/RotationModifierParams.h b/APEX_1.4/module/iofx/include/autogen/RotationModifierParams.h
new file mode 100644
index 00000000..4bc2a457
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/RotationModifierParams.h
@@ -0,0 +1,235 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_RotationModifierParams_h
+#define HEADER_RotationModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace RotationModifierParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	const char* rollType;
+	float maxRotationRatePerSec;
+	float maxSettleRatePerSec;
+	float inAirRotationMultiplier;
+	float collisionRotationMultiplier;
+	bool includeVerticalDirection;
+
+};
+
+static const uint32_t checksum[] = { 0xd2cf5d27, 0xa1732803, 0xcaa84b84, 0x18ed9e7c, };
+
+} // namespace RotationModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class RotationModifierParams : public NvParameterized::NvParameters, public RotationModifierParamsNS::ParametersStruct
+{
+public:
+	RotationModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~RotationModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("RotationModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)2;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(RotationModifierParamsNS::checksum);
+		return RotationModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const RotationModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		RotationModifierParams* tmpThis = const_cast<RotationModifierParams*>(this);
+		return *(static_cast<RotationModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	RotationModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<RotationModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class RotationModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		RotationModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(RotationModifierParams), RotationModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, RotationModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RotationModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(RotationModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, RotationModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, RotationModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, RotationModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RotationModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of RotationModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (RotationModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (RotationModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (RotationModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (RotationModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (RotationModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/RotationRateModifierParams.h b/APEX_1.4/module/iofx/include/autogen/RotationRateModifierParams.h
new file mode 100644
index 00000000..5290b1ae
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/RotationRateModifierParams.h
@@ -0,0 +1,230 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_RotationRateModifierParams_h
+#define HEADER_RotationRateModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace RotationRateModifierParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float rotationRate;
+
+};
+
+static const uint32_t checksum[] = { 0x250808c0, 0x4e8042ab, 0x9e0339e9, 0x3130e44d, };
+
+} // namespace RotationRateModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class RotationRateModifierParams : public NvParameterized::NvParameters, public RotationRateModifierParamsNS::ParametersStruct
+{
+public:
+	RotationRateModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~RotationRateModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("RotationRateModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(RotationRateModifierParamsNS::checksum);
+		return RotationRateModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const RotationRateModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		RotationRateModifierParams* tmpThis = const_cast<RotationRateModifierParams*>(this);
+		return *(static_cast<RotationRateModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	RotationRateModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<RotationRateModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class RotationRateModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		RotationRateModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(RotationRateModifierParams), RotationRateModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, RotationRateModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RotationRateModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(RotationRateModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, RotationRateModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, RotationRateModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, RotationRateModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RotationRateModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of RotationRateModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (RotationRateModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (RotationRateModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (RotationRateModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (RotationRateModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (RotationRateModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/RotationRateVsLifeModifierParams.h b/APEX_1.4/module/iofx/include/autogen/RotationRateVsLifeModifierParams.h
new file mode 100644
index 00000000..4ab0547f
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/RotationRateVsLifeModifierParams.h
@@ -0,0 +1,244 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_RotationRateVsLifeModifierParams_h
+#define HEADER_RotationRateVsLifeModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace RotationRateVsLifeModifierParamsNS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x704cda91, 0xcc96c538, 0x11f054f6, 0xa3fc1c9e, };
+
+} // namespace RotationRateVsLifeModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class RotationRateVsLifeModifierParams : public NvParameterized::NvParameters, public RotationRateVsLifeModifierParamsNS::ParametersStruct
+{
+public:
+	RotationRateVsLifeModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~RotationRateVsLifeModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("RotationRateVsLifeModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(RotationRateVsLifeModifierParamsNS::checksum);
+		return RotationRateVsLifeModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const RotationRateVsLifeModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		RotationRateVsLifeModifierParams* tmpThis = const_cast<RotationRateVsLifeModifierParams*>(this);
+		return *(static_cast<RotationRateVsLifeModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	RotationRateVsLifeModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<RotationRateVsLifeModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class RotationRateVsLifeModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		RotationRateVsLifeModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(RotationRateVsLifeModifierParams), RotationRateVsLifeModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, RotationRateVsLifeModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RotationRateVsLifeModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(RotationRateVsLifeModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, RotationRateVsLifeModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, RotationRateVsLifeModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, RotationRateVsLifeModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RotationRateVsLifeModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of RotationRateVsLifeModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (RotationRateVsLifeModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (RotationRateVsLifeModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (RotationRateVsLifeModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (RotationRateVsLifeModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (RotationRateVsLifeModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ScaleAlongVelocityModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ScaleAlongVelocityModifierParams.h
new file mode 100644
index 00000000..c6ae8535
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ScaleAlongVelocityModifierParams.h
@@ -0,0 +1,230 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ScaleAlongVelocityModifierParams_h
+#define HEADER_ScaleAlongVelocityModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ScaleAlongVelocityModifierParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float scaleFactor;
+
+};
+
+static const uint32_t checksum[] = { 0x3c361211, 0x221d234b, 0x639bf597, 0xcca2608b, };
+
+} // namespace ScaleAlongVelocityModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleAlongVelocityModifierParams : public NvParameterized::NvParameters, public ScaleAlongVelocityModifierParamsNS::ParametersStruct
+{
+public:
+	ScaleAlongVelocityModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleAlongVelocityModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleAlongVelocityModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ScaleAlongVelocityModifierParamsNS::checksum);
+		return ScaleAlongVelocityModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleAlongVelocityModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ScaleAlongVelocityModifierParams* tmpThis = const_cast<ScaleAlongVelocityModifierParams*>(this);
+		return *(static_cast<ScaleAlongVelocityModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleAlongVelocityModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleAlongVelocityModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ScaleAlongVelocityModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleAlongVelocityModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleAlongVelocityModifierParams), ScaleAlongVelocityModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleAlongVelocityModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleAlongVelocityModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleAlongVelocityModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleAlongVelocityModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleAlongVelocityModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleAlongVelocityModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleAlongVelocityModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleAlongVelocityModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ScaleAlongVelocityModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleAlongVelocityModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleAlongVelocityModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleAlongVelocityModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleAlongVelocityModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ScaleByMassModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ScaleByMassModifierParams.h
new file mode 100644
index 00000000..27735cc6
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ScaleByMassModifierParams.h
@@ -0,0 +1,229 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ScaleByMassModifierParams_h
+#define HEADER_ScaleByMassModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ScaleByMassModifierParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+
+};
+
+static const uint32_t checksum[] = { 0x0164ba51, 0x109896dc, 0x1c51ccab, 0xc0cebd7a, };
+
+} // namespace ScaleByMassModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleByMassModifierParams : public NvParameterized::NvParameters, public ScaleByMassModifierParamsNS::ParametersStruct
+{
+public:
+	ScaleByMassModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleByMassModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleByMassModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ScaleByMassModifierParamsNS::checksum);
+		return ScaleByMassModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleByMassModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ScaleByMassModifierParams* tmpThis = const_cast<ScaleByMassModifierParams*>(this);
+		return *(static_cast<ScaleByMassModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleByMassModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleByMassModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ScaleByMassModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleByMassModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleByMassModifierParams), ScaleByMassModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleByMassModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleByMassModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleByMassModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleByMassModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleByMassModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleByMassModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleByMassModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleByMassModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ScaleByMassModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleByMassModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleByMassModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleByMassModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleByMassModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ScaleVsCameraDistance2DModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ScaleVsCameraDistance2DModifierParams.h
new file mode 100644
index 00000000..9addb5c9
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ScaleVsCameraDistance2DModifierParams.h
@@ -0,0 +1,244 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ScaleVsCameraDistance2DModifierParams_h
+#define HEADER_ScaleVsCameraDistance2DModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ScaleVsCameraDistance2DModifierParamsNS
+{
+
+struct scaleCameraDistanceStruct_Type;
+
+struct scaleCameraDistanceStruct_DynamicArray1D_Type
+{
+	scaleCameraDistanceStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct scaleCameraDistanceStruct_Type
+{
+	float cameraDistance;
+	physx::PxVec2 scale;
+};
+
+struct ParametersStruct
+{
+
+	scaleCameraDistanceStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0xa1847ef6, 0x35e96cc6, 0xd3de86e9, 0x977d685a, };
+
+} // namespace ScaleVsCameraDistance2DModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsCameraDistance2DModifierParams : public NvParameterized::NvParameters, public ScaleVsCameraDistance2DModifierParamsNS::ParametersStruct
+{
+public:
+	ScaleVsCameraDistance2DModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsCameraDistance2DModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsCameraDistance2DModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ScaleVsCameraDistance2DModifierParamsNS::checksum);
+		return ScaleVsCameraDistance2DModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsCameraDistance2DModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsCameraDistance2DModifierParams* tmpThis = const_cast<ScaleVsCameraDistance2DModifierParams*>(this);
+		return *(static_cast<ScaleVsCameraDistance2DModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsCameraDistance2DModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsCameraDistance2DModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ScaleVsCameraDistance2DModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsCameraDistance2DModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsCameraDistance2DModifierParams), ScaleVsCameraDistance2DModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsCameraDistance2DModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsCameraDistance2DModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsCameraDistance2DModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsCameraDistance2DModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsCameraDistance2DModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsCameraDistance2DModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsCameraDistance2DModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsCameraDistance2DModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ScaleVsCameraDistance2DModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsCameraDistance2DModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsCameraDistance2DModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsCameraDistance2DModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsCameraDistance2DModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ScaleVsCameraDistance3DModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ScaleVsCameraDistance3DModifierParams.h
new file mode 100644
index 00000000..715ac901
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ScaleVsCameraDistance3DModifierParams.h
@@ -0,0 +1,244 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ScaleVsCameraDistance3DModifierParams_h
+#define HEADER_ScaleVsCameraDistance3DModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ScaleVsCameraDistance3DModifierParamsNS
+{
+
+struct scaleCameraDistanceStruct_Type;
+
+struct scaleCameraDistanceStruct_DynamicArray1D_Type
+{
+	scaleCameraDistanceStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct scaleCameraDistanceStruct_Type
+{
+	float cameraDistance;
+	physx::PxVec3 scale;
+};
+
+struct ParametersStruct
+{
+
+	scaleCameraDistanceStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x661390b6, 0x5566a427, 0x6507630a, 0x6aff3b6e, };
+
+} // namespace ScaleVsCameraDistance3DModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsCameraDistance3DModifierParams : public NvParameterized::NvParameters, public ScaleVsCameraDistance3DModifierParamsNS::ParametersStruct
+{
+public:
+	ScaleVsCameraDistance3DModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsCameraDistance3DModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsCameraDistance3DModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ScaleVsCameraDistance3DModifierParamsNS::checksum);
+		return ScaleVsCameraDistance3DModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsCameraDistance3DModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsCameraDistance3DModifierParams* tmpThis = const_cast<ScaleVsCameraDistance3DModifierParams*>(this);
+		return *(static_cast<ScaleVsCameraDistance3DModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsCameraDistance3DModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsCameraDistance3DModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ScaleVsCameraDistance3DModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsCameraDistance3DModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsCameraDistance3DModifierParams), ScaleVsCameraDistance3DModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsCameraDistance3DModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsCameraDistance3DModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsCameraDistance3DModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsCameraDistance3DModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsCameraDistance3DModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsCameraDistance3DModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsCameraDistance3DModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsCameraDistance3DModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ScaleVsCameraDistance3DModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsCameraDistance3DModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsCameraDistance3DModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsCameraDistance3DModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsCameraDistance3DModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ScaleVsCameraDistanceModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ScaleVsCameraDistanceModifierParams.h
new file mode 100644
index 00000000..253eabce
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ScaleVsCameraDistanceModifierParams.h
@@ -0,0 +1,245 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ScaleVsCameraDistanceModifierParams_h
+#define HEADER_ScaleVsCameraDistanceModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ScaleVsCameraDistanceModifierParamsNS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	const char* scaleAxis;
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x2c4aba3d, 0xa1d08f53, 0xfb08d5f3, 0xe12927dd, };
+
+} // namespace ScaleVsCameraDistanceModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsCameraDistanceModifierParams : public NvParameterized::NvParameters, public ScaleVsCameraDistanceModifierParamsNS::ParametersStruct
+{
+public:
+	ScaleVsCameraDistanceModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsCameraDistanceModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsCameraDistanceModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ScaleVsCameraDistanceModifierParamsNS::checksum);
+		return ScaleVsCameraDistanceModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsCameraDistanceModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsCameraDistanceModifierParams* tmpThis = const_cast<ScaleVsCameraDistanceModifierParams*>(this);
+		return *(static_cast<ScaleVsCameraDistanceModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsCameraDistanceModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsCameraDistanceModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ScaleVsCameraDistanceModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsCameraDistanceModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsCameraDistanceModifierParams), ScaleVsCameraDistanceModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsCameraDistanceModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsCameraDistanceModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsCameraDistanceModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsCameraDistanceModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsCameraDistanceModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsCameraDistanceModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsCameraDistanceModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsCameraDistanceModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ScaleVsCameraDistanceModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsCameraDistanceModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsCameraDistanceModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsCameraDistanceModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsCameraDistanceModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ScaleVsDensity2DModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ScaleVsDensity2DModifierParams.h
new file mode 100644
index 00000000..fb5f0e4f
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ScaleVsDensity2DModifierParams.h
@@ -0,0 +1,244 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ScaleVsDensity2DModifierParams_h
+#define HEADER_ScaleVsDensity2DModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ScaleVsDensity2DModifierParamsNS
+{
+
+struct scaleDensityStruct_Type;
+
+struct scaleDensityStruct_DynamicArray1D_Type
+{
+	scaleDensityStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct scaleDensityStruct_Type
+{
+	float density;
+	physx::PxVec2 scale;
+};
+
+struct ParametersStruct
+{
+
+	scaleDensityStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x67c772d8, 0x2f573535, 0xdd3f3715, 0xea4c896d, };
+
+} // namespace ScaleVsDensity2DModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsDensity2DModifierParams : public NvParameterized::NvParameters, public ScaleVsDensity2DModifierParamsNS::ParametersStruct
+{
+public:
+	ScaleVsDensity2DModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsDensity2DModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsDensity2DModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ScaleVsDensity2DModifierParamsNS::checksum);
+		return ScaleVsDensity2DModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsDensity2DModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsDensity2DModifierParams* tmpThis = const_cast<ScaleVsDensity2DModifierParams*>(this);
+		return *(static_cast<ScaleVsDensity2DModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsDensity2DModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsDensity2DModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ScaleVsDensity2DModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsDensity2DModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsDensity2DModifierParams), ScaleVsDensity2DModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsDensity2DModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsDensity2DModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsDensity2DModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsDensity2DModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsDensity2DModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsDensity2DModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsDensity2DModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsDensity2DModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ScaleVsDensity2DModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsDensity2DModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsDensity2DModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsDensity2DModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsDensity2DModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ScaleVsDensity3DModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ScaleVsDensity3DModifierParams.h
new file mode 100644
index 00000000..de04c5b1
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ScaleVsDensity3DModifierParams.h
@@ -0,0 +1,244 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ScaleVsDensity3DModifierParams_h
+#define HEADER_ScaleVsDensity3DModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ScaleVsDensity3DModifierParamsNS
+{
+
+struct scaleDensityStruct_Type;
+
+struct scaleDensityStruct_DynamicArray1D_Type
+{
+	scaleDensityStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct scaleDensityStruct_Type
+{
+	float density;
+	physx::PxVec3 scale;
+};
+
+struct ParametersStruct
+{
+
+	scaleDensityStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x0dddf0d6, 0x459996e0, 0x32b4d7ce, 0x8e0d1b52, };
+
+} // namespace ScaleVsDensity3DModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsDensity3DModifierParams : public NvParameterized::NvParameters, public ScaleVsDensity3DModifierParamsNS::ParametersStruct
+{
+public:
+	ScaleVsDensity3DModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsDensity3DModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsDensity3DModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ScaleVsDensity3DModifierParamsNS::checksum);
+		return ScaleVsDensity3DModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsDensity3DModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsDensity3DModifierParams* tmpThis = const_cast<ScaleVsDensity3DModifierParams*>(this);
+		return *(static_cast<ScaleVsDensity3DModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsDensity3DModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsDensity3DModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ScaleVsDensity3DModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsDensity3DModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsDensity3DModifierParams), ScaleVsDensity3DModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsDensity3DModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsDensity3DModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsDensity3DModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsDensity3DModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsDensity3DModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsDensity3DModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsDensity3DModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsDensity3DModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ScaleVsDensity3DModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsDensity3DModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsDensity3DModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsDensity3DModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsDensity3DModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ScaleVsDensityModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ScaleVsDensityModifierParams.h
new file mode 100644
index 00000000..3e1b38ea
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ScaleVsDensityModifierParams.h
@@ -0,0 +1,245 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ScaleVsDensityModifierParams_h
+#define HEADER_ScaleVsDensityModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ScaleVsDensityModifierParamsNS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	const char* scaleAxis;
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x6f22ca8e, 0x609b223e, 0x81d9cacc, 0x9ca002f4, };
+
+} // namespace ScaleVsDensityModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsDensityModifierParams : public NvParameterized::NvParameters, public ScaleVsDensityModifierParamsNS::ParametersStruct
+{
+public:
+	ScaleVsDensityModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsDensityModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsDensityModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ScaleVsDensityModifierParamsNS::checksum);
+		return ScaleVsDensityModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsDensityModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsDensityModifierParams* tmpThis = const_cast<ScaleVsDensityModifierParams*>(this);
+		return *(static_cast<ScaleVsDensityModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsDensityModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsDensityModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ScaleVsDensityModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsDensityModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsDensityModifierParams), ScaleVsDensityModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsDensityModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsDensityModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsDensityModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsDensityModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsDensityModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsDensityModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsDensityModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsDensityModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ScaleVsDensityModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsDensityModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsDensityModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsDensityModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsDensityModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ScaleVsLife2DModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ScaleVsLife2DModifierParams.h
new file mode 100644
index 00000000..7b51e51b
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ScaleVsLife2DModifierParams.h
@@ -0,0 +1,244 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ScaleVsLife2DModifierParams_h
+#define HEADER_ScaleVsLife2DModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ScaleVsLife2DModifierParamsNS
+{
+
+struct scaleLifeStruct_Type;
+
+struct scaleLifeStruct_DynamicArray1D_Type
+{
+	scaleLifeStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct scaleLifeStruct_Type
+{
+	float lifeRemaining;
+	physx::PxVec2 scale;
+};
+
+struct ParametersStruct
+{
+
+	scaleLifeStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x6db3956a, 0xa58c530d, 0xff315c26, 0xddb49833, };
+
+} // namespace ScaleVsLife2DModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsLife2DModifierParams : public NvParameterized::NvParameters, public ScaleVsLife2DModifierParamsNS::ParametersStruct
+{
+public:
+	ScaleVsLife2DModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsLife2DModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsLife2DModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ScaleVsLife2DModifierParamsNS::checksum);
+		return ScaleVsLife2DModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsLife2DModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsLife2DModifierParams* tmpThis = const_cast<ScaleVsLife2DModifierParams*>(this);
+		return *(static_cast<ScaleVsLife2DModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsLife2DModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsLife2DModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ScaleVsLife2DModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsLife2DModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsLife2DModifierParams), ScaleVsLife2DModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsLife2DModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsLife2DModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsLife2DModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsLife2DModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsLife2DModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsLife2DModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsLife2DModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsLife2DModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ScaleVsLife2DModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsLife2DModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsLife2DModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsLife2DModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsLife2DModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ScaleVsLife3DModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ScaleVsLife3DModifierParams.h
new file mode 100644
index 00000000..d1dcb372
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ScaleVsLife3DModifierParams.h
@@ -0,0 +1,244 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ScaleVsLife3DModifierParams_h
+#define HEADER_ScaleVsLife3DModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ScaleVsLife3DModifierParamsNS
+{
+
+struct scaleLifeStruct_Type;
+
+struct scaleLifeStruct_DynamicArray1D_Type
+{
+	scaleLifeStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct scaleLifeStruct_Type
+{
+	float lifeRemaining;
+	physx::PxVec3 scale;
+};
+
+struct ParametersStruct
+{
+
+	scaleLifeStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0xbaddcfda, 0x2f4deda9, 0x2c23286e, 0xf19659fd, };
+
+} // namespace ScaleVsLife3DModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsLife3DModifierParams : public NvParameterized::NvParameters, public ScaleVsLife3DModifierParamsNS::ParametersStruct
+{
+public:
+	ScaleVsLife3DModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsLife3DModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsLife3DModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ScaleVsLife3DModifierParamsNS::checksum);
+		return ScaleVsLife3DModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsLife3DModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsLife3DModifierParams* tmpThis = const_cast<ScaleVsLife3DModifierParams*>(this);
+		return *(static_cast<ScaleVsLife3DModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsLife3DModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsLife3DModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ScaleVsLife3DModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsLife3DModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsLife3DModifierParams), ScaleVsLife3DModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsLife3DModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsLife3DModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsLife3DModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsLife3DModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsLife3DModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsLife3DModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsLife3DModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsLife3DModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ScaleVsLife3DModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsLife3DModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsLife3DModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsLife3DModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsLife3DModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ScaleVsLifeModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ScaleVsLifeModifierParams.h
new file mode 100644
index 00000000..d087f4bc
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ScaleVsLifeModifierParams.h
@@ -0,0 +1,245 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ScaleVsLifeModifierParams_h
+#define HEADER_ScaleVsLifeModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ScaleVsLifeModifierParamsNS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	const char* scaleAxis;
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0xfed4c822, 0x131f7e2d, 0x1bedc356, 0xcbf77236, };
+
+} // namespace ScaleVsLifeModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsLifeModifierParams : public NvParameterized::NvParameters, public ScaleVsLifeModifierParamsNS::ParametersStruct
+{
+public:
+	ScaleVsLifeModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsLifeModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsLifeModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ScaleVsLifeModifierParamsNS::checksum);
+		return ScaleVsLifeModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsLifeModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsLifeModifierParams* tmpThis = const_cast<ScaleVsLifeModifierParams*>(this);
+		return *(static_cast<ScaleVsLifeModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsLifeModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsLifeModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ScaleVsLifeModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsLifeModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsLifeModifierParams), ScaleVsLifeModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsLifeModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsLifeModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsLifeModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsLifeModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsLifeModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsLifeModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsLifeModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsLifeModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ScaleVsLifeModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsLifeModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsLifeModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsLifeModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsLifeModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ScaleVsTemperature2DModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ScaleVsTemperature2DModifierParams.h
new file mode 100644
index 00000000..59ebbf6d
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ScaleVsTemperature2DModifierParams.h
@@ -0,0 +1,244 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ScaleVsTemperature2DModifierParams_h
+#define HEADER_ScaleVsTemperature2DModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ScaleVsTemperature2DModifierParamsNS
+{
+
+struct scaleTemperatureStruct_Type;
+
+struct scaleTemperatureStruct_DynamicArray1D_Type
+{
+	scaleTemperatureStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct scaleTemperatureStruct_Type
+{
+	float temperature;
+	physx::PxVec2 scale;
+};
+
+struct ParametersStruct
+{
+
+	scaleTemperatureStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0xd5330296, 0xc6fa1947, 0x152d1b30, 0x07453e5c, };
+
+} // namespace ScaleVsTemperature2DModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsTemperature2DModifierParams : public NvParameterized::NvParameters, public ScaleVsTemperature2DModifierParamsNS::ParametersStruct
+{
+public:
+	ScaleVsTemperature2DModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsTemperature2DModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsTemperature2DModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ScaleVsTemperature2DModifierParamsNS::checksum);
+		return ScaleVsTemperature2DModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsTemperature2DModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsTemperature2DModifierParams* tmpThis = const_cast<ScaleVsTemperature2DModifierParams*>(this);
+		return *(static_cast<ScaleVsTemperature2DModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsTemperature2DModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsTemperature2DModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ScaleVsTemperature2DModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsTemperature2DModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsTemperature2DModifierParams), ScaleVsTemperature2DModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsTemperature2DModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsTemperature2DModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsTemperature2DModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsTemperature2DModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsTemperature2DModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsTemperature2DModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsTemperature2DModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsTemperature2DModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ScaleVsTemperature2DModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsTemperature2DModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsTemperature2DModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsTemperature2DModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsTemperature2DModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ScaleVsTemperature3DModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ScaleVsTemperature3DModifierParams.h
new file mode 100644
index 00000000..986e223b
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ScaleVsTemperature3DModifierParams.h
@@ -0,0 +1,244 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ScaleVsTemperature3DModifierParams_h
+#define HEADER_ScaleVsTemperature3DModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ScaleVsTemperature3DModifierParamsNS
+{
+
+struct scaleTemperatureStruct_Type;
+
+struct scaleTemperatureStruct_DynamicArray1D_Type
+{
+	scaleTemperatureStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct scaleTemperatureStruct_Type
+{
+	float temperature;
+	physx::PxVec3 scale;
+};
+
+struct ParametersStruct
+{
+
+	scaleTemperatureStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x25b25469, 0xa653dacc, 0x1c3167df, 0xd3a6b16f, };
+
+} // namespace ScaleVsTemperature3DModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsTemperature3DModifierParams : public NvParameterized::NvParameters, public ScaleVsTemperature3DModifierParamsNS::ParametersStruct
+{
+public:
+	ScaleVsTemperature3DModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsTemperature3DModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsTemperature3DModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ScaleVsTemperature3DModifierParamsNS::checksum);
+		return ScaleVsTemperature3DModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsTemperature3DModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsTemperature3DModifierParams* tmpThis = const_cast<ScaleVsTemperature3DModifierParams*>(this);
+		return *(static_cast<ScaleVsTemperature3DModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsTemperature3DModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsTemperature3DModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ScaleVsTemperature3DModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsTemperature3DModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsTemperature3DModifierParams), ScaleVsTemperature3DModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsTemperature3DModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsTemperature3DModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsTemperature3DModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsTemperature3DModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsTemperature3DModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsTemperature3DModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsTemperature3DModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsTemperature3DModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ScaleVsTemperature3DModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsTemperature3DModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsTemperature3DModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsTemperature3DModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsTemperature3DModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ScaleVsTemperatureModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ScaleVsTemperatureModifierParams.h
new file mode 100644
index 00000000..5d4ee275
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ScaleVsTemperatureModifierParams.h
@@ -0,0 +1,245 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ScaleVsTemperatureModifierParams_h
+#define HEADER_ScaleVsTemperatureModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ScaleVsTemperatureModifierParamsNS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	const char* scaleAxis;
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0xd0fc7da0, 0x19500653, 0x8b0cfc22, 0xa80392bd, };
+
+} // namespace ScaleVsTemperatureModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsTemperatureModifierParams : public NvParameterized::NvParameters, public ScaleVsTemperatureModifierParamsNS::ParametersStruct
+{
+public:
+	ScaleVsTemperatureModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsTemperatureModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsTemperatureModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ScaleVsTemperatureModifierParamsNS::checksum);
+		return ScaleVsTemperatureModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsTemperatureModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsTemperatureModifierParams* tmpThis = const_cast<ScaleVsTemperatureModifierParams*>(this);
+		return *(static_cast<ScaleVsTemperatureModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsTemperatureModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsTemperatureModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ScaleVsTemperatureModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsTemperatureModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsTemperatureModifierParams), ScaleVsTemperatureModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsTemperatureModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsTemperatureModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsTemperatureModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsTemperatureModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsTemperatureModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsTemperatureModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsTemperatureModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsTemperatureModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ScaleVsTemperatureModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsTemperatureModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsTemperatureModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsTemperatureModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsTemperatureModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/SimpleScaleModifierParams.h b/APEX_1.4/module/iofx/include/autogen/SimpleScaleModifierParams.h
new file mode 100644
index 00000000..cc86d886
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/SimpleScaleModifierParams.h
@@ -0,0 +1,230 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_SimpleScaleModifierParams_h
+#define HEADER_SimpleScaleModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace SimpleScaleModifierParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxVec3 scaleFactor;
+
+};
+
+static const uint32_t checksum[] = { 0x7a1ac6ca, 0x76ef1cd2, 0x991bfe05, 0x30c11a09, };
+
+} // namespace SimpleScaleModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class SimpleScaleModifierParams : public NvParameterized::NvParameters, public SimpleScaleModifierParamsNS::ParametersStruct
+{
+public:
+	SimpleScaleModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~SimpleScaleModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("SimpleScaleModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(SimpleScaleModifierParamsNS::checksum);
+		return SimpleScaleModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const SimpleScaleModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		SimpleScaleModifierParams* tmpThis = const_cast<SimpleScaleModifierParams*>(this);
+		return *(static_cast<SimpleScaleModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	SimpleScaleModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<SimpleScaleModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class SimpleScaleModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		SimpleScaleModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(SimpleScaleModifierParams), SimpleScaleModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, SimpleScaleModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SimpleScaleModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(SimpleScaleModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, SimpleScaleModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, SimpleScaleModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, SimpleScaleModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SimpleScaleModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of SimpleScaleModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (SimpleScaleModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (SimpleScaleModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (SimpleScaleModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (SimpleScaleModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (SimpleScaleModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/SpriteIofxParameters.h b/APEX_1.4/module/iofx/include/autogen/SpriteIofxParameters.h
new file mode 100644
index 00000000..28292c11
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/SpriteIofxParameters.h
@@ -0,0 +1,240 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_SpriteIofxParameters_h
+#define HEADER_SpriteIofxParameters_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace SpriteIofxParametersNS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::Interface* spriteMaterialName;
+	REF_DynamicArray1D_Type spawnModifierList;
+	REF_DynamicArray1D_Type continuousModifierList;
+
+};
+
+static const uint32_t checksum[] = { 0x9763d523, 0x7dae1ae1, 0x3bb7aa9d, 0x67a8d368, };
+
+} // namespace SpriteIofxParametersNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class SpriteIofxParameters : public NvParameterized::NvParameters, public SpriteIofxParametersNS::ParametersStruct
+{
+public:
+	SpriteIofxParameters(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~SpriteIofxParameters();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("SpriteIofxParameters");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)4;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(SpriteIofxParametersNS::checksum);
+		return SpriteIofxParametersNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const SpriteIofxParametersNS::ParametersStruct& parameters(void) const
+	{
+		SpriteIofxParameters* tmpThis = const_cast<SpriteIofxParameters*>(this);
+		return *(static_cast<SpriteIofxParametersNS::ParametersStruct*>(tmpThis));
+	}
+
+	SpriteIofxParametersNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<SpriteIofxParametersNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class SpriteIofxParametersFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		SpriteIofxParameters::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(SpriteIofxParameters), SpriteIofxParameters::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, SpriteIofxParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SpriteIofxParameters");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(SpriteIofxParameters)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, SpriteIofxParameters)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, SpriteIofxParameters::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, SpriteIofxParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SpriteIofxParameters");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of SpriteIofxParameters here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (SpriteIofxParameters*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (SpriteIofxParameters::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (SpriteIofxParameters::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (SpriteIofxParameters::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (SpriteIofxParameters::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/SubtextureVsLifeModifierParams.h b/APEX_1.4/module/iofx/include/autogen/SubtextureVsLifeModifierParams.h
new file mode 100644
index 00000000..59793101
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/SubtextureVsLifeModifierParams.h
@@ -0,0 +1,244 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_SubtextureVsLifeModifierParams_h
+#define HEADER_SubtextureVsLifeModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace SubtextureVsLifeModifierParamsNS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x38be217d, 0xe6774f18, 0x591a0a04, 0x64e61b1e, };
+
+} // namespace SubtextureVsLifeModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class SubtextureVsLifeModifierParams : public NvParameterized::NvParameters, public SubtextureVsLifeModifierParamsNS::ParametersStruct
+{
+public:
+	SubtextureVsLifeModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~SubtextureVsLifeModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("SubtextureVsLifeModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(SubtextureVsLifeModifierParamsNS::checksum);
+		return SubtextureVsLifeModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const SubtextureVsLifeModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		SubtextureVsLifeModifierParams* tmpThis = const_cast<SubtextureVsLifeModifierParams*>(this);
+		return *(static_cast<SubtextureVsLifeModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	SubtextureVsLifeModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<SubtextureVsLifeModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class SubtextureVsLifeModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		SubtextureVsLifeModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(SubtextureVsLifeModifierParams), SubtextureVsLifeModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, SubtextureVsLifeModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SubtextureVsLifeModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(SubtextureVsLifeModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, SubtextureVsLifeModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, SubtextureVsLifeModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, SubtextureVsLifeModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SubtextureVsLifeModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of SubtextureVsLifeModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (SubtextureVsLifeModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (SubtextureVsLifeModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (SubtextureVsLifeModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (SubtextureVsLifeModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (SubtextureVsLifeModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/iofx/include/autogen/ViewDirectionSortingModifierParams.h b/APEX_1.4/module/iofx/include/autogen/ViewDirectionSortingModifierParams.h
new file mode 100644
index 00000000..eea2ddf0
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/autogen/ViewDirectionSortingModifierParams.h
@@ -0,0 +1,230 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ViewDirectionSortingModifierParams_h
+#define HEADER_ViewDirectionSortingModifierParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace iofx
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ViewDirectionSortingModifierParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	const char* sortType;
+
+};
+
+static const uint32_t checksum[] = { 0x273be54c, 0xc9bfbfeb, 0x0523921d, 0x48c3bc2d, };
+
+} // namespace ViewDirectionSortingModifierParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ViewDirectionSortingModifierParams : public NvParameterized::NvParameters, public ViewDirectionSortingModifierParamsNS::ParametersStruct
+{
+public:
+	ViewDirectionSortingModifierParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ViewDirectionSortingModifierParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ViewDirectionSortingModifierParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ViewDirectionSortingModifierParamsNS::checksum);
+		return ViewDirectionSortingModifierParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ViewDirectionSortingModifierParamsNS::ParametersStruct& parameters(void) const
+	{
+		ViewDirectionSortingModifierParams* tmpThis = const_cast<ViewDirectionSortingModifierParams*>(this);
+		return *(static_cast<ViewDirectionSortingModifierParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ViewDirectionSortingModifierParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ViewDirectionSortingModifierParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ViewDirectionSortingModifierParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ViewDirectionSortingModifierParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ViewDirectionSortingModifierParams), ViewDirectionSortingModifierParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ViewDirectionSortingModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ViewDirectionSortingModifierParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ViewDirectionSortingModifierParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ViewDirectionSortingModifierParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ViewDirectionSortingModifierParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ViewDirectionSortingModifierParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ViewDirectionSortingModifierParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ViewDirectionSortingModifierParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ViewDirectionSortingModifierParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ViewDirectionSortingModifierParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ViewDirectionSortingModifierParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ViewDirectionSortingModifierParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ViewDirectionSortingModifierParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace iofx
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif