Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

28 files changed, 6385 insertions, 0 deletions

diff --git a/APEX_1.4/module/framework_legacy/include/ConversionBufferF32x4_0p0_0p1.h b/APEX_1.4/module/framework_legacy/include/ConversionBufferF32x4_0p0_0p1.h
new file mode 100644
index 00000000..695f4c00
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/ConversionBufferF32x4_0p0_0p1.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#ifndef MODULE_CONVERSIONBUFFERF32X4_0P0_0P1H_H
+#define MODULE_CONVERSIONBUFFERF32X4_0P0_0P1H_H
+
+#include "NvParamConversionTemplate.h"
+#include "BufferF32x4_0p0.h"
+#include "BufferF32x4_0p1.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BufferF32x4_0p0, 
+						nvidia::parameterized::BufferF32x4_0p1, 
+						nvidia::parameterized::BufferF32x4_0p0::ClassVersion, 
+						nvidia::parameterized::BufferF32x4_0p1::ClassVersion>
+						ConversionBufferF32x4_0p0_0p1Parent;
+
+class ConversionBufferF32x4_0p0_0p1: public ConversionBufferF32x4_0p0_0p1Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionBufferF32x4_0p0_0p1));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionBufferF32x4_0p0_0p1)(t) : 0;
+	}
+
+protected:
+	ConversionBufferF32x4_0p0_0p1(NvParameterized::Traits* t) : ConversionBufferF32x4_0p0_0p1Parent(t) {}
+
+	const NvParameterized::PrefVer* getPreferredVersions() const
+	{
+		static NvParameterized::PrefVer prefVers[] =
+		{
+			//TODO:
+			//	Add your preferred versions for included references here.
+			//	Entry format is
+			//		{ (const char*)longName, (uint32_t)preferredVersion }
+
+			{ 0, 0 } // Terminator (do not remove!)
+		};
+
+		return prefVers;
+	}
+
+	bool convert()
+	{
+		//TODO:
+		//	Write custom conversion code here using mNewData and mLegacyData members.
+		//
+		//	Note that
+		//		- mNewData has already been initialized with default values
+		//		- same-named/same-typed members have already been copied
+		//			from mLegacyData to mNewData
+		//		- included references were moved to mNewData
+		//			(and updated to preferred versions according to getPreferredVersions)
+		//
+		//	For more info see the versioning wiki.
+
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/ConversionSubmeshParameters_0p0_0p1.h b/APEX_1.4/module/framework_legacy/include/ConversionSubmeshParameters_0p0_0p1.h
new file mode 100644
index 00000000..4416500e
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/ConversionSubmeshParameters_0p0_0p1.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#ifndef MODULE_CONVERSIONSUBMESHPARAMETERS_0P0_0P1H_H
+#define MODULE_CONVERSIONSUBMESHPARAMETERS_0P0_0P1H_H
+
+#include "NvParamConversionTemplate.h"
+#include "SubmeshParameters_0p0.h"
+#include "SubmeshParameters_0p1.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::SubmeshParameters_0p0, 
+						nvidia::parameterized::SubmeshParameters_0p1, 
+						nvidia::parameterized::SubmeshParameters_0p0::ClassVersion, 
+						nvidia::parameterized::SubmeshParameters_0p1::ClassVersion>
+						ConversionSubmeshParameters_0p0_0p1Parent;
+
+class ConversionSubmeshParameters_0p0_0p1: public ConversionSubmeshParameters_0p0_0p1Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionSubmeshParameters_0p0_0p1));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionSubmeshParameters_0p0_0p1)(t) : 0;
+	}
+
+protected:
+	ConversionSubmeshParameters_0p0_0p1(NvParameterized::Traits* t) : ConversionSubmeshParameters_0p0_0p1Parent(t) {}
+
+	const NvParameterized::PrefVer* getPreferredVersions() const
+	{
+		static NvParameterized::PrefVer prefVers[] =
+		{
+			//TODO:
+			//	Add your preferred versions for included references here.
+			//	Entry format is
+			//		{ (const char*)longName, (uint32_t)preferredVersion }
+
+			{ 0, 0 } // Terminator (do not remove!)
+		};
+
+		return prefVers;
+	}
+
+	bool convert()
+	{
+		//TODO:
+		//	Write custom conversion code here using mNewData and mLegacyData members.
+		//
+		//	Note that
+		//		- mNewData has already been initialized with default values
+		//		- same-named/same-typed members have already been copied
+		//			from mLegacyData to mNewData
+		//		- included references were moved to mNewData
+		//			(and updated to preferred versions according to getPreferredVersions)
+		//
+		//	For more info see the versioning wiki.
+
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/ConversionVertexBufferParameters_0p0_0p1.h b/APEX_1.4/module/framework_legacy/include/ConversionVertexBufferParameters_0p0_0p1.h
new file mode 100644
index 00000000..a4479d1f
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/ConversionVertexBufferParameters_0p0_0p1.h
@@ -0,0 +1,189 @@
+/*
+ * 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_CONVERSIONVERTEXBUFFERPARAMETERS_0P0_0P1H_H
+#define MODULE_CONVERSIONVERTEXBUFFERPARAMETERS_0P0_0P1H_H
+
+#include "NvParamConversionTemplate.h"
+#include "VertexBufferParameters_0p0.h"
+#include "VertexBufferParameters_0p1.h"
+
+#include "VertexFormatParameters.h"
+
+#include <BufferF32x1.h>
+#include <BufferU16x1.h>
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::VertexBufferParameters_0p0, 
+						nvidia::parameterized::VertexBufferParameters_0p1, 
+						nvidia::parameterized::VertexBufferParameters_0p0::ClassVersion, 
+						nvidia::parameterized::VertexBufferParameters_0p1::ClassVersion>
+						ConversionVertexBufferParameters_0p0_0p1Parent;
+
+class ConversionVertexBufferParameters_0p0_0p1: public ConversionVertexBufferParameters_0p0_0p1Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionVertexBufferParameters_0p0_0p1));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionVertexBufferParameters_0p0_0p1)(t) : 0;
+	}
+
+protected:
+	ConversionVertexBufferParameters_0p0_0p1(NvParameterized::Traits* t) : ConversionVertexBufferParameters_0p0_0p1Parent(t) {}
+
+	const NvParameterized::PrefVer* getPreferredVersions() const
+	{
+		static NvParameterized::PrefVer prefVers[] =
+		{
+			//TODO:
+			//	Add your preferred versions for included references here.
+			//	Entry format is
+			//		{ (const char *)longName, (uint32_t)preferredVersion }
+
+			{ "vertexFormat", 0 },
+			{ 0, 0 } // Terminator (do not remove!)
+		};
+
+		return prefVers;
+	}
+
+	bool convert()
+	{
+		//TODO:
+		//	Write custom conversion code here using mNewData and mLegacyData members.
+		//
+		//	Note that
+		//		- mNewData has already been initialized with default values
+		//		- same-named/same-typed members have already been copied
+		//			from mLegacyData to mNewData
+		//		- included references were moved to mNewData
+		//			(and updated to preferred versions according to getPreferredVersions)
+		//
+		//	For more info see the versioning wiki.
+
+
+
+		// if one of these fails it means that they have been upgraded. Then the proper (_0p0.h) files need to be included
+		// and the types also need the _0p0 suffix. Then it should work again.
+		PX_COMPILE_TIME_ASSERT(VertexFormatParameters::ClassVersion == 0);
+		PX_COMPILE_TIME_ASSERT(BufferF32x1::ClassVersion == 0);
+		PX_COMPILE_TIME_ASSERT(BufferU16x1::ClassVersion == 0);
+
+
+		VertexFormatParameters* format = static_cast<VertexFormatParameters*>(mNewData->vertexFormat);
+
+		int32_t boneWeightID = -1;
+		int32_t boneIndexID = -1;
+		uint32_t numBoneWeights = 0;
+		uint32_t numBoneIndices = 0;
+
+		for (uint32_t formatID = 0; formatID < (uint32_t)format->bufferFormats.arraySizes[0]; formatID++)
+		{
+			const uint32_t semantic = (uint32_t)format->bufferFormats.buf[formatID].semantic;
+			if (semantic == RenderVertexSemantic::BONE_INDEX)
+			{
+				boneIndexID = (int32_t)formatID;
+				switch (format->bufferFormats.buf[formatID].format)
+				{
+				case RenderDataFormat::USHORT1:	
+					numBoneIndices = 1;
+					break;
+				case RenderDataFormat::USHORT2:
+					numBoneIndices = 2;
+					break;
+				case RenderDataFormat::USHORT3:
+					numBoneIndices = 3;
+					break;
+				case RenderDataFormat::USHORT4:
+					numBoneIndices = 4;
+					break;
+				}
+			}
+			else if (semantic == RenderVertexSemantic::BONE_WEIGHT)
+			{
+				boneWeightID = (int32_t)formatID;
+				switch (format->bufferFormats.buf[formatID].format)
+				{
+				case RenderDataFormat::FLOAT1:
+					numBoneWeights = 1;
+					break;
+				case RenderDataFormat::FLOAT2:
+					numBoneWeights = 2;
+					break;
+				case RenderDataFormat::FLOAT3:
+					numBoneWeights = 3;
+					break;
+				case RenderDataFormat::FLOAT4:
+					numBoneWeights = 4;
+					break;
+				}
+			}
+		}
+
+
+		// sort bone weights
+		if (numBoneIndices > 1 && numBoneWeights == numBoneIndices)
+		{
+			float* boneWeightBuffer = static_cast<BufferF32x1*>(mNewData->buffers.buf[boneWeightID])->data.buf;
+			uint16_t* boneIndexBuffer = static_cast<BufferU16x1*>(mNewData->buffers.buf[boneIndexID])->data.buf;
+
+			for (uint32_t vi = 0; vi < mNewData->vertexCount; vi++)
+			{
+				float* verifyWeights = boneWeightBuffer + vi * numBoneWeights;
+				uint16_t* verifyIndices = boneIndexBuffer + vi * numBoneWeights;
+
+				float sum = 0.0f;
+				for (uint32_t j = 0; j < numBoneWeights; j++)
+				{
+					sum += verifyWeights[j];
+				}
+
+				if (physx::PxAbs(1 - sum) > 0.001)
+				{
+					if (sum > 0.0f)
+					{
+						for (uint32_t j = 0; j < numBoneWeights; j++)
+						{
+							verifyWeights[j] /= sum;
+						}
+					}
+				}
+
+				// PH: bubble sort, don't kill me for this
+				for (uint32_t j = 1; j < numBoneWeights; j++)
+				{
+					for (uint32_t k = 1; k < numBoneWeights; k++)
+					{
+						if (verifyWeights[k - 1] < verifyWeights[k])
+						{
+							nvidia::swap(verifyWeights[k - 1], verifyWeights[k]);
+							nvidia::swap(verifyIndices[k - 1], verifyIndices[k]);
+						}
+					}
+				}
+			}
+		}
+
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/BufferF32x1_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/BufferF32x1_0p0.h
new file mode 100644
index 00000000..2590fcd7
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/BufferF32x1_0p0.h
@@ -0,0 +1,238 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BufferF32x1_0p0_h
+#define HEADER_BufferF32x1_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BufferF32x1_0p0NS
+{
+
+
+struct F32_DynamicArray1D_Type
+{
+	float* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	F32_DynamicArray1D_Type data;
+
+};
+
+static const uint32_t checksum[] = { 0xcdd104f7, 0x061ac76e, 0xc255d951, 0x1e7cffef, };
+
+} // namespace BufferF32x1_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BufferF32x1_0p0 : public NvParameterized::NvParameters, public BufferF32x1_0p0NS::ParametersStruct
+{
+public:
+	BufferF32x1_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BufferF32x1_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BufferF32x1");
+	}
+
+	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(BufferF32x1_0p0NS::checksum);
+		return BufferF32x1_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BufferF32x1_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BufferF32x1_0p0* tmpThis = const_cast<BufferF32x1_0p0*>(this);
+		return *(static_cast<BufferF32x1_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BufferF32x1_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BufferF32x1_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BufferF32x1_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BufferF32x1_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BufferF32x1_0p0), BufferF32x1_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BufferF32x1_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferF32x1_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BufferF32x1_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BufferF32x1_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BufferF32x1_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BufferF32x1_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferF32x1_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BufferF32x1_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BufferF32x1_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BufferF32x1_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BufferF32x1_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BufferF32x1_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BufferF32x1_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/BufferF32x2_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/BufferF32x2_0p0.h
new file mode 100644
index 00000000..2b1027b9
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/BufferF32x2_0p0.h
@@ -0,0 +1,244 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BufferF32x2_0p0_h
+#define HEADER_BufferF32x2_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BufferF32x2_0p0NS
+{
+
+struct F32x2_Type;
+
+struct F32x2_DynamicArray1D_Type
+{
+	F32x2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct F32x2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	F32x2_DynamicArray1D_Type data;
+
+};
+
+static const uint32_t checksum[] = { 0x788349ee, 0x95c560e2, 0x9633945e, 0x8cc784a0, };
+
+} // namespace BufferF32x2_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BufferF32x2_0p0 : public NvParameterized::NvParameters, public BufferF32x2_0p0NS::ParametersStruct
+{
+public:
+	BufferF32x2_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BufferF32x2_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BufferF32x2");
+	}
+
+	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(BufferF32x2_0p0NS::checksum);
+		return BufferF32x2_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BufferF32x2_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BufferF32x2_0p0* tmpThis = const_cast<BufferF32x2_0p0*>(this);
+		return *(static_cast<BufferF32x2_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BufferF32x2_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BufferF32x2_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BufferF32x2_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BufferF32x2_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BufferF32x2_0p0), BufferF32x2_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BufferF32x2_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferF32x2_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BufferF32x2_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BufferF32x2_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BufferF32x2_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BufferF32x2_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferF32x2_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BufferF32x2_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BufferF32x2_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BufferF32x2_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BufferF32x2_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BufferF32x2_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BufferF32x2_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/BufferF32x3_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/BufferF32x3_0p0.h
new file mode 100644
index 00000000..1f98c01e
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/BufferF32x3_0p0.h
@@ -0,0 +1,245 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BufferF32x3_0p0_h
+#define HEADER_BufferF32x3_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BufferF32x3_0p0NS
+{
+
+struct F32x3_Type;
+
+struct VEC3_DynamicArray1D_Type
+{
+	physx::PxVec3* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct F32x3_Type
+{
+	float x;
+	float y;
+	float z;
+};
+
+struct ParametersStruct
+{
+
+	VEC3_DynamicArray1D_Type data;
+
+};
+
+static const uint32_t checksum[] = { 0x458b554a, 0x7ed3e930, 0x0299ff33, 0x9d69c11b, };
+
+} // namespace BufferF32x3_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BufferF32x3_0p0 : public NvParameterized::NvParameters, public BufferF32x3_0p0NS::ParametersStruct
+{
+public:
+	BufferF32x3_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BufferF32x3_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BufferF32x3");
+	}
+
+	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(BufferF32x3_0p0NS::checksum);
+		return BufferF32x3_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BufferF32x3_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BufferF32x3_0p0* tmpThis = const_cast<BufferF32x3_0p0*>(this);
+		return *(static_cast<BufferF32x3_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BufferF32x3_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BufferF32x3_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BufferF32x3_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BufferF32x3_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BufferF32x3_0p0), BufferF32x3_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BufferF32x3_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferF32x3_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BufferF32x3_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BufferF32x3_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BufferF32x3_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BufferF32x3_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferF32x3_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BufferF32x3_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BufferF32x3_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BufferF32x3_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BufferF32x3_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BufferF32x3_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BufferF32x3_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/BufferF32x4_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/BufferF32x4_0p0.h
new file mode 100644
index 00000000..c9f2d53d
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/BufferF32x4_0p0.h
@@ -0,0 +1,246 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BufferF32x4_0p0_h
+#define HEADER_BufferF32x4_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BufferF32x4_0p0NS
+{
+
+struct F32x4_Type;
+
+struct F32x4_DynamicArray1D_Type
+{
+	F32x4_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct F32x4_Type
+{
+	float x;
+	float y;
+	float z;
+	float w;
+};
+
+struct ParametersStruct
+{
+
+	F32x4_DynamicArray1D_Type data;
+
+};
+
+static const uint32_t checksum[] = { 0x012d3904, 0x3cb30964, 0xb8d324aa, 0x2a5b2583, };
+
+} // namespace BufferF32x4_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BufferF32x4_0p0 : public NvParameterized::NvParameters, public BufferF32x4_0p0NS::ParametersStruct
+{
+public:
+	BufferF32x4_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BufferF32x4_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BufferF32x4");
+	}
+
+	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(BufferF32x4_0p0NS::checksum);
+		return BufferF32x4_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BufferF32x4_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BufferF32x4_0p0* tmpThis = const_cast<BufferF32x4_0p0*>(this);
+		return *(static_cast<BufferF32x4_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BufferF32x4_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BufferF32x4_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BufferF32x4_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BufferF32x4_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BufferF32x4_0p0), BufferF32x4_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BufferF32x4_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferF32x4_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BufferF32x4_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BufferF32x4_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BufferF32x4_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BufferF32x4_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferF32x4_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BufferF32x4_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BufferF32x4_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BufferF32x4_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BufferF32x4_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BufferF32x4_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BufferF32x4_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/BufferF32x4_0p1.h b/APEX_1.4/module/framework_legacy/include/autogen/BufferF32x4_0p1.h
new file mode 100644
index 00000000..e6225d64
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/BufferF32x4_0p1.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_BufferF32x4_0p1_h
+#define HEADER_BufferF32x4_0p1_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BufferF32x4_0p1NS
+{
+
+struct F32x4_Type;
+
+struct F32x4_DynamicArray1D_Type
+{
+	F32x4_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct F32x4_Type
+{
+	PX_ALIGN(16, float x);
+	float y;
+	float z;
+	float w;
+};
+
+struct ParametersStruct
+{
+
+	F32x4_DynamicArray1D_Type data;
+
+};
+
+static const uint32_t checksum[] = { 0x80321851, 0xa99e95a1, 0xd26ec9a8, 0x14206b37, };
+
+} // namespace BufferF32x4_0p1NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BufferF32x4_0p1 : public NvParameterized::NvParameters, public BufferF32x4_0p1NS::ParametersStruct
+{
+public:
+	BufferF32x4_0p1(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BufferF32x4_0p1();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BufferF32x4");
+	}
+
+	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(BufferF32x4_0p1NS::checksum);
+		return BufferF32x4_0p1NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BufferF32x4_0p1NS::ParametersStruct& parameters(void) const
+	{
+		BufferF32x4_0p1* tmpThis = const_cast<BufferF32x4_0p1*>(this);
+		return *(static_cast<BufferF32x4_0p1NS::ParametersStruct*>(tmpThis));
+	}
+
+	BufferF32x4_0p1NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BufferF32x4_0p1NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BufferF32x4_0p1Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BufferF32x4_0p1::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BufferF32x4_0p1), BufferF32x4_0p1::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BufferF32x4_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferF32x4_0p1");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BufferF32x4_0p1)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BufferF32x4_0p1)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BufferF32x4_0p1::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BufferF32x4_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferF32x4_0p1");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BufferF32x4_0p1 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BufferF32x4_0p1*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BufferF32x4_0p1::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BufferF32x4_0p1::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BufferF32x4_0p1::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BufferF32x4_0p1::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/BufferU16x1_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/BufferU16x1_0p0.h
new file mode 100644
index 00000000..4cd7f5ca
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/BufferU16x1_0p0.h
@@ -0,0 +1,238 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BufferU16x1_0p0_h
+#define HEADER_BufferU16x1_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BufferU16x1_0p0NS
+{
+
+
+struct U16_DynamicArray1D_Type
+{
+	uint16_t* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	U16_DynamicArray1D_Type data;
+
+};
+
+static const uint32_t checksum[] = { 0x3c20aee2, 0x4e6abe8c, 0x8c1e5625, 0x7cabf8fc, };
+
+} // namespace BufferU16x1_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BufferU16x1_0p0 : public NvParameterized::NvParameters, public BufferU16x1_0p0NS::ParametersStruct
+{
+public:
+	BufferU16x1_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BufferU16x1_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BufferU16x1");
+	}
+
+	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(BufferU16x1_0p0NS::checksum);
+		return BufferU16x1_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BufferU16x1_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BufferU16x1_0p0* tmpThis = const_cast<BufferU16x1_0p0*>(this);
+		return *(static_cast<BufferU16x1_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BufferU16x1_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BufferU16x1_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BufferU16x1_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BufferU16x1_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BufferU16x1_0p0), BufferU16x1_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BufferU16x1_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU16x1_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BufferU16x1_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BufferU16x1_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BufferU16x1_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BufferU16x1_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU16x1_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BufferU16x1_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BufferU16x1_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BufferU16x1_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BufferU16x1_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BufferU16x1_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BufferU16x1_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/BufferU16x2_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/BufferU16x2_0p0.h
new file mode 100644
index 00000000..38ccd1fa
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/BufferU16x2_0p0.h
@@ -0,0 +1,244 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BufferU16x2_0p0_h
+#define HEADER_BufferU16x2_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BufferU16x2_0p0NS
+{
+
+struct U16x2_Type;
+
+struct U16x2_DynamicArray1D_Type
+{
+	U16x2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct U16x2_Type
+{
+	uint16_t x;
+	uint16_t y;
+};
+
+struct ParametersStruct
+{
+
+	U16x2_DynamicArray1D_Type data;
+
+};
+
+static const uint32_t checksum[] = { 0x35087bb2, 0x98bdb0fd, 0x22e601f6, 0x79ba85e9, };
+
+} // namespace BufferU16x2_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BufferU16x2_0p0 : public NvParameterized::NvParameters, public BufferU16x2_0p0NS::ParametersStruct
+{
+public:
+	BufferU16x2_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BufferU16x2_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BufferU16x2");
+	}
+
+	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(BufferU16x2_0p0NS::checksum);
+		return BufferU16x2_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BufferU16x2_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BufferU16x2_0p0* tmpThis = const_cast<BufferU16x2_0p0*>(this);
+		return *(static_cast<BufferU16x2_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BufferU16x2_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BufferU16x2_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BufferU16x2_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BufferU16x2_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BufferU16x2_0p0), BufferU16x2_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BufferU16x2_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU16x2_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BufferU16x2_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BufferU16x2_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BufferU16x2_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BufferU16x2_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU16x2_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BufferU16x2_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BufferU16x2_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BufferU16x2_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BufferU16x2_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BufferU16x2_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BufferU16x2_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/BufferU16x3_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/BufferU16x3_0p0.h
new file mode 100644
index 00000000..19e04296
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/BufferU16x3_0p0.h
@@ -0,0 +1,245 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BufferU16x3_0p0_h
+#define HEADER_BufferU16x3_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BufferU16x3_0p0NS
+{
+
+struct U16x3_Type;
+
+struct U16x3_DynamicArray1D_Type
+{
+	U16x3_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct U16x3_Type
+{
+	uint16_t x;
+	uint16_t y;
+	uint16_t z;
+};
+
+struct ParametersStruct
+{
+
+	U16x3_DynamicArray1D_Type data;
+
+};
+
+static const uint32_t checksum[] = { 0x904a928f, 0x9f3f0b91, 0x29168b39, 0x31638e80, };
+
+} // namespace BufferU16x3_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BufferU16x3_0p0 : public NvParameterized::NvParameters, public BufferU16x3_0p0NS::ParametersStruct
+{
+public:
+	BufferU16x3_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BufferU16x3_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BufferU16x3");
+	}
+
+	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(BufferU16x3_0p0NS::checksum);
+		return BufferU16x3_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BufferU16x3_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BufferU16x3_0p0* tmpThis = const_cast<BufferU16x3_0p0*>(this);
+		return *(static_cast<BufferU16x3_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BufferU16x3_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BufferU16x3_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BufferU16x3_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BufferU16x3_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BufferU16x3_0p0), BufferU16x3_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BufferU16x3_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU16x3_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BufferU16x3_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BufferU16x3_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BufferU16x3_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BufferU16x3_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU16x3_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BufferU16x3_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BufferU16x3_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BufferU16x3_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BufferU16x3_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BufferU16x3_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BufferU16x3_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/BufferU16x4_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/BufferU16x4_0p0.h
new file mode 100644
index 00000000..da9afbc3
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/BufferU16x4_0p0.h
@@ -0,0 +1,246 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BufferU16x4_0p0_h
+#define HEADER_BufferU16x4_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BufferU16x4_0p0NS
+{
+
+struct U16x4_Type;
+
+struct U16x4_DynamicArray1D_Type
+{
+	U16x4_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct U16x4_Type
+{
+	uint16_t x;
+	uint16_t y;
+	uint16_t z;
+	uint16_t w;
+};
+
+struct ParametersStruct
+{
+
+	U16x4_DynamicArray1D_Type data;
+
+};
+
+static const uint32_t checksum[] = { 0x17ce6b83, 0x32ba98aa, 0xd03f98f6, 0x26918369, };
+
+} // namespace BufferU16x4_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BufferU16x4_0p0 : public NvParameterized::NvParameters, public BufferU16x4_0p0NS::ParametersStruct
+{
+public:
+	BufferU16x4_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BufferU16x4_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BufferU16x4");
+	}
+
+	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(BufferU16x4_0p0NS::checksum);
+		return BufferU16x4_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BufferU16x4_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BufferU16x4_0p0* tmpThis = const_cast<BufferU16x4_0p0*>(this);
+		return *(static_cast<BufferU16x4_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BufferU16x4_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BufferU16x4_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BufferU16x4_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BufferU16x4_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BufferU16x4_0p0), BufferU16x4_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BufferU16x4_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU16x4_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BufferU16x4_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BufferU16x4_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BufferU16x4_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BufferU16x4_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU16x4_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BufferU16x4_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BufferU16x4_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BufferU16x4_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BufferU16x4_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BufferU16x4_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BufferU16x4_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/BufferU32x1_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/BufferU32x1_0p0.h
new file mode 100644
index 00000000..6b38c223
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/BufferU32x1_0p0.h
@@ -0,0 +1,238 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BufferU32x1_0p0_h
+#define HEADER_BufferU32x1_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BufferU32x1_0p0NS
+{
+
+
+struct U32_DynamicArray1D_Type
+{
+	uint32_t* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	U32_DynamicArray1D_Type data;
+
+};
+
+static const uint32_t checksum[] = { 0xaea8bce2, 0x233c95f7, 0xdaa9d0d3, 0x43951dbe, };
+
+} // namespace BufferU32x1_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BufferU32x1_0p0 : public NvParameterized::NvParameters, public BufferU32x1_0p0NS::ParametersStruct
+{
+public:
+	BufferU32x1_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BufferU32x1_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BufferU32x1");
+	}
+
+	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(BufferU32x1_0p0NS::checksum);
+		return BufferU32x1_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BufferU32x1_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BufferU32x1_0p0* tmpThis = const_cast<BufferU32x1_0p0*>(this);
+		return *(static_cast<BufferU32x1_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BufferU32x1_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BufferU32x1_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BufferU32x1_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BufferU32x1_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BufferU32x1_0p0), BufferU32x1_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BufferU32x1_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU32x1_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BufferU32x1_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BufferU32x1_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BufferU32x1_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BufferU32x1_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU32x1_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BufferU32x1_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BufferU32x1_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BufferU32x1_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BufferU32x1_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BufferU32x1_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BufferU32x1_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/BufferU32x2_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/BufferU32x2_0p0.h
new file mode 100644
index 00000000..79e72675
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/BufferU32x2_0p0.h
@@ -0,0 +1,244 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BufferU32x2_0p0_h
+#define HEADER_BufferU32x2_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BufferU32x2_0p0NS
+{
+
+struct U32x2_Type;
+
+struct U32x2_DynamicArray1D_Type
+{
+	U32x2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct U32x2_Type
+{
+	uint32_t x;
+	uint32_t y;
+};
+
+struct ParametersStruct
+{
+
+	U32x2_DynamicArray1D_Type data;
+
+};
+
+static const uint32_t checksum[] = { 0x8f8dc3d4, 0x45e914f5, 0xe6432284, 0xf7487471, };
+
+} // namespace BufferU32x2_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BufferU32x2_0p0 : public NvParameterized::NvParameters, public BufferU32x2_0p0NS::ParametersStruct
+{
+public:
+	BufferU32x2_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BufferU32x2_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BufferU32x2");
+	}
+
+	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(BufferU32x2_0p0NS::checksum);
+		return BufferU32x2_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BufferU32x2_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BufferU32x2_0p0* tmpThis = const_cast<BufferU32x2_0p0*>(this);
+		return *(static_cast<BufferU32x2_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BufferU32x2_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BufferU32x2_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BufferU32x2_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BufferU32x2_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BufferU32x2_0p0), BufferU32x2_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BufferU32x2_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU32x2_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BufferU32x2_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BufferU32x2_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BufferU32x2_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BufferU32x2_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU32x2_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BufferU32x2_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BufferU32x2_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BufferU32x2_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BufferU32x2_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BufferU32x2_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BufferU32x2_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/BufferU32x3_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/BufferU32x3_0p0.h
new file mode 100644
index 00000000..6341515e
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/BufferU32x3_0p0.h
@@ -0,0 +1,245 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BufferU32x3_0p0_h
+#define HEADER_BufferU32x3_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BufferU32x3_0p0NS
+{
+
+struct U32x3_Type;
+
+struct U32x3_DynamicArray1D_Type
+{
+	U32x3_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct U32x3_Type
+{
+	uint32_t x;
+	uint32_t y;
+	uint32_t z;
+};
+
+struct ParametersStruct
+{
+
+	U32x3_DynamicArray1D_Type data;
+
+};
+
+static const uint32_t checksum[] = { 0xc0b737db, 0x1cae35c4, 0xe957acc9, 0x68cb2306, };
+
+} // namespace BufferU32x3_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BufferU32x3_0p0 : public NvParameterized::NvParameters, public BufferU32x3_0p0NS::ParametersStruct
+{
+public:
+	BufferU32x3_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BufferU32x3_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BufferU32x3");
+	}
+
+	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(BufferU32x3_0p0NS::checksum);
+		return BufferU32x3_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BufferU32x3_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BufferU32x3_0p0* tmpThis = const_cast<BufferU32x3_0p0*>(this);
+		return *(static_cast<BufferU32x3_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BufferU32x3_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BufferU32x3_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BufferU32x3_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BufferU32x3_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BufferU32x3_0p0), BufferU32x3_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BufferU32x3_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU32x3_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BufferU32x3_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BufferU32x3_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BufferU32x3_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BufferU32x3_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU32x3_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BufferU32x3_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BufferU32x3_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BufferU32x3_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BufferU32x3_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BufferU32x3_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BufferU32x3_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/BufferU32x4_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/BufferU32x4_0p0.h
new file mode 100644
index 00000000..fd617860
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/BufferU32x4_0p0.h
@@ -0,0 +1,246 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BufferU32x4_0p0_h
+#define HEADER_BufferU32x4_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BufferU32x4_0p0NS
+{
+
+struct U32x4_Type;
+
+struct U32x4_DynamicArray1D_Type
+{
+	U32x4_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct U32x4_Type
+{
+	uint32_t x;
+	uint32_t y;
+	uint32_t z;
+	uint32_t w;
+};
+
+struct ParametersStruct
+{
+
+	U32x4_DynamicArray1D_Type data;
+
+};
+
+static const uint32_t checksum[] = { 0x8e5349d3, 0xbf3dae15, 0x22c57bb9, 0x7c602608, };
+
+} // namespace BufferU32x4_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BufferU32x4_0p0 : public NvParameterized::NvParameters, public BufferU32x4_0p0NS::ParametersStruct
+{
+public:
+	BufferU32x4_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BufferU32x4_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BufferU32x4");
+	}
+
+	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(BufferU32x4_0p0NS::checksum);
+		return BufferU32x4_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BufferU32x4_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BufferU32x4_0p0* tmpThis = const_cast<BufferU32x4_0p0*>(this);
+		return *(static_cast<BufferU32x4_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BufferU32x4_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BufferU32x4_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BufferU32x4_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BufferU32x4_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BufferU32x4_0p0), BufferU32x4_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BufferU32x4_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU32x4_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BufferU32x4_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BufferU32x4_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BufferU32x4_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BufferU32x4_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU32x4_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BufferU32x4_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BufferU32x4_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BufferU32x4_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BufferU32x4_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BufferU32x4_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BufferU32x4_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/BufferU8x1_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/BufferU8x1_0p0.h
new file mode 100644
index 00000000..98fe5124
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/BufferU8x1_0p0.h
@@ -0,0 +1,238 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BufferU8x1_0p0_h
+#define HEADER_BufferU8x1_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BufferU8x1_0p0NS
+{
+
+
+struct U8_DynamicArray1D_Type
+{
+	uint8_t* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	U8_DynamicArray1D_Type data;
+
+};
+
+static const uint32_t checksum[] = { 0x9c4137b9, 0x1fe24c98, 0xae580b55, 0x7e908e02, };
+
+} // namespace BufferU8x1_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BufferU8x1_0p0 : public NvParameterized::NvParameters, public BufferU8x1_0p0NS::ParametersStruct
+{
+public:
+	BufferU8x1_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BufferU8x1_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BufferU8x1");
+	}
+
+	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(BufferU8x1_0p0NS::checksum);
+		return BufferU8x1_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BufferU8x1_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BufferU8x1_0p0* tmpThis = const_cast<BufferU8x1_0p0*>(this);
+		return *(static_cast<BufferU8x1_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BufferU8x1_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BufferU8x1_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BufferU8x1_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BufferU8x1_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BufferU8x1_0p0), BufferU8x1_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BufferU8x1_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU8x1_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BufferU8x1_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BufferU8x1_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BufferU8x1_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BufferU8x1_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU8x1_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BufferU8x1_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BufferU8x1_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BufferU8x1_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BufferU8x1_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BufferU8x1_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BufferU8x1_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/BufferU8x2_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/BufferU8x2_0p0.h
new file mode 100644
index 00000000..39a2fb3c
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/BufferU8x2_0p0.h
@@ -0,0 +1,244 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BufferU8x2_0p0_h
+#define HEADER_BufferU8x2_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BufferU8x2_0p0NS
+{
+
+struct U8x2_Type;
+
+struct U8x2_DynamicArray1D_Type
+{
+	U8x2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct U8x2_Type
+{
+	uint8_t x;
+	uint8_t y;
+};
+
+struct ParametersStruct
+{
+
+	U8x2_DynamicArray1D_Type data;
+
+};
+
+static const uint32_t checksum[] = { 0x9857276c, 0xc24be4d6, 0x1aee732c, 0xf8979343, };
+
+} // namespace BufferU8x2_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BufferU8x2_0p0 : public NvParameterized::NvParameters, public BufferU8x2_0p0NS::ParametersStruct
+{
+public:
+	BufferU8x2_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BufferU8x2_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BufferU8x2");
+	}
+
+	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(BufferU8x2_0p0NS::checksum);
+		return BufferU8x2_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BufferU8x2_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BufferU8x2_0p0* tmpThis = const_cast<BufferU8x2_0p0*>(this);
+		return *(static_cast<BufferU8x2_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BufferU8x2_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BufferU8x2_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BufferU8x2_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BufferU8x2_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BufferU8x2_0p0), BufferU8x2_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BufferU8x2_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU8x2_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BufferU8x2_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BufferU8x2_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BufferU8x2_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BufferU8x2_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU8x2_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BufferU8x2_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BufferU8x2_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BufferU8x2_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BufferU8x2_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BufferU8x2_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BufferU8x2_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/BufferU8x3_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/BufferU8x3_0p0.h
new file mode 100644
index 00000000..dfc0cf28
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/BufferU8x3_0p0.h
@@ -0,0 +1,245 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BufferU8x3_0p0_h
+#define HEADER_BufferU8x3_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BufferU8x3_0p0NS
+{
+
+struct U8x3_Type;
+
+struct U8x3_DynamicArray1D_Type
+{
+	U8x3_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct U8x3_Type
+{
+	uint8_t x;
+	uint8_t y;
+	uint8_t z;
+};
+
+struct ParametersStruct
+{
+
+	U8x3_DynamicArray1D_Type data;
+
+};
+
+static const uint32_t checksum[] = { 0xf5cdaf40, 0x1d38c18b, 0x85082025, 0x4cefb88a, };
+
+} // namespace BufferU8x3_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BufferU8x3_0p0 : public NvParameterized::NvParameters, public BufferU8x3_0p0NS::ParametersStruct
+{
+public:
+	BufferU8x3_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BufferU8x3_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BufferU8x3");
+	}
+
+	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(BufferU8x3_0p0NS::checksum);
+		return BufferU8x3_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BufferU8x3_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BufferU8x3_0p0* tmpThis = const_cast<BufferU8x3_0p0*>(this);
+		return *(static_cast<BufferU8x3_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BufferU8x3_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BufferU8x3_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BufferU8x3_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BufferU8x3_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BufferU8x3_0p0), BufferU8x3_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BufferU8x3_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU8x3_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BufferU8x3_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BufferU8x3_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BufferU8x3_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BufferU8x3_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU8x3_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BufferU8x3_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BufferU8x3_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BufferU8x3_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BufferU8x3_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BufferU8x3_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BufferU8x3_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/BufferU8x4_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/BufferU8x4_0p0.h
new file mode 100644
index 00000000..6d1f0800
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/BufferU8x4_0p0.h
@@ -0,0 +1,246 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BufferU8x4_0p0_h
+#define HEADER_BufferU8x4_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BufferU8x4_0p0NS
+{
+
+struct U8x4_Type;
+
+struct U8x4_DynamicArray1D_Type
+{
+	U8x4_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct U8x4_Type
+{
+	uint8_t x;
+	uint8_t y;
+	uint8_t z;
+	uint8_t w;
+};
+
+struct ParametersStruct
+{
+
+	U8x4_DynamicArray1D_Type data;
+
+};
+
+static const uint32_t checksum[] = { 0x8364dd0f, 0xbc7542d0, 0x1a22d2d2, 0x01fc1923, };
+
+} // namespace BufferU8x4_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BufferU8x4_0p0 : public NvParameterized::NvParameters, public BufferU8x4_0p0NS::ParametersStruct
+{
+public:
+	BufferU8x4_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BufferU8x4_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BufferU8x4");
+	}
+
+	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(BufferU8x4_0p0NS::checksum);
+		return BufferU8x4_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BufferU8x4_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BufferU8x4_0p0* tmpThis = const_cast<BufferU8x4_0p0*>(this);
+		return *(static_cast<BufferU8x4_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BufferU8x4_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BufferU8x4_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BufferU8x4_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BufferU8x4_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BufferU8x4_0p0), BufferU8x4_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BufferU8x4_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU8x4_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BufferU8x4_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BufferU8x4_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BufferU8x4_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BufferU8x4_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BufferU8x4_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BufferU8x4_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BufferU8x4_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BufferU8x4_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BufferU8x4_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BufferU8x4_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BufferU8x4_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/ModuleFrameworkLegacyRegistration.h b/APEX_1.4/module/framework_legacy/include/autogen/ModuleFrameworkLegacyRegistration.h
new file mode 100644
index 00000000..365053cd
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/ModuleFrameworkLegacyRegistration.h
@@ -0,0 +1,192 @@
+/*
+ * 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_MODULEFRAMEWORKLEGACYREGISTRATIONH_H
+#define MODULE_MODULEFRAMEWORKLEGACYREGISTRATIONH_H
+
+#include "PsAllocator.h"
+#include "NvRegistrationsForTraitsBase.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "PxAssert.h"
+#include <stdint.h>
+
+// INCLUDE GENERATED FACTORIES
+#include "BufferF32x4_0p0.h"
+#include "SubmeshParameters_0p0.h"
+#include "VertexBufferParameters_0p0.h"
+#include "VertexFormatParameters_0p0.h"
+#include "VertexBufferParameters_0p1.h"
+#include "SurfaceBufferParameters_0p1.h"
+#include "SubmeshParameters_0p1.h"
+#include "RenderMeshAssetParameters_0p0.h"
+#include "BufferU8x1_0p0.h"
+#include "BufferU8x2_0p0.h"
+#include "BufferU8x3_0p0.h"
+#include "BufferU8x4_0p0.h"
+#include "BufferU16x1_0p0.h"
+#include "BufferU16x2_0p0.h"
+#include "BufferU16x3_0p0.h"
+#include "BufferU16x4_0p0.h"
+#include "BufferU32x1_0p0.h"
+#include "BufferU32x2_0p0.h"
+#include "BufferU32x3_0p0.h"
+#include "BufferU32x4_0p0.h"
+#include "BufferF32x1_0p0.h"
+#include "BufferF32x2_0p0.h"
+#include "BufferF32x3_0p0.h"
+#include "BufferF32x4_0p1.h"
+
+
+// INCLUDE GENERATED CONVERSION
+#include "ConversionBufferF32x4_0p0_0p1.h"
+#include "ConversionSubmeshParameters_0p0_0p1.h"
+#include "ConversionVertexBufferParameters_0p0_0p1.h"
+
+
+// global namespace
+
+class ModuleFrameworkLegacyRegistration : public NvParameterized::RegistrationsForTraitsBase
+{
+public:
+	static void invokeRegistration(NvParameterized::Traits* parameterizedTraits)
+	{
+		if (parameterizedTraits)
+		{
+			ModuleFrameworkLegacyRegistration().registerAll(*parameterizedTraits);
+		}
+	}
+
+	static void invokeUnregistration(NvParameterized::Traits* parameterizedTraits)
+	{
+		if (parameterizedTraits)
+		{
+			ModuleFrameworkLegacyRegistration().unregisterAll(*parameterizedTraits);
+		}
+	}
+
+	void registerAvailableFactories(NvParameterized::Traits& parameterizedTraits)
+	{
+		::NvParameterized::Factory* factoriesToRegister[] = {
+// REGISTER GENERATED FACTORIES
+			new nvidia::parameterized::BufferF32x4_0p0Factory(),
+			new nvidia::parameterized::SubmeshParameters_0p0Factory(),
+			new nvidia::parameterized::VertexBufferParameters_0p0Factory(),
+
+		};
+
+		for (size_t i = 0; i < sizeof(factoriesToRegister)/sizeof(factoriesToRegister[0]); ++i)
+		{
+			parameterizedTraits.registerFactory(*factoriesToRegister[i]);
+		}
+	}
+
+	virtual void registerAvailableConverters(NvParameterized::Traits& parameterizedTraits)
+	{
+// REGISTER GENERATED CONVERSION
+			{
+			typedef nvidia::apex::legacy::ConversionBufferF32x4_0p0_0p1 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionSubmeshParameters_0p0_0p1 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionVertexBufferParameters_0p0_0p1 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+
+	}
+
+	void unregisterAvailableFactories(NvParameterized::Traits& parameterizedTraits)
+	{
+		struct FactoryDesc
+		{
+			const char* name;
+			uint32_t version;
+		};
+
+		::NvParameterized::Factory* factoriesToUnregister[] = {
+// UNREGISTER GENERATED FACTORIES
+			new nvidia::parameterized::BufferF32x4_0p0Factory(),
+			new nvidia::parameterized::SubmeshParameters_0p0Factory(),
+			new nvidia::parameterized::VertexBufferParameters_0p0Factory(),
+
+		};
+
+		for (size_t i = 0; i < sizeof(factoriesToUnregister)/sizeof(factoriesToUnregister[0]); ++i)
+		{
+			::NvParameterized::Factory* removedFactory = parameterizedTraits.removeFactory(factoriesToUnregister[i]->getClassName(), factoriesToUnregister[i]->getVersion());
+			if (!removedFactory) 
+			{
+				PX_ASSERT_WITH_MESSAGE(0, "Factory can not be removed!");
+			}
+			else
+			{
+				removedFactory->freeParameterDefinitionTable(&parameterizedTraits);
+				delete removedFactory;
+				delete factoriesToUnregister[i];
+			}
+		}
+	}
+
+	virtual void unregisterAvailableConverters(NvParameterized::Traits& parameterizedTraits)
+	{
+// UNREGISTER GENERATED CONVERSION
+			{
+			typedef nvidia::apex::legacy::ConversionBufferF32x4_0p0_0p1 ConverterToUnregister;
+			::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(),
+								ConverterToUnregister::TOldClass::ClassVersion,
+								ConverterToUnregister::TNewClass::ClassVersion);
+			if (removedConv) {
+				removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE 
+			} else {
+				// assert("Conversion was not found");
+			}
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionSubmeshParameters_0p0_0p1 ConverterToUnregister;
+			::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(),
+								ConverterToUnregister::TOldClass::ClassVersion,
+								ConverterToUnregister::TNewClass::ClassVersion);
+			if (removedConv) {
+				removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE 
+			} else {
+				// assert("Conversion was not found");
+			}
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionVertexBufferParameters_0p0_0p1 ConverterToUnregister;
+			::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(),
+								ConverterToUnregister::TOldClass::ClassVersion,
+								ConverterToUnregister::TNewClass::ClassVersion);
+			if (removedConv) {
+				removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE 
+			} else {
+				// assert("Conversion was not found");
+			}
+			}
+
+	}
+
+};
+
+// global namespace
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/RenderMeshAssetParameters_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/RenderMeshAssetParameters_0p0.h
new file mode 100644
index 00000000..efff0ed6
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/RenderMeshAssetParameters_0p0.h
@@ -0,0 +1,260 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without 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_RenderMeshAssetParameters_0p0_h
+#define HEADER_RenderMeshAssetParameters_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace RenderMeshAssetParameters_0p0NS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct STRING_DynamicArray1D_Type
+{
+	NvParameterized::DummyStringStruct* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct BOUNDS3_DynamicArray1D_Type
+{
+	physx::PxBounds3* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	REF_DynamicArray1D_Type submeshes;
+	STRING_DynamicArray1D_Type materialNames;
+	BOUNDS3_DynamicArray1D_Type partBounds;
+	uint32_t textureUVOrigin;
+	uint32_t boneCount;
+	bool deleteStaticBuffersAfterUse;
+	bool isReferenced;
+
+};
+
+static const uint32_t checksum[] = { 0x119d6f62, 0x8d1ff03d, 0x19864d20, 0x93421fd0, };
+
+} // namespace RenderMeshAssetParameters_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class RenderMeshAssetParameters_0p0 : public NvParameterized::NvParameters, public RenderMeshAssetParameters_0p0NS::ParametersStruct
+{
+public:
+	RenderMeshAssetParameters_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~RenderMeshAssetParameters_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("RenderMeshAssetParameters");
+	}
+
+	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(RenderMeshAssetParameters_0p0NS::checksum);
+		return RenderMeshAssetParameters_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const RenderMeshAssetParameters_0p0NS::ParametersStruct& parameters(void) const
+	{
+		RenderMeshAssetParameters_0p0* tmpThis = const_cast<RenderMeshAssetParameters_0p0*>(this);
+		return *(static_cast<RenderMeshAssetParameters_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	RenderMeshAssetParameters_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<RenderMeshAssetParameters_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class RenderMeshAssetParameters_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		RenderMeshAssetParameters_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(RenderMeshAssetParameters_0p0), RenderMeshAssetParameters_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, RenderMeshAssetParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RenderMeshAssetParameters_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(RenderMeshAssetParameters_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, RenderMeshAssetParameters_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, RenderMeshAssetParameters_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, RenderMeshAssetParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RenderMeshAssetParameters_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of RenderMeshAssetParameters_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (RenderMeshAssetParameters_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (RenderMeshAssetParameters_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (RenderMeshAssetParameters_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (RenderMeshAssetParameters_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (RenderMeshAssetParameters_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/SubmeshParameters_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/SubmeshParameters_0p0.h
new file mode 100644
index 00000000..a12e853d
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/SubmeshParameters_0p0.h
@@ -0,0 +1,241 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without 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_SubmeshParameters_0p0_h
+#define HEADER_SubmeshParameters_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace SubmeshParameters_0p0NS
+{
+
+
+struct U32_DynamicArray1D_Type
+{
+	uint32_t* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::Interface* vertexBuffer;
+	U32_DynamicArray1D_Type indexBuffer;
+	U32_DynamicArray1D_Type vertexPartition;
+	U32_DynamicArray1D_Type indexPartition;
+
+};
+
+static const uint32_t checksum[] = { 0x67cd8f04, 0xc7809f1f, 0xd4c743b2, 0xea3b5308, };
+
+} // namespace SubmeshParameters_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class SubmeshParameters_0p0 : public NvParameterized::NvParameters, public SubmeshParameters_0p0NS::ParametersStruct
+{
+public:
+	SubmeshParameters_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~SubmeshParameters_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("SubmeshParameters");
+	}
+
+	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(SubmeshParameters_0p0NS::checksum);
+		return SubmeshParameters_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const SubmeshParameters_0p0NS::ParametersStruct& parameters(void) const
+	{
+		SubmeshParameters_0p0* tmpThis = const_cast<SubmeshParameters_0p0*>(this);
+		return *(static_cast<SubmeshParameters_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	SubmeshParameters_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<SubmeshParameters_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class SubmeshParameters_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		SubmeshParameters_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(SubmeshParameters_0p0), SubmeshParameters_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, SubmeshParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SubmeshParameters_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(SubmeshParameters_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, SubmeshParameters_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, SubmeshParameters_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, SubmeshParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SubmeshParameters_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of SubmeshParameters_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (SubmeshParameters_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (SubmeshParameters_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (SubmeshParameters_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (SubmeshParameters_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (SubmeshParameters_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/SubmeshParameters_0p1.h b/APEX_1.4/module/framework_legacy/include/autogen/SubmeshParameters_0p1.h
new file mode 100644
index 00000000..20521e03
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/SubmeshParameters_0p1.h
@@ -0,0 +1,242 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without 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_SubmeshParameters_0p1_h
+#define HEADER_SubmeshParameters_0p1_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace SubmeshParameters_0p1NS
+{
+
+
+struct U32_DynamicArray1D_Type
+{
+	uint32_t* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::Interface* vertexBuffer;
+	U32_DynamicArray1D_Type indexBuffer;
+	U32_DynamicArray1D_Type vertexPartition;
+	U32_DynamicArray1D_Type indexPartition;
+	U32_DynamicArray1D_Type smoothingGroups;
+
+};
+
+static const uint32_t checksum[] = { 0xb2b4f308, 0x5f4b8da6, 0x4d45daeb, 0xbfc7d9b0, };
+
+} // namespace SubmeshParameters_0p1NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class SubmeshParameters_0p1 : public NvParameterized::NvParameters, public SubmeshParameters_0p1NS::ParametersStruct
+{
+public:
+	SubmeshParameters_0p1(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~SubmeshParameters_0p1();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("SubmeshParameters");
+	}
+
+	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(SubmeshParameters_0p1NS::checksum);
+		return SubmeshParameters_0p1NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const SubmeshParameters_0p1NS::ParametersStruct& parameters(void) const
+	{
+		SubmeshParameters_0p1* tmpThis = const_cast<SubmeshParameters_0p1*>(this);
+		return *(static_cast<SubmeshParameters_0p1NS::ParametersStruct*>(tmpThis));
+	}
+
+	SubmeshParameters_0p1NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<SubmeshParameters_0p1NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class SubmeshParameters_0p1Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		SubmeshParameters_0p1::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(SubmeshParameters_0p1), SubmeshParameters_0p1::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, SubmeshParameters_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SubmeshParameters_0p1");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(SubmeshParameters_0p1)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, SubmeshParameters_0p1)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, SubmeshParameters_0p1::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, SubmeshParameters_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SubmeshParameters_0p1");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of SubmeshParameters_0p1 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (SubmeshParameters_0p1*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (SubmeshParameters_0p1::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (SubmeshParameters_0p1::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (SubmeshParameters_0p1::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (SubmeshParameters_0p1::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/SurfaceBufferParameters_0p1.h b/APEX_1.4/module/framework_legacy/include/autogen/SurfaceBufferParameters_0p1.h
new file mode 100644
index 00000000..824c6bcc
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/SurfaceBufferParameters_0p1.h
@@ -0,0 +1,233 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without 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_SurfaceBufferParameters_0p1_h
+#define HEADER_SurfaceBufferParameters_0p1_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace SurfaceBufferParameters_0p1NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	uint32_t width;
+	uint32_t height;
+	uint32_t surfaceFormat;
+	NvParameterized::Interface* buffer;
+
+};
+
+static const uint32_t checksum[] = { 0x8c5efe70, 0x9563a3a7, 0x2a52ffa7, 0x43e1a4fb, };
+
+} // namespace SurfaceBufferParameters_0p1NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class SurfaceBufferParameters_0p1 : public NvParameterized::NvParameters, public SurfaceBufferParameters_0p1NS::ParametersStruct
+{
+public:
+	SurfaceBufferParameters_0p1(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~SurfaceBufferParameters_0p1();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("SurfaceBufferParameters");
+	}
+
+	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(SurfaceBufferParameters_0p1NS::checksum);
+		return SurfaceBufferParameters_0p1NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const SurfaceBufferParameters_0p1NS::ParametersStruct& parameters(void) const
+	{
+		SurfaceBufferParameters_0p1* tmpThis = const_cast<SurfaceBufferParameters_0p1*>(this);
+		return *(static_cast<SurfaceBufferParameters_0p1NS::ParametersStruct*>(tmpThis));
+	}
+
+	SurfaceBufferParameters_0p1NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<SurfaceBufferParameters_0p1NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class SurfaceBufferParameters_0p1Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		SurfaceBufferParameters_0p1::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(SurfaceBufferParameters_0p1), SurfaceBufferParameters_0p1::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, SurfaceBufferParameters_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SurfaceBufferParameters_0p1");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(SurfaceBufferParameters_0p1)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, SurfaceBufferParameters_0p1)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, SurfaceBufferParameters_0p1::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, SurfaceBufferParameters_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SurfaceBufferParameters_0p1");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of SurfaceBufferParameters_0p1 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (SurfaceBufferParameters_0p1*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (SurfaceBufferParameters_0p1::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (SurfaceBufferParameters_0p1::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (SurfaceBufferParameters_0p1::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (SurfaceBufferParameters_0p1::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/VertexBufferParameters_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/VertexBufferParameters_0p0.h
new file mode 100644
index 00000000..eccfbdcd
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/VertexBufferParameters_0p0.h
@@ -0,0 +1,240 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_VertexBufferParameters_0p0_h
+#define HEADER_VertexBufferParameters_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace VertexBufferParameters_0p0NS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	uint32_t vertexCount;
+	NvParameterized::Interface* vertexFormat;
+	REF_DynamicArray1D_Type buffers;
+
+};
+
+static const uint32_t checksum[] = { 0x4ceee932, 0xa2baf8dc, 0x980290c7, 0xf043b552, };
+
+} // namespace VertexBufferParameters_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class VertexBufferParameters_0p0 : public NvParameterized::NvParameters, public VertexBufferParameters_0p0NS::ParametersStruct
+{
+public:
+	VertexBufferParameters_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~VertexBufferParameters_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("VertexBufferParameters");
+	}
+
+	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(VertexBufferParameters_0p0NS::checksum);
+		return VertexBufferParameters_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const VertexBufferParameters_0p0NS::ParametersStruct& parameters(void) const
+	{
+		VertexBufferParameters_0p0* tmpThis = const_cast<VertexBufferParameters_0p0*>(this);
+		return *(static_cast<VertexBufferParameters_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	VertexBufferParameters_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<VertexBufferParameters_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class VertexBufferParameters_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		VertexBufferParameters_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(VertexBufferParameters_0p0), VertexBufferParameters_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, VertexBufferParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VertexBufferParameters_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(VertexBufferParameters_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, VertexBufferParameters_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, VertexBufferParameters_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, VertexBufferParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VertexBufferParameters_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of VertexBufferParameters_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (VertexBufferParameters_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (VertexBufferParameters_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (VertexBufferParameters_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (VertexBufferParameters_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (VertexBufferParameters_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/VertexBufferParameters_0p1.h b/APEX_1.4/module/framework_legacy/include/autogen/VertexBufferParameters_0p1.h
new file mode 100644
index 00000000..dbb4e357
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/VertexBufferParameters_0p1.h
@@ -0,0 +1,240 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_VertexBufferParameters_0p1_h
+#define HEADER_VertexBufferParameters_0p1_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace VertexBufferParameters_0p1NS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	uint32_t vertexCount;
+	NvParameterized::Interface* vertexFormat;
+	REF_DynamicArray1D_Type buffers;
+
+};
+
+static const uint32_t checksum[] = { 0x14ae7314, 0xe50741cb, 0x15eb480c, 0x63f6c571, };
+
+} // namespace VertexBufferParameters_0p1NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class VertexBufferParameters_0p1 : public NvParameterized::NvParameters, public VertexBufferParameters_0p1NS::ParametersStruct
+{
+public:
+	VertexBufferParameters_0p1(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~VertexBufferParameters_0p1();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("VertexBufferParameters");
+	}
+
+	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(VertexBufferParameters_0p1NS::checksum);
+		return VertexBufferParameters_0p1NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const VertexBufferParameters_0p1NS::ParametersStruct& parameters(void) const
+	{
+		VertexBufferParameters_0p1* tmpThis = const_cast<VertexBufferParameters_0p1*>(this);
+		return *(static_cast<VertexBufferParameters_0p1NS::ParametersStruct*>(tmpThis));
+	}
+
+	VertexBufferParameters_0p1NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<VertexBufferParameters_0p1NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class VertexBufferParameters_0p1Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		VertexBufferParameters_0p1::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(VertexBufferParameters_0p1), VertexBufferParameters_0p1::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, VertexBufferParameters_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VertexBufferParameters_0p1");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(VertexBufferParameters_0p1)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, VertexBufferParameters_0p1)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, VertexBufferParameters_0p1::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, VertexBufferParameters_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VertexBufferParameters_0p1");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of VertexBufferParameters_0p1 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (VertexBufferParameters_0p1*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (VertexBufferParameters_0p1::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (VertexBufferParameters_0p1::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (VertexBufferParameters_0p1::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (VertexBufferParameters_0p1::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/framework_legacy/include/autogen/VertexFormatParameters_0p0.h b/APEX_1.4/module/framework_legacy/include/autogen/VertexFormatParameters_0p0.h
new file mode 100644
index 00000000..5fd9c8f2
--- /dev/null
+++ b/APEX_1.4/module/framework_legacy/include/autogen/VertexFormatParameters_0p0.h
@@ -0,0 +1,250 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_VertexFormatParameters_0p0_h
+#define HEADER_VertexFormatParameters_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace VertexFormatParameters_0p0NS
+{
+
+struct BufferFormat_Type;
+
+struct BufferFormat_DynamicArray1D_Type
+{
+	BufferFormat_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct BufferFormat_Type
+{
+	NvParameterized::DummyStringStruct name;
+	int32_t semantic;
+	uint32_t id;
+	uint32_t format;
+	uint32_t access;
+	bool serialize;
+};
+
+struct ParametersStruct
+{
+
+	uint32_t winding;
+	bool hasSeparateBoneBuffer;
+	BufferFormat_DynamicArray1D_Type bufferFormats;
+
+};
+
+static const uint32_t checksum[] = { 0xa7c1ed95, 0x570ed2b1, 0x55717659, 0x9951d139, };
+
+} // namespace VertexFormatParameters_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class VertexFormatParameters_0p0 : public NvParameterized::NvParameters, public VertexFormatParameters_0p0NS::ParametersStruct
+{
+public:
+	VertexFormatParameters_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~VertexFormatParameters_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("VertexFormatParameters");
+	}
+
+	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(VertexFormatParameters_0p0NS::checksum);
+		return VertexFormatParameters_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const VertexFormatParameters_0p0NS::ParametersStruct& parameters(void) const
+	{
+		VertexFormatParameters_0p0* tmpThis = const_cast<VertexFormatParameters_0p0*>(this);
+		return *(static_cast<VertexFormatParameters_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	VertexFormatParameters_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<VertexFormatParameters_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class VertexFormatParameters_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		VertexFormatParameters_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(VertexFormatParameters_0p0), VertexFormatParameters_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, VertexFormatParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VertexFormatParameters_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(VertexFormatParameters_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, VertexFormatParameters_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, VertexFormatParameters_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, VertexFormatParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VertexFormatParameters_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of VertexFormatParameters_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (VertexFormatParameters_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (VertexFormatParameters_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (VertexFormatParameters_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (VertexFormatParameters_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (VertexFormatParameters_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif