Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

45 files changed, 21941 insertions, 0 deletions

diff --git a/APEX_1.4/framework/src/ApexAssetPreviewScene.cpp b/APEX_1.4/framework/src/ApexAssetPreviewScene.cpp
new file mode 100644
index 00000000..ea79202f
--- /dev/null
+++ b/APEX_1.4/framework/src/ApexAssetPreviewScene.cpp
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "Apex.h"
+#include "ApexDefs.h"
+#include "ApexAssetPreviewScene.h"
+#include "ApexSceneTasks.h"
+#include "ApexSDKImpl.h"
+#include "ApexActor.h"
+#include "FrameworkPerfScope.h"
+#include "ApexRenderDebug.h"
+#include "ModuleIntl.h"
+#include "ApexPvdClient.h"
+#include "PsTime.h"
+#include "ApexUsingNamespace.h"
+#include "PsSync.h"
+#include "PxTask.h"
+#include "PxTaskManager.h"
+#include "PxGpuDispatcher.h"
+#include "PxCudaContextManager.h"
+
+
+namespace nvidia
+{
+namespace apex
+{
+
+	ApexAssetPreviewScene::ApexAssetPreviewScene(ApexSDKImpl* sdk) : mApexSDK(sdk)
+	, mShowFullInfo(false)
+	{
+		mCameraMatrix = PxMat44(PxIdentity);
+	}
+
+	void ApexAssetPreviewScene::setCameraMatrix(const PxMat44& cameraMatrix)
+	{
+		mCameraMatrix = cameraMatrix;
+	}
+
+	PxMat44 ApexAssetPreviewScene::getCameraMatrix() const
+	{
+		return mCameraMatrix;
+	}
+
+	void ApexAssetPreviewScene::setShowFullInfo(bool showFullInfo)
+	{
+		mShowFullInfo = showFullInfo;
+	}
+
+	bool ApexAssetPreviewScene::getShowFullInfo() const
+	{
+		return mShowFullInfo;
+	}
+
+	void ApexAssetPreviewScene::release()
+	{
+		mApexSDK->releaseAssetPreviewScene(this);
+	}
+
+	void ApexAssetPreviewScene::destroy()
+	{
+		PX_DELETE(this);
+	}
+}
+} // end namespace nvidia::apex
diff --git a/APEX_1.4/framework/src/ApexCreateSDK.cpp b/APEX_1.4/framework/src/ApexCreateSDK.cpp
new file mode 100644
index 00000000..2f37d62d
--- /dev/null
+++ b/APEX_1.4/framework/src/ApexCreateSDK.cpp
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "Apex.h"
+#include "ApexSDKImpl.h"
+#include "ProfilerCallback.h"
+#include "PxTaskManager.h"
+#include "PxCpuDispatcher.h"
+#include "ApexCudaContextManager.h"
+#if APEX_CUDA_SUPPORT && !defined(INSTALLER)
+#include "CudaContextManager.h"
+#include "PhysXDeviceSettings.h"
+#endif
+#include "PxCudaContextManager.h"
+#include "PxErrorCallback.h"
+
+#if PX_PHYSICS_VERSION_MAJOR == 0
+#include "ThreadPool.h"
+#endif
+
+namespace nvidia
+{
+namespace apex
+{
+
+ApexSDKImpl* gApexSdk = NULL;	// For an SDK singleton
+
+APEX_API ApexSDK*	CALL_CONV GetApexSDK()
+{
+	return gApexSdk;
+}
+APEX_API ApexSDKIntl*	CALL_CONV GetInternalApexSDK()
+{
+	return gApexSdk;
+}
+
+ApexSDK* CreateApexSDK(const ApexSDKDesc& desc, ApexCreateError* errorCode, uint32_t APEXsdkVersion, PxAllocatorCallback* alloc)
+{
+	PX_UNUSED(alloc);
+
+	if (errorCode)
+	{
+		*errorCode = APEX_CE_NO_ERROR;
+	}
+
+	if (gApexSdk != NULL)
+	{
+		return gApexSdk;
+	}
+
+	if (APEXsdkVersion != APEX_SDK_VERSION)
+	{
+		if (errorCode)
+		{
+			*errorCode = APEX_CE_WRONG_VERSION;
+		}
+		return NULL;
+	}
+
+	if (!desc.isValid())	//this checks for SDK and cooking version mismatch!
+	{
+		if (errorCode)
+		{
+			if (desc.physXSDKVersion != PX_PHYSICS_VERSION)
+			{
+				*errorCode = APEX_CE_WRONG_VERSION;
+			}
+			else
+			{
+				*errorCode = APEX_CE_DESCRIPTOR_INVALID;
+			}
+		}
+		return NULL;
+	}
+
+
+	PX_ASSERT(alloc == 0);
+
+	gApexSdk = PX_NEW(ApexSDKImpl)(errorCode, APEXsdkVersion);
+	gApexSdk->init(desc);
+
+	return gApexSdk;
+}
+
+int GetSuggestedCudaDeviceOrdinal(PxErrorCallback& errc)
+{
+#if APEX_CUDA_SUPPORT && !defined(INSTALLER)
+	return PhysXDeviceSettings::getSuggestedCudaDeviceOrdinal(errc);
+#else
+	PX_UNUSED(errc);
+	return -1;
+#endif
+}
+
+PxCudaContextManager* CreateCudaContextManager(const PxCudaContextManagerDesc& desc, PxErrorCallback& errorCallback)
+{
+#if APEX_CUDA_SUPPORT && !defined(INSTALLER)
+	return physx::createCudaContextManager(desc, errorCallback);
+#else
+	PX_UNUSED(desc);
+	PX_UNUSED(errorCallback);
+	return NULL;
+#endif
+}
+
+
+#if PX_PHYSICS_VERSION_MAJOR == 0
+
+/* We route allocations of these objects through the APEX SDK because PXTASK objects
+ * require a foundation instance.
+ */
+
+PxCpuDispatcher* ApexSDKImpl::getDefaultThreadPool()
+{
+	if (!mApexThreadPool)
+	{
+		mApexThreadPool = createDefaultThreadPool(0);
+	}
+
+	return mApexThreadPool;
+}
+
+PxCpuDispatcher* ApexSDKImpl::createCpuDispatcher(uint32_t numThreads)
+{
+	PxCpuDispatcher* cd = createDefaultThreadPool(numThreads);
+	mUserAllocThreadPools.pushBack(cd);
+	return cd;
+}
+
+void ApexSDKImpl::releaseCpuDispatcher(PxCpuDispatcher& cd)
+{
+	if (&cd == mApexThreadPool)
+	{
+		PX_DELETE(mApexThreadPool);
+		mApexThreadPool = 0;
+		return;
+	}
+	for (uint32_t i = 0; i < mUserAllocThreadPools.size(); i++)
+	{
+		if (&cd == mUserAllocThreadPools[i])
+		{
+			PX_DELETE(&cd);
+			mUserAllocThreadPools.replaceWithLast(i);
+			return;
+		}
+	}
+}
+
+#endif
+
+}
+} // end namespace nvidia::apex
diff --git a/APEX_1.4/framework/src/ApexCustomBufferIterator.cpp b/APEX_1.4/framework/src/ApexCustomBufferIterator.cpp
new file mode 100644
index 00000000..c472c388
--- /dev/null
+++ b/APEX_1.4/framework/src/ApexCustomBufferIterator.cpp
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "ApexCustomBufferIterator.h"
+#include "PsString.h"
+
+namespace nvidia
+{
+namespace apex
+{
+
+ApexCustomBufferIterator::ApexCustomBufferIterator() :
+	mData(NULL),
+	mElemSize(0),
+	mMaxTriangles(0)
+{
+}
+
+void ApexCustomBufferIterator::setData(void* data, uint32_t elemSize, uint32_t maxTriangles)
+{
+	mData = (uint8_t*)data;
+	mElemSize = elemSize;
+	mMaxTriangles = maxTriangles;
+}
+
+void ApexCustomBufferIterator::addCustomBuffer(const char* name, RenderDataFormat::Enum format, uint32_t offset)
+{
+	CustomBuffer buffer;
+	buffer.name = name;
+	buffer.offset = offset;
+	buffer.format = format;
+
+	mCustomBuffers.pushBack(buffer);
+}
+void* ApexCustomBufferIterator::getVertex(uint32_t triangleIndex, uint32_t vertexIndex) const
+{
+	if (mData == NULL || triangleIndex >= mMaxTriangles)
+	{
+		return NULL;
+	}
+
+	return mData + mElemSize * (triangleIndex * 3 + vertexIndex);
+}
+int32_t ApexCustomBufferIterator::getAttributeIndex(const char* attributeName) const
+{
+	if (attributeName == NULL || attributeName[0] == 0)
+	{
+		return -1;
+	}
+
+	for (uint32_t i = 0; i < mCustomBuffers.size(); i++)
+	{
+		if (nvidia::strcmp(mCustomBuffers[i].name, attributeName) == 0)
+		{
+			return (int32_t)i;
+		}
+	}
+	return -1;
+}
+void* ApexCustomBufferIterator::getVertexAttribute(uint32_t triangleIndex, uint32_t vertexIndex, const char* attributeName, RenderDataFormat::Enum& outFormat) const
+{
+	outFormat = RenderDataFormat::UNSPECIFIED;
+
+	uint8_t* elementData = (uint8_t*)getVertex(triangleIndex, vertexIndex);
+	if (elementData == NULL)
+	{
+		return NULL;
+	}
+
+
+	for (uint32_t i = 0; i < mCustomBuffers.size(); i++)
+	{
+		if (nvidia::strcmp(mCustomBuffers[i].name, attributeName) == 0)
+		{
+			outFormat = mCustomBuffers[i].format;
+			return elementData + mCustomBuffers[i].offset;
+		}
+	}
+	return NULL;
+}
+
+void* ApexCustomBufferIterator::getVertexAttribute(uint32_t triangleIndex, uint32_t vertexIndex, uint32_t attributeIndex, RenderDataFormat::Enum& outFormat, const char*& outName) const
+{
+	outFormat = RenderDataFormat::UNSPECIFIED;
+	outName = NULL;
+
+	uint8_t* elementData = (uint8_t*)getVertex(triangleIndex, vertexIndex);
+	if (elementData == NULL || attributeIndex >= mCustomBuffers.size())
+	{
+		return NULL;
+	}
+
+	outName = mCustomBuffers[attributeIndex].name;
+	outFormat = mCustomBuffers[attributeIndex].format;
+	return elementData + mCustomBuffers[attributeIndex].offset;
+}
+
+}
+} // end namespace nvidia::apex
diff --git a/APEX_1.4/framework/src/ApexRenderDebug.cpp b/APEX_1.4/framework/src/ApexRenderDebug.cpp
new file mode 100644
index 00000000..414be4d4
--- /dev/null
+++ b/APEX_1.4/framework/src/ApexRenderDebug.cpp
@@ -0,0 +1,567 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "ApexUsingNamespace.h"
+#include "ApexRenderDebug.h"
+#include "ApexRenderable.h"
+
+#pragma warning(disable:4996)
+#pragma warning(disable:4100)
+#pragma warning(disable:4189)
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+#include <PxRenderBuffer.h>
+#endif // PX_PHYSICS_VERSION_MAJOR
+
+#include "RenderDebugInterface.h"
+#include "UserRenderer.h"
+#include "ApexSDKImpl.h"
+#include "PxIntrinsics.h"
+#include "PsString.h"
+#include "RenderDebugTyped.h"
+
+namespace nvidia
+{
+namespace apex
+{
+
+#if defined(WITHOUT_DEBUG_VISUALIZE)
+
+RenderDebugInterface* createApexRenderDebug(ApexSDKImpl* /*a*/)
+{
+	return NULL;
+}
+void releaseApexRenderDebug(RenderDebugInterface* /*n*/) 
+{
+}
+
+#else
+
+typedef physx::Array< RenderContext >      RenderContextVector;
+typedef physx::Array< UserRenderResource*>    RenderResourceVector;
+
+
+class ApexRenderDebug : public RenderDebugInterface, public ApexRWLockable, public UserAllocated
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	ApexRenderDebug(ApexSDKImpl* sdk, RENDER_DEBUG::RenderDebugInterface* iface, bool useRemote)
+	: mRenderDebugIface(iface)
+	{
+		mApexSDK = sdk;
+		if (mRenderDebugUntyped == NULL)
+		{
+			RENDER_DEBUG::RenderDebug::Desc desc;
+			desc.runMode = useRemote ? RENDER_DEBUG::RenderDebug::RM_CLIENT : RENDER_DEBUG::RenderDebug::RM_LOCAL;
+			desc.foundation = mApexSDK->getFoundation();
+			mRenderDebugUntyped = createRenderDebugExport(desc);
+		}
+		if (mRenderDebugUntyped)
+		{
+			mRenderDebug = mRenderDebugUntyped->getRenderDebugTyped();
+		}
+		else
+		{
+			PX_ASSERT(0);
+		}
+		mWireFrameMaterial = INVALID_RESOURCE_ID;
+		mSolidShadedMaterial = INVALID_RESOURCE_ID;
+		mLastRenderSolidCount = 0;
+		mLastRenderLineCount = 0;
+		mRenderSolidCount = 0;
+		mRenderLineCount = 0;
+		mUseDebugRenderable = false;
+	}
+
+	virtual RENDER_DEBUG::RenderDebugTyped* getRenderDebugInterface()
+	{
+		PX_ASSERT(mRenderDebugUntyped != NULL && mRenderDebug != NULL);
+		return mRenderDebug;
+	}
+
+	virtual ~ApexRenderDebug(void)
+	{
+		if (mRenderDebug)
+		{
+			mRenderDebugUntyped->release();
+			mRenderDebugUntyped = NULL;
+		}
+		// APEX specific stuff
+		{
+			RenderResourceVector::Iterator i;
+			for (i = mRenderLineResources.begin(); i != mRenderLineResources.end(); ++i)
+			{
+				UserRenderResource* resource = (*i);
+				PX_ASSERT(resource);
+				UserRenderVertexBuffer* vbuffer = resource->getVertexBuffer(0);
+				PX_ASSERT(vbuffer);
+				mApexSDK->getUserRenderResourceManager()->releaseResource(*resource);
+				mApexSDK->getUserRenderResourceManager()->releaseVertexBuffer(*vbuffer);
+			}
+		}
+		{
+			RenderResourceVector::Iterator i;
+			for (i = mRenderSolidResources.begin(); i != mRenderSolidResources.end(); ++i)
+			{
+				UserRenderResource* resource = (*i);
+				PX_ASSERT(resource);
+				UserRenderVertexBuffer* vbuffer = resource->getVertexBuffer(0);
+				PX_ASSERT(vbuffer);
+				mApexSDK->getUserRenderResourceManager()->releaseResource(*resource);
+				mApexSDK->getUserRenderResourceManager()->releaseVertexBuffer(*vbuffer);
+			}
+		}
+		mApexSDK->getInternalResourceProvider()->releaseResource(mWireFrameMaterial);
+		mApexSDK->getInternalResourceProvider()->releaseResource(mSolidShadedMaterial);
+	};
+
+	/*
+	\brief Method to support rendering to a legacy PhysX SDK DebugRenderable object instead
+	of to the APEX Render Resources API (i.e.: Renderable).
+
+	This method is used to enable or disable the use of a legacy DebugRenderable.  When enabled,
+	use the getDebugRenderable() method to get a legacy DebugRenerable object that will contain
+	all the debug output.
+	*/
+	virtual void	setUseDebugRenderable(bool state)
+	{
+		mUseDebugRenderable = state;
+		if (state == false)
+		{
+#if PX_PHYSICS_VERSION_MAJOR == 3
+			mPxDebugTriangles.clear();
+			mPxDebugLines.clear();
+			mPxDebugTrianglesScreenSpace.clear();
+			mPxDebugLinesScreenSpace.clear();
+#endif
+		}
+	}
+
+
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+
+	/*
+	\brief Method to support rendering to a legacy PhysX SDK PxRenderBuffer object instead
+	of to the APEX Render Resources API (i.e.: Renderable).
+
+	When enabled with a call to setUseDebugRenderable(true), this method will return a legacy
+	DebugRenderable object that contains all of the output of the RenderDebug class.
+	*/
+	virtual void	getRenderBuffer(PhysXRenderBuffer& renderable)
+	{
+		renderable.mNbPoints = 0;
+		renderable.mPoints = NULL;
+		renderable.mNbLines = mPxDebugLines.size();
+		renderable.mLines = renderable.mNbLines ? &mPxDebugLines[0] : NULL;
+		renderable.mNbTriangles = mPxDebugTriangles.size();
+		renderable.mTriangles = renderable.mNbTriangles ? &mPxDebugTriangles[0] : NULL;
+		renderable.mNbTexts = 0;
+		renderable.mTexts = NULL;
+	}
+
+	/*
+	\brief Method to support rendering to a legacy PhysX SDK PxRenderBuffer object instead
+	of to the APEX Render Resources API (i.e.: Renderable).
+
+	When enabled with a call to setUseDebugRenderable(true), this method will return a legacy
+	DebugRenderable object that contains all of the output of the RenderDebug class.
+	*/
+	virtual void	getRenderBufferScreenSpace(PhysXRenderBuffer& renderable)
+	{
+		renderable.mNbPoints = 0;
+		renderable.mPoints = NULL;
+		renderable.mNbLines = mPxDebugLinesScreenSpace.size();
+		renderable.mLines = renderable.mNbLines ? &mPxDebugLinesScreenSpace[0] : NULL;
+		renderable.mNbTriangles = mPxDebugTrianglesScreenSpace.size();
+		renderable.mTriangles = renderable.mNbTriangles ? &mPxDebugTrianglesScreenSpace[0] : NULL;
+		renderable.mNbTexts = 0;
+		renderable.mTexts = NULL;
+	}
+
+
+	virtual void	addDebugRenderable(const physx::PxRenderBuffer& renderBuffer)
+	{
+		// Points
+		mRenderDebug->pushRenderState();
+
+		const uint32_t color          = mRenderDebug->getCurrentColor();;
+		const uint32_t arrowColor     = mRenderDebug->getCurrentArrowColor();
+
+		const uint32_t numPoints      = renderBuffer.getNbPoints();
+		const physx::PxDebugPoint* points = renderBuffer.getPoints();
+		for (uint32_t i = 0; i < numPoints; i++)
+		{
+			const physx::PxDebugPoint& point = points[i];
+			mRenderDebug->setCurrentColor(point.color, arrowColor);
+			mRenderDebug->debugPoint(point.pos, 0.01f);
+		}
+
+		// Lines
+		const uint32_t numLines     = renderBuffer.getNbLines();
+		const physx::PxDebugLine* lines = renderBuffer.getLines();
+		for (uint32_t i = 0; i < numLines; i++)
+		{
+			const physx::PxDebugLine& line = lines[i];
+			mRenderDebug->debugGradientLine(line.pos0, line.pos1, line.color0, line.color1);
+		}
+
+		// Triangles
+		const uint32_t numTriangles         = renderBuffer.getNbTriangles();
+		const physx::PxDebugTriangle* triangles = renderBuffer.getTriangles();
+		for (uint32_t i = 0; i < numTriangles; i++)
+		{
+			const physx::PxDebugTriangle& triangle = triangles[i];
+			mRenderDebug->debugGradientTri(triangle.pos0, triangle.pos1, triangle.pos2, triangle.color0, triangle.color1, triangle.color2);
+		}
+
+		// Texts
+		const uint32_t numTexts				= renderBuffer.getNbTexts();
+		const physx::PxDebugText* texts			= renderBuffer.getTexts();
+		for (uint32_t i = 0; i < numTexts; i++)
+		{
+			const physx::PxDebugText& text = texts[i];
+			mRenderDebug->debugText(text.position, text.string);
+		}
+
+		mRenderDebug->setCurrentColor(color, arrowColor);
+
+		mRenderDebug->popRenderState();
+	}
+#endif // PX_PHYSICS_VERSION_MAJOR == 3
+
+	/**
+	\brief Release an object instance.
+
+	Calling this will unhook the class and delete it from memory.
+	You should not keep any reference to this class instance after calling release
+	*/
+	virtual void release()
+	{
+		delete this;
+	}
+
+	virtual void lockRenderResources()
+	{
+
+	}
+
+	/**
+	\brief Unlocks the renderable data of this Renderable actor.
+
+	See locking semantics for xRenderDataProvider::lockRenderResources().
+	*/
+	virtual void unlockRenderResources()
+	{
+
+	}
+
+	/**
+	\brief Update the renderable data of this Renderable actor.
+
+	When called, this method will use the UserRenderResourceManager interface to inform the user
+	about its render resource needs.  It will also call the writeBuffer() methods of various graphics
+	buffers.  It must be called by the user each frame before any calls to dispatchRenderResources().
+	If the actor is not being rendered, this function may also be skipped.
+	*/
+	virtual void updateRenderResources(bool /*rewriteBuffers*/ = false, void* /*userRenderData*/ = 0)
+	{
+		URR_SCOPE;
+
+		mRenderSolidContexts.clear();
+		mRenderLineContexts.clear();
+
+		// Free up the line draw vertex buffer resources if the debug renderer is now using a lot less memory than the last frame.
+		if (mRenderLineCount < (mLastRenderLineCount / 2))
+		{
+			RenderResourceVector::Iterator i;
+			for (i = mRenderLineResources.begin(); i != mRenderLineResources.end(); ++i)
+			{
+				UserRenderResource* resource = (*i);
+				PX_ASSERT(resource);
+				UserRenderVertexBuffer* vbuffer = resource->getVertexBuffer(0);
+				PX_ASSERT(vbuffer);
+				mApexSDK->getUserRenderResourceManager()->releaseResource(*resource);
+				mApexSDK->getUserRenderResourceManager()->releaseVertexBuffer(*vbuffer);
+			}
+			mRenderLineResources.clear();
+		}
+		// free up the solid shaded triangle vertex buffers if the debug renderer is now using a lot less memory than the last frame.
+		if (mRenderSolidCount < mLastRenderSolidCount / 2) // if we have less than 1/2 the number of solid shaded triangles we did last frame, free up the resources.
+		{
+			RenderResourceVector::Iterator i;
+			for (i = mRenderSolidResources.begin(); i != mRenderSolidResources.end(); ++i)
+			{
+				UserRenderResource* resource = (*i);
+				PX_ASSERT(resource);
+				UserRenderVertexBuffer* vbuffer = resource->getVertexBuffer(0);
+				PX_ASSERT(vbuffer);
+				mApexSDK->getUserRenderResourceManager()->releaseResource(*resource);
+				mApexSDK->getUserRenderResourceManager()->releaseVertexBuffer(*vbuffer);
+			}
+			mRenderSolidResources.clear();
+		}
+
+		mLastRenderSolidCount = mRenderSolidCount;
+		mLastRenderLineCount  = mRenderLineCount;
+		mRenderSolidCount = 0;
+		mRenderLineCount = 0;
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+		mPxDebugLines.clear();
+		mPxDebugTriangles.clear();
+		mPxDebugLinesScreenSpace.clear();
+		mPxDebugTrianglesScreenSpace.clear();
+#endif
+	}
+
+	virtual void dispatchRenderResources(UserRenderer& renderer)
+	{
+		mRenderDebug->render(1.0f / 60.0f, mRenderDebugIface);
+	}
+
+	virtual void debugRenderLines(uint32_t lcount, const RENDER_DEBUG::RenderDebugVertex* vertices, bool /*useZ*/, bool isScreenSpace)
+	{
+#if PX_PHYSICS_VERSION_MAJOR == 3
+			if (mUseDebugRenderable)
+			{
+				for (uint32_t i = 0; i < lcount; i++)
+				{
+					PxVec3 v1( vertices[0].mPos[0], vertices[0].mPos[1], vertices[0].mPos[2] );
+					PxVec3 v2( vertices[1].mPos[0], vertices[1].mPos[1], vertices[1].mPos[2] );
+					PxDebugLine l(v1,v2,vertices->mColor);
+					l.color1 = vertices[1].mColor;
+					if ( isScreenSpace )
+					{
+						mPxDebugLinesScreenSpace.pushBack(l);
+					}
+					else
+					{
+						mPxDebugLines.pushBack(l);
+					}
+					vertices += 2;
+				}
+			}
+			else
+#endif
+		{
+			mRenderLineCount += (lcount * 2);
+			if (mWireFrameMaterial == INVALID_RESOURCE_ID)
+			{
+				const char* mname = mApexSDK->getWireframeMaterial();
+				ResID name_space = mApexSDK->getInternalResourceProvider()->createNameSpace(APEX_MATERIALS_NAME_SPACE);
+				mWireFrameMaterial = mApexSDK->getInternalResourceProvider()->createResource(name_space, mname, true);
+			}
+
+			const uint32_t MAX_LINE_VERTEX = 2048;
+
+			PX_ASSERT((lcount * 2) <= MAX_LINE_VERTEX);
+
+			uint32_t rcount = (uint32_t)mRenderLineContexts.size();
+			RenderContext context;
+
+			UserRenderResource* resource;
+
+			if (rcount < mRenderLineResources.size())
+			{
+				resource = mRenderLineResources[rcount];
+			}
+			else
+			{
+				UserRenderResourceDesc resourceDesc;
+				UserRenderVertexBufferDesc vbdesc;
+				vbdesc.hint = RenderBufferHint::DYNAMIC;
+				vbdesc.buffersRequest[RenderVertexSemantic::POSITION] = RenderDataFormat::FLOAT3;
+				vbdesc.buffersRequest[RenderVertexSemantic::COLOR]    = RenderDataFormat::B8G8R8A8;
+				vbdesc.maxVerts = MAX_LINE_VERTEX;
+				resourceDesc.cullMode = RenderCullMode::NONE;
+
+				for (uint32_t i = 0; i < RenderVertexSemantic::NUM_SEMANTICS; i++)
+				{
+					PX_ASSERT(vbdesc.buffersRequest[i] == RenderDataFormat::UNSPECIFIED || vertexSemanticFormatValid((RenderVertexSemantic::Enum)i, vbdesc.buffersRequest[i]));
+				}
+
+				UserRenderVertexBuffer* vb = mApexSDK->getUserRenderResourceManager()->createVertexBuffer(vbdesc);
+				UserRenderVertexBuffer* vertexBuffers[1] = { vb };
+				resourceDesc.vertexBuffers = vertexBuffers;
+				resourceDesc.numVertexBuffers = 1;
+
+				resourceDesc.primitives = RenderPrimitiveType::LINES;
+
+				resource = mApexSDK->getUserRenderResourceManager()->createResource(resourceDesc);
+				resource->setMaterial(mApexSDK->getInternalResourceProvider()->getResource(mWireFrameMaterial));
+				mRenderLineResources.pushBack(resource);
+			}
+
+			UserRenderVertexBuffer* vb = resource->getVertexBuffer(0);
+
+			resource->setVertexBufferRange(0, lcount * 2);
+
+			RenderVertexBufferData writeData;
+			writeData.setSemanticData(RenderVertexSemantic::POSITION, vertices[0].mPos,   sizeof(RENDER_DEBUG::RenderDebugVertex), RenderDataFormat::FLOAT3);
+			writeData.setSemanticData(RenderVertexSemantic::COLOR,   &vertices[0].mColor, sizeof(RENDER_DEBUG::RenderDebugVertex), RenderDataFormat::B8G8R8A8);
+			vb->writeBuffer(writeData, 0, lcount * 2);
+
+			context.isScreenSpace = isScreenSpace;
+			context.local2world = PxMat44(PxIdentity);
+			context.renderResource = 0;
+			context.world2local = PxMat44(PxIdentity);
+
+			mRenderLineContexts.pushBack(context);
+		}
+
+	}
+
+	virtual void debugRenderTriangles(uint32_t tcount, const RENDER_DEBUG::RenderDebugSolidVertex* vertices, bool /*useZ*/, bool isScreenSpace)
+	{
+#if PX_PHYSICS_VERSION_MAJOR == 3
+			if (mUseDebugRenderable)
+			{
+				for (uint32_t i = 0; i < tcount; i++)
+				{
+					PxVec3 v1( vertices[0].mPos[0], vertices[0].mPos[1], vertices[0].mPos[2] );
+					PxVec3 v2( vertices[1].mPos[0], vertices[1].mPos[1], vertices[1].mPos[2] );
+					PxVec3 v3( vertices[2].mPos[0], vertices[2].mPos[1], vertices[2].mPos[2] );
+					PxDebugTriangle t( v1,v2, v3, vertices->mColor );
+					t.color1 = vertices[1].mColor;
+					t.color2 = vertices[2].mColor;
+					if ( isScreenSpace )
+					{
+						mPxDebugTrianglesScreenSpace.pushBack(t);
+					}
+					else
+					{
+						mPxDebugTriangles.pushBack(t);
+					}
+					vertices += 3;
+				}
+			}
+			else
+#endif
+		{
+
+			mRenderSolidCount += (tcount * 3);
+
+			if (mSolidShadedMaterial == INVALID_RESOURCE_ID)
+			{
+				const char* mname = mApexSDK->getSolidShadedMaterial();
+				ResID name_space = mApexSDK->getInternalResourceProvider()->createNameSpace(APEX_MATERIALS_NAME_SPACE);
+				mSolidShadedMaterial = mApexSDK->getInternalResourceProvider()->createResource(name_space, mname, true);
+			}
+
+			const uint32_t MAX_SOLID_VERTEX = 2048;
+			PX_ASSERT((tcount * 3) <= MAX_SOLID_VERTEX);
+
+			uint32_t rcount = (uint32_t)mRenderSolidContexts.size();
+			RenderContext context;
+
+			UserRenderResource* resource;
+
+			if (rcount < mRenderSolidResources.size())
+			{
+				resource = mRenderSolidResources[rcount];
+			}
+			else
+			{
+				UserRenderResourceDesc renderResourceDesc;
+				UserRenderVertexBufferDesc vbdesc;
+				vbdesc.hint = RenderBufferHint::DYNAMIC;
+				vbdesc.buffersRequest[RenderVertexSemantic::POSITION] = RenderDataFormat::FLOAT3;
+				vbdesc.buffersRequest[RenderVertexSemantic::NORMAL] = RenderDataFormat::FLOAT3;
+				vbdesc.buffersRequest[RenderVertexSemantic::COLOR]    = RenderDataFormat::B8G8R8A8;
+				vbdesc.maxVerts = MAX_SOLID_VERTEX;
+				renderResourceDesc.cullMode = RenderCullMode::COUNTER_CLOCKWISE;
+
+				for (uint32_t i = 0; i < RenderVertexSemantic::NUM_SEMANTICS; i++)
+				{
+					PX_ASSERT(vbdesc.buffersRequest[i] == RenderDataFormat::UNSPECIFIED || vertexSemanticFormatValid((RenderVertexSemantic::Enum)i, vbdesc.buffersRequest[i]));
+				}
+
+				UserRenderVertexBuffer* vb = mApexSDK->getUserRenderResourceManager()->createVertexBuffer(vbdesc);
+				UserRenderVertexBuffer* vertexBuffers[1] = { vb };
+				renderResourceDesc.vertexBuffers = vertexBuffers;
+				renderResourceDesc.numVertexBuffers = 1;
+
+				renderResourceDesc.primitives = RenderPrimitiveType::TRIANGLES;
+				resource = mApexSDK->getUserRenderResourceManager()->createResource(renderResourceDesc);
+				resource->setMaterial(mApexSDK->getInternalResourceProvider()->getResource(mSolidShadedMaterial));
+				mRenderSolidResources.pushBack(resource);
+			}
+
+			UserRenderVertexBuffer* vb = resource->getVertexBuffer(0);
+
+			resource->setVertexBufferRange(0, tcount * 3);
+
+			RenderVertexBufferData writeData;
+			writeData.setSemanticData(RenderVertexSemantic::POSITION, vertices[0].mPos,    sizeof(RENDER_DEBUG::RenderDebugSolidVertex), RenderDataFormat::FLOAT3);
+			writeData.setSemanticData(RenderVertexSemantic::NORMAL,   vertices[0].mNormal, sizeof(RENDER_DEBUG::RenderDebugSolidVertex), RenderDataFormat::FLOAT3);
+			writeData.setSemanticData(RenderVertexSemantic::COLOR,   &vertices[0].mColor,  sizeof(RENDER_DEBUG::RenderDebugSolidVertex), RenderDataFormat::B8G8R8A8);
+			vb->writeBuffer(writeData, 0, tcount * 3);
+
+			context.isScreenSpace = isScreenSpace;
+			context.local2world = PxMat44(PxIdentity);
+			context.renderResource = 0;
+			context.world2local = PxMat44(PxIdentity);
+
+			mRenderSolidContexts.pushBack(context);
+		}
+	}
+
+	virtual PxBounds3 getBounds() const { return PxBounds3(); }
+
+	virtual void releaseRenderDebug(void)
+	{
+		release();
+	}
+private:
+	static RENDER_DEBUG::RenderDebug*	mRenderDebugUntyped;	
+	RENDER_DEBUG::RenderDebugTyped*		mRenderDebug;
+	uint32_t                             mRenderSolidCount;
+	uint32_t                             mRenderLineCount;
+
+	uint32_t                             mLastRenderLineCount;
+	uint32_t                             mLastRenderSolidCount;
+	ApexSDKImpl*	mApexSDK;
+	ResID                           mWireFrameMaterial;
+	ResID                           mSolidShadedMaterial;
+	RenderResourceVector              mRenderLineResources;
+	RenderContextVector               mRenderLineContexts;
+
+	RenderResourceVector              mRenderSolidResources;
+	RenderContextVector               mRenderSolidContexts;
+
+	bool							  mUseDebugRenderable;
+#if PX_PHYSICS_VERSION_MAJOR == 3
+	physx::Array<PxDebugLine>		  mPxDebugLines;
+	physx::Array<PxDebugTriangle>	  mPxDebugTriangles;
+	physx::Array<PxDebugLine>		  mPxDebugLinesScreenSpace;
+	physx::Array<PxDebugTriangle>	  mPxDebugTrianglesScreenSpace;
+#endif
+	RENDER_DEBUG::RenderDebugInterface* mRenderDebugIface;
+};
+
+RENDER_DEBUG::RenderDebug*	ApexRenderDebug::mRenderDebugUntyped = NULL;
+
+RenderDebugInterface* createApexRenderDebug(ApexSDKImpl* a, RENDER_DEBUG::RenderDebugInterface* iface, bool useRemote)
+{
+	return PX_NEW(ApexRenderDebug)(a, iface, useRemote);
+}
+
+void releaseApexRenderDebug(RenderDebugInterface* n)
+{
+	delete static_cast< ApexRenderDebug*>(n);
+}
+
+#endif // WITHOUT_DEBUG_VISUALIZE
+
+}
+} // end namespace nvidia::apex
diff --git a/APEX_1.4/framework/src/ApexRenderMeshActor.cpp b/APEX_1.4/framework/src/ApexRenderMeshActor.cpp
new file mode 100644
index 00000000..a7bdc298
--- /dev/null
+++ b/APEX_1.4/framework/src/ApexRenderMeshActor.cpp
@@ -0,0 +1,2784 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "ApexRenderMeshActor.h"
+#include "FrameworkPerfScope.h"
+#include "PsAllocator.h"
+#include "RenderDebugInterface.h"
+#include "DebugRenderParams.h"
+
+#include "RenderContext.h"
+#include "RenderMeshActorDesc.h"
+#include "UserRenderBoneBuffer.h"
+#include "UserRenderBoneBufferDesc.h"
+#include "UserRenderIndexBuffer.h"
+#include "UserRenderIndexBufferDesc.h"
+#include "UserRenderResource.h"
+#include "UserRenderResourceDesc.h"
+#include "UserRenderVertexBuffer.h"
+#include "UserRenderer.h"
+
+#include "PsIntrinsics.h"
+#include "PxProfiler.h"
+
+#define VERBOSE 0
+
+namespace nvidia
+{
+namespace apex
+{
+// ApexRenderMeshActor methods
+
+ApexRenderMeshActor::ApexRenderMeshActor(const RenderMeshActorDesc& desc, ApexRenderMeshAsset& asset, ResourceList& list) :
+	mRenderMeshAsset(&asset),
+	mIndexBufferHint(RenderBufferHint::STATIC),
+	mMaxInstanceCount(0),
+	mInstanceCount(0),
+	mInstanceOffset(0),
+	mInstanceBuffer(NULL),
+	mRenderResource(NULL),
+	mRenderWithoutSkinning(false),
+	mForceBoneIndexChannel(false),
+	mApiVisibilityChanged(false),
+	mPartVisibilityChanged(false),
+	mInstanceCountChanged(false),
+	mKeepVisibleBonesPacked(false),
+	mForceFallbackSkinning(false),
+	mBonePosesDirty(false),
+	mOneUserVertexBufferChanged(false),
+	mBoneBufferInUse(false),
+	mReleaseResourcesIfNothingToRender(true),
+	mCreateRenderResourcesAfterInit(false),
+	mBufferVisibility(false),
+	mKeepPreviousFrameBoneBuffer(false),
+	mPreviousFrameBoneBufferValid(false),
+	mSkinningMode(RenderMeshActorSkinningMode::Default)
+{
+#if ENABLE_INSTANCED_MESH_CLEANUP_HACK
+	mOrderedInstanceTemp     = 0;
+	mOrderedInstanceTempSize = 0;
+#endif
+	list.add(*this);
+	init(desc, (uint16_t) asset.getPartCount(), (uint16_t) asset.getBoneCount());
+}
+
+ApexRenderMeshActor::~ApexRenderMeshActor()
+{
+#if ENABLE_INSTANCED_MESH_CLEANUP_HACK
+	if (mOrderedInstanceTemp)
+	{
+		PX_FREE(mOrderedInstanceTemp);
+		mOrderedInstanceTemp = 0;
+	}
+#endif
+}
+
+void ApexRenderMeshActor::release()
+{
+	if (mInRelease)
+	{
+		return;
+	}
+	mInRelease = true;
+	mRenderMeshAsset->releaseActor(*this);
+}
+
+void ApexRenderMeshActor::destroy()
+{
+	ApexActor::destroy();
+
+	releaseRenderResources();
+
+	// Release named resources
+	ResourceProviderIntl* resourceProvider = GetInternalApexSDK()->getInternalResourceProvider();
+	if (resourceProvider != NULL)
+	{
+		for (uint32_t i = 0; i < mSubmeshData.size(); i++)
+		{
+			if (mSubmeshData[i].materialID != mRenderMeshAsset->mMaterialIDs[i])
+			{
+				resourceProvider->releaseResource(mSubmeshData[i].materialID);
+			}
+			mSubmeshData[i].materialID = INVALID_RESOURCE_ID;
+			mSubmeshData[i].material = NULL;
+			mSubmeshData[i].isMaterialPointerValid = false;
+		}
+	}
+
+	delete this;
+}
+
+
+void ApexRenderMeshActor::loadMaterial(SubmeshData& submeshData)
+{
+	ResourceProviderIntl* resourceProvider = GetInternalApexSDK()->getInternalResourceProvider();
+	submeshData.material = resourceProvider->getResource(submeshData.materialID);
+	submeshData.isMaterialPointerValid = true;
+
+	if (submeshData.material != NULL)
+	{
+		UserRenderResourceManager* rrm = GetInternalApexSDK()->getUserRenderResourceManager();
+		submeshData.maxBonesPerMaterial = rrm->getMaxBonesForMaterial(submeshData.material);
+
+		if (submeshData.maxBonesPerMaterial == 0)
+		{
+			submeshData.maxBonesPerMaterial = mRenderMeshAsset->getBoneCount();
+		}
+	}
+}
+
+
+void ApexRenderMeshActor::init(const RenderMeshActorDesc& desc, uint16_t partCount, uint16_t boneCount)
+{
+	// TODO - LRR - This happened once, it shouldn't happen any more, let me know if it does
+	//PX_ASSERT(boneCount != 0);
+	//if (boneCount == 0)
+	//	boneCount = partCount;
+
+	mRenderWithoutSkinning = desc.renderWithoutSkinning;
+	mForceBoneIndexChannel = desc.forceBoneIndexChannel;
+
+	if (mRenderWithoutSkinning)
+	{
+		boneCount = 1;
+	}
+
+	const uint32_t oldBoneCount = mTransforms.size();
+	mTransforms.resize(boneCount);
+	for (uint32_t i = oldBoneCount; i < boneCount; ++i)
+	{
+		mTransforms[i] = PxMat44(PxIdentity);
+	}
+
+	mVisiblePartsForAPI.reserve(partCount);
+	mVisiblePartsForAPI.lockCapacity(true);
+	mVisiblePartsForRendering.reserve(partCount);
+	mVisiblePartsForRendering.reset();	// size to 0, without reallocating
+
+	mBufferVisibility = desc.bufferVisibility;
+
+	mKeepPreviousFrameBoneBuffer = desc.keepPreviousFrameBoneBuffer;
+	mPreviousFrameBoneBufferValid = false;
+
+	mApiVisibilityChanged = true;
+	mPartVisibilityChanged = !mBufferVisibility;
+
+	for (uint32_t i = 0; i < partCount; ++i)
+	{
+		setVisibility(desc.visible, (uint16_t) i);
+	}
+
+	mIndexBufferHint  = desc.indexBufferHint;
+	mMaxInstanceCount = desc.maxInstanceCount;
+	mInstanceCount    = 0;
+	mInstanceOffset   = 0;
+	mInstanceBuffer   = NULL;
+
+	if (desc.keepVisibleBonesPacked && !mRenderWithoutSkinning)
+	{
+		if (mRenderMeshAsset->getBoneCount() == mRenderMeshAsset->getPartCount())
+		{
+			mKeepVisibleBonesPacked = true;
+		}
+		else
+		{
+			APEX_INVALID_PARAMETER("RenderMeshActorDesc::keepVisibleBonesPacked is only allowed when the number of bones (%d) equals the number of parts (%d)\n",
+			                       mRenderMeshAsset->getBoneCount(), mRenderMeshAsset->getPartCount());
+		}
+	}
+
+	if (desc.forceFallbackSkinning)
+	{
+		if (mKeepVisibleBonesPacked)
+		{
+			APEX_INVALID_PARAMETER("RenderMeshActorDesc::forceFallbackSkinning can not be used when RenderMeshActorDesc::keepVisibleBonesPacked is also used!\n");
+		}
+		else
+		{
+			mForceFallbackSkinning = true;
+		}
+	}
+
+	ResourceProviderIntl* resourceProvider = GetInternalApexSDK()->getInternalResourceProvider();
+	ResID materialNS = GetInternalApexSDK()->getMaterialNameSpace();
+
+	bool loadMaterialsOnActorCreation = !GetInternalApexSDK()->getRMALoadMaterialsLazily();
+
+	if (mRenderWithoutSkinning)
+	{
+		// make sure that createRenderResources() is called in this special case!
+		mCreateRenderResourcesAfterInit = true;
+	}
+
+	mSubmeshData.reserve(mRenderMeshAsset->getSubmeshCount());
+	for (uint32_t submeshIndex = 0; submeshIndex < mRenderMeshAsset->getSubmeshCount(); submeshIndex++)
+	{
+		SubmeshData submeshData;
+
+		// Resolve override material names using the NRP...
+		if (submeshIndex < desc.overrideMaterialCount && resourceProvider != NULL)
+		{
+			submeshData.materialID = resourceProvider->createResource(materialNS, desc.overrideMaterials[submeshIndex]);;
+		}
+		else
+		{
+			submeshData.materialID = mRenderMeshAsset->mMaterialIDs[submeshIndex];
+		}
+
+		submeshData.maxBonesPerMaterial = 0;
+
+		if (loadMaterialsOnActorCreation)
+		{
+			loadMaterial(submeshData);
+		}
+
+		mSubmeshData.pushBack(submeshData);
+	}
+}
+
+bool ApexRenderMeshActor::setVisibility(bool visible, uint16_t partIndex)
+{
+	WRITE_ZONE();
+	uint32_t oldRank = UINT32_MAX, newRank = UINT32_MAX;
+
+	bool changed;
+
+	if (visible)
+	{
+		changed = mVisiblePartsForAPI.useAndReturnRanks(partIndex, newRank, oldRank);
+		if (changed)
+		{
+			mApiVisibilityChanged = true;
+			if (!mBufferVisibility)
+			{
+				mPartVisibilityChanged = true;
+			}
+			if (mKeepVisibleBonesPacked && newRank != oldRank)
+			{
+				mTMSwapBuffer.pushBack(newRank << 16 | oldRank);
+			}
+		}
+	}
+	else
+	{
+		changed = mVisiblePartsForAPI.freeAndReturnRanks(partIndex, newRank, oldRank);
+		if (changed)
+		{
+			mApiVisibilityChanged = true;
+			if (!mBufferVisibility)
+			{
+				mPartVisibilityChanged = true;
+			}
+			if (mKeepVisibleBonesPacked && newRank != oldRank)
+			{
+				mTMSwapBuffer.pushBack(newRank << 16 | oldRank);
+			}
+		}
+	}
+
+	return changed;
+}
+
+bool ApexRenderMeshActor::getVisibilities(uint8_t* visibilityArray, uint32_t visibilityArraySize) const
+{
+	READ_ZONE();
+	uint8_t changed = 0;
+	const uint32_t numParts = PxMin(mRenderMeshAsset->getPartCount(), visibilityArraySize);
+	for (uint32_t index = 0; index < numParts; ++index)
+	{
+		const uint8_t newVisibility = (uint8_t)isVisible((uint16_t) index);
+		changed |= newVisibility ^(*visibilityArray);
+		*visibilityArray++ = newVisibility;
+	}
+	return changed != 0;
+}
+
+void ApexRenderMeshActor::updateRenderResources(bool rewriteBuffers, void* userRenderData)
+{
+	updateRenderResources(!mRenderWithoutSkinning, rewriteBuffers, userRenderData);
+}
+
+void ApexRenderMeshActor::updateRenderResources(bool useBones, bool rewriteBuffers, void* userRenderData)
+{
+	URR_SCOPE;
+
+#if VERBOSE > 1
+	printf("updateRenderResources(useBones=%s, rewriteBuffers=%s, userRenderData=0x%p)\n", useBones ? "true" : "false", rewriteBuffers ? "true" : "false", userRenderData);
+#endif
+
+	UserRenderResourceManager* rrm = GetInternalApexSDK()->getUserRenderResourceManager();
+
+	// fill out maxBonesPerMaterial (if it hasn't already been filled out). Also create fallback skinning if necessary.
+	for (uint32_t submeshIndex = 0; submeshIndex < mSubmeshData.size(); submeshIndex++)
+	{
+		SubmeshData& submeshData = mSubmeshData[submeshIndex];
+
+		if (submeshData.maxBonesPerMaterial == 0 && rrm != NULL)
+		{
+			if (!submeshData.isMaterialPointerValid)
+			{
+				// this should only be reached, when renderMeshActorLoadMaterialsLazily is true.
+				// URR may not be called asynchronously in that case (for example in a render thread)
+				ResourceProviderIntl* nrp = GetInternalApexSDK()->getInternalResourceProvider();
+				submeshData.material = nrp->getResource(submeshData.materialID);
+				submeshData.isMaterialPointerValid = true;
+			}
+
+			submeshData.maxBonesPerMaterial = rrm->getMaxBonesForMaterial(submeshData.material);
+
+			if (submeshData.maxBonesPerMaterial == 0)
+			{
+				submeshData.maxBonesPerMaterial = mRenderMeshAsset->getBoneCount();
+			}
+		}
+
+		bool needsFallbackSkinning = mForceFallbackSkinning || submeshData.maxBonesPerMaterial < mTransforms.size();
+		if (needsFallbackSkinning && !mKeepVisibleBonesPacked && submeshData.fallbackSkinningMemory == NULL)
+		{
+			createFallbackSkinning(submeshIndex);
+		}
+	}
+
+	PX_PROFILE_ZONE("ApexRenderMesh::updateRenderResources", GetInternalApexSDK()->getContextId());
+
+	const bool invisible = visiblePartCount() == 0;
+	const bool instanceless = mMaxInstanceCount > 0 && mInstanceCount == 0;
+	if ((mReleaseResourcesIfNothingToRender && ((mPartVisibilityChanged && invisible) || (mInstanceCountChanged && instanceless))) || rewriteBuffers)
+	{
+		// First send out signals that the resource is no longer needed.
+		for (uint32_t submeshIndex = 0; submeshIndex < mSubmeshData.size(); ++submeshIndex)
+		{
+			SubmeshData& submeshData = mSubmeshData[submeshIndex];
+			for (uint32_t i = 0; i < submeshData.renderResources.size(); ++i)
+			{
+				UserRenderResource* renderResource = submeshData.renderResources[i].resource;
+				if (renderResource != NULL)
+				{
+					if (renderResource->getBoneBuffer() != NULL)
+					{
+						renderResource->setBoneBufferRange(0, 0);
+					}
+					if (renderResource->getInstanceBuffer() != NULL)
+					{
+						renderResource->setInstanceBufferRange(0, 0);
+					}
+				}
+			}
+		}
+
+		// Now release the resources
+		releaseRenderResources();
+		mPartVisibilityChanged = false;
+		mBonePosesDirty = false;
+		mInstanceCountChanged = false;
+
+		// Rewrite buffers condition
+		if (rewriteBuffers)
+		{
+			mCreateRenderResourcesAfterInit = true; // createRenderResources
+			mPartVisibilityChanged = true; // writeBuffer for submesh data
+		}
+
+		return;
+	}
+
+	if (mCreateRenderResourcesAfterInit || mOneUserVertexBufferChanged || mPartVisibilityChanged || mBoneBufferInUse != useBones)
+	{
+		createRenderResources(useBones, userRenderData);
+		mCreateRenderResourcesAfterInit = false;
+	}
+	if (mRenderResource)
+	{
+		mRenderResource->setInstanceBufferRange(mInstanceOffset, mInstanceCount);
+	}
+
+	PX_ASSERT(mSubmeshData.size() == mRenderMeshAsset->getSubmeshCount());
+
+	for (uint32_t submeshIndex = 0; submeshIndex < mRenderMeshAsset->getSubmeshCount(); ++submeshIndex)
+	{
+		SubmeshData& submeshData = mSubmeshData[submeshIndex];
+
+		if (submeshData.indexBuffer == NULL)
+		{
+			continue;
+		}
+
+		if (mPartVisibilityChanged || submeshData.staticColorReplacementDirty)
+		{
+			updatePartVisibility(submeshIndex, useBones, userRenderData);
+			submeshData.staticColorReplacementDirty = false;
+		}
+		if (mBonePosesDirty)
+		{
+			if (submeshData.userDynamicVertexBuffer && !submeshData.userSpecifiedData)
+			{
+				updateFallbackSkinning(submeshIndex);
+			}
+
+			// Set up the previous bone buffer, if requested and available.  If we're packing bones, we need to do a remapping
+			PX_ASSERT(!mPreviousFrameBoneBufferValid || mTransformsLastFrame.size() == mTransforms.size());
+			const uint32_t tmBufferSize = mKeepVisibleBonesPacked ? getRenderVisiblePartCount() : mTransforms.size();
+			if (mPreviousFrameBoneBufferValid && mTransformsLastFrame.size() == mTransforms.size() && mKeepVisibleBonesPacked)
+			{
+				mRemappedPreviousBoneTMs.resize(tmBufferSize);
+				for (uint32_t tmNum = 0; tmNum < tmBufferSize; ++tmNum)
+				{
+					mRemappedPreviousBoneTMs[tmNum] = mTransformsLastFrame[mVisiblePartsForAPILastFrame.getRank(mVisiblePartsForAPI.usedIndices()[tmNum])];
+				}
+			}
+			else
+			{
+				mRemappedPreviousBoneTMs.resize(0);
+			}
+
+			updateBonePoses(submeshIndex);
+
+			// move this under the render lock because the fracture buffer processing accesses these arrays
+			// this used to be at the end of dispatchRenderResources
+			if (mKeepPreviousFrameBoneBuffer)
+			{
+				PX_ASSERT(mTransforms.size() != 0);
+				mTransformsLastFrame = mTransforms;
+				mVisiblePartsForAPILastFrame = mVisiblePartsForAPI;
+				mPreviousFrameBoneBufferValid = true;
+			}
+		}
+
+		if (submeshData.userDynamicVertexBuffer && (submeshData.fallbackSkinningDirty || submeshData.userVertexBufferAlwaysDirty))
+		{
+			writeUserBuffers(submeshIndex);
+			submeshData.fallbackSkinningDirty = false;
+		}
+
+		if (mMaxInstanceCount)
+		{
+			updateInstances(submeshIndex);
+		}
+
+		if (!submeshData.isMaterialPointerValid)
+		{
+			// this should only be reached, when renderMeshActorLoadMaterialsLazily is true.
+			// URR may not be called asynchronously in that case (for example in a render thread)
+			ResourceProviderIntl* nrp = GetInternalApexSDK()->getInternalResourceProvider();
+			submeshData.material = nrp->getResource(submeshData.materialID);
+			submeshData.isMaterialPointerValid = true;
+		}
+
+		for (uint32_t i = 0; i < submeshData.renderResources.size(); ++i)
+		{
+			UserRenderResource* res = submeshData.renderResources[i].resource;
+			if (res != NULL)
+			{
+				// LRR - poor workaround for http://nvbugs/534501, you'll crash here if you have more than 60 bones/material
+				// and keepVisibleBonesPacked == false
+				res->setMaterial(submeshData.material);
+			}
+		}
+	}
+	mBonePosesDirty = false;
+	mPartVisibilityChanged = false;
+}
+
+
+
+void ApexRenderMeshActor::dispatchRenderResources(UserRenderer& renderer)
+{
+	dispatchRenderResources(renderer, PxMat44(PxIdentity));
+}
+
+
+
+void ApexRenderMeshActor::dispatchRenderResources(UserRenderer& renderer, const PxMat44& globalPose)
+{
+	PX_PROFILE_ZONE("ApexRenderMesh::dispatchRenderResources", GetInternalApexSDK()->getContextId());
+
+	RenderContext context;
+
+	// Assign the transform to the context when there is 1 part and no instancing
+
+	// if there are no parts to render, return early
+	// else if using instancing and there are not instances, return early
+	// else if not using instancing and there is just 1 part (no bone buffer), save the transform to the context
+	// else (using instancing and/or multiple parts), just assign identity to context
+	if (mRenderMeshAsset->getPartCount() == 0 && !mRenderMeshAsset->getOpaqueMesh())
+	{
+		return;
+	}
+	else if (mInstanceCount == 0 && mMaxInstanceCount > 0)
+	{
+		return;
+	}
+	else if (mMaxInstanceCount == 0 && mTransforms.size() == 1)
+	{
+		context.local2world = globalPose * mTransforms[0]; // provide context for non-instanced ARMs with a single bone
+		context.world2local = context.local2world.inverseRT();
+	}
+	else
+	{
+		context.local2world = globalPose;
+		context.world2local = globalPose.inverseRT();
+	}
+	if (mRenderMeshAsset->getOpaqueMesh())
+	{
+		if (mRenderResource)
+		{
+			context.renderResource = mRenderResource;
+			renderer.renderResource(context);
+		}
+	}
+	else
+	{
+		for (uint32_t submeshIndex = 0; submeshIndex < mSubmeshData.size(); ++submeshIndex)
+		{
+			for (uint32_t i = 0; i < mSubmeshData[submeshIndex].renderResources.size(); ++i)
+			{
+				context.renderResource = mSubmeshData[submeshIndex].renderResources[i].resource;
+
+				// no reason to render if we don't have any indices
+				if ((mSubmeshData[submeshIndex].indexBuffer && (mSubmeshData[submeshIndex].visibleTriangleCount == 0)) || (mSubmeshData[submeshIndex].renderResources[i].vertexCount == 0))
+				{
+					continue;
+				}
+
+				if (context.renderResource)
+				{
+                    context.renderMeshName = mRenderMeshAsset->getName();
+					renderer.renderResource(context);
+				}
+			}
+		}
+	}
+}
+
+
+
+void ApexRenderMeshActor::addVertexBuffer(uint32_t submeshIndex, bool alwaysDirty, PxVec3* position, PxVec3* normal, PxVec4* tangents)
+{
+#if VERBOSE
+	GetInternalApexSDK()->getErrorCallback().reportError(PxErrorCode::eNO_ERROR, "addVertexBuffer\n", __FILE__, __LINE__);
+	printf("addVertexBuffer(submeshIndex=%d)\n", submeshIndex);
+#endif
+	if (submeshIndex < mSubmeshData.size())
+	{
+		SubmeshData& submeshData = mSubmeshData[submeshIndex];
+
+		if (submeshData.userSpecifiedData)
+		{
+			APEX_INVALID_PARAMETER("Cannot add user buffer to submesh %d, it's already assigned!", submeshIndex);
+		}
+		else
+		{
+			submeshData.userSpecifiedData = true;
+			submeshData.userPositions = position;
+			submeshData.userNormals = normal;
+			submeshData.userTangents4 = tangents;
+
+			submeshData.userVertexBufferAlwaysDirty = alwaysDirty;
+			mOneUserVertexBufferChanged = true;
+		}
+	}
+}
+
+
+
+void ApexRenderMeshActor::removeVertexBuffer(uint32_t submeshIndex)
+{
+#if VERBOSE
+	GetInternalApexSDK()->getErrorCallback().reportError(PxErrorCode::eNO_ERROR, "removeVertexBuffer\n", __FILE__, __LINE__);
+	printf("removeVertexBuffer(submeshIndex=%d)\n", submeshIndex);
+#endif
+	if (submeshIndex < mSubmeshData.size())
+	{
+		SubmeshData& submeshData = mSubmeshData[submeshIndex];
+
+		if (!submeshData.userSpecifiedData)
+		{
+			APEX_INVALID_PARAMETER("Cannot remove user buffer to submesh %d, it's not assigned!", submeshIndex);
+		}
+		else
+		{
+			submeshData.userSpecifiedData = false;
+			submeshData.userPositions = NULL;
+			submeshData.userNormals = NULL;
+			submeshData.userTangents4 = NULL;
+
+			submeshData.userVertexBufferAlwaysDirty = false;
+			mOneUserVertexBufferChanged = true;
+
+			if (submeshData.fallbackSkinningMemory != NULL)
+			{
+				distributeFallbackData(submeshIndex);
+			}
+		}
+	}
+}
+
+
+
+void ApexRenderMeshActor::setStaticPositionReplacement(uint32_t submeshIndex, const PxVec3* staticPositions)
+{
+	PX_ASSERT(staticPositions != NULL);
+
+	PX_ASSERT(submeshIndex < mSubmeshData.size());
+	if (submeshIndex < mSubmeshData.size())
+	{
+		SubmeshData& submeshData = mSubmeshData[submeshIndex];
+
+		PX_ASSERT(submeshData.staticPositionReplacement == NULL);
+		submeshData.staticPositionReplacement = staticPositions;
+
+		PX_ASSERT(submeshData.staticBufferReplacement == NULL);
+		PX_ASSERT(submeshData.dynamicBufferReplacement == NULL);
+	}
+}
+
+void ApexRenderMeshActor::setStaticColorReplacement(uint32_t submeshIndex, const ColorRGBA* staticColors)
+{
+	PX_ASSERT(staticColors != NULL);
+
+	PX_ASSERT(submeshIndex < mSubmeshData.size());
+	if (submeshIndex < mSubmeshData.size())
+	{
+		SubmeshData& submeshData = mSubmeshData[submeshIndex];
+
+		submeshData.staticColorReplacement = staticColors;
+		submeshData.staticColorReplacementDirty = true;
+	}
+}
+
+
+
+void ApexRenderMeshActor::setInstanceBuffer(UserRenderInstanceBuffer* instBuf)
+{
+	WRITE_ZONE();
+	mInstanceBuffer = instBuf;
+
+	for (nvidia::Array<SubmeshData>::Iterator it = mSubmeshData.begin(), end = mSubmeshData.end(); it != end; ++it)
+	{
+		it->instanceBuffer = mInstanceBuffer;
+		it->userIndexBufferChanged = true;
+	}
+
+	mOneUserVertexBufferChanged = true;
+}
+
+void ApexRenderMeshActor::setMaxInstanceCount(uint32_t count)
+{
+	WRITE_ZONE();
+	mMaxInstanceCount = count;
+}
+
+void ApexRenderMeshActor::setInstanceBufferRange(uint32_t from, uint32_t count)
+{
+	WRITE_ZONE();
+	mInstanceOffset = from;
+	mInstanceCountChanged = count != mInstanceCount;
+	mInstanceCount = count < mMaxInstanceCount ? count : mMaxInstanceCount;
+}
+
+
+
+void ApexRenderMeshActor::getLodRange(float& min, float& max, bool& intOnly) const
+{
+	READ_ZONE();
+	PX_UNUSED(min);
+	PX_UNUSED(max);
+	PX_UNUSED(intOnly);
+	APEX_INVALID_OPERATION("RenderMeshActor does not support this operation");
+}
+
+
+
+float ApexRenderMeshActor::getActiveLod() const
+{
+	READ_ZONE();
+	APEX_INVALID_OPERATION("RenderMeshActor does not support this operation");
+	return -1.0f;
+}
+
+void ApexRenderMeshActor::forceLod(float lod)
+{
+	WRITE_ZONE();
+	PX_UNUSED(lod);
+	APEX_INVALID_OPERATION("RenderMeshActor does not support this operation");
+}
+
+
+
+void ApexRenderMeshActor::createRenderResources(bool useBones, void* userRenderData)
+{
+#if VERBOSE
+	printf("createRenderResources(useBones=%s, userRenderData=0x%p)\n", useBones ? "true" : "false", userRenderData);
+#endif
+
+	PX_PROFILE_ZONE("ApexRenderMesh::createRenderResources", GetInternalApexSDK()->getContextId());
+
+	if (mRenderMeshAsset->getOpaqueMesh())
+	{
+		if (mRenderResource == NULL || mRenderResource->getInstanceBuffer() != mInstanceBuffer)
+		{
+			UserRenderResourceManager* rrm = GetInternalApexSDK()->getUserRenderResourceManager();
+			if (mRenderResource != NULL)
+			{
+				rrm->releaseResource(*mRenderResource);
+				mRenderResource = NULL;
+			}
+
+			UserRenderResourceDesc desc;
+			desc.instanceBuffer = mInstanceBuffer;
+			desc.opaqueMesh = mRenderMeshAsset->getOpaqueMesh();
+			desc.userRenderData = userRenderData;
+			mRenderResource = rrm->createResource(desc);
+		}
+	}
+
+	PX_ASSERT(mSubmeshData.size() == mRenderMeshAsset->getSubmeshCount());
+
+	UserRenderResourceManager* rrm = GetInternalApexSDK()->getUserRenderResourceManager();
+
+	bool createAndFillSharedVertexBuffersAll = mOneUserVertexBufferChanged;
+	if (mRenderMeshAsset->mRuntimeSubmeshData.empty())
+	{
+		mRenderMeshAsset->mRuntimeSubmeshData.resize(mRenderMeshAsset->getSubmeshCount());
+		memset(mRenderMeshAsset->mRuntimeSubmeshData.begin(), 0, sizeof(ApexRenderMeshAsset::SubmeshData) * mRenderMeshAsset->mRuntimeSubmeshData.size());
+		createAndFillSharedVertexBuffersAll = true;
+	}
+
+	bool fill2ndVertexBuffersAll = false;
+	if (!mPerActorVertexBuffers.size())
+	{
+		// Create a separate (instanced) buffer for bone indices and/or colors
+		fill2ndVertexBuffersAll = mKeepVisibleBonesPacked;
+		for (uint32_t submeshIndex = 0; !fill2ndVertexBuffersAll && submeshIndex < mRenderMeshAsset->getSubmeshCount(); ++submeshIndex)
+		{
+			fill2ndVertexBuffersAll = (mSubmeshData[submeshIndex].staticColorReplacement != NULL);
+		}
+		if (fill2ndVertexBuffersAll)
+		{
+			mPerActorVertexBuffers.resize(mRenderMeshAsset->getSubmeshCount());
+		}
+	}
+
+	PX_ASSERT(mRenderMeshAsset->mRuntimeSubmeshData.size() == mSubmeshData.size());
+	PX_ASSERT(mRenderMeshAsset->getSubmeshCount() == mSubmeshData.size());
+	for (uint32_t submeshIndex = 0; submeshIndex < mRenderMeshAsset->getSubmeshCount(); ++submeshIndex)
+	{
+		ApexRenderSubmesh& submesh = *mRenderMeshAsset->mSubmeshes[submeshIndex];
+		SubmeshData& submeshData = mSubmeshData[submeshIndex];
+
+		if (submesh.getVertexBuffer().getVertexCount() == 0 || !submeshHasVisibleTriangles(submeshIndex))
+		{
+			for (uint32_t i = 0; i < submeshData.renderResources.size(); ++i)
+			{
+				if (submeshData.renderResources[i].resource != NULL)
+				{
+					UserRenderBoneBuffer* boneBuffer = submeshData.renderResources[i].resource->getBoneBuffer();
+					rrm->releaseResource(*submeshData.renderResources[i].resource);
+					if (boneBuffer)
+					{
+						rrm->releaseBoneBuffer(*boneBuffer);
+					}
+					submeshData.renderResources[i].resource = NULL;
+				}
+			}
+			continue;
+		}
+
+		bool fill2ndVertexBuffers = fill2ndVertexBuffersAll;
+		// Handling color replacement through "2nd vertex buffer"
+		if ((mKeepVisibleBonesPacked || submeshData.staticColorReplacement != NULL) && mPerActorVertexBuffers[submeshIndex] == NULL)
+		{
+			fill2ndVertexBuffers = true;
+		}
+
+		bool createAndFillSharedVertexBuffers = createAndFillSharedVertexBuffersAll;
+
+		// create vertex buffers if some buffer replacements are present in the actor
+		if (submeshData.staticPositionReplacement != NULL && submeshData.staticBufferReplacement == NULL && submeshData.dynamicBufferReplacement == NULL)
+		{
+			createAndFillSharedVertexBuffers = true;
+		}
+
+		{
+			ApexRenderMeshAsset::SubmeshData& runtimeSubmeshData = mRenderMeshAsset->mRuntimeSubmeshData[submeshIndex];
+			if (runtimeSubmeshData.staticVertexBuffer == NULL && runtimeSubmeshData.dynamicVertexBuffer == NULL && runtimeSubmeshData.skinningVertexBuffer == NULL)
+			{
+				createAndFillSharedVertexBuffers = true;
+			}
+
+			// create vertex buffers if not all static vertex buffers have been created by the previous actors that were doing this
+			if (runtimeSubmeshData.needsStaticData && runtimeSubmeshData.staticVertexBuffer == NULL)
+			{
+				createAndFillSharedVertexBuffers = true;
+			}
+
+			if (runtimeSubmeshData.needsDynamicData && runtimeSubmeshData.dynamicVertexBuffer == NULL)
+			{
+				createAndFillSharedVertexBuffers = true;
+			}
+		}
+
+
+		VertexBufferIntl& srcVB = submesh.getVertexBufferWritable();
+		const VertexFormat& vf = srcVB.getFormat();
+
+		bool fillStaticSharedVertexBuffer = false;
+		bool fillDynamicSharedVertexBuffer = false;
+		bool fillSkinningSharedVertexBuffer = false;
+
+		if (createAndFillSharedVertexBuffers)
+		{
+			UserRenderVertexBufferDesc staticBufDesc, dynamicBufDesc, boneBufDesc;
+			staticBufDesc.moduleIdentifier = mRenderMeshAsset->mOwnerModuleID;
+			staticBufDesc.maxVerts = srcVB.getVertexCount();
+			staticBufDesc.hint = RenderBufferHint::STATIC;
+			staticBufDesc.uvOrigin = mRenderMeshAsset->getTextureUVOrigin();
+			staticBufDesc.numCustomBuffers = 0;
+			staticBufDesc.canBeShared = true;
+
+			dynamicBufDesc = staticBufDesc;
+			boneBufDesc = dynamicBufDesc;
+			bool useDynamicBuffer = false;
+			bool replaceStaticBuffer = false;
+			bool replaceDynamicBuffer = false;
+
+			// extract all the buffers into one of the three descs
+			for (uint32_t i = 0; i < vf.getBufferCount(); ++i)
+			{
+				RenderVertexSemantic::Enum semantic = vf.getBufferSemantic(i);
+				if (semantic >= RenderVertexSemantic::POSITION && semantic <= RenderVertexSemantic::COLOR)
+				{
+					if (vf.getBufferAccess(i) == RenderDataAccess::STATIC)
+					{
+						staticBufDesc.buffersRequest[semantic]	= vf.getBufferFormat(i);
+
+						if (semantic == RenderVertexSemantic::POSITION && submeshData.staticPositionReplacement != NULL)
+						{
+							replaceStaticBuffer = true;
+						}
+					}
+					else
+					{
+						dynamicBufDesc.buffersRequest[semantic]	= vf.getBufferFormat(i);
+						useDynamicBuffer = true;
+
+						if (semantic == RenderVertexSemantic::POSITION && submeshData.staticPositionReplacement != NULL)
+						{
+							replaceDynamicBuffer = true;
+						}
+					}
+				}
+				else if (semantic == RenderVertexSemantic::CUSTOM)
+				{
+					++staticBufDesc.numCustomBuffers;
+				}
+			}
+
+			if (staticBufDesc.numCustomBuffers)
+			{
+				staticBufDesc.customBuffersIdents = &mRenderMeshAsset->mRuntimeCustomSubmeshData[submeshIndex].customBufferVoidPtrs[0];
+				staticBufDesc.customBuffersRequest = &mRenderMeshAsset->mRuntimeCustomSubmeshData[submeshIndex].customBufferFormats[0];
+			}
+
+			// PH: only create bone indices/weights if more than one bone is present. one bone just needs local2world
+			if (mTransforms.size() > 1)
+			{
+				UserRenderVertexBufferDesc* boneDesc = vf.hasSeparateBoneBuffer() ? &boneBufDesc : &staticBufDesc;
+
+				if (!fill2ndVertexBuffers)
+				{
+					uint32_t bufferIndex = (uint32_t)vf.getBufferIndexFromID(vf.getSemanticID(RenderVertexSemantic::BONE_INDEX));
+					boneDesc->buffersRequest[RenderVertexSemantic::BONE_INDEX] = vf.getBufferFormat(bufferIndex);
+					bufferIndex = (uint32_t)vf.getBufferIndexFromID(vf.getSemanticID(RenderVertexSemantic::BONE_WEIGHT));
+					boneDesc->buffersRequest[RenderVertexSemantic::BONE_WEIGHT] = vf.getBufferFormat(bufferIndex);
+				}
+			}
+			else
+			if (mForceBoneIndexChannel)
+			{
+				// Note, it is assumed here that this means there's an actor which will handle dynamic parts, and will require a shared bone index buffer
+				UserRenderVertexBufferDesc* boneDesc = vf.hasSeparateBoneBuffer() ? &boneBufDesc : &staticBufDesc;
+
+				if (!fill2ndVertexBuffers)
+				{
+					uint32_t bufferIndex = (uint32_t)vf.getBufferIndexFromID(vf.getSemanticID(RenderVertexSemantic::BONE_INDEX));
+					boneDesc->buffersRequest[RenderVertexSemantic::BONE_INDEX] = vf.getBufferFormat(bufferIndex);
+				}
+			}
+
+			for (uint32_t semantic = RenderVertexSemantic::TEXCOORD0; semantic <= RenderVertexSemantic::TEXCOORD3; ++semantic)
+			{
+				uint32_t bufferIndex = (uint32_t)vf.getBufferIndexFromID(vf.getSemanticID((RenderVertexSemantic::Enum)semantic));
+				staticBufDesc.buffersRequest[ semantic ]	= vf.getBufferFormat(bufferIndex);
+			}
+
+			{
+				uint32_t bufferIndex = (uint32_t)vf.getBufferIndexFromID(vf.getSemanticID(RenderVertexSemantic::DISPLACEMENT_TEXCOORD));
+				staticBufDesc.buffersRequest[ RenderVertexSemantic::DISPLACEMENT_TEXCOORD ] = vf.getBufferFormat(bufferIndex);
+				bufferIndex       = (uint32_t)vf.getBufferIndexFromID(vf.getSemanticID(RenderVertexSemantic::DISPLACEMENT_FLAGS));
+				staticBufDesc.buffersRequest[ RenderVertexSemantic::DISPLACEMENT_FLAGS ] = vf.getBufferFormat(bufferIndex);
+			}
+
+			// empty static buffer?
+			uint32_t numEntries = staticBufDesc.numCustomBuffers;
+			for (uint32_t i = 0; i < RenderVertexSemantic::NUM_SEMANTICS; i++)
+			{
+				numEntries += (staticBufDesc.buffersRequest[i] == RenderDataFormat::UNSPECIFIED) ? 0 : 1;
+
+				PX_ASSERT(staticBufDesc.buffersRequest[i] == RenderDataFormat::UNSPECIFIED || vertexSemanticFormatValid((RenderVertexSemantic::Enum)i, staticBufDesc.buffersRequest[i]));
+				PX_ASSERT(dynamicBufDesc.buffersRequest[i] == RenderDataFormat::UNSPECIFIED || vertexSemanticFormatValid((RenderVertexSemantic::Enum)i, dynamicBufDesc.buffersRequest[i]));
+				PX_ASSERT(boneBufDesc.buffersRequest[i] == RenderDataFormat::UNSPECIFIED || vertexSemanticFormatValid((RenderVertexSemantic::Enum)i, boneBufDesc.buffersRequest[i]));
+			}
+
+			if (numEntries > 0)
+			{
+				if (replaceStaticBuffer)
+				{
+					submeshData.staticBufferReplacement = rrm->createVertexBuffer(staticBufDesc);
+					fillStaticSharedVertexBuffer = true;
+				}
+				else if (mRenderMeshAsset->mRuntimeSubmeshData[submeshIndex].staticVertexBuffer == NULL)
+				{
+					mRenderMeshAsset->mRuntimeSubmeshData[submeshIndex].staticVertexBuffer = rrm->createVertexBuffer(staticBufDesc);
+					fillStaticSharedVertexBuffer = true;
+				}
+				mRenderMeshAsset->mRuntimeSubmeshData[submeshIndex].needsStaticData = true;
+			}
+
+			if (useDynamicBuffer)
+			{
+				// only create this if we don't create a per-actor dynamic buffer
+				if (submeshData.fallbackSkinningMemory == NULL && !submeshData.userSpecifiedData)
+				{
+					if (replaceDynamicBuffer)
+					{
+						submeshData.dynamicBufferReplacement = rrm->createVertexBuffer(dynamicBufDesc);
+						fillDynamicSharedVertexBuffer = true;
+					}
+					else if (mRenderMeshAsset->mRuntimeSubmeshData[submeshIndex].dynamicVertexBuffer == NULL)
+					{
+						mRenderMeshAsset->mRuntimeSubmeshData[submeshIndex].dynamicVertexBuffer = rrm->createVertexBuffer(dynamicBufDesc);
+						fillDynamicSharedVertexBuffer = true;
+					}
+				}
+				mRenderMeshAsset->mRuntimeSubmeshData[submeshIndex].needsDynamicData = true;
+			}
+
+			uint32_t bufferIndex = (uint32_t)vf.getBufferIndexFromID(vf.getSemanticID(RenderVertexSemantic::BONE_INDEX));
+			const uint32_t bonesPerVertex = vertexSemanticFormatElementCount(RenderVertexSemantic::BONE_INDEX, vf.getBufferFormat(bufferIndex));
+			if (vf.hasSeparateBoneBuffer() && bonesPerVertex > 0 && mTransforms.size() > 1 && useBones && mRenderMeshAsset->mRuntimeSubmeshData[submeshIndex].skinningVertexBuffer == NULL)
+			{
+				mRenderMeshAsset->mRuntimeSubmeshData[submeshIndex].skinningVertexBuffer = rrm->createVertexBuffer(boneBufDesc);
+				fillSkinningSharedVertexBuffer = true;
+			}
+		}
+
+		if ((submeshData.fallbackSkinningMemory != NULL || submeshData.userSpecifiedData) && submeshData.userDynamicVertexBuffer == NULL)
+		{
+			UserRenderVertexBufferDesc perActorDynamicBufDesc;
+			perActorDynamicBufDesc.moduleIdentifier = mRenderMeshAsset->mOwnerModuleID;
+			perActorDynamicBufDesc.maxVerts = srcVB.getVertexCount();
+			perActorDynamicBufDesc.uvOrigin = mRenderMeshAsset->getTextureUVOrigin();
+			perActorDynamicBufDesc.hint = RenderBufferHint::DYNAMIC;
+			perActorDynamicBufDesc.canBeShared = false;
+
+			if (submeshData.userPositions != NULL)
+			{
+				perActorDynamicBufDesc.buffersRequest[RenderVertexSemantic::POSITION] = RenderDataFormat::FLOAT3;
+			}
+
+			if (submeshData.userNormals != NULL)
+			{
+				perActorDynamicBufDesc.buffersRequest[RenderVertexSemantic::NORMAL] = RenderDataFormat::FLOAT3;
+			}
+
+			if (submeshData.userTangents4 != NULL)
+			{
+				perActorDynamicBufDesc.buffersRequest[RenderVertexSemantic::TANGENT] = RenderDataFormat::FLOAT4;
+			}
+
+			submeshData.userDynamicVertexBuffer = rrm->createVertexBuffer(perActorDynamicBufDesc);
+		}
+
+		if (fill2ndVertexBuffers)
+		{
+			UserRenderVertexBufferDesc bufDesc;
+			bufDesc.moduleIdentifier = mRenderMeshAsset->mOwnerModuleID;
+			bufDesc.maxVerts = srcVB.getVertexCount();
+			bufDesc.hint = RenderBufferHint::DYNAMIC;
+			if (mKeepVisibleBonesPacked)
+			{
+				bufDesc.buffersRequest[ RenderVertexSemantic::BONE_INDEX ] = RenderDataFormat::USHORT1;
+			}
+			if (submeshData.staticColorReplacement)
+			{
+				bufDesc.buffersRequest[ RenderVertexSemantic::COLOR ] = RenderDataFormat::R8G8B8A8;
+			}
+			bufDesc.uvOrigin = mRenderMeshAsset->getTextureUVOrigin();
+			bufDesc.canBeShared = false;
+			for (uint32_t i = 0; i < RenderVertexSemantic::NUM_SEMANTICS; i++)
+			{
+				PX_ASSERT(bufDesc.buffersRequest[i] == RenderDataFormat::UNSPECIFIED || vertexSemanticFormatValid((RenderVertexSemantic::Enum)i, bufDesc.buffersRequest[i]));
+			}
+			mPerActorVertexBuffers[submeshIndex] = rrm->createVertexBuffer(bufDesc);
+		}
+
+		// creates and/or fills index buffers
+		updatePartVisibility(submeshIndex, useBones, userRenderData);
+
+		if (fillStaticSharedVertexBuffer || fillDynamicSharedVertexBuffer || fillSkinningSharedVertexBuffer)
+		{
+			const VertexFormat& vf = srcVB.getFormat();
+
+			RenderVertexBufferData    dynamicWriteData;
+			RenderVertexBufferData    staticWriteData;
+			RenderVertexBufferData    skinningWriteData;
+			RenderVertexBufferData&	skinningWriteDataRef = vf.hasSeparateBoneBuffer() ? skinningWriteData : staticWriteData;
+
+			UserRenderVertexBuffer* staticVb = mRenderMeshAsset->mRuntimeSubmeshData[submeshIndex].staticVertexBuffer;
+			UserRenderVertexBuffer* dynamicVb = mRenderMeshAsset->mRuntimeSubmeshData[submeshIndex].dynamicVertexBuffer;
+			UserRenderVertexBuffer* skinningVb = mRenderMeshAsset->mRuntimeSubmeshData[submeshIndex].skinningVertexBuffer;
+
+			if (submeshData.staticBufferReplacement != NULL)
+			{
+				staticVb = submeshData.staticBufferReplacement;
+			}
+
+			if (submeshData.dynamicBufferReplacement != NULL)
+			{
+				dynamicVb = submeshData.dynamicBufferReplacement;
+			}
+
+			for (uint32_t semantic = RenderVertexSemantic::POSITION; semantic <= RenderVertexSemantic::COLOR; ++semantic)
+			{
+				if (semantic == RenderVertexSemantic::COLOR && submeshData.staticColorReplacement != NULL)
+				{
+					// Gets done in updatePartVisibility if submeshData.staticColorReplacement is used
+					continue;
+				}
+
+				RenderDataFormat::Enum format;
+				int32_t bufferIndex = vf.getBufferIndexFromID(vf.getSemanticID((RenderVertexSemantic::Enum)semantic));
+				if (bufferIndex < 0)
+				{
+					continue;
+				}
+				const void* src = srcVB.getBufferAndFormat(format, (uint32_t)bufferIndex);
+
+				if (semantic == RenderVertexSemantic::POSITION && submeshData.staticPositionReplacement != NULL)
+				{
+					src = submeshData.staticPositionReplacement;
+				}
+
+				if (format != RenderDataFormat::UNSPECIFIED)
+				{
+					if (srcVB.getFormat().getBufferAccess((uint32_t)bufferIndex) == RenderDataAccess::STATIC)
+					{
+						staticWriteData.setSemanticData((RenderVertexSemantic::Enum)semantic, src, RenderDataFormat::getFormatDataSize(format), format);
+					}
+					else
+					{
+						dynamicWriteData.setSemanticData((RenderVertexSemantic::Enum)semantic, src, RenderDataFormat::getFormatDataSize(format), format);
+					}
+				}
+			}
+
+			for (uint32_t semantic = RenderVertexSemantic::TEXCOORD0; semantic <= RenderVertexSemantic::TEXCOORD3; ++semantic)
+			{
+				RenderDataFormat::Enum format;
+				int32_t bufferIndex = vf.getBufferIndexFromID(vf.getSemanticID((RenderVertexSemantic::Enum)semantic));
+				if (bufferIndex < 0)
+				{
+					continue;
+				}
+				const void* src = srcVB.getBufferAndFormat(format, (uint32_t)bufferIndex);
+				if (format != RenderDataFormat::UNSPECIFIED)
+				{
+					staticWriteData.setSemanticData((RenderVertexSemantic::Enum)semantic, src, RenderDataFormat::getFormatDataSize(format), format);
+				}
+			}
+
+			for (uint32_t semantic = RenderVertexSemantic::DISPLACEMENT_TEXCOORD; semantic <= RenderVertexSemantic::DISPLACEMENT_FLAGS; ++semantic)
+			{
+				int32_t bufferIndex = vf.getBufferIndexFromID(vf.getSemanticID((RenderVertexSemantic::Enum)semantic));
+				if (bufferIndex >= 0)
+				{
+					RenderDataFormat::Enum format;
+					const void* src = srcVB.getBufferAndFormat(format, (uint32_t)bufferIndex);
+					if (format != RenderDataFormat::UNSPECIFIED)
+					{
+						staticWriteData.setSemanticData((RenderVertexSemantic::Enum)semantic, src, RenderDataFormat::getFormatDataSize(format), format);
+					}
+				}
+			}
+
+			nvidia::Array<RenderSemanticData> semanticData;
+
+			const uint32_t numCustom = vf.getCustomBufferCount();
+			if (numCustom)
+			{
+				// NvParameterized::Handle custom vertex buffer semantics
+				semanticData.resize(numCustom);
+
+				uint32_t writeIndex = 0;
+				for (uint32_t i = 0; i < vf.getBufferCount(); i++)
+				{
+					// Fill in a RenderSemanticData for each custom semantic
+					if (vf.getBufferSemantic(i) != RenderVertexSemantic::CUSTOM)
+					{
+						continue;
+					}
+					semanticData[writeIndex].data = srcVB.getBuffer(i);
+					RenderDataFormat::Enum fmt = mRenderMeshAsset->mRuntimeCustomSubmeshData[submeshIndex].customBufferFormats[writeIndex];
+					semanticData[writeIndex].stride = RenderDataFormat::getFormatDataSize(fmt);
+					semanticData[writeIndex].format = fmt;
+					semanticData[writeIndex].ident = mRenderMeshAsset->mRuntimeCustomSubmeshData[submeshIndex].customBufferVoidPtrs[writeIndex];
+
+					writeIndex++;
+				}
+				PX_ASSERT(writeIndex == numCustom);
+				staticWriteData.setCustomSemanticData(&semanticData[0], numCustom);
+			}
+
+			physx::Array<uint16_t> boneIndicesModuloMaxBoneCount;
+
+			if (mTransforms.size() > 1 || mForceBoneIndexChannel)
+			{
+				uint32_t bufferIndex = (uint32_t)vf.getBufferIndexFromID(vf.getSemanticID(RenderVertexSemantic::BONE_INDEX));
+				const uint32_t numBonesPerVertex = vertexSemanticFormatElementCount(RenderVertexSemantic::BONE_INDEX, vf.getBufferFormat(bufferIndex));
+				if (numBonesPerVertex == 1)
+				{
+					// Gets done in updatePartVisibility if keepVisibleBonesPacked is true
+					if (!mKeepVisibleBonesPacked)
+					{
+						RenderDataFormat::Enum format;
+						const VertexFormat& vf = srcVB.getFormat();
+						uint32_t bufferIndex = (uint32_t)vf.getBufferIndexFromID(vf.getSemanticID(RenderVertexSemantic::BONE_INDEX));
+						const void* src = srcVB.getBufferAndFormat(format, bufferIndex);
+						if (format != RenderDataFormat::UNSPECIFIED)
+						{
+							if (mForceBoneIndexChannel && format == RenderDataFormat::USHORT1 && submeshData.maxBonesPerMaterial > 0 && submeshData.maxBonesPerMaterial < mRenderMeshAsset->getBoneCount())
+							{
+								boneIndicesModuloMaxBoneCount.resize(srcVB.getVertexCount());
+								uint16_t* srcBuf = (uint16_t*)src;
+								for (uint32_t vertexNum = 0; vertexNum < srcVB.getVertexCount(); ++vertexNum)
+								{
+									boneIndicesModuloMaxBoneCount[vertexNum] = *(srcBuf++)%submeshData.maxBonesPerMaterial;
+								}
+								src = &boneIndicesModuloMaxBoneCount[0];
+							}
+							skinningWriteDataRef.setSemanticData(RenderVertexSemantic::BONE_INDEX, src, RenderDataFormat::getFormatDataSize(format), format);
+						}
+					}
+				}
+				else
+				{
+					RenderDataFormat::Enum format;
+					const void* src;
+					const VertexFormat& vf = srcVB.getFormat();
+					uint32_t bufferIndex = (uint32_t)vf.getBufferIndexFromID(vf.getSemanticID(nvidia::RenderVertexSemantic::BONE_INDEX));
+					src = srcVB.getBufferAndFormat(format, bufferIndex);
+					if (format != RenderDataFormat::UNSPECIFIED)
+					{
+						skinningWriteDataRef.setSemanticData(RenderVertexSemantic::BONE_INDEX, src, RenderDataFormat::getFormatDataSize(format), format);
+					}
+					bufferIndex = (uint32_t)vf.getBufferIndexFromID(vf.getSemanticID(nvidia::RenderVertexSemantic::BONE_WEIGHT));
+					src = srcVB.getBufferAndFormat(format, bufferIndex);
+					if (format != RenderDataFormat::UNSPECIFIED)
+					{
+						skinningWriteDataRef.setSemanticData(RenderVertexSemantic::BONE_WEIGHT, src, RenderDataFormat::getFormatDataSize(format), format);
+					}
+				}
+			}
+
+			if (staticVb != NULL && fillStaticSharedVertexBuffer)
+			{
+				staticVb->writeBuffer(staticWriteData,   0, srcVB.getVertexCount());
+			}
+			if (dynamicVb != NULL && fillDynamicSharedVertexBuffer)
+			{
+				dynamicVb->writeBuffer(dynamicWriteData,  0, srcVB.getVertexCount());
+			}
+			if (skinningVb != NULL && fillSkinningSharedVertexBuffer)
+			{
+				skinningVb->writeBuffer(skinningWriteData, 0, srcVB.getVertexCount());
+			}
+
+			// TODO - SJB - Beta2 - release submesh after updateRenderResources() returns. It requires acquiring the actor lock as game engine could delay these
+			// writes so long as it holds the render lock.  Could be done in updateBounds(), which implictly has the lock.  Perhaps we need to catch lock release
+			// so it happens immediately.
+		}
+
+		// Delete static vertex buffers after writing them
+		if (mRenderMeshAsset->mParams->deleteStaticBuffersAfterUse)
+		{
+			ApexVertexFormat dynamicFormats;
+			dynamicFormats.copy((const ApexVertexFormat&)vf);
+			for (uint32_t semantic = RenderVertexSemantic::POSITION; semantic < RenderVertexSemantic::NUM_SEMANTICS; ++semantic)
+			{
+				uint32_t bufferIndex = (uint32_t)vf.getBufferIndexFromID(vf.getSemanticID((RenderVertexSemantic::Enum)semantic));
+				if (dynamicFormats.getBufferAccess(bufferIndex) == RenderDataAccess::STATIC)
+				{
+					dynamicFormats.setBufferFormat(bufferIndex, RenderDataFormat::UNSPECIFIED);
+				}
+			}
+			srcVB.build(dynamicFormats, srcVB.getVertexCount());
+		}
+	}
+	mOneUserVertexBufferChanged = false;
+	mPartVisibilityChanged = false;
+	mBoneBufferInUse = useBones;
+}
+
+void ApexRenderMeshActor::updatePartVisibility(uint32_t submeshIndex, bool useBones, void* userRenderData)
+{
+#if VERBOSE
+	printf("updatePartVisibility(submeshIndex=%d, useBones=%s, userRenderData=0x%p)\n", submeshIndex, useBones ? "true" : "false", userRenderData);
+	printf("  mPartVisibilityChanged=%s\n", mPartVisibilityChanged ? "true" : "false");
+#endif
+
+	const ApexRenderSubmesh& submesh = *mRenderMeshAsset->mSubmeshes[submeshIndex];
+	SubmeshData& submeshData = mSubmeshData[ submeshIndex ];
+
+	UserRenderResourceManager* rrm = GetInternalApexSDK()->getUserRenderResourceManager();
+	PX_ASSERT(rrm != NULL);
+
+	// we end up with a division by 0 otherwise :(
+	PX_ASSERT(submeshData.maxBonesPerMaterial > 0);
+
+	const uint32_t partCount = mKeepVisibleBonesPacked ? getRenderVisiblePartCount() : mRenderMeshAsset->getPartCount();
+
+	// only use bones if there is no fallback skinning
+	useBones &= submeshData.fallbackSkinningMemory == NULL;
+
+	uint32_t resourceCount;
+	if (!useBones)
+	{
+		// If we're not skinning, we only need one resource
+		resourceCount = 1;
+	}
+	else
+	{
+		// LRR - poor workaround for http://nvbugs/534501
+		if (mKeepVisibleBonesPacked)
+		{
+			resourceCount = partCount == 0 ? 0 : (partCount + submeshData.maxBonesPerMaterial - 1) / submeshData.maxBonesPerMaterial;
+		}
+		else
+		{
+			resourceCount = partCount == 0 ? 0 : (mRenderMeshAsset->getBoneCount() + submeshData.maxBonesPerMaterial - 1) / submeshData.maxBonesPerMaterial;
+		}
+	}
+
+	// Eliminate unneeded resources:
+	const uint32_t start = (submeshData.userIndexBufferChanged || useBones != mBoneBufferInUse) ? 0 : resourceCount;
+	for (uint32_t i = start; i < submeshData.renderResources.size(); ++i)
+	{
+		if (submeshData.renderResources[i].resource != NULL)
+		{
+			UserRenderBoneBuffer* boneBuffer = submeshData.renderResources[i].resource->getBoneBuffer();
+			rrm->releaseResource(*submeshData.renderResources[i].resource);
+
+			if (boneBuffer)
+			{
+				rrm->releaseBoneBuffer(*boneBuffer);
+			}
+
+			submeshData.renderResources[i].resource = NULL;
+		}
+	}
+	submeshData.userIndexBufferChanged = false;
+
+	uint16_t resourceBoneCount = 0;
+	uint32_t resourceNum = 0;
+	uint32_t startIndex = 0;
+
+	if (mKeepVisibleBonesPacked)
+	{
+		if (mBoneIndexTempBuffer.size() < submesh.getVertexBuffer().getVertexCount())
+		{
+			mBoneIndexTempBuffer.resize(submesh.getVertexBuffer().getVertexCount());	// A new index buffer to remap the bone indices to the smaller buffer
+		}
+	}
+
+	uint32_t boneIndexStart = uint32_t(-1);
+	uint32_t boneIndexEnd = 0;
+
+	// Figure out how many indices we'll need
+	uint32_t totalIndexCount = submesh.getTotalIndexCount();	// Worst case
+
+	const uint32_t* visiblePartIndexPtr = getRenderVisibleParts();
+
+	if (mKeepVisibleBonesPacked)
+	{
+		// We can do better
+		totalIndexCount = 0;
+		for (uint32_t partNum = 0; partNum < partCount; ++partNum)
+		{
+			totalIndexCount += submesh.getIndexCount(visiblePartIndexPtr[partNum]);
+		}
+	}
+
+	uint32_t newIndexBufferRequestSize = submeshData.indexBufferRequestedSize;
+
+	// If there has not already been an index buffer request, set to exact size
+	if (newIndexBufferRequestSize == 0 || totalIndexCount >= 0x80000000)	// special handling of potential overflow
+	{
+		newIndexBufferRequestSize = totalIndexCount;
+	}
+	else
+	{
+		// If the buffer has already been requested, see if we need to grow or shrink it
+		while (totalIndexCount > newIndexBufferRequestSize)
+		{
+			newIndexBufferRequestSize *= 2;
+		}
+		while (2*totalIndexCount < newIndexBufferRequestSize)
+		{
+			newIndexBufferRequestSize /= 2;
+		}
+	}
+
+	// In case our doubling schedule gave it a larger size than we'll ever need
+	if (newIndexBufferRequestSize > submesh.getTotalIndexCount())
+	{
+		newIndexBufferRequestSize = submesh.getTotalIndexCount();
+	}
+
+	if (submeshData.indexBuffer != NULL && newIndexBufferRequestSize != submeshData.indexBufferRequestedSize)
+	{
+		// Release the old buffer
+		rrm->releaseIndexBuffer(*submeshData.indexBuffer);
+		submeshData.indexBuffer = NULL;
+		releaseSubmeshRenderResources(submeshIndex);
+	}
+
+	// Create the index buffer now if needed
+	if (submeshData.indexBuffer == NULL && newIndexBufferRequestSize > 0)
+	{
+		UserRenderIndexBufferDesc indexDesc;
+		indexDesc.maxIndices = newIndexBufferRequestSize;
+		indexDesc.hint       = mIndexBufferHint;
+		indexDesc.format     = RenderDataFormat::UINT1;
+		submeshData.indexBuffer = rrm->createIndexBuffer(indexDesc);
+		submeshData.indexBufferRequestedSize = newIndexBufferRequestSize;
+	}
+
+	submeshData.renderResources.resize(resourceCount, ResourceData());
+
+	submeshData.visibleTriangleCount = 0;
+	// KHA - batch writes to temporary buffer so that index buffer is only locked once per frame
+	if(mPartIndexTempBuffer.size() < totalIndexCount)
+	{
+		mPartIndexTempBuffer.resize(totalIndexCount);
+	}
+	for (uint32_t partNum = 0; partNum < partCount;)
+	{
+		uint32_t partIndex;
+		bool partIsVisible;
+		if (mKeepVisibleBonesPacked)
+		{
+			partIndex = visiblePartIndexPtr[partNum++];
+			partIsVisible = true;
+
+			const uint32_t indexStart = submesh.getFirstVertexIndex(partIndex);
+			const uint32_t vertexCount = submesh.getVertexCount(partIndex);
+
+			uint16_t* boneIndex = mBoneIndexTempBuffer.begin() + indexStart;
+			const uint16_t* boneIndexStop = boneIndex + vertexCount;
+
+			boneIndexStart = PxMin(boneIndexStart, indexStart);
+			boneIndexEnd = PxMax(boneIndexEnd, indexStart + vertexCount);
+
+			while (boneIndex < boneIndexStop)
+			{
+				*boneIndex++ = resourceBoneCount;
+			}
+		}
+		else
+		{
+			partIndex = partNum++;
+			partIsVisible = isVisible((uint16_t)partIndex);
+		}
+
+		if (partIsVisible)
+		{
+			const uint32_t indexCount = submesh.getIndexCount(partIndex);
+			const uint32_t* indices = submesh.getIndexBuffer(partIndex);
+			const uint32_t currentIndexNum = submeshData.visibleTriangleCount * 3;
+			if (indexCount > 0 && mPartVisibilityChanged)
+			{
+				memcpy(mPartIndexTempBuffer.begin() + currentIndexNum, indices, indexCount * sizeof(uint32_t));
+			}
+			submeshData.visibleTriangleCount += indexCount / 3;
+		}
+
+		// LRR - poor workaround for http://nvbugs/534501
+		bool generateNewRenderResource = false;
+
+		const bool oneBonePerPart = mSkinningMode != RenderMeshActorSkinningMode::AllBonesPerPart;
+
+		const uint16_t bonesToAdd = oneBonePerPart ? 1u : (uint16_t)mRenderMeshAsset->getBoneCount();
+		resourceBoneCount = PxMin<uint16_t>((uint16_t)(resourceBoneCount + bonesToAdd), (uint16_t)submeshData.maxBonesPerMaterial);
+
+		// Check if we exceed max bones limit or if this is the last part
+		if ((useBones && resourceBoneCount == submeshData.maxBonesPerMaterial) || partNum == partCount)
+		{
+			generateNewRenderResource = true;
+		}
+		if (generateNewRenderResource)
+		{
+			submeshData.renderResources[resourceNum].boneCount = resourceBoneCount;
+			submeshData.renderResources[resourceNum].vertexCount = submeshData.visibleTriangleCount * 3 - startIndex;
+			UserRenderResource*& renderResource = submeshData.renderResources[resourceNum].resource;	// Next resource
+			++resourceNum;
+			if (renderResource == NULL)	// Create if needed
+			{
+				UserRenderVertexBuffer* vertexBuffers[5] = { NULL };
+				uint32_t numVertexBuffers = 0;
+
+				if (submeshData.staticBufferReplacement != NULL)
+				{
+					vertexBuffers[numVertexBuffers++] = submeshData.staticBufferReplacement;
+				}
+				else if (mRenderMeshAsset->mRuntimeSubmeshData[submeshIndex].staticVertexBuffer != NULL)
+				{
+					vertexBuffers[numVertexBuffers++] = mRenderMeshAsset->mRuntimeSubmeshData[ submeshIndex ].staticVertexBuffer;
+				}
+
+				if (submeshData.userDynamicVertexBuffer != NULL && (submeshData.userSpecifiedData || submeshData.fallbackSkinningMemory != NULL))
+				{
+					vertexBuffers[numVertexBuffers++] = submeshData.userDynamicVertexBuffer;
+				}
+				else if (submeshData.dynamicBufferReplacement != NULL)
+				{
+					vertexBuffers[numVertexBuffers++] = submeshData.dynamicBufferReplacement;
+				}
+				else if (mRenderMeshAsset->mRuntimeSubmeshData[submeshIndex].dynamicVertexBuffer != NULL)
+				{
+					if (submeshData.userDynamicVertexBuffer != NULL && mReleaseResourcesIfNothingToRender)
+					{
+						rrm->releaseVertexBuffer(*submeshData.userDynamicVertexBuffer);
+						submeshData.userDynamicVertexBuffer = NULL;
+					}
+
+					vertexBuffers[numVertexBuffers++] = mRenderMeshAsset->mRuntimeSubmeshData[submeshIndex].dynamicVertexBuffer;
+				}
+
+				if (useBones && mRenderMeshAsset->mRuntimeSubmeshData[submeshIndex].skinningVertexBuffer != NULL)
+				{
+					vertexBuffers[numVertexBuffers++] = mRenderMeshAsset->mRuntimeSubmeshData[submeshIndex].skinningVertexBuffer;
+				}
+
+				// Separate (instanced) buffer for bone indices
+				if (mPerActorVertexBuffers.size())
+				{
+					vertexBuffers[numVertexBuffers++] = mPerActorVertexBuffers[ submeshIndex ];
+				}
+
+				PX_ASSERT(numVertexBuffers <= 5);
+
+				UserRenderResourceDesc resourceDesc;
+				resourceDesc.primitives = RenderPrimitiveType::TRIANGLES;
+
+				resourceDesc.vertexBuffers = vertexBuffers;
+				resourceDesc.numVertexBuffers = numVertexBuffers;
+
+				resourceDesc.numVerts = submesh.getVertexBuffer().getVertexCount();
+
+				resourceDesc.indexBuffer = submeshData.indexBuffer;
+				resourceDesc.firstIndex = startIndex;
+				resourceDesc.numIndices = submeshData.visibleTriangleCount * 3 - startIndex;
+
+				// not assuming partcount == bonecount anymore
+				//if (mRenderMeshAsset->getPartCount() > 1)
+				const uint32_t numBones = mRenderMeshAsset->getBoneCount();
+				if (numBones > 1 && useBones)
+				{
+					UserRenderBoneBufferDesc boneDesc;
+					// we don't need to use the minimum of numBones and max bones because the 
+					// bone buffer update contains the proper range
+					boneDesc.maxBones = submeshData.maxBonesPerMaterial;
+					boneDesc.hint = RenderBufferHint::DYNAMIC;
+					boneDesc.buffersRequest[ RenderBoneSemantic::POSE ] = RenderDataFormat::FLOAT4x4;
+					if (mKeepPreviousFrameBoneBuffer)
+					{
+						boneDesc.buffersRequest[ RenderBoneSemantic::PREVIOUS_POSE ] = RenderDataFormat::FLOAT4x4;
+					}
+					resourceDesc.boneBuffer = rrm->createBoneBuffer(boneDesc);
+					PX_ASSERT(resourceDesc.boneBuffer);
+					if (resourceDesc.boneBuffer)
+					{
+						resourceDesc.numBones = numBones;
+					}
+				}
+
+				resourceDesc.instanceBuffer = submeshData.instanceBuffer;
+				resourceDesc.numInstances = 0;
+
+				if (!submeshData.isMaterialPointerValid)
+				{
+					// this should only be reached, when renderMeshActorLoadMaterialsLazily is true.
+					// URR may not be called asynchronously in that case (for example in a render thread)
+					ResourceProviderIntl* nrp = GetInternalApexSDK()->getInternalResourceProvider();
+					if (nrp != NULL)
+					{
+						submeshData.material = nrp->getResource(submeshData.materialID);
+						submeshData.isMaterialPointerValid = true;
+					}
+				}
+
+				resourceDesc.material = submeshData.material;
+
+				resourceDesc.submeshIndex = submeshIndex;
+
+				resourceDesc.userRenderData = userRenderData;
+
+				resourceDesc.cullMode = submesh.getVertexBuffer().getFormat().getWinding();
+
+				if (resourceDesc.isValid()) // TODO: should probably make this an if-statement... -jgd // I did, -poh
+				{
+					renderResource = rrm->createResource(resourceDesc);
+				}
+			}
+
+			if (renderResource != NULL)
+			{
+				renderResource->setIndexBufferRange(startIndex, submeshData.visibleTriangleCount * 3 - startIndex);
+				startIndex = submeshData.visibleTriangleCount * 3;
+
+				if (renderResource->getBoneBuffer() != NULL)
+				{
+					renderResource->setBoneBufferRange(0, resourceBoneCount);
+					// TODO - LRR - make useBoneVisibilitySemantic work with >1 bone/part
+					// if visible bone optimization enabled (as set in the actor desc)
+					// {
+					//		if (renderMesh->getBoneBuffer() != NULL)
+					//		if we have a 1:1 bone:part mapping, as determined when asset is loaded (or authored)
+					//			renderMesh->getBoneBuffer()->writeBuffer(RenderBoneSemantic::VISIBLE_INDEX, visibleParts.usedIndices(), sizeof(uint32_t), 0, visibleParts.usedCount());
+					//		else
+					//		{
+					//			// run through index buffer, and find all bones referenced by visible verts and store in visibleBones
+					//			renderMesh->getBoneBuffer()->writeBuffer(RenderBoneSemantic::VISIBLE_INDEX, visibleBones.usedIndices(), sizeof(uint32_t), 0, visibleBones.usedCount());
+					//		}
+					// }
+				}
+			}
+
+			resourceBoneCount = 0;
+		}
+	}
+
+	if (boneIndexStart == uint32_t(-1))
+	{
+		boneIndexStart = 0;
+	}
+
+	// KHA - Write temporary buffer to index buffer
+	if(submeshData.indexBuffer != NULL && mPartVisibilityChanged)
+	{
+		submeshData.indexBuffer->writeBuffer(mPartIndexTempBuffer.begin(), sizeof(uint32_t), 0, submeshData.visibleTriangleCount*3);
+	}
+
+	// Write re-mapped bone indices
+	if (mPerActorVertexBuffers.size())
+	{
+		if (mTransforms.size() > 1 && mKeepVisibleBonesPacked)
+		{
+			RenderVertexBufferData skinningWriteData;
+			skinningWriteData.setSemanticData(RenderVertexSemantic::BONE_INDEX, mBoneIndexTempBuffer.begin() + boneIndexStart, sizeof(uint16_t), RenderDataFormat::USHORT1);
+			if (submeshData.staticColorReplacement != NULL)
+			{
+				skinningWriteData.setSemanticData(RenderVertexSemantic::COLOR, submeshData.staticColorReplacement + boneIndexStart, sizeof(ColorRGBA), RenderDataFormat::R8G8B8A8);
+			}
+			mPerActorVertexBuffers[submeshIndex]->writeBuffer(skinningWriteData, boneIndexStart, boneIndexEnd - boneIndexStart);
+		}
+		else
+		if (submeshData.staticColorReplacement != NULL)
+		{
+			RenderVertexBufferData skinningWriteData;
+			skinningWriteData.setSemanticData(RenderVertexSemantic::COLOR, submeshData.staticColorReplacement, sizeof(ColorRGBA), RenderDataFormat::R8G8B8A8);
+			mPerActorVertexBuffers[submeshIndex]->writeBuffer(skinningWriteData, 0, submesh.getVertexBuffer().getVertexCount());
+		}
+	}
+
+	mBonePosesDirty = true;
+
+#if VERBOSE
+	printf("-updatePartVisibility(submeshIndex=%d, useBones=%s, userRenderData=0x%p)\n", submeshIndex, useBones ? "true" : "false", userRenderData);
+#endif
+}
+
+void ApexRenderMeshActor::updateBonePoses(uint32_t submeshIndex)
+{
+// There can now be >1 bones per part
+//	if (mRenderMeshAsset->getPartCount() > 1)
+	if (mRenderMeshAsset->getBoneCount() > 1)
+	{
+		SubmeshData& submeshData = mSubmeshData[ submeshIndex ];
+		PxMat44* boneTMs = mTransforms.begin();
+		const uint32_t tmBufferSize = mKeepVisibleBonesPacked ? getRenderVisiblePartCount() : mTransforms.size();
+
+		// Set up the previous bone buffer, if requested and available
+		PxMat44* previousBoneTMs = NULL;
+		if (!mPreviousFrameBoneBufferValid || mTransformsLastFrame.size() != mTransforms.size())
+		{
+			previousBoneTMs = boneTMs;
+		}
+		else
+		if (!mKeepVisibleBonesPacked || mRemappedPreviousBoneTMs.size() == 0)
+		{
+			previousBoneTMs = mTransformsLastFrame.begin();
+		}
+		else
+		{
+			previousBoneTMs = mRemappedPreviousBoneTMs.begin();
+		}
+
+		uint32_t tmsRemaining = tmBufferSize;
+		for (uint32_t i = 0; i < submeshData.renderResources.size(); ++i)
+		{
+			UserRenderResource* renderResource = submeshData.renderResources[i].resource;
+			const uint32_t resourceBoneCount = submeshData.renderResources[i].boneCount;
+			if (renderResource && renderResource->getBoneBuffer() != NULL)
+			{
+				RenderBoneBufferData boneWriteData;
+				boneWriteData.setSemanticData(RenderBoneSemantic::POSE, boneTMs, sizeof(PxMat44), RenderDataFormat::FLOAT4x4);
+				if (mKeepPreviousFrameBoneBuffer)
+				{
+					boneWriteData.setSemanticData(RenderBoneSemantic::PREVIOUS_POSE, previousBoneTMs, sizeof(PxMat44), RenderDataFormat::FLOAT4x4);
+				}
+				renderResource->getBoneBuffer()->writeBuffer(boneWriteData, 0, PxMin(tmsRemaining, resourceBoneCount));
+				tmsRemaining -= resourceBoneCount;
+				boneTMs += resourceBoneCount;
+				previousBoneTMs += resourceBoneCount;
+			}
+		}
+	}
+}
+
+void ApexRenderMeshActor::releaseSubmeshRenderResources(uint32_t submeshIndex)
+{
+#if VERBOSE
+	printf("releaseSubmeshRenderResources()\n");
+#endif
+
+	if (submeshIndex >= mSubmeshData.size())
+	{
+		return;
+	}
+
+	UserRenderResourceManager* rrm = GetInternalApexSDK()->getUserRenderResourceManager();
+
+	SubmeshData& submeshData = mSubmeshData[submeshIndex];
+	for (uint32_t j = submeshData.renderResources.size(); j--;)
+	{
+		if (submeshData.renderResources[j].resource != NULL)
+		{
+			if (submeshData.renderResources[j].resource->getBoneBuffer() != NULL)
+			{
+				rrm->releaseBoneBuffer(*submeshData.renderResources[j].resource->getBoneBuffer());
+			}
+			rrm->releaseResource(*submeshData.renderResources[j].resource);
+			submeshData.renderResources[j].resource = NULL;
+		}
+	}
+	submeshData.renderResources.reset();
+}
+
+
+void ApexRenderMeshActor::releaseRenderResources()
+{
+#if VERBOSE
+	printf("releaseRenderResources()\n");
+#endif
+
+	UserRenderResourceManager* rrm = GetInternalApexSDK()->getUserRenderResourceManager();
+
+	for (uint32_t i = mSubmeshData.size(); i--;)
+	{
+		releaseSubmeshRenderResources(i);
+
+		SubmeshData& submeshData = mSubmeshData[i];
+
+		if (submeshData.indexBuffer != NULL)
+		{
+			rrm->releaseIndexBuffer(*submeshData.indexBuffer);
+			submeshData.indexBuffer = NULL;
+		}
+		submeshData.instanceBuffer = NULL;
+
+		if (submeshData.staticBufferReplacement != NULL)
+		{
+			rrm->releaseVertexBuffer(*submeshData.staticBufferReplacement);
+			submeshData.staticBufferReplacement = NULL;
+		}
+
+		if (submeshData.dynamicBufferReplacement != NULL)
+		{
+			rrm->releaseVertexBuffer(*submeshData.dynamicBufferReplacement);
+			submeshData.dynamicBufferReplacement = NULL;
+		}
+
+		if (submeshData.userDynamicVertexBuffer != NULL)
+		{
+			rrm->releaseVertexBuffer(*submeshData.userDynamicVertexBuffer);
+			submeshData.userDynamicVertexBuffer = NULL;
+		}
+		submeshData.userIndexBufferChanged = false;
+	}
+
+	for (uint32_t i = mPerActorVertexBuffers.size(); i--;)
+	{
+		if (mPerActorVertexBuffers[i] != NULL)
+		{
+			rrm->releaseVertexBuffer(*mPerActorVertexBuffers[i]);
+			mPerActorVertexBuffers[i] = NULL;
+		}
+	}
+	mPerActorVertexBuffers.reset();
+
+	if (mRenderResource)
+	{
+		rrm->releaseResource(*mRenderResource);
+		mRenderResource = NULL;
+	}
+
+	mBoneBufferInUse = false;
+}
+
+
+
+bool ApexRenderMeshActor::submeshHasVisibleTriangles(uint32_t submeshIndex) const
+{
+	const ApexRenderSubmesh& submesh = *mRenderMeshAsset->mSubmeshes[submeshIndex];
+
+	const uint32_t partCount = getRenderVisiblePartCount();
+	const uint32_t* visiblePartIndexPtr = getRenderVisibleParts();
+
+	for (uint32_t partNum = 0; partNum < partCount;)
+	{
+		const uint32_t partIndex = visiblePartIndexPtr[partNum++];
+		const uint32_t indexCount = submesh.getIndexCount(partIndex);
+
+		if (indexCount > 0)
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+
+void ApexRenderMeshActor::createFallbackSkinning(uint32_t submeshIndex)
+{
+	if (mTransforms.size() == 1)
+	{
+		return;
+	}
+
+#if VERBOSE
+	printf("createFallbackSkinning(submeshIndex=%d)\n", submeshIndex);
+#endif
+	const VertexBuffer& vertexBuffer = mRenderMeshAsset->getSubmesh(submeshIndex).getVertexBuffer();
+	const VertexFormat& format = vertexBuffer.getFormat();
+
+	const uint32_t bufferCount = format.getBufferCount();
+
+	uint32_t bufferSize = 0;
+	for (uint32_t bufferIndex = 0; bufferIndex < bufferCount; bufferIndex++)
+	{
+		if (format.getBufferAccess(bufferIndex) == RenderDataAccess::DYNAMIC)
+		{
+			RenderDataFormat::Enum bufferFormat = format.getBufferFormat(bufferIndex);
+			RenderVertexSemantic::Enum bufferSemantic = format.getBufferSemantic(bufferIndex);
+
+			if (bufferSemantic == RenderVertexSemantic::POSITION ||
+			        bufferSemantic == RenderVertexSemantic::NORMAL ||
+			        bufferSemantic == RenderVertexSemantic::TANGENT)
+			{
+				if (bufferFormat == RenderDataFormat::FLOAT3)
+				{
+					bufferSize += sizeof(PxVec3);
+				}
+				else if (bufferFormat == RenderDataFormat::FLOAT4)
+				{
+					bufferSize += sizeof(PxVec4);
+				}
+			}
+		}
+	}
+
+	if (bufferSize > 0)
+	{
+		PX_ASSERT(mSubmeshData[submeshIndex].fallbackSkinningMemory == NULL);
+		mSubmeshData[submeshIndex].fallbackSkinningMemorySize = bufferSize * vertexBuffer.getVertexCount();
+		mSubmeshData[submeshIndex].fallbackSkinningMemory = PX_ALLOC(mSubmeshData[submeshIndex].fallbackSkinningMemorySize, "fallbackSkinnningMemory");
+
+		PX_ASSERT(mSubmeshData[submeshIndex].fallbackSkinningDirty == false);
+
+		if (!mSubmeshData[submeshIndex].userSpecifiedData)
+		{
+			distributeFallbackData(submeshIndex);
+			mOneUserVertexBufferChanged = true;
+		}
+	}
+}
+
+
+
+void ApexRenderMeshActor::distributeFallbackData(uint32_t submeshIndex)
+{
+	const VertexBuffer& vertexBuffer = mRenderMeshAsset->getSubmesh(submeshIndex).getVertexBuffer();
+	const VertexFormat& format = vertexBuffer.getFormat();
+	const uint32_t bufferCount = format.getBufferCount();
+	const uint32_t vertexCount = vertexBuffer.getVertexCount();
+
+	unsigned char* memoryIterator = (unsigned char*)mSubmeshData[submeshIndex].fallbackSkinningMemory;
+
+	uint32_t sizeUsed = 0;
+	for (uint32_t bufferIndex = 0; bufferIndex < bufferCount; bufferIndex++)
+	{
+		if (format.getBufferAccess(bufferIndex) == RenderDataAccess::DYNAMIC)
+		{
+			RenderDataFormat::Enum bufferFormat = format.getBufferFormat(bufferIndex);
+			RenderVertexSemantic::Enum bufferSemantic = format.getBufferSemantic(bufferIndex);
+
+			if (bufferSemantic == RenderVertexSemantic::POSITION && bufferFormat == RenderDataFormat::FLOAT3)
+			{
+				mSubmeshData[submeshIndex].userPositions = (PxVec3*)memoryIterator;
+				memoryIterator += sizeof(PxVec3) * vertexCount;
+				sizeUsed += sizeof(PxVec3);
+			}
+			else if (bufferSemantic == RenderVertexSemantic::NORMAL && bufferFormat == RenderDataFormat::FLOAT3)
+			{
+				mSubmeshData[submeshIndex].userNormals = (PxVec3*)memoryIterator;
+				memoryIterator += sizeof(PxVec3) * vertexCount;
+				sizeUsed += sizeof(PxVec3);
+			}
+			else if (bufferSemantic == RenderVertexSemantic::TANGENT && bufferFormat == RenderDataFormat::FLOAT4)
+			{
+				mSubmeshData[submeshIndex].userTangents4 = (PxVec4*)memoryIterator;
+				memoryIterator += sizeof(PxVec4) * vertexCount;
+				sizeUsed += sizeof(PxVec4);
+			}
+		}
+	}
+
+	PX_ASSERT(sizeUsed * vertexCount == mSubmeshData[submeshIndex].fallbackSkinningMemorySize);
+}
+
+
+
+void ApexRenderMeshActor::updateFallbackSkinning(uint32_t submeshIndex)
+{
+	if (mSubmeshData[submeshIndex].fallbackSkinningMemory == NULL || mSubmeshData[submeshIndex].userSpecifiedData)
+	{
+		return;
+	}
+
+#if VERBOSE
+	printf("updateFallbackSkinning(submeshIndex=%d)\n", submeshIndex);
+#endif
+	PX_PROFILE_ZONE("ApexRenderMesh::updateFallbackSkinning", GetInternalApexSDK()->getContextId());
+
+	const VertexBuffer& vertexBuffer = mRenderMeshAsset->getSubmesh(submeshIndex).getVertexBuffer();
+	const VertexFormat& format = vertexBuffer.getFormat();
+
+	PxVec3* outPositions = mSubmeshData[submeshIndex].userPositions;
+	PxVec3* outNormals = mSubmeshData[submeshIndex].userNormals;
+	PxVec4* outTangents = mSubmeshData[submeshIndex].userTangents4;
+
+	if (outPositions == NULL && outNormals == NULL && outTangents == NULL)
+	{
+		return;
+	}
+
+	RenderDataFormat::Enum inFormat;
+	const uint32_t positionIndex = (uint32_t)format.getBufferIndexFromID(format.getSemanticID(RenderVertexSemantic::POSITION));
+	const PxVec3* inPositions = (const PxVec3*)vertexBuffer.getBufferAndFormat(inFormat, positionIndex);
+	PX_ASSERT(inPositions == NULL || inFormat == RenderDataFormat::FLOAT3);
+
+	if (inPositions != NULL && mSubmeshData[submeshIndex].staticPositionReplacement != NULL)
+	{
+		inPositions = mSubmeshData[submeshIndex].staticPositionReplacement;
+	}
+
+	const uint32_t normalIndex = (uint32_t)format.getBufferIndexFromID(format.getSemanticID(RenderVertexSemantic::NORMAL));
+	const PxVec3* inNormals = (const PxVec3*)vertexBuffer.getBufferAndFormat(inFormat, normalIndex);
+	PX_ASSERT(inNormals == NULL || inFormat == RenderDataFormat::FLOAT3);
+
+	const uint32_t tangentIndex = (uint32_t)format.getBufferIndexFromID(format.getSemanticID(RenderVertexSemantic::TANGENT));
+	const PxVec4* inTangents = (const PxVec4*)vertexBuffer.getBufferAndFormat(inFormat, tangentIndex);
+	PX_ASSERT(inTangents == NULL || inFormat == RenderDataFormat::FLOAT4);
+
+	const uint32_t boneIndexIndex = (uint32_t)format.getBufferIndexFromID(format.getSemanticID(RenderVertexSemantic::BONE_INDEX));
+	const uint16_t* inBoneIndices = (const uint16_t*)vertexBuffer.getBufferAndFormat(inFormat, boneIndexIndex);
+	PX_ASSERT(inBoneIndices == NULL || inFormat == RenderDataFormat::USHORT1 || inFormat == RenderDataFormat::USHORT2 || inFormat == RenderDataFormat::USHORT3 || inFormat == RenderDataFormat::USHORT4);
+
+	const uint32_t boneWeightIndex = (uint32_t)format.getBufferIndexFromID(format.getSemanticID(RenderVertexSemantic::BONE_WEIGHT));
+	const float* inBoneWeights = (const float*)vertexBuffer.getBufferAndFormat(inFormat, boneWeightIndex);
+	PX_ASSERT(inBoneWeights == NULL || inFormat == RenderDataFormat::FLOAT1 || inFormat == RenderDataFormat::FLOAT2 || inFormat == RenderDataFormat::FLOAT3 || inFormat == RenderDataFormat::FLOAT4);
+
+	uint32_t numBonesPerVertex = 0;
+	switch (inFormat)
+	{
+	case RenderDataFormat::FLOAT1:
+		numBonesPerVertex = 1;
+		break;
+	case RenderDataFormat::FLOAT2:
+		numBonesPerVertex = 2;
+		break;
+	case RenderDataFormat::FLOAT3:
+		numBonesPerVertex = 3;
+		break;
+	case RenderDataFormat::FLOAT4:
+		numBonesPerVertex = 4;
+		break;
+	default:
+		break;
+	}
+
+	PX_ASSERT((inPositions != NULL) == (outPositions != NULL));
+	PX_ASSERT((inNormals != NULL) == (outNormals != NULL));
+	PX_ASSERT((inTangents != NULL) == (outTangents != NULL));
+
+	if (inBoneWeights == NULL || inBoneIndices == NULL || numBonesPerVertex == 0)
+	{
+		return;
+	}
+
+	// clear all data
+	nvidia::intrinsics::memSet(mSubmeshData[submeshIndex].fallbackSkinningMemory, 0, mSubmeshData[submeshIndex].fallbackSkinningMemorySize);
+
+	const uint32_t vertexCount = vertexBuffer.getVertexCount();
+	for (uint32_t i = 0; i < vertexCount; i++)
+	{
+		for (uint32_t k = 0; k < numBonesPerVertex; k++)
+		{
+			const uint32_t boneIndex = inBoneIndices[i * numBonesPerVertex + k];
+			PX_ASSERT(boneIndex < mTransforms.size());
+			PxMat44& transform = mTransforms[boneIndex];
+
+			const float boneWeight = inBoneWeights[i * numBonesPerVertex + k];
+			if (boneWeight > 0.0f)
+			{
+				if (outPositions != NULL)
+				{
+					outPositions[i] += transform.transform(inPositions[i]) * boneWeight;
+				}
+
+				if (outNormals != NULL)
+				{
+					outNormals[i] += transform.rotate(inNormals[i]) * boneWeight;
+				}
+
+				if (outTangents != NULL)
+				{
+					outTangents[i] += PxVec4(transform.rotate(inTangents[i].getXYZ()) * boneWeight, 0.0f);
+				}
+			}
+		}
+		if (outTangents != NULL)
+		{
+			outTangents[i].w = inTangents[i].w;
+		}
+	}
+
+	mSubmeshData[submeshIndex].fallbackSkinningDirty = true;
+}
+
+
+
+void ApexRenderMeshActor::writeUserBuffers(uint32_t submeshIndex)
+{
+	PxVec3* outPositions = mSubmeshData[submeshIndex].userPositions;
+	PxVec3* outNormals = mSubmeshData[submeshIndex].userNormals;
+	PxVec4* outTangents4 = mSubmeshData[submeshIndex].userTangents4;
+
+	if (outPositions == NULL && outNormals == NULL && outTangents4 == NULL)
+	{
+		return;
+	}
+
+	RenderVertexBufferData dynamicWriteData;
+	if (outPositions != NULL)
+	{
+		dynamicWriteData.setSemanticData(RenderVertexSemantic::POSITION, outPositions, sizeof(PxVec3), RenderDataFormat::FLOAT3);
+	}
+
+	if (outNormals != NULL)
+	{
+		dynamicWriteData.setSemanticData(RenderVertexSemantic::NORMAL, outNormals, sizeof(PxVec3), RenderDataFormat::FLOAT3);
+	}
+
+	if (outTangents4)
+	{
+		dynamicWriteData.setSemanticData(RenderVertexSemantic::TANGENT, outTangents4, sizeof(PxVec4), RenderDataFormat::FLOAT4);
+	}
+
+	const uint32_t vertexCount = mRenderMeshAsset->mSubmeshes[submeshIndex]->getVertexBuffer().getVertexCount();
+
+	mSubmeshData[submeshIndex].userDynamicVertexBuffer->writeBuffer(dynamicWriteData, 0, vertexCount);
+}
+
+
+
+void ApexRenderMeshActor::visualizeTangentSpace(RenderDebugInterface& batcher, float normalScale, float tangentScale, float bitangentScale, PxMat33* scaledRotations, PxVec3* translations, uint32_t stride, uint32_t numberOfTransforms) const
+{
+#ifdef WITHOUT_DEBUG_VISUALIZE
+	PX_UNUSED(batcher);
+	PX_UNUSED(normalScale);
+	PX_UNUSED(tangentScale);
+	PX_UNUSED(bitangentScale);
+	PX_UNUSED(scaledRotations);
+	PX_UNUSED(translations);
+	PX_UNUSED(stride);
+	PX_UNUSED(numberOfTransforms);
+#else
+
+	if (normalScale <= 0.0f && tangentScale <= 0.0f && bitangentScale <= 0.0f)
+	{
+		return;
+	}
+
+	using RENDER_DEBUG::DebugColors;
+	uint32_t debugColorRed = RENDER_DEBUG_IFACE(&batcher)->getDebugColor(DebugColors::Red);
+	uint32_t debugColorGreen = RENDER_DEBUG_IFACE(&batcher)->getDebugColor(DebugColors::Green);
+	uint32_t debugColorBlue = RENDER_DEBUG_IFACE(&batcher)->getDebugColor(DebugColors::Blue);
+
+	RENDER_DEBUG_IFACE(&batcher)->pushRenderState();
+
+	const uint32_t submeshCount = mRenderMeshAsset->getSubmeshCount();
+	PX_ASSERT(mSubmeshData.size() == submeshCount);
+	for (uint32_t submeshIndex = 0; submeshIndex < submeshCount; ++submeshIndex)
+	{
+		const PxVec3* positions = NULL;
+		const PxVec3* normals = NULL;
+		const PxVec3* tangents = NULL;
+		const PxVec4* tangents4 = NULL;
+
+		const uint16_t* boneIndices = NULL;
+		const float* boneWeights = NULL;
+
+		uint32_t numBonesPerVertex = 0;
+
+		if (mSubmeshData[submeshIndex].userSpecifiedData || mSubmeshData[submeshIndex].fallbackSkinningMemory != NULL)
+		{
+			positions = mSubmeshData[submeshIndex].userPositions;
+			normals = mSubmeshData[submeshIndex].userNormals;
+			tangents4 = mSubmeshData[submeshIndex].userTangents4;
+		}
+		else
+		{
+			const VertexBuffer& vertexBuffer = mRenderMeshAsset->getSubmesh(submeshIndex).getVertexBuffer();
+			const VertexFormat& format = vertexBuffer.getFormat();
+
+			RenderDataFormat::Enum inFormat;
+			const uint32_t positionIndex = (uint32_t)format.getBufferIndexFromID(format.getSemanticID(RenderVertexSemantic::POSITION));
+			positions = (const PxVec3*)vertexBuffer.getBufferAndFormat(inFormat, positionIndex);
+			PX_ASSERT(positions == NULL || inFormat == RenderDataFormat::FLOAT3);
+
+			if (positions != NULL && mSubmeshData[submeshIndex].staticPositionReplacement != NULL)
+			{
+				positions = mSubmeshData[submeshIndex].staticPositionReplacement;
+			}
+
+			const uint32_t normalIndex = (uint32_t)format.getBufferIndexFromID(format.getSemanticID(RenderVertexSemantic::NORMAL));
+			normals = (const PxVec3*)vertexBuffer.getBufferAndFormat(inFormat, normalIndex);
+			PX_ASSERT(normals == NULL || inFormat == RenderDataFormat::FLOAT3);
+
+			const uint32_t tangentIndex = (uint32_t)format.getBufferIndexFromID(format.getSemanticID(RenderVertexSemantic::TANGENT));
+			tangents = (const PxVec3*)vertexBuffer.getBufferAndFormat(inFormat, tangentIndex);
+			PX_ASSERT(tangents == NULL || inFormat == RenderDataFormat::FLOAT3 || inFormat == RenderDataFormat::FLOAT4);
+			if (inFormat == RenderDataFormat::FLOAT4)
+			{
+				tangents4 = (const PxVec4*)tangents;
+				tangents = NULL;
+			}
+
+			const uint32_t boneIndexIndex = (uint32_t)format.getBufferIndexFromID(format.getSemanticID(RenderVertexSemantic::BONE_INDEX));
+			boneIndices = (const uint16_t*)vertexBuffer.getBufferAndFormat(inFormat, boneIndexIndex);
+			PX_ASSERT(boneIndices == NULL || inFormat == RenderDataFormat::USHORT1 || inFormat == RenderDataFormat::USHORT2 || inFormat == RenderDataFormat::USHORT3 || inFormat == RenderDataFormat::USHORT4);
+
+			switch (inFormat)
+			{
+			case RenderDataFormat::USHORT1:
+				numBonesPerVertex = 1;
+				break;
+			case RenderDataFormat::USHORT2:
+				numBonesPerVertex = 2;
+				break;
+			case RenderDataFormat::USHORT3:
+				numBonesPerVertex = 3;
+				break;
+			case RenderDataFormat::USHORT4:
+				numBonesPerVertex = 4;
+				break;
+			default:
+				break;
+			}
+
+			const uint32_t boneWeightIndex = (uint32_t)format.getBufferIndexFromID(format.getSemanticID(RenderVertexSemantic::BONE_WEIGHT));
+			boneWeights = (const float*)vertexBuffer.getBufferAndFormat(inFormat, boneWeightIndex);
+			PX_ASSERT(boneWeights == NULL || inFormat == RenderDataFormat::FLOAT1 || inFormat == RenderDataFormat::FLOAT2 || inFormat == RenderDataFormat::FLOAT3 || inFormat == RenderDataFormat::FLOAT4);
+		}
+
+		const uint32_t partCount = visiblePartCount();
+		const uint32_t* visibleParts = getVisibleParts();
+		for (uint32_t visiblePartIndex = 0; visiblePartIndex < partCount; visiblePartIndex++)
+		{
+			const uint32_t partIndex = visibleParts[visiblePartIndex];
+
+			const RenderSubmesh& submesh = mRenderMeshAsset->getSubmesh(submeshIndex);
+			const uint32_t vertexStart = submesh.getFirstVertexIndex(partIndex);
+			const uint32_t vertexEnd = vertexStart + submesh.getVertexCount(partIndex);
+
+			for (uint32_t i = vertexStart; i < vertexEnd; i++)
+			{
+				PxVec3 position(0.0f), tangent(0.0f), bitangent(0.0f), normal(0.0f);
+				if (numBonesPerVertex == 0)
+				{
+					position = positions[i];
+					if (normals != NULL)
+					{
+						normal = normals[i].getNormalized();
+					}
+					if (tangents4 != NULL)
+					{
+						tangent = tangents4[i].getXYZ().getNormalized();
+						bitangent = normal.cross(tangent) * tangents4[i].w;
+					}
+					else if (tangents != NULL)
+					{
+						tangent = tangents[i].getNormalized();
+						bitangent = normal.cross(tangent);
+					}
+
+				}
+				else if (numBonesPerVertex == 1)
+				{
+					PX_ASSERT(boneIndices != NULL);
+					uint32_t boneIndex = 0;
+					if (mRenderWithoutSkinning)
+					{
+						boneIndex = 0;
+					}
+					else if (mKeepVisibleBonesPacked)
+					{
+						boneIndex = visiblePartIndex;
+					}
+					else
+					{
+						boneIndex = boneIndices[i];
+					}
+
+					const PxMat44& tm = mTransforms[boneIndex];
+					position = tm.transform(positions[i]);
+					if (normals != NULL)
+					{
+						normal = tm.rotate(normals[i].getNormalized());
+					}
+					if (tangents4 != NULL)
+					{
+						tangent = tm.rotate(tangents4[i].getXYZ().getNormalized());
+						bitangent = normal.cross(tangent) * tangents4[i].w;
+					}
+					else if (tangents != NULL)
+					{
+						tangent = tm.rotate(tangents[i].getNormalized());
+						bitangent = normal.cross(tangent);
+					}
+				}
+				else
+				{
+					position = tangent = bitangent = normal = PxVec3(0.0f);
+					for (uint32_t k = 0; k < numBonesPerVertex; k++)
+					{
+						const float weight = boneWeights[i * numBonesPerVertex + k];
+						if (weight > 0.0f)
+						{
+							const PxMat44& tm = mTransforms[boneIndices[i * numBonesPerVertex + k]];
+							position += tm.transform(positions[i]) * weight;
+							if (normals != NULL)
+							{
+								normal += tm.rotate(normals[i]) * weight;
+							}
+							if (tangents4 != NULL)
+							{
+								tangent += tm.rotate(tangents4[i].getXYZ()) * weight;
+							}
+							else if (tangents != NULL)
+							{
+								tangent += tm.rotate(tangents[i]) * weight;
+							}
+						}
+					}
+					normal.normalize();
+					tangent.normalize();
+					if (tangents4 != NULL)
+					{
+						bitangent = normal.cross(tangent) * tangents4[i].w;
+					}
+					else if (tangents != NULL)
+					{
+						bitangent = normal.cross(tangent);
+					}
+				}
+
+				if (numberOfTransforms == 0 || scaledRotations == NULL || translations == NULL)
+				{
+					if (!tangent.isZero() && tangentScale > 0.0f)
+					{
+						RENDER_DEBUG_IFACE(&batcher)->setCurrentColor(debugColorRed);
+						RENDER_DEBUG_IFACE(&batcher)->debugLine(position, position + tangent * tangentScale);
+					}
+
+					if (!bitangent.isZero() && bitangentScale > 0.0f)
+					{
+						RENDER_DEBUG_IFACE(&batcher)->setCurrentColor(debugColorGreen);
+						RENDER_DEBUG_IFACE(&batcher)->debugLine(position, position + bitangent * bitangentScale);
+					}
+
+					if (!normal.isZero() && normalScale > 0.0f)
+					{
+						RENDER_DEBUG_IFACE(&batcher)->setCurrentColor(debugColorBlue);
+						RENDER_DEBUG_IFACE(&batcher)->debugLine(position, position + normal * normalScale);
+					}
+				}
+				else	//instancing
+				{
+					for (uint32_t k = 0; k < numberOfTransforms; k++)
+					{
+						PxMat33& scaledRotation = *(PxMat33*)((uint8_t*)scaledRotations + k*stride);
+						PxVec3& translation = *(PxVec3*)((uint8_t*)translations + k*stride);
+
+						PxVec3 newPos = scaledRotation.transform(position) + translation;	//full transform
+
+						PxVec3 newTangent = scaledRotation.transform(tangent);	//without translation
+						PxVec3 newBitangent = scaledRotation.transform(bitangent);
+
+						PxVec3 newNormal = (scaledRotation.getInverse()).getTranspose().transform(normal);
+
+						if (!tangent.isZero() && tangentScale > 0.0f)
+						{
+							RENDER_DEBUG_IFACE(&batcher)->setCurrentColor(debugColorRed);
+							RENDER_DEBUG_IFACE(&batcher)->debugLine(newPos, newPos + newTangent * tangentScale);
+						}
+
+						if (!bitangent.isZero() && bitangentScale > 0.0f)
+						{
+							RENDER_DEBUG_IFACE(&batcher)->setCurrentColor(debugColorGreen);
+							RENDER_DEBUG_IFACE(&batcher)->debugLine(newPos, newPos + newBitangent * bitangentScale);
+						}
+
+						if (!normal.isZero() && normalScale > 0.0f)
+						{
+							RENDER_DEBUG_IFACE(&batcher)->setCurrentColor(debugColorBlue);
+							RENDER_DEBUG_IFACE(&batcher)->debugLine(newPos, newPos + newNormal * normalScale);
+						}
+					}
+				}
+			}
+		}
+
+	}
+
+	RENDER_DEBUG_IFACE(&batcher)->popRenderState();
+#endif
+}
+
+
+
+
+ApexRenderMeshActor::SubmeshData::SubmeshData() :
+	indexBuffer(NULL),
+	fallbackSkinningMemory(NULL),
+	userDynamicVertexBuffer(NULL),
+	instanceBuffer(NULL),
+	userPositions(NULL),
+	userNormals(NULL),
+	userTangents4(NULL),
+	staticColorReplacement(NULL),
+	staticColorReplacementDirty(false),
+	staticPositionReplacement(NULL),
+	staticBufferReplacement(NULL),
+	dynamicBufferReplacement(NULL),
+	fallbackSkinningMemorySize(0),
+	visibleTriangleCount(0),
+	materialID(INVALID_RESOURCE_ID),
+	material(NULL),
+	isMaterialPointerValid(false),
+	maxBonesPerMaterial(0),
+	indexBufferRequestedSize(0),
+	userSpecifiedData(false),
+	userVertexBufferAlwaysDirty(false),
+	userIndexBufferChanged(false),
+	fallbackSkinningDirty(false)
+{
+}
+
+
+
+ApexRenderMeshActor::SubmeshData::~SubmeshData()
+{
+	if (fallbackSkinningMemory != NULL)
+	{
+		PX_FREE(fallbackSkinningMemory);
+		fallbackSkinningMemory = NULL;
+	}
+	fallbackSkinningMemorySize = 0;
+}
+
+
+
+void ApexRenderMeshActor::setTM(const PxMat44& tm, uint32_t boneIndex /* = 0 */)
+{
+	WRITE_ZONE();
+	PX_ASSERT(boneIndex < mRenderMeshAsset->getBoneCount());
+	mBonePosesDirty = true;
+	PxMat44& boneTM = accessTM(boneIndex);
+	boneTM.column0 = tm.column0;
+	boneTM.column1 = tm.column1;
+	boneTM.column2 = tm.column2;
+	boneTM.column3 = tm.column3;
+}
+
+
+
+void ApexRenderMeshActor::setTM(const PxMat44& tm, const PxVec3& scale, uint32_t boneIndex /* = 0 */)
+{
+	// Assumes tm is pure rotation.  This can allow some optimization.
+	WRITE_ZONE();
+	PX_ASSERT(boneIndex < mRenderMeshAsset->getBoneCount());
+	mBonePosesDirty = true;
+	PxMat44& boneTM = accessTM(boneIndex);
+	boneTM.column0 = tm.column0;
+	boneTM.column1 = tm.column1;
+	boneTM.column2 = tm.column2;
+	boneTM.column3 = tm.column3;
+	boneTM.scale(PxVec4(scale, 1.f));
+}
+
+
+void ApexRenderMeshActor::setLastFrameTM(const PxMat44& tm, uint32_t boneIndex /* = 0 */)
+{
+	if (!mPreviousFrameBoneBufferValid)
+	{
+		return;
+	}
+
+	PX_ASSERT(boneIndex < mRenderMeshAsset->getBoneCount());
+	PxMat44& boneTM = accessLastFrameTM(boneIndex);
+	boneTM.column0 = tm.column0;
+	boneTM.column1 = tm.column1;
+	boneTM.column2 = tm.column2;
+	boneTM.column3 = tm.column3;
+}
+
+
+
+void ApexRenderMeshActor::setLastFrameTM(const PxMat44& tm, const PxVec3& scale, uint32_t boneIndex /* = 0 */)
+{
+	if (!mPreviousFrameBoneBufferValid)
+	{
+		return;
+	}
+
+	// Assumes tm is pure rotation.  This can allow some optimization.
+
+	PX_ASSERT(boneIndex < mRenderMeshAsset->getBoneCount());
+	PxMat44& boneTM = accessLastFrameTM(boneIndex);
+	boneTM.column0 = tm.column0;
+	boneTM.column1 = tm.column1;
+	boneTM.column2 = tm.column2;
+	boneTM.column3 = tm.column3;
+	boneTM.scale(PxVec4(scale, 1.f));
+}
+
+
+void ApexRenderMeshActor::setSkinningMode(RenderMeshActorSkinningMode::Enum mode)
+{
+	if (mode >= RenderMeshActorSkinningMode::Default && mode < RenderMeshActorSkinningMode::Count)
+	{
+		mSkinningMode = mode;
+	}
+}
+
+RenderMeshActorSkinningMode::Enum ApexRenderMeshActor::getSkinningMode() const
+{
+	return mSkinningMode;
+}
+
+
+void ApexRenderMeshActor::syncVisibility(bool useLock)
+{
+	WRITE_ZONE();
+	if (mApiVisibilityChanged && mBufferVisibility)
+	{
+		if (useLock)
+		{
+			lockRenderResources();
+		}
+		mVisiblePartsForRendering.resize(mVisiblePartsForAPI.usedCount());
+		memcpy(mVisiblePartsForRendering.begin(), mVisiblePartsForAPI.usedIndices(), mVisiblePartsForAPI.usedCount()*sizeof(uint32_t));
+		const uint32_t swapBufferSize = mTMSwapBuffer.size();
+		for (uint32_t i = 0; i < swapBufferSize; ++i)
+		{
+			const uint32_t swapIndices = mTMSwapBuffer[i];
+			nvidia::swap(mTransforms[swapIndices >> 16], mTransforms[swapIndices & 0xFFFF]);
+		}
+		mTMSwapBuffer.reset();
+		mPartVisibilityChanged = true;
+		mApiVisibilityChanged = false;
+		if (useLock)
+		{
+			unlockRenderResources();
+		}
+	}
+}
+
+// TODO - LRR - update part bounds actor bounds to work with >1 bones per part
+void ApexRenderMeshActor::updateBounds()
+{
+	mRenderBounds.setEmpty();
+	const uint32_t* visiblePartIndexPtr = mVisiblePartsForAPI.usedIndices();
+	const uint32_t* visiblePartIndexPtrStop = visiblePartIndexPtr + mVisiblePartsForAPI.usedCount();
+	if (mTransforms.size() < mRenderMeshAsset->getPartCount())
+	{
+		// BRG - for static meshes.  We should create a mapping for more generality.
+		PX_ASSERT(mTransforms.size() == 1);
+		PxMat44& tm = accessTM();
+		while (visiblePartIndexPtr < visiblePartIndexPtrStop)
+		{
+			const uint32_t partIndex = *visiblePartIndexPtr++;
+			PxBounds3 partBounds = mRenderMeshAsset->getBounds(partIndex);
+			partBounds = PxBounds3::basisExtent(tm.transform(partBounds.getCenter()), PxMat33(tm.getBasis(0), tm.getBasis(1), tm.getBasis(2)), partBounds.getExtents());
+			mRenderBounds.include(partBounds);
+		}
+	}
+	else
+	{
+		while (visiblePartIndexPtr < visiblePartIndexPtrStop)
+		{
+			const uint32_t partIndex = *visiblePartIndexPtr++;
+			PxBounds3 partBounds = mRenderMeshAsset->getBounds(partIndex);
+			PxMat44& tm = accessTM(partIndex);
+			partBounds = PxBounds3::basisExtent(tm.transform(partBounds.getCenter()), PxMat33(tm.getBasis(0), tm.getBasis(1), tm.getBasis(2)), partBounds.getExtents());
+			mRenderBounds.include(partBounds);
+		}
+	}
+}
+
+void ApexRenderMeshActor::updateInstances(uint32_t submeshIndex)
+{
+	PX_PROFILE_ZONE("ApexRenderMesh::updateInstances", GetInternalApexSDK()->getContextId());
+
+	for (uint32_t i = 0; i < mSubmeshData[submeshIndex].renderResources.size(); ++i)
+	{
+		UserRenderResource* renderResource = mSubmeshData[submeshIndex].renderResources[i].resource;
+		renderResource->setInstanceBufferRange(mInstanceOffset, mInstanceCount);
+	}
+}
+
+void ApexRenderMeshActor::setReleaseResourcesIfNothingToRender(bool value)
+{
+	WRITE_ZONE();
+	mReleaseResourcesIfNothingToRender = value;
+}
+
+void ApexRenderMeshActor::setBufferVisibility(bool bufferVisibility)
+{
+	WRITE_ZONE();
+	mBufferVisibility = bufferVisibility;
+	mPartVisibilityChanged = true;
+}
+
+void ApexRenderMeshActor::setOverrideMaterial(uint32_t index, const char* overrideMaterialName)
+{
+	WRITE_ZONE();
+	ResourceProviderIntl* nrp = GetInternalApexSDK()->getInternalResourceProvider();
+	if (nrp != NULL && index < mSubmeshData.size())
+	{
+		// do create before release, so we don't release the resource if the newID is the same as the old
+		ResID materialNS = GetInternalApexSDK()->getMaterialNameSpace();
+
+		ResID newID = nrp->createResource(materialNS, overrideMaterialName);
+		nrp->releaseResource(mSubmeshData[index].materialID);
+
+		mSubmeshData[index].materialID = newID;
+		mSubmeshData[index].material = NULL;
+		mSubmeshData[index].isMaterialPointerValid = false;
+		mSubmeshData[index].maxBonesPerMaterial = 0;
+
+		if (!GetInternalApexSDK()->getRMALoadMaterialsLazily())
+		{
+			loadMaterial(mSubmeshData[index]);
+		}
+	}
+}
+
+// Need an inverse
+PX_INLINE PxMat44 inverse(const PxMat44& m)
+{
+	const PxMat33 invM33 = PxMat33(m.getBasis(0), m.getBasis(1), m.getBasis(2)).getInverse();
+	return PxMat44(invM33, -(invM33.transform(m.getPosition())));
+}
+
+bool ApexRenderMeshActor::rayCast(RenderMeshActorRaycastHitData& hitData,
+                                  const PxVec3& worldOrig, const PxVec3& worldDisp,
+                                  RenderMeshActorRaycastFlags::Enum flags,
+                                  RenderCullMode::Enum winding,
+                                  int32_t partIndex) const
+{
+	READ_ZONE();
+	PX_ASSERT(mRenderMeshAsset != NULL);
+	PX_ASSERT(worldOrig.isFinite() && worldDisp.isFinite()  && !worldDisp.isZero());
+
+	// Come up with a part range which matches the flags, and if partIndex > 0, ensure it lies within the part range
+	uint32_t rankStart = (flags & RenderMeshActorRaycastFlags::VISIBLE_PARTS) != 0 ? 0 : mVisiblePartsForAPI.usedCount();
+	uint32_t rankStop = (flags & RenderMeshActorRaycastFlags::INVISIBLE_PARTS) != 0 ? mRenderMeshAsset->getPartCount() : mVisiblePartsForAPI.usedCount();
+	// We use the visibility index bank, since it holds visible and invisible parts contiguously
+	if (rankStart >= rankStop)
+	{
+		return false;	// No parts selected for raycast
+	}
+	if (partIndex >= 0)
+	{
+		const uint32_t partRank = mVisiblePartsForAPI.getRank((uint32_t)partIndex);
+		if (partRank < rankStart || partRank >= rankStop)
+		{
+			return false;
+		}
+		rankStart = partRank;
+		rankStop = partRank + 1;
+	}
+	const uint32_t* partIndices = mVisiblePartsForAPI.usedIndices();
+
+	// Allocate an inverse transform and local ray for each part and calculate them
+	const uint32_t tmCount = mRenderWithoutSkinning ? 1 : rankStop - rankStart;	// Only need one transform if not skinning
+
+	PX_ALLOCA(invTMs, PxMat44, tmCount);
+	PX_ALLOCA(localOrigs, PxVec3, tmCount);
+	PX_ALLOCA(localDisps, PxVec3, tmCount);
+
+	if (mRenderWithoutSkinning)
+	{
+		invTMs[0] = inverse(mTransforms[0]);
+		localOrigs[0] = invTMs[0].transform(worldOrig);
+		localDisps[0] = invTMs[0].rotate(worldDisp);
+	}
+	else
+	{
+		for (uint32_t partRank = rankStart; partRank < rankStop; ++partRank)
+		{
+			invTMs[partRank - rankStart] = inverse(mTransforms[partRank - rankStart]);
+			localOrigs[partRank - rankStart] = invTMs[partRank - rankStart].transform(worldOrig);
+			localDisps[partRank - rankStart] = invTMs[partRank - rankStart].rotate(worldDisp);
+		}
+	}
+
+	// Side "discriminant" - used to reduce branches in inner loops
+	const float disc = winding == RenderCullMode::CLOCKWISE ? 1.0f : (winding == RenderCullMode::COUNTER_CLOCKWISE ? -1.0f : 0.0f);
+
+	// Keeping hit time as a fraction
+	float tNum = -1.0f;
+	float tDen = 0.0f;
+
+	// To do: handle multiple-weighted vertices, and other cases where the number of parts does not equal the number of bones (besides non-skinned, which we do handle)
+//	if (single-weighted vertices)
+	{
+		// Traverse the selected parts:
+		const uint32_t submeshCount = mRenderMeshAsset->getSubmeshCount();
+		for (uint32_t submeshIndex = 0; submeshIndex < submeshCount; ++submeshIndex)
+		{
+			const RenderSubmesh& submesh = mRenderMeshAsset->getSubmesh(submeshIndex);
+			const VertexBuffer& vertexBuffer = submesh.getVertexBuffer();
+			const VertexFormat& vertexFormat = vertexBuffer.getFormat();
+			RenderDataFormat::Enum positionFormat;
+			const PxVec3* vertexPositions = (const PxVec3*)vertexBuffer.getBufferAndFormat(positionFormat, (uint32_t)vertexFormat.getBufferIndexFromID(vertexFormat.getSemanticID(nvidia::RenderVertexSemantic::POSITION)));
+			if (positionFormat != RenderDataFormat::FLOAT3)
+			{
+				continue;	// Not handling any position format other than FLOAT3
+			}
+			for (uint32_t partRank = rankStart; partRank < rankStop; ++partRank)
+			{
+				const uint32_t cachedLocalIndex = mRenderWithoutSkinning ? 0 : partRank - rankStart;
+				const PxVec3& localOrig = localOrigs[cachedLocalIndex];
+				const PxVec3& localDisp = localDisps[cachedLocalIndex];
+				const uint32_t partIndex = partIndices[partRank];
+				const uint32_t* ib = submesh.getIndexBuffer(partIndex);
+				const uint32_t* ibStop = ib + submesh.getIndexCount(partIndex);
+				PX_ASSERT(submesh.getIndexCount(partIndex) % 3 == 0);
+				for (; ib < ibStop; ib += 3)
+				{
+					const PxVec3 offsetVertices[3] = { vertexPositions[ib[0]] - localOrig, vertexPositions[ib[1]] - localOrig, vertexPositions[ib[2]] - localOrig };
+					const PxVec3 triangleNormal = (offsetVertices[1] - offsetVertices[0]).cross(offsetVertices[2] - offsetVertices[0]);
+					const float den = triangleNormal.dot(localDisp);
+					if (den > -PX_EPS_F32 * PX_EPS_F32)
+					{
+						// Ray misses plane (or is too near parallel)
+						continue;
+					}
+					const float sides[3] = { (offsetVertices[0].cross(offsetVertices[1])).dot(localDisp), (offsetVertices[1].cross(offsetVertices[2])).dot(localDisp), (offsetVertices[2].cross(offsetVertices[0])).dot(localDisp) };
+					if ((int)(sides[0]*disc > 0.0f) | (int)(sides[1]*disc > 0.0f) | (int)(sides[2]*disc > 0.0f))
+					{
+						// Ray misses triangle
+						continue;
+					}
+					// Ray has hit the triangle; calculate time of intersection
+					const float num = offsetVertices[0].dot(triangleNormal);
+					// Since den and tDen both have the same (negative) sign, this is equivalent to : if (num/den < tNum/tDen)
+					if (num * tDen < tNum * den)
+					{
+						// This intersection is earliest
+						tNum = num;
+						tDen = den;
+						hitData.partIndex = partIndex;
+						hitData.submeshIndex = submeshIndex;
+						hitData.vertexIndices[0] = ib[0];
+						hitData.vertexIndices[1] = ib[1];
+						hitData.vertexIndices[2] = ib[2];
+					}
+				}
+			}
+		}
+
+		if (tDen == 0.0f)
+		{
+			// No intersection found
+			return false;
+		}
+
+		// Found a triangle.  Fill in hit data
+		hitData.time = tNum / tDen;
+
+		// See if normal, tangent, or binormal can be found
+		const RenderSubmesh& submesh = mRenderMeshAsset->getSubmesh(hitData.submeshIndex);
+		const VertexBuffer& vertexBuffer = submesh.getVertexBuffer();
+		const VertexFormat& vertexFormat = vertexBuffer.getFormat();
+
+		const int32_t normalBufferIndex = vertexFormat.getBufferIndexFromID(vertexFormat.getSemanticID(nvidia::RenderVertexSemantic::NORMAL));
+		const int32_t tangentBufferIndex = vertexFormat.getBufferIndexFromID(vertexFormat.getSemanticID(nvidia::RenderVertexSemantic::TANGENT));
+		const int32_t binormalBufferIndex = vertexFormat.getBufferIndexFromID(vertexFormat.getSemanticID(nvidia::RenderVertexSemantic::BINORMAL));
+
+		ExplicitRenderTriangle triangle;
+		const bool haveNormal = vertexBuffer.getBufferData(&triangle.vertices[0].normal, nvidia::RenderDataFormat::FLOAT3, 0, (uint32_t)normalBufferIndex, hitData.vertexIndices[0], 1);
+		const bool haveTangent = vertexBuffer.getBufferData(&triangle.vertices[0].tangent, nvidia::RenderDataFormat::FLOAT3, 0, (uint32_t)tangentBufferIndex, hitData.vertexIndices[0], 1);
+		const bool haveBinormal = vertexBuffer.getBufferData(&triangle.vertices[0].binormal, nvidia::RenderDataFormat::FLOAT3, 0, (uint32_t)binormalBufferIndex, hitData.vertexIndices[0], 1);
+
+		uint32_t fieldMask = 0;
+
+		if (haveNormal)
+		{
+			vertexBuffer.getBufferData(&triangle.vertices[1].normal, nvidia::RenderDataFormat::FLOAT3, 0, (uint32_t)normalBufferIndex, hitData.vertexIndices[1], 1);
+			vertexBuffer.getBufferData(&triangle.vertices[2].normal, nvidia::RenderDataFormat::FLOAT3, 0, (uint32_t)normalBufferIndex, hitData.vertexIndices[2], 1);
+			fieldMask |= 1 << TriangleFrame::Normal_x | 1 << TriangleFrame::Normal_y | 1 << TriangleFrame::Normal_z;
+		}
+		else
+		{
+			hitData.normal = PxVec3(0.0f);
+		}
+
+		if (haveTangent)
+		{
+			vertexBuffer.getBufferData(&triangle.vertices[1].tangent, nvidia::RenderDataFormat::FLOAT3, 0, (uint32_t)tangentBufferIndex, hitData.vertexIndices[1], 1);
+			vertexBuffer.getBufferData(&triangle.vertices[2].tangent, nvidia::RenderDataFormat::FLOAT3, 0, (uint32_t)tangentBufferIndex, hitData.vertexIndices[2], 1);
+			fieldMask |= 1 << TriangleFrame::Tangent_x | 1 << TriangleFrame::Tangent_y | 1 << TriangleFrame::Tangent_z;
+		}
+		else
+		{
+			hitData.tangent = PxVec3(0.0f);
+		}
+
+		if (haveBinormal)
+		{
+			vertexBuffer.getBufferData(&triangle.vertices[1].binormal, nvidia::RenderDataFormat::FLOAT3, 0, (uint32_t)binormalBufferIndex, hitData.vertexIndices[1], 1);
+			vertexBuffer.getBufferData(&triangle.vertices[2].binormal, nvidia::RenderDataFormat::FLOAT3, 0, (uint32_t)binormalBufferIndex, hitData.vertexIndices[2], 1);
+			fieldMask |= 1 << TriangleFrame::Binormal_x | 1 << TriangleFrame::Binormal_y | 1 << TriangleFrame::Binormal_z;
+		}
+		else
+		{
+			hitData.binormal = PxVec3(0.0f);
+		}
+
+		if (fieldMask != 0)
+		{
+			// We know the positions are in the correct format from the check in the raycast
+			const PxVec3* vertexPositions = (const PxVec3*)vertexBuffer.getBuffer(
+				(uint32_t)vertexFormat.getBufferIndexFromID(vertexFormat.getSemanticID(nvidia::RenderVertexSemantic::POSITION)));
+			triangle.vertices[0].position = vertexPositions[hitData.vertexIndices[0]];
+			triangle.vertices[1].position = vertexPositions[hitData.vertexIndices[1]];
+			triangle.vertices[2].position = vertexPositions[hitData.vertexIndices[2]];
+			TriangleFrame frame(triangle, fieldMask);
+
+			// Find the local hit position
+			const uint32_t partRank = mVisiblePartsForAPI.getRank(hitData.partIndex);
+			const uint32_t cachedLocalIndex = mRenderWithoutSkinning ? 0 : partRank - rankStart;
+			const PxMat44& tm = mTransforms[mRenderWithoutSkinning ? 0 : hitData.partIndex];
+
+			Vertex v;
+			v.position = localOrigs[cachedLocalIndex] + hitData.time * localDisps[cachedLocalIndex];
+			frame.interpolateVertexData(v);
+			if (haveNormal)
+			{
+				hitData.normal = invTMs[cachedLocalIndex].getTranspose().rotate(v.normal);
+				hitData.normal.normalize();
+			}
+
+			if (haveTangent)
+			{
+				hitData.tangent = tm.rotate(v.tangent);
+				hitData.tangent.normalize();
+			}
+
+			if (haveBinormal)
+			{
+				hitData.binormal = tm.rotate(v.binormal);
+				hitData.binormal.normalize();
+			}
+			else
+			{
+				if (haveNormal && haveTangent)
+				{
+					hitData.binormal = hitData.normal.cross(hitData.tangent);
+					hitData.binormal.normalize();
+				}
+			}
+		}
+
+		return true;
+	}
+}
+
+void ApexRenderMeshActor::visualize(RenderDebugInterface& batcher, nvidia::apex::DebugRenderParams* debugParams, PxMat33* scaledRotations, PxVec3* translations, uint32_t stride, uint32_t numberOfTransforms) const
+{
+#ifdef WITHOUT_DEBUG_VISUALIZE
+	PX_UNUSED(batcher);
+	PX_UNUSED(debugParams);
+	PX_UNUSED(scaledRotations);
+	PX_UNUSED(translations);
+	PX_UNUSED(stride);
+	PX_UNUSED(numberOfTransforms);
+#else
+	PX_ASSERT(&batcher != NULL);
+	if ( !mEnableDebugVisualization ) return;
+
+	// This implementation seems to work for destruction and clothing!
+	const float scale = debugParams->Scale;
+	visualizeTangentSpace(batcher, debugParams->RenderNormals * scale, debugParams->RenderTangents * scale, debugParams->RenderBitangents * scale, scaledRotations, translations, stride, numberOfTransforms);
+#endif
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/ApexRenderMeshAsset.cpp b/APEX_1.4/framework/src/ApexRenderMeshAsset.cpp
new file mode 100644
index 00000000..6a199fa5
--- /dev/null
+++ b/APEX_1.4/framework/src/ApexRenderMeshAsset.cpp
@@ -0,0 +1,495 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "ApexRenderMeshAsset.h"
+#include "ApexRenderMeshActor.h"
+#include "ApexSharedUtils.h"
+
+#include "ApexSDKIntl.h"
+#include "ResourceProviderIntl.h"
+
+namespace nvidia
+{
+namespace apex
+{
+
+
+// ApexRenderMeshAsset functions
+
+ApexRenderMeshAsset::ApexRenderMeshAsset(ResourceList& list, const char* name, AuthObjTypeID ownerModuleID) :
+	mOwnerModuleID(ownerModuleID),
+	mParams(NULL),
+	mOpaqueMesh(NULL),
+	mName(name)
+{
+	list.add(*this);
+}
+
+
+
+ApexRenderMeshAsset::~ApexRenderMeshAsset()
+{
+	// this should have been cleared in releaseActor()
+	PX_ASSERT(mRuntimeSubmeshData.empty());
+
+	// Release named resources
+	ResourceProviderIntl* resourceProvider = GetInternalApexSDK()->getInternalResourceProvider();
+	for (uint32_t i = 0 ; i < mMaterialIDs.size() ; i++)
+	{
+		resourceProvider->releaseResource(mMaterialIDs[i]);
+	}
+
+	setSubmeshCount(0);
+}
+
+
+
+void ApexRenderMeshAsset::destroy()
+{
+	for (uint32_t i = 0; i < mSubmeshes.size(); i++)
+	{
+		mSubmeshes[i]->setParams(NULL, NULL);
+	}
+
+	if (mParams != NULL)
+	{
+		if (!mParams->isReferenced)
+		{
+			mParams->destroy();
+		}
+		mParams = NULL;
+	}
+
+	// this is necessary so that all the actors will be destroyed before the destructor runs
+	mActorList.clear();
+
+	delete this;
+}
+
+
+
+bool ApexRenderMeshAsset::createFromParameters(RenderMeshAssetParameters* params)
+{
+	mParams = params;
+
+	NvParameterized::Handle handle(*mParams);
+	uint32_t size;
+
+	// submeshes
+	mParams->getParameterHandle("submeshes", handle);
+	mParams->getArraySize(handle, (int32_t&)size);
+	setSubmeshCount(size);
+	for (uint32_t i = 0; i < size; ++i)
+	{
+		NvParameterized::Handle elementHandle(*mParams);
+		handle.getChildHandle((int32_t)i, elementHandle);
+		NvParameterized::Interface* submeshParams = NULL;
+		mParams->getParamRef(elementHandle, submeshParams);
+
+		mSubmeshes[i]->setParams(static_cast<SubmeshParameters*>(submeshParams), NULL);
+	}
+
+	createLocalData();
+
+	return true;
+}
+
+// Load all of our named resources (that consists of materials) if they are
+// not registered in the NRP
+uint32_t ApexRenderMeshAsset::forceLoadAssets()
+{
+	uint32_t assetLoadedCount = 0;
+	ResourceProviderIntl* nrp = GetInternalApexSDK()->getInternalResourceProvider();
+	ResID materialNS = GetInternalApexSDK()->getMaterialNameSpace();
+
+	for (uint32_t i = 0; i < mMaterialIDs.size(); i++)
+	{
+
+		if (!nrp->checkResource(materialNS, mParams->materialNames.buf[i]))
+		{
+			/* we know for SURE that createResource() has already been called, so just getResource() */
+			nrp->getResource(mMaterialIDs[i]);
+			assetLoadedCount++;
+		}
+	}
+
+	return assetLoadedCount;
+}
+
+
+RenderMeshActor* ApexRenderMeshAsset::createActor(const RenderMeshActorDesc& desc)
+{
+	return PX_NEW(ApexRenderMeshActor)(desc, *this, mActorList);
+}
+
+
+
+void ApexRenderMeshAsset::releaseActor(RenderMeshActor& renderMeshActor)
+{
+	ApexRenderMeshActor* actor = DYNAMIC_CAST(ApexRenderMeshActor*)(&renderMeshActor);
+	actor->destroy();
+
+	// Last one out turns out the lights
+	if (!mActorList.getSize())
+	{
+		UserRenderResourceManager* rrm = GetInternalApexSDK()->getUserRenderResourceManager();
+		for (uint32_t i = 0 ; i < mRuntimeSubmeshData.size() ; i++)
+		{
+			if (mRuntimeSubmeshData[i].staticVertexBuffer != NULL)
+			{
+				rrm->releaseVertexBuffer(*mRuntimeSubmeshData[i].staticVertexBuffer);
+				mRuntimeSubmeshData[i].staticVertexBuffer = NULL;
+			}
+			if (mRuntimeSubmeshData[i].skinningVertexBuffer != NULL)
+			{
+				rrm->releaseVertexBuffer(*mRuntimeSubmeshData[i].skinningVertexBuffer);
+				mRuntimeSubmeshData[i].skinningVertexBuffer = NULL;
+			}
+			if (mRuntimeSubmeshData[i].dynamicVertexBuffer != NULL)
+			{
+				rrm->releaseVertexBuffer(*mRuntimeSubmeshData[i].dynamicVertexBuffer);
+				mRuntimeSubmeshData[i].dynamicVertexBuffer = NULL;
+			}
+		}
+		mRuntimeSubmeshData.clear();
+	}
+}
+
+
+
+void ApexRenderMeshAsset::permuteBoneIndices(const physx::Array<int32_t>& old2new)
+{
+	int32_t maxBoneIndex = -1;
+	for (uint32_t i = 0; i < mSubmeshes.size(); i++)
+	{
+		RenderDataFormat::Enum format;
+		const VertexBuffer& vb = mSubmeshes[i]->getVertexBuffer();
+		const VertexFormat& vf = vb.getFormat();
+		uint32_t bufferIndex = (uint32_t)vf.getBufferIndexFromID(vf.getSemanticID(nvidia::RenderVertexSemantic::BONE_INDEX));
+		uint16_t* boneIndices = (uint16_t*)vb.getBufferAndFormat(format, bufferIndex);
+		if (boneIndices == NULL)
+		{
+			continue;
+		}
+
+		uint32_t numBonesPerVertex = 0;
+		switch (format)
+		{
+		case RenderDataFormat::USHORT1:
+			numBonesPerVertex = 1;
+			break;
+		case RenderDataFormat::USHORT2:
+			numBonesPerVertex = 2;
+			break;
+		case RenderDataFormat::USHORT3:
+			numBonesPerVertex = 3;
+			break;
+		case RenderDataFormat::USHORT4:
+			numBonesPerVertex = 4;
+			break;
+		default:
+			continue;
+		}
+
+		const uint32_t numVertices = vb.getVertexCount();
+		for (uint32_t j = 0; j < numVertices; j++)
+		{
+			for (uint32_t k = 0; k < numBonesPerVertex; k++)
+			{
+				uint16_t& index = boneIndices[j * numBonesPerVertex + k];
+				PX_ASSERT(old2new[index] >= 0);
+				PX_ASSERT(old2new[index] <= 0xffff);
+				index = (uint16_t)old2new[index];
+				maxBoneIndex = PxMax(maxBoneIndex, (int32_t)index);
+			}
+		}
+	}
+	mParams->boneCount = (uint32_t)maxBoneIndex + 1;
+}
+
+
+void ApexRenderMeshAsset::reverseWinding()
+{
+	for (uint32_t submeshId = 0; submeshId < mSubmeshes.size(); submeshId++)
+	{
+		uint32_t numIndices = mSubmeshes[submeshId]->getTotalIndexCount();
+		// assume that all of the parts are contiguous
+		uint32_t* indices = mSubmeshes[submeshId]->getIndexBufferWritable(0);
+		for (uint32_t i = 0; i < numIndices; i += 3)
+		{
+			nvidia::swap<uint32_t>(indices[i + 1], indices[i + 2]);
+		}
+	}
+
+	updatePartBounds();
+}
+
+void ApexRenderMeshAsset::applyTransformation(const PxMat44& transformation, float scale)
+{
+	for (uint32_t submeshId = 0; submeshId < mSubmeshes.size(); submeshId++)
+	{
+		VertexBufferIntl& vb = mSubmeshes[submeshId]->getVertexBufferWritable();
+		vb.applyScale(scale);
+		vb.applyTransformation(transformation);
+	}
+
+	// if the transform will mirror the mesh, change the triangle winding in the ib
+
+	const PxMat33 tm(transformation.column0.getXYZ(),
+						transformation.column1.getXYZ(),
+						transformation.column2.getXYZ());
+
+	if (tm.getDeterminant() * scale < 0.0f)
+	{
+		reverseWinding();
+	}
+	else
+	{
+		updatePartBounds();
+	}
+}
+
+
+
+void ApexRenderMeshAsset::applyScale(float scale)
+{
+	for (uint32_t submeshId = 0; submeshId < mSubmeshes.size(); submeshId++)
+	{
+		VertexBufferIntl& vb = mSubmeshes[submeshId]->getVertexBufferWritable();
+		vb.applyScale(scale);
+	}
+
+	for (int partId = 0; partId < mParams->partBounds.arraySizes[0]; partId++)
+	{
+		PX_ASSERT(!mParams->partBounds.buf[partId].isEmpty());
+		mParams->partBounds.buf[partId].minimum *= scale;
+		mParams->partBounds.buf[partId].maximum *= scale;
+	}
+
+	if (scale < 0.0f)
+	{
+		for (int partId = 0; partId < mParams->partBounds.arraySizes[0]; partId++)
+		{
+			PX_ASSERT(!mParams->partBounds.buf[partId].isEmpty());
+			nvidia::swap(mParams->partBounds.buf[partId].minimum, mParams->partBounds.buf[partId].maximum);
+		}
+	}
+}
+
+
+
+bool ApexRenderMeshAsset::mergeBinormalsIntoTangents()
+{
+	bool changed = false;
+	for (uint32_t submeshId = 0; submeshId < mSubmeshes.size(); submeshId++)
+	{
+		VertexBufferIntl& vb = mSubmeshes[submeshId]->getVertexBufferWritable();
+		changed |= vb.mergeBinormalsIntoTangents();
+	}
+	return changed;
+}
+
+
+
+TextureUVOrigin::Enum ApexRenderMeshAsset::getTextureUVOrigin() const
+{
+	PX_ASSERT(mParams->textureUVOrigin < 4);
+	return static_cast<TextureUVOrigin::Enum>(mParams->textureUVOrigin);
+}
+
+
+
+void ApexRenderMeshAsset::createLocalData()
+{
+	mMaterialIDs.resize((uint32_t)mParams->materialNames.arraySizes[0]);
+	ResourceProviderIntl* resourceProvider = GetInternalApexSDK()->getInternalResourceProvider();
+	ResID materialNS = GetInternalApexSDK()->getMaterialNameSpace();
+	ResID customVBNS = GetInternalApexSDK()->getCustomVBNameSpace();
+
+
+	// Resolve material names using the NRP...
+	for (uint32_t i = 0; i < (uint32_t)mParams->materialNames.arraySizes[0]; ++i)
+	{
+		if (resourceProvider)
+		{
+			mMaterialIDs[i] = resourceProvider->createResource(materialNS, mParams->materialNames.buf[i]);
+		}
+		else
+		{
+			mMaterialIDs[i] = INVALID_RESOURCE_ID;
+		}
+	}
+
+	// Resolve custom vertex buffer semantics using the NRP...
+	mRuntimeCustomSubmeshData.resize(getSubmeshCount());
+	//JPB memset(mRuntimeCustomSubmeshData.begin(), 0, sizeof(CustomSubmeshData) * mRuntimeCustomSubmeshData.size());
+
+	for (uint32_t i = 0; i < getSubmeshCount(); ++i)
+	{
+		const VertexFormat& fmt = getSubmesh(i).getVertexBuffer().getFormat();
+
+		mRuntimeCustomSubmeshData[i].customBufferFormats.resize(fmt.getCustomBufferCount());
+		mRuntimeCustomSubmeshData[i].customBufferVoidPtrs.resize(fmt.getCustomBufferCount());
+
+		uint32_t customBufferIndex = 0;
+		for (uint32_t j = 0; j < fmt.getBufferCount(); ++j)
+		{
+			if (fmt.getBufferSemantic(j) != RenderVertexSemantic::CUSTOM)
+			{
+				continue;
+			}
+			RenderDataFormat::Enum f = fmt.getBufferFormat(j);
+			const char* name = fmt.getBufferName(j);
+
+			mRuntimeCustomSubmeshData[i].customBufferFormats[customBufferIndex] = f;
+			mRuntimeCustomSubmeshData[i].customBufferVoidPtrs[customBufferIndex] = 0;
+
+			if (resourceProvider)
+			{
+				ResID id = resourceProvider->createResource(customVBNS, name, true);
+				mRuntimeCustomSubmeshData[i].customBufferVoidPtrs[customBufferIndex] = GetInternalApexSDK()->getInternalResourceProvider()->getResource(id);
+			}
+
+			++customBufferIndex;
+		}
+	}
+
+	// find the bone count
+	// LRR - required for new deserialize path
+	// PH - mBoneCount is now serialized
+	if (mParams->boneCount == 0)
+	{
+		for (uint32_t i = 0; i < getSubmeshCount(); i++)
+		{
+
+			RenderDataFormat::Enum format;
+			const VertexBuffer& vb = mSubmeshes[i]->getVertexBuffer();
+			const VertexFormat& vf = vb.getFormat();
+			uint32_t bufferIndex = (uint32_t)vf.getBufferIndexFromID(vf.getSemanticID(nvidia::RenderVertexSemantic::BONE_INDEX));
+			uint16_t* boneIndices = (uint16_t*)vb.getBufferAndFormat(format, bufferIndex);
+
+			if (boneIndices == NULL)
+			{
+				continue;
+			}
+
+			if (!vertexSemanticFormatValid(RenderVertexSemantic::BONE_INDEX, format))
+			{
+				continue;
+			}
+
+			const uint32_t bonesPerVert = vertexSemanticFormatElementCount(RenderVertexSemantic::BONE_INDEX, format);
+
+			PX_ASSERT(format == RenderDataFormat::USHORT1 || format == RenderDataFormat::USHORT2 || format == RenderDataFormat::USHORT3 || format == RenderDataFormat::USHORT4);
+
+			const uint32_t numVertices = vb.getVertexCount();
+			for (uint32_t v = 0; v < numVertices; v++)
+			{
+				for (uint32_t b = 0; b < bonesPerVert; b++)
+				{
+					mParams->boneCount = PxMax(mParams->boneCount, (uint32_t)(boneIndices[v * bonesPerVert + b] + 1));
+				}
+			}
+		}
+	}
+
+	// PH - have one bone at all times, if it's just one, it is used as current pose (see ApexRenderMeshActor::dispatchRenderResources)
+	if (mParams->boneCount == 0)
+	{
+		mParams->boneCount = 1;
+	}
+}
+
+void ApexRenderMeshAsset::getStats(RenderMeshAssetStats& stats) const
+{
+	stats.totalBytes = sizeof(ApexRenderMeshAsset);
+
+	for (int i = 0; i < mParams->materialNames.arraySizes[0]; ++i)
+	{
+		stats.totalBytes += (uint32_t) strlen(mParams->materialNames.buf[i]) + 1;
+	}
+
+	stats.totalBytes += mParams->partBounds.arraySizes[0] * sizeof(PxBounds3);
+	stats.totalBytes += mName.len() + 1;
+
+	stats.submeshCount = mSubmeshes.size();
+	stats.partCount = (uint32_t)mParams->partBounds.arraySizes[0];
+	stats.vertexCount = 0;
+	stats.indexCount = 0;
+	stats.vertexBufferBytes = 0;
+	stats.indexBufferBytes = 0;
+
+	for (uint32_t i = 0; i < mSubmeshes.size(); ++i)
+	{
+		const ApexRenderSubmesh& submesh =	*mSubmeshes[i];
+
+		submesh.addStats(stats);
+	}
+}
+
+
+void ApexRenderMeshAsset::updatePartBounds()
+{
+	for (int i = 0; i < mParams->partBounds.arraySizes[0]; i++)
+	{
+		mParams->partBounds.buf[i].setEmpty();
+	}
+
+	for (uint32_t i = 0; i < mSubmeshes.size(); i++)
+	{
+		const uint32_t* part = mSubmeshes[i]->mParams->vertexPartition.buf;
+
+		RenderDataFormat::Enum format;
+		const VertexBuffer& vb = mSubmeshes[i]->getVertexBuffer();
+		const VertexFormat& vf = vb.getFormat();
+		uint32_t bufferIndex = (uint32_t)vf.getBufferIndexFromID(vf.getSemanticID(nvidia::RenderVertexSemantic::POSITION));
+		PxVec3* positions = (PxVec3*)vb.getBufferAndFormat(format, bufferIndex);
+		if (positions == NULL)
+		{
+			continue;
+		}
+		if (format != RenderDataFormat::FLOAT3)
+		{
+			continue;
+		}
+
+		for (int p = 0; p < mParams->partBounds.arraySizes[0]; p++)
+		{
+			const uint32_t start = part[p];
+			const uint32_t end = part[p + 1];
+			for (uint32_t v = start; v < end; v++)
+			{
+				mParams->partBounds.buf[p].include(positions[v]);
+			}
+		}
+	}
+}
+
+void ApexRenderMeshAsset::setSubmeshCount(uint32_t submeshCount)
+{
+	const uint32_t oldSize = mSubmeshes.size();
+
+	for (uint32_t i = oldSize; i-- > submeshCount;)
+	{
+		PX_DELETE(mSubmeshes[i]);
+	}
+
+	mSubmeshes.resize(submeshCount);
+
+	for (uint32_t i = oldSize; i < submeshCount; ++i)
+	{
+		mSubmeshes[i] = PX_NEW(ApexRenderSubmesh);
+	}
+}
+
+
+}
+} // end namespace nvidia::apex
diff --git a/APEX_1.4/framework/src/ApexRenderMeshAssetAuthoring.cpp b/APEX_1.4/framework/src/ApexRenderMeshAssetAuthoring.cpp
new file mode 100644
index 00000000..1ccc32f0
--- /dev/null
+++ b/APEX_1.4/framework/src/ApexRenderMeshAssetAuthoring.cpp
@@ -0,0 +1,650 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+#include "PsArray.h"
+#include "ApexRenderMeshAssetAuthoring.h"
+#include "ApexRenderMeshActor.h"
+#include "ApexSharedUtils.h"
+#include "ApexCustomBufferIterator.h"
+#include "ApexUsingNamespace.h"
+#include "ApexSDKIntl.h"
+#include "ResourceProviderIntl.h"
+
+#include "PsSort.h"
+
+#ifndef WITHOUT_APEX_AUTHORING
+
+namespace nvidia
+{
+namespace apex
+{
+
+
+PX_INLINE bool PxVec3equals(const PxVec3& a, const PxVec3& v, float epsilon)
+{
+	return
+		PxEquals(a.x, v.x, epsilon) &&
+		PxEquals(a.y, v.y, epsilon) &&
+		PxEquals(a.z, v.z, epsilon);
+}
+
+ApexRenderMeshAssetAuthoring::ApexRenderMeshAssetAuthoring(ResourceList& list, RenderMeshAssetParameters* params, const char* name)
+{
+	list.add(*this);
+
+	createFromParameters(params);
+
+	mName = name;
+}
+
+ApexRenderMeshAssetAuthoring::ApexRenderMeshAssetAuthoring(ResourceList& list)
+{
+	list.add(*this);
+}
+
+ApexRenderMeshAssetAuthoring::~ApexRenderMeshAssetAuthoring()
+{
+}
+
+// We will create our vertex map here.  Remapping will be from sorting by part index
+
+
+void ApexRenderMeshAssetAuthoring::createRenderMesh(const MeshDesc& meshDesc, bool createMappingInformation)
+{
+	if (!meshDesc.isValid())
+	{
+		APEX_INVALID_OPERATION("MeshDesc is not valid!");
+		return;
+	}
+
+	if (mParams != NULL)
+	{
+		mParams->destroy();
+	}
+
+	NvParameterized::Traits* traits = GetInternalApexSDK()->getParameterizedTraits();
+	mParams = (RenderMeshAssetParameters*)traits->createNvParameterized(RenderMeshAssetParameters::staticClassName());
+	NvParameterized::Handle rootHandle(*mParams);
+
+	// Submeshes
+	mParams->getParameterHandle("materialNames", rootHandle);
+	rootHandle.resizeArray((int32_t)meshDesc.m_numSubmeshes);
+	mParams->getParameterHandle("submeshes", rootHandle);
+	rootHandle.resizeArray((int32_t)meshDesc.m_numSubmeshes);
+	setSubmeshCount(0);
+	setSubmeshCount(meshDesc.m_numSubmeshes);
+	for (uint32_t submeshNum = 0; submeshNum < meshDesc.m_numSubmeshes; ++submeshNum)
+	{
+		ApexRenderSubmesh& submesh = *mSubmeshes[submeshNum];
+		SubmeshParameters* submeshParams = (SubmeshParameters*)traits->createNvParameterized(SubmeshParameters::staticClassName());
+		submesh.createFromParameters(submeshParams);
+		mParams->submeshes.buf[submeshNum] = submeshParams;
+		//NvParameterized::Handle submeshHandle( submeshParams );
+		const SubmeshDesc& submeshDesc = meshDesc.m_submeshes[submeshNum];
+
+		// Material name
+		NvParameterized::Handle handle(*mParams);
+		mParams->getParameterHandle("materialNames", handle);
+		NvParameterized::Handle elementHandle(*mParams);
+		handle.getChildHandle((int32_t)submeshNum, elementHandle);
+		mParams->setParamString(elementHandle, submeshDesc.m_materialName);
+
+		// Index buffer
+
+		physx::Array<VertexPart> submeshMap;
+		submeshMap.resize(submeshDesc.m_numVertices);
+		const uint32_t invalidPart = PxMax(1u, submeshDesc.m_numParts);
+		for (uint32_t i = 0; i < submeshDesc.m_numVertices; ++i)
+		{
+			submeshMap[i].part = invalidPart;
+			submeshMap[i].vertexIndex = i;
+		}
+		bool success = false;
+		switch (submeshDesc.m_indexType)
+		{
+		case IndexType::UINT:
+			success = fillSubmeshMap<uint32_t>(submeshMap, submeshDesc.m_partIndices, submeshDesc.m_numParts, submeshDesc.m_vertexIndices, submeshDesc.m_numIndices, submeshDesc.m_numVertices);
+			break;
+		case IndexType::USHORT:
+			success = fillSubmeshMap<uint16_t>(submeshMap, submeshDesc.m_partIndices, submeshDesc.m_numParts, submeshDesc.m_vertexIndices, submeshDesc.m_numIndices, submeshDesc.m_numVertices);
+			break;
+		default:
+			PX_ALWAYS_ASSERT();
+		}
+
+		// error message?
+		if (!success)
+		{
+			return;
+		}
+
+		if (submeshMap.size() > 1)
+		{
+			shdfnd::sort(submeshMap.begin(), submeshMap.size(), VertexPart());
+		}
+
+		uint32_t vertexCount = 0;
+		for (; vertexCount < submeshDesc.m_numVertices; ++vertexCount)
+		{
+			if (submeshMap[vertexCount].part == invalidPart)
+			{
+				break;
+			}
+		}
+
+		// Create inverse map for our internal remapping
+		Array<int32_t> invMap;	// maps old indices to new indices
+		invMap.resize(submeshDesc.m_numVertices);
+		for (uint32_t i = 0; i < submeshDesc.m_numVertices; ++i)
+		{
+			const uint32_t vIndex = submeshMap[i].vertexIndex;
+			if (i >= vertexCount)
+			{
+				invMap[vIndex] = -1;
+			}
+			else
+			{
+				invMap[vIndex] = (int32_t)i;
+			}
+		}
+
+		// Copy index buffer (remapping)
+		NvParameterized::Handle ibHandle(submeshParams);
+		submeshParams->getParameterHandle("indexBuffer", ibHandle);
+		ibHandle.resizeArray((int32_t)submeshDesc.m_numIndices);
+		switch (submeshDesc.m_indexType)
+		{
+		case IndexType::UINT:
+			for (uint32_t i = 0; i < submeshDesc.m_numIndices; ++i)
+			{
+				const uint32_t index = submeshDesc.m_vertexIndices != NULL ? ((uint32_t*)submeshDesc.m_vertexIndices)[i] : i;
+				submeshParams->indexBuffer.buf[i] = (uint32_t)invMap[index];
+				PX_ASSERT(submeshParams->indexBuffer.buf[i] != (uint32_t)-1);
+			}
+			break;
+		case IndexType::USHORT:
+			for (uint32_t i = 0; i < submeshDesc.m_numIndices; ++i)
+			{
+				const uint16_t index = submeshDesc.m_vertexIndices != NULL ? ((uint16_t*)submeshDesc.m_vertexIndices)[i] : (uint16_t)i;
+				submeshParams->indexBuffer.buf[i] = (uint32_t)invMap[index];
+				PX_ASSERT(submeshParams->indexBuffer.buf[i] != (uint32_t)-1);
+			}
+			break;
+		default:
+			PX_ALWAYS_ASSERT();
+		}
+
+		// Smoothing groups
+		int32_t smoothingGroupArraySize = 0;
+		if (submeshDesc.m_smoothingGroups != NULL)
+		{
+			switch (submeshDesc.m_primitive)
+			{
+			case Primitive::TRIANGLE_LIST:
+				smoothingGroupArraySize = (int32_t)submeshDesc.m_numIndices/3;
+				break;
+			default:
+				PX_ALWAYS_ASSERT();	// We only have one kind of primitive
+			}
+		}
+		if (smoothingGroupArraySize != 0)
+		{
+			NvParameterized::Handle sgHandle(submeshParams);
+			submeshParams->getParameterHandle("smoothingGroups", sgHandle);
+			sgHandle.resizeArray(smoothingGroupArraySize);
+			sgHandle.setParamU32Array(submeshDesc.m_smoothingGroups, smoothingGroupArraySize, 0);
+		}
+
+		// Index partition
+		NvParameterized::Handle ipHandle(submeshParams);
+		submeshParams->getParameterHandle("indexPartition", ipHandle);
+		ipHandle.resizeArray(PxMax((int32_t)submeshDesc.m_numParts + 1, 2));
+
+		if (submeshDesc.m_numParts == 0)
+		{
+			submeshParams->indexPartition.buf[0] = 0;
+			submeshParams->indexPartition.buf[1] = submeshDesc.m_numIndices;
+		}
+		else
+		{
+			switch (submeshDesc.m_indexType)
+			{
+			case IndexType::UINT:
+				for (uint32_t i = 0; i < submeshDesc.m_numParts; ++i)
+				{
+					submeshParams->indexPartition.buf[i] = ((uint32_t*)submeshDesc.m_partIndices)[i];
+				}
+				submeshParams->indexPartition.buf[submeshDesc.m_numParts] = submeshDesc.m_numIndices;
+				break;
+			case IndexType::USHORT:
+				for (uint32_t i = 0; i < submeshDesc.m_numParts; ++i)
+				{
+					submeshParams->indexPartition.buf[i] = (uint32_t)((uint16_t*)submeshDesc.m_partIndices)[i];
+				}
+				submeshParams->indexPartition.buf[submeshDesc.m_numParts] = submeshDesc.m_numIndices;
+				break;
+			default:
+				PX_ALWAYS_ASSERT();
+			}
+		}
+
+		// Vertex partition
+		Array<uint32_t> lookup;
+		createIndexStartLookup(lookup, 0, submeshDesc.m_numParts, (int32_t*)submeshMap.begin(), vertexCount, sizeof(VertexPart));
+		NvParameterized::Handle vpHandle(submeshParams);
+		submeshParams->getParameterHandle("vertexPartition", vpHandle);
+		vpHandle.resizeArray((int32_t)lookup.size());
+		vpHandle.setParamU32Array(lookup.begin(), (int32_t)lookup.size());
+
+		// Vertex buffer
+
+		// Create format description
+		ApexVertexFormat format;
+
+		for (uint32_t i = 0; i < submeshDesc.m_numVertexBuffers; ++i)
+		{
+			const VertexBuffer& vb = submeshDesc.m_vertexBuffers[i];
+			for (uint32_t semantic = 0; semantic < RenderVertexSemantic::NUM_SEMANTICS; ++semantic)
+			{
+				RenderVertexSemantic::Enum vertexSemantic = (RenderVertexSemantic::Enum)semantic;
+				RenderDataFormat::Enum vertexFormat = vb.getSemanticData(vertexSemantic).format;
+
+				if (vertexSemanticFormatValid(vertexSemantic, vertexFormat))
+				{
+					int32_t bufferIndex = format.addBuffer(format.getSemanticName(vertexSemantic));
+					format.setBufferFormat((uint32_t)bufferIndex, vb.getSemanticData(vertexSemantic).format);
+				}
+				else if (vertexFormat != RenderDataFormat::UNSPECIFIED)
+				{
+					APEX_INVALID_PARAMETER("Format (%d) is not valid for Semantic (%s)", vertexFormat, format.getSemanticName(vertexSemantic));
+				}
+			}
+		}
+
+		format.setWinding(submeshDesc.m_cullMode);
+
+		// Include custom buffers
+		for (uint32_t i = 0; i < submeshDesc.m_numVertexBuffers; ++i)
+		{
+			const VertexBuffer& vb = submeshDesc.m_vertexBuffers[i];
+			for (uint32_t index = 0; index < vb.getNumCustomSemantics(); ++index)
+			{
+				const RenderSemanticData& data = vb.getCustomSemanticData(index);
+				// BRG - reusing data.ident as the custom channel name.  What to do with the serialize parameter?
+				int32_t bufferIndex = format.addBuffer((char*)data.ident);
+				format.setBufferFormat((uint32_t)bufferIndex, data.format);
+
+				// PH: custom buffers are never serialized this way, we might need to change this!
+				format.setBufferSerialize((uint32_t)bufferIndex, data.serialize);
+			}
+		}
+
+		if (createMappingInformation)
+		{
+			int32_t bufferIndex = format.addBuffer("VERTEX_ORIGINAL_INDEX");
+			format.setBufferFormat((uint32_t)bufferIndex, RenderDataFormat::UINT1);
+		}
+
+		// Create apex vertex buffer
+		submesh.buildVertexBuffer(format, vertexCount);
+
+		// Now fill in...
+		for (uint32_t i = 0; i < submeshDesc.m_numVertexBuffers; ++i)
+		{
+			const VertexBuffer& vb = submeshDesc.m_vertexBuffers[i];
+			const VertexFormat& vf = submesh.getVertexBuffer().getFormat();
+
+			RenderSemanticData boneWeightData;
+			RenderSemanticData boneIndexData;
+			RenderDataFormat::Enum checkFormatBoneWeight = RenderDataFormat::UNSPECIFIED;
+			RenderDataFormat::Enum checkFormatBoneIndex = RenderDataFormat::UNSPECIFIED;
+			RenderDataFormat::Enum dstFormatBoneWeight = RenderDataFormat::UNSPECIFIED;
+			RenderDataFormat::Enum dstFormatBoneIndex = RenderDataFormat::UNSPECIFIED;
+			void* dstDataWeight = NULL;
+			void* dstDataIndex = NULL;
+			uint32_t numBoneWeights = 0;
+			uint32_t numBoneIndices = 0;
+
+			for (uint32_t semantic = 0; semantic < RenderVertexSemantic::NUM_SEMANTICS; ++semantic)
+			{
+				if (vertexSemanticFormatValid((RenderVertexSemantic::Enum)semantic, vb.getSemanticData((RenderVertexSemantic::Enum)semantic).format))
+				{
+					RenderDataFormat::Enum dstFormat;
+					void* dst = submesh.getVertexBufferWritable().getBufferAndFormatWritable(dstFormat, (uint32_t)vf.getBufferIndexFromID(vf.getSemanticID((RenderVertexSemantic::Enum)semantic)));
+					const RenderSemanticData& data = vb.getSemanticData((RenderVertexSemantic::Enum)semantic);
+
+					copyRenderVertexBuffer(dst, dstFormat, 0, 0, data.data, data.srcFormat, data.stride, 0, submeshDesc.m_numVertices, invMap.begin());
+
+					if (semantic == RenderVertexSemantic::BONE_WEIGHT)
+					{
+						boneWeightData = data;
+						// Verification code for bone weights.
+						switch (data.srcFormat)
+						{
+						case RenderDataFormat::FLOAT1:
+							checkFormatBoneWeight = RenderDataFormat::FLOAT1;
+							numBoneWeights = 1;
+							break;
+						case RenderDataFormat::FLOAT2:
+							checkFormatBoneWeight = RenderDataFormat::FLOAT2;
+							numBoneWeights = 2;
+							break;
+						case RenderDataFormat::FLOAT3:
+							checkFormatBoneWeight = RenderDataFormat::FLOAT3;
+							numBoneWeights = 3;
+							break;
+						case RenderDataFormat::FLOAT4:
+							checkFormatBoneWeight = RenderDataFormat::FLOAT4;
+							numBoneWeights = 4;
+							break;
+						default:
+							break;
+						}
+
+						dstDataWeight = dst;
+						dstFormatBoneWeight = dstFormat;
+					}
+					else if (semantic == RenderVertexSemantic::BONE_INDEX)
+					{
+						boneIndexData = data;
+						switch (data.srcFormat)
+						{
+						case RenderDataFormat::USHORT1:
+							checkFormatBoneIndex = RenderDataFormat::USHORT1;
+							numBoneIndices = 1;
+							break;
+						case RenderDataFormat::USHORT2:
+							checkFormatBoneIndex = RenderDataFormat::USHORT2;
+							numBoneIndices = 2;
+							break;
+						case RenderDataFormat::USHORT3:
+							checkFormatBoneIndex = RenderDataFormat::USHORT3;
+							numBoneIndices = 3;
+							break;
+						case RenderDataFormat::USHORT4:
+							checkFormatBoneIndex = RenderDataFormat::USHORT4;
+							numBoneIndices = 4;
+							break;
+						default:
+							break;
+						}
+						dstDataIndex = dst;
+						dstFormatBoneIndex = dstFormat;
+					}
+				}
+			}
+
+			// some verification code
+			if (numBoneIndices > 1 && numBoneWeights == numBoneIndices)
+			{
+				float verifyWeights[4] = { 0.0f };
+				uint16_t verifyIndices[4] = { 0 };
+				for (uint32_t vi = 0; vi < submeshDesc.m_numVertices; vi++)
+				{
+					const int32_t dest = invMap[vi];
+					if (dest >= 0)
+					{
+
+						copyRenderVertexBuffer(verifyWeights, checkFormatBoneWeight, 0, 0, boneWeightData.data, boneWeightData.srcFormat, boneWeightData.stride, vi, 1);
+						copyRenderVertexBuffer(verifyIndices, checkFormatBoneIndex, 0, 0, boneIndexData.data, boneIndexData.srcFormat, boneIndexData.stride, vi, 1);
+
+						float sum = 0.0f;
+						for (uint32_t j = 0; j < numBoneWeights; j++)
+						{
+							sum += verifyWeights[j];
+						}
+
+						if (PxAbs(1 - sum) > 0.001)
+						{
+							if (sum > 0.0f)
+							{
+								for (uint32_t j = 0; j < numBoneWeights; j++)
+								{
+									verifyWeights[j] /= sum;
+								}
+							}
+
+							APEX_INVALID_PARAMETER("Submesh %d Vertex %d has been normalized, bone weight was (%f)", i, vi, 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]);
+								}
+							}
+						}
+
+						for (uint32_t j = 0; j < numBoneWeights; j++)
+						{
+							if (verifyWeights[j] == 0.0f)
+							{
+								verifyIndices[j] = 0;
+							}
+						}
+
+						copyRenderVertexBuffer(dstDataWeight, dstFormatBoneWeight, 0, (uint32_t)dest, verifyWeights, checkFormatBoneWeight, 0, 0, 1);
+						copyRenderVertexBuffer(dstDataIndex, dstFormatBoneIndex, 0, (uint32_t)dest, verifyIndices, checkFormatBoneIndex, 0, 0, 1);
+					}
+				}
+			}
+
+			// Custom buffers
+			for (uint32_t index = 0; index < vb.getNumCustomSemantics(); ++index)
+			{
+				const RenderSemanticData& data = vb.getCustomSemanticData(index);
+				const int32_t bufferIndex = format.getBufferIndexFromID(format.getID((char*)data.ident));
+				PX_ASSERT(bufferIndex >= 0);
+				void* dst = const_cast<void*>(submesh.getVertexBuffer().getBuffer((uint32_t)bufferIndex));
+				RenderDataFormat::Enum srcFormat = data.srcFormat != RenderDataFormat::UNSPECIFIED ? data.srcFormat : data.format;
+				copyRenderVertexBuffer(dst, data.format, 0, 0, data.data, srcFormat, data.stride, 0, submeshDesc.m_numVertices, invMap.begin());
+			}
+		}
+
+		if (createMappingInformation)
+		{
+			const VertexFormat::BufferID bufferID = format.getID("VERTEX_ORIGINAL_INDEX");
+			const int32_t bufferIndex = format.getBufferIndexFromID(bufferID);
+			RenderDataFormat::Enum bufferFormat = format.getBufferFormat((uint32_t)bufferIndex);
+			PX_ASSERT(bufferIndex >= 0);
+			const void* dst = submesh.getVertexBuffer().getBuffer((uint32_t)bufferIndex);
+			copyRenderVertexBuffer(const_cast<void*>(dst), bufferFormat, 0, 0, &submeshMap[0].vertexIndex , RenderDataFormat::UINT1 , sizeof(VertexPart), 0, vertexCount, NULL);
+		}
+	}
+
+	// Part bounds
+	uint32_t partCount = 1;
+	for (uint32_t submeshNum = 0; submeshNum < meshDesc.m_numSubmeshes; ++submeshNum)
+	{
+		partCount = PxMax(partCount, meshDesc.m_submeshes[submeshNum].m_numParts);
+	}
+	mParams->getParameterHandle("partBounds", rootHandle);
+	mParams->resizeArray(rootHandle, (int32_t)partCount);
+	for (uint32_t partNum = 0; partNum < partCount; ++partNum)
+	{
+		mParams->partBounds.buf[partNum].setEmpty();
+		// Add part vertices
+		for (uint32_t submeshNum = 0; submeshNum < meshDesc.m_numSubmeshes; ++submeshNum)
+		{
+			SubmeshParameters* submeshParams = DYNAMIC_CAST(SubmeshParameters*)(mParams->submeshes.buf[submeshNum]);
+			ApexRenderSubmesh& submesh = *mSubmeshes[submeshNum];
+			RenderDataFormat::Enum positionFormat;
+			const VertexFormat& vf = submesh.getVertexBuffer().getFormat();
+			const PxVec3* positions = (const PxVec3*)submesh.getVertexBuffer().getBufferAndFormat(positionFormat, 
+				(uint32_t)vf.getBufferIndexFromID(vf.getSemanticID(RenderVertexSemantic::POSITION)));
+			if (positions && positionFormat == RenderDataFormat::FLOAT3)
+			{
+				for (uint32_t vertexIndex = submeshParams->vertexPartition.buf[partNum]; vertexIndex < submeshParams->vertexPartition.buf[partNum + 1]; ++vertexIndex)
+				{
+					mParams->partBounds.buf[partNum].include(positions[vertexIndex]);
+				}
+			}
+		}
+	}
+
+	mParams->textureUVOrigin = meshDesc.m_uvOrigin;
+
+	createLocalData();
+}
+
+uint32_t ApexRenderMeshAssetAuthoring::createReductionMap(uint32_t* map, const Vertex* vertices, const uint32_t* smoothingGroups, uint32_t vertexCount,
+        const PxVec3& positionTolerance, float normalTolerance, float UVTolerance)
+{
+	physx::Array<BoundsRep> vertexNeighborhoods;
+	vertexNeighborhoods.resize(vertexCount);
+	const PxVec3 neighborhoodExtent = 0.5f * positionTolerance;
+	for (uint32_t vertexNum = 0; vertexNum < vertexCount; ++vertexNum)
+	{
+		vertexNeighborhoods[vertexNum].aabb = PxBounds3(vertices[vertexNum].position - neighborhoodExtent, vertices[vertexNum].position + neighborhoodExtent);
+	}
+
+	physx::Array<IntPair> vertexNeighbors;
+	if (vertexNeighborhoods.size() > 0)
+	{
+		boundsCalculateOverlaps(vertexNeighbors, Bounds3XYZ, &vertexNeighborhoods[0], vertexNeighborhoods.size(), sizeof(vertexNeighborhoods[0]));
+	}
+
+	for (uint32_t i = 0; i < vertexCount; ++i)
+	{
+		map[i] = i;
+	}
+
+	for (uint32_t pairNum = 0; pairNum < vertexNeighbors.size(); ++pairNum)
+	{
+		const IntPair& pair = vertexNeighbors[pairNum];
+		const uint32_t map0 = map[pair.i0];
+		const uint32_t map1 = map[pair.i1];
+		if (smoothingGroups != NULL && smoothingGroups[map0] != smoothingGroups[map1])
+		{
+			continue;
+		}
+		const Vertex& vertex0 = vertices[map0];
+		const Vertex& vertex1 = vertices[map1];
+		if (PxAbs(vertex0.position.x - vertex1.position.x) > positionTolerance.x ||
+		        PxAbs(vertex0.position.y - vertex1.position.y) > positionTolerance.y ||
+		        PxAbs(vertex0.position.z - vertex1.position.z) > positionTolerance.z)
+		{
+			continue;
+		}
+		if (!PxVec3equals(vertex0.normal, vertex1.normal, normalTolerance) ||
+		        !PxVec3equals(vertex0.tangent, vertex1.tangent, normalTolerance) ||
+		        !PxVec3equals(vertex0.binormal, vertex1.binormal, normalTolerance))
+		{
+			continue;
+		}
+		uint32_t uvNum = 0;
+		for (; uvNum < VertexFormat::MAX_UV_COUNT; ++uvNum)
+		{
+			const VertexUV& uv0 = vertex0.uv[uvNum];
+			const VertexUV& uv1 = vertex1.uv[uvNum];
+			if (PxAbs(uv0[0] - uv1[0]) > UVTolerance || PxAbs(uv0[1] - uv1[1]) > UVTolerance)
+			{
+				break;
+			}
+		}
+		if (uvNum < VertexFormat::MAX_UV_COUNT)
+		{
+			continue;
+		}
+		map[pair.i1] = map0;
+	}
+
+	physx::Array<int32_t> offsets(vertexCount, -1);
+	for (uint32_t i = 0; i < vertexCount; ++i)
+	{
+		offsets[map[i]] = 0;
+	}
+	int32_t delta = 0;
+	for (uint32_t i = 0; i < vertexCount; ++i)
+	{
+		delta += offsets[i];
+		offsets[i] = delta;
+	}
+	for (uint32_t i = 0; i < vertexCount; ++i)
+	{
+		map[i] += offsets[map[i]];
+	}
+	return vertexCount + delta;
+}
+
+
+
+void ApexRenderMeshAssetAuthoring::setMaterialName(uint32_t submeshIndex, const char* name)
+{
+	size_t maxMaterials = (uint32_t)mParams->materialNames.arraySizes[0];
+	PX_ASSERT(submeshIndex < maxMaterials);
+	if (submeshIndex < maxMaterials)
+	{
+		NvParameterized::Handle handle(*mParams);
+		mParams->getParameterHandle("materialNames", handle);
+		NvParameterized::Handle elementHandle(*mParams);
+		handle.getChildHandle((int32_t)submeshIndex, elementHandle);
+		mParams->setParamString(elementHandle, name ? name : "");
+	}
+}
+
+void						ApexRenderMeshAssetAuthoring::setWindingOrder(uint32_t submeshIndex, RenderCullMode::Enum winding)
+{
+	ApexRenderSubmesh& subMesh = *ApexRenderMeshAsset::mSubmeshes[submeshIndex];
+	VertexBufferIntl& vb = subMesh.getVertexBufferWritable();
+	vb.getFormatWritable().setWinding(winding);
+}
+
+RenderCullMode::Enum		ApexRenderMeshAssetAuthoring::getWindingOrder(uint32_t submeshIndex) const
+{
+	const RenderSubmesh& subMesh = getSubmesh(submeshIndex);
+	const nvidia::apex::VertexBuffer& vb = subMesh.getVertexBuffer();
+	const VertexFormat& format = vb.getFormat();
+	return format.getWinding();
+}
+
+
+
+template <typename PxU>
+bool ApexRenderMeshAssetAuthoring::fillSubmeshMap(physx::Array<VertexPart>& submeshMap, const void* const partIndicesVoid,
+        uint32_t numParts, const void* const vertexIndicesVoid,
+        uint32_t numSubmeshIndices, uint32_t numSubmeshVertices)
+{
+	PxU partIndexStart = 0;
+	if (numParts == 0)
+	{
+		numParts = 1;
+	}
+
+	const PxU* const partIndices = partIndicesVoid != NULL ? reinterpret_cast<const PxU * const>(partIndicesVoid) : &partIndexStart;
+	const PxU* const vertexIndices = reinterpret_cast<const PxU * const>(vertexIndicesVoid);
+
+	for (uint32_t i = 0; i < numParts; ++i)
+	{
+		const uint32_t stop = i + 1 < numParts ? partIndices[i + 1] : numSubmeshIndices;
+		for (uint32_t j = partIndices[i]; j < stop; ++j)
+		{
+			const uint32_t vertexIndex = vertexIndices != NULL ? vertexIndices[j] : j;
+			if (vertexIndex >= numSubmeshVertices)
+			{
+				return false;	// to do: issue error - index out of range
+			}
+			if (submeshMap[vertexIndex].part != numParts && submeshMap[vertexIndex].part != i)
+			{
+				return false;	// to do: issue error - vertex in more than one part
+			}
+			submeshMap[vertexIndex].part = i;
+		}
+	}
+	return true;
+}
+
+}
+} // end namespace nvidia::apex
+#endif
diff --git a/APEX_1.4/framework/src/ApexRenderSubmesh.cpp b/APEX_1.4/framework/src/ApexRenderSubmesh.cpp
new file mode 100644
index 00000000..150e2432
--- /dev/null
+++ b/APEX_1.4/framework/src/ApexRenderSubmesh.cpp
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "ApexRenderSubmesh.h"
+
+//#include "ApexStream.h"
+//#include "ApexSharedSerialization.h"
+#include "ApexSDKIntl.h"
+
+
+namespace nvidia
+{
+namespace apex
+{
+
+PX_INLINE uint32_t findIndexedNeighbors(uint32_t indexedNeighbors[3], uint32_t triangleIndex,
+        const uint32_t* indexBuffer, const uint32_t* vertexTriangleRefs, const uint32_t* vertexToTriangleMap)
+{
+	uint32_t indexedNeighborCount = 0;
+	const uint32_t* triangleVertexIndices = indexBuffer + 3 * triangleIndex;
+	for (uint32_t v = 0; v < 3; ++v)
+	{
+		const uint32_t vertexIndex = triangleVertexIndices[v];
+		const uint32_t prevVertexIndex = triangleVertexIndices[(3 >> v) ^ 1];
+		// Find all other triangles which have this vertex
+		const uint32_t mapStart = vertexTriangleRefs[vertexIndex];
+		const uint32_t mapStop = vertexTriangleRefs[vertexIndex + 1];
+		for (uint32_t i = mapStart; i < mapStop; ++i)
+		{
+			const uint32_t neighborTriangleIndex = vertexToTriangleMap[i];
+			// See if the previous vertex on the triangle matches the next vertex on the neighbor.  (This will
+			// automatically exclude the triangle itself, so no check to exclude a self-check is made.)
+			const uint32_t* neighborTriangleVertexIndices = indexBuffer + 3 * neighborTriangleIndex;
+			const uint8_t indexMatch = (uint8_t)((uint8_t)(neighborTriangleVertexIndices[0] == vertexIndex) |
+													     (uint8_t)(neighborTriangleVertexIndices[1] == vertexIndex) << 1 |
+													     (uint8_t)(neighborTriangleVertexIndices[2] == vertexIndex) << 2);
+			const uint32_t nextNeighborVertexIndex = neighborTriangleVertexIndices[indexMatch & 3];
+			if (nextNeighborVertexIndex == prevVertexIndex)
+			{
+				// Found a neighbor
+				indexedNeighbors[indexedNeighborCount++] = neighborTriangleIndex;
+			}
+		}
+	}
+
+	return indexedNeighborCount;
+}
+
+
+
+void ApexRenderSubmesh::applyPermutation(const Array<uint32_t>& old2new, const Array<uint32_t>& new2old)
+{
+	if (mParams->vertexPartition.arraySizes[0] == 2)
+	{
+		mVertexBuffer.applyPermutation(new2old);
+	}
+
+	const uint32_t numIndices = (uint32_t)mParams->indexBuffer.arraySizes[0];
+	for (uint32_t i = 0; i < numIndices; i++)
+	{
+		PX_ASSERT(mParams->indexBuffer.buf[i] < old2new.size());
+		mParams->indexBuffer.buf[i] = old2new[mParams->indexBuffer.buf[i]];
+	}
+}
+
+
+
+bool ApexRenderSubmesh::createFromParameters(SubmeshParameters* params)
+{
+	mParams = params;
+
+	if (mParams->vertexBuffer == NULL)
+	{
+		NvParameterized::Traits* traits = GetInternalApexSDK()->getParameterizedTraits();
+		mParams->vertexBuffer = traits->createNvParameterized(VertexBufferParameters::staticClassName());
+	}
+	mVertexBuffer.setParams(static_cast<VertexBufferParameters*>(mParams->vertexBuffer));
+
+	return true;
+}
+
+
+
+void ApexRenderSubmesh::setParams(SubmeshParameters* submeshParams, VertexBufferParameters* vertexBufferParams)
+{
+
+	if (vertexBufferParams == NULL && submeshParams != NULL)
+	{
+		vertexBufferParams = static_cast<VertexBufferParameters*>(submeshParams->vertexBuffer);
+		PX_ASSERT(vertexBufferParams != NULL);
+	}
+	else if (submeshParams != NULL && submeshParams->vertexBuffer == NULL)
+	{
+		submeshParams->vertexBuffer = vertexBufferParams;
+	}
+	else if (mParams == NULL)
+	{
+		// Only emit this warning if mParams is empty yet (not on destruction of the object)
+		APEX_INTERNAL_ERROR("Confliciting parameterized objects!");
+	}
+	mParams = submeshParams;
+
+	mVertexBuffer.setParams(vertexBufferParams);
+}
+
+
+
+void ApexRenderSubmesh::addStats(RenderMeshAssetStats& stats) const
+{
+	stats.vertexCount += mVertexBuffer.getVertexCount();
+	stats.indexCount += mParams->indexBuffer.arraySizes[0];
+
+	const uint32_t submeshVertexBytes = mVertexBuffer.getAllocationSize();
+	stats.vertexBufferBytes += submeshVertexBytes;
+	stats.totalBytes += submeshVertexBytes;
+
+	const uint32_t submeshIndexBytes = mParams->indexBuffer.arraySizes[0] * sizeof(uint32_t);
+	stats.indexBufferBytes += submeshIndexBytes;
+	stats.totalBytes += submeshIndexBytes;
+
+	stats.totalBytes += mParams->smoothingGroups.arraySizes[0] * sizeof(uint32_t);
+}
+
+
+
+void ApexRenderSubmesh::buildVertexBuffer(const VertexFormat& format, uint32_t vertexCount)
+{
+	mVertexBuffer.build(format, vertexCount);
+}
+
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/ApexResourceProvider.cpp b/APEX_1.4/framework/src/ApexResourceProvider.cpp
new file mode 100644
index 00000000..ee4e4105
--- /dev/null
+++ b/APEX_1.4/framework/src/ApexResourceProvider.cpp
@@ -0,0 +1,702 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "Apex.h"
+#include "ResourceProviderIntl.h"
+#include "ApexResourceProvider.h"
+#include "PsUserAllocated.h"
+#include "ApexSDKImpl.h"
+#include "PsString.h"
+#include <ctype.h> // for toupper()
+
+namespace nvidia
+{
+namespace apex
+{
+
+#pragma warning(disable: 4355)
+
+ApexResourceProvider::ApexResourceProvider() 
+: mNSNames(this, 0, false, 0)
+, mCaseSensitive(false)
+{
+}
+
+ApexResourceProvider::~ApexResourceProvider()
+{
+}
+
+/* == Public ResourceProvider interface == */
+void ApexResourceProvider::registerCallback(ResourceCallback* func)
+{
+	mUserCallback = func;
+}
+
+void ApexResourceProvider::setResource(const char* nameSpace, const char* name, void* resource, bool incRefCount)
+{
+	setResource(nameSpace, name, resource, true, incRefCount);
+}
+
+void ApexResourceProvider::setResource(const char* nameSpace, const char* name, void* resource, bool valueIsSet, bool incRefCount)
+{
+	PX_ASSERT(nameSpace);
+	PX_ASSERT(name);
+	uint32_t nsIndex = getNSIndex(createNameSpaceInternal(nameSpace, true));
+	if (nsIndex < mNameSpaces.size())
+	{
+		ResID id = mNameSpaces[nsIndex]->getOrCreateID(name, nameSpace);
+		PX_ASSERT(id < mResources.size());
+		if (id < mResources.size())
+		{
+			ApexResourceProvider::resource& res = mResources[id];
+			res.ptr = resource;
+			res.valueIsSet = (uint8_t)valueIsSet;
+			if (incRefCount)
+			{
+				res.refCount++;
+			}
+		}
+	}
+}
+
+void* ApexResourceProvider::getResource(const char* nameSpace, const char* name)
+{
+	PX_ASSERT(nameSpace);
+	PX_ASSERT(name);
+	uint32_t nsIndex = getNSIndex(createNameSpaceInternal(nameSpace, true));
+	if (nsIndex < mNameSpaces.size())
+	{
+		ResID id = mNameSpaces[nsIndex]->getOrCreateID(name, nameSpace);
+		PX_ASSERT(id < mResources.size());
+		if (id < mResources.size())
+		{
+			return getResource(id);
+		}
+	}
+	return NULL;
+}
+
+/* == Internal ResourceProviderIntl interface == */
+ResID ApexResourceProvider::createNameSpaceInternal(const char* &nameSpace, bool releaseAtExit)
+{
+	/* create or get a name space */
+	size_t  nextID = mResources.size();
+	ResID nsID = mNSNames.getOrCreateID(nameSpace, "NameSpace");
+	if (nsID == (ResID) nextID)
+	{
+		NameSpace* ns = PX_NEW(NameSpace)(this, nsID, releaseAtExit, nameSpace);
+		if (ns)
+		{
+			ResID id = getNSID(nameSpace);
+			mNSID.insert(id, mNameSpaces.size());
+
+			mResources[nsID].ptr = (void*)(size_t) id;
+			mNameSpaces.pushBack(ns);
+		}
+		else
+		{
+			return INVALID_RESOURCE_ID;
+		}
+	}
+	ResID ret = (ResID)(size_t) mResources[nsID].ptr;
+	return ret;
+}
+
+ResID ApexResourceProvider::createResource(ResID nameSpace, const char* name, bool refCount)
+{
+	uint32_t nsIndex = getNSIndex(nameSpace);
+	if (nsIndex < mNameSpaces.size())
+	{
+		NameSpace* ns = mNameSpaces[nsIndex];
+		ResID id = ns->getOrCreateID(name, mResources[ns->getID()].name);
+		PX_ASSERT(id < mResources.size());
+		if (id < mResources.size() && refCount)
+		{
+			mResources[id].refCount++;
+		}
+		return id;
+	}
+	else
+	{
+		return INVALID_RESOURCE_ID;
+	}
+}
+
+bool ApexResourceProvider::checkResource(ResID nameSpace, const char* name)
+{
+	/* Return true is named resource has known non-null pointer */
+	uint32_t nsIndex = getNSIndex(nameSpace);
+	if (nsIndex < mNameSpaces.size())
+	{
+		NameSpace* ns = mNameSpaces[nsIndex];
+		ResID id = ns->getOrCreateID(name, mResources[ns->getID()].name);
+		PX_ASSERT(id < mResources.size());
+		return checkResource(id);
+	}
+	return false;
+}
+
+bool ApexResourceProvider::checkResource(ResID id)
+{
+	if (mResources.size() <= id)
+	{
+		return false;
+	}
+
+	ApexResourceProvider::resource& res = mResources[id];
+
+	if (!res.valueIsSet)
+	{
+		return false;
+	}
+
+	return true;
+}
+
+void ApexResourceProvider::generateUniqueName(ResID nameSpace, ApexSimpleString& name)
+{
+	uint32_t nsIndex = getNSIndex(nameSpace);
+	if (nsIndex < mNameSpaces.size())
+	{
+		ApexSimpleString test;
+		uint32_t   count = 1;
+		char	buf[64];
+		*buf = '.';
+
+		do
+		{
+			shdfnd::snprintf(buf + 1,60, "%d", count);
+			test = name + ApexSimpleString(buf);
+			if (!checkResource(nameSpace, test.c_str()))
+			{
+				break;
+			}
+		}
+		while (++count < 0xFFFFFFF0);
+
+		name = test;
+	}
+}
+
+void ApexResourceProvider::releaseResource(ResID id)
+{
+	if (mResources.size() <= id)
+	{
+		return;
+	}
+
+	ApexResourceProvider::resource& res = mResources[id];
+
+	PX_ASSERT(res.refCount);
+	if (res.refCount > 0)
+	{
+		res.refCount--;
+
+		if (res.refCount == 0 && mUserCallback &&
+		        res.valueIsSet && res.ptr != NULL)
+		{
+			if (mResources[id].usedGetResource)   // Defect DE641 only callback to the user, if this resource was created by a GetResource request
+			{
+				mUserCallback->releaseResource(res.nameSpace, res.name, res.ptr);
+			}
+			res.ptr = (void*) UnknownValue;
+			res.valueIsSet = false;
+			res.usedGetResource = false;
+		}
+		// if the ptr is NULL and we're releasing it, we do want to call requestResource next time it is requested, so valueIsSet = false
+		else if (res.refCount == 0 && res.valueIsSet && res.ptr == NULL)
+		{
+			res.ptr = (void*) UnknownValue;
+			res.valueIsSet = false;
+			res.usedGetResource = false;
+		}
+	}
+}
+
+void* ApexResourceProvider::getResource(ResID id)
+{
+	if (mResources.size() <= id)
+	{
+		return NULL;
+	}
+	else if (!mResources[id].valueIsSet)
+	{
+		// PH: WARNING: This MUST not be a reference, mResource can be altered during the requestResource() operation!!!!
+		ApexResourceProvider::resource res = mResources[id];
+		if (mUserCallback)
+		{
+			// tmp ensures that the [] operator is called AFTER mResources is possibly
+			// resized by something in requestResources
+			void* tmp = mUserCallback->requestResource(res.nameSpace, res.name);
+			res.ptr = tmp;
+			res.valueIsSet = true;
+			res.usedGetResource = true;
+		}
+		else
+		{
+			res.ptr = NULL;
+		}
+		mResources[id] = res;
+	}
+	return mResources[id].ptr;
+}
+
+const char* ApexResourceProvider::getResourceName(ResID id)
+{
+	if (mResources.size() <= id)
+	{
+		return NULL;
+	}
+	return mResources[id].name;
+}
+const char* ApexResourceProvider::getResourceNameSpace(ResID id)
+{
+	if (mResources.size() <= id)
+	{
+		return NULL;
+	}
+	return mResources[id].nameSpace;
+}
+
+
+bool ApexResourceProvider::getResourceIDs(const char* nameSpace, ResID* outResIDs, uint32_t& outCount, uint32_t inCount)
+{
+	outCount = 0;
+
+	if (!outResIDs)
+	{
+		return false;
+	}
+
+	for (uint32_t i = 0; i < mResources.size(); i++)
+	{
+		if (stringsMatch(mResources[i].nameSpace, nameSpace))
+		{
+			if (outCount > inCount)
+			{
+				outCount = 0;
+				return false;
+			}
+			outResIDs[outCount++] = i;
+		}
+	}
+
+	return true;
+}
+
+void ApexResourceProvider::destroy()
+{
+	if (mUserCallback)
+	{
+		for (uint32_t i = 0 ; i < mResources.size() ; i++)
+		{
+			ApexResourceProvider::resource& res = mResources[i];
+			if (res.refCount != 0 && res.valueIsSet && res.ptr != NULL)
+			{
+				ResID resIndex = mNSNames.getOrCreateID(res.nameSpace, "NameSpace");
+				PX_ASSERT(mResources[resIndex].ptr);
+				uint32_t nsIndex = getNSIndex((ResID)(size_t)mResources[resIndex].ptr);
+				if (nsIndex < mNameSpaces.size() &&
+					mNameSpaces[nsIndex]->releaseAtExit())
+				{
+					if (res.usedGetResource) // this check added for PhysXLab DE4349
+				{
+					mUserCallback->releaseResource(res.nameSpace, res.name, res.ptr);
+				}
+					else
+					{
+						APEX_DEBUG_WARNING("Unreleased resource found during teardown: Namespace <%s>, Name <%s>", res.nameSpace, res.name);
+					}
+				}
+			}
+		}
+	}
+	mResources.clear();
+	for (uint32_t i = 0 ; i < mNameSpaces.size() ; i++)
+	{
+		PX_DELETE(mNameSpaces[i]);
+	}
+	mNameSpaces.clear();
+	delete this;
+}
+
+ApexResourceProvider::NameSpace::NameSpace(ApexResourceProvider* arp, ResID nsid, bool releaseAtExit, const char* nameSpace) :
+	mReleaseAtExit(releaseAtExit),
+	mArp(arp),
+	mId(nsid)
+{
+	memset(hash, 0, sizeof(hash));
+	mNameSpace = 0;
+	if (nameSpace)
+	{
+		uint32_t len = (uint32_t) strlen(nameSpace);
+		mNameSpace = (char*)PX_ALLOC(len + 1, PX_DEBUG_EXP("ApexResourceProvider::NameSpace"));
+		memcpy(mNameSpace, nameSpace, len + 1);
+	}
+}
+
+ApexResourceProvider::NameSpace::~NameSpace()
+{
+	// Free up all collision chains in the hash table
+	for (uint32_t i = 0 ; i < HashSize ; i++)
+	{
+		while (hash[i])
+		{
+			const char* entry = hash[i];
+			const entryHeader* hdr = (const entryHeader*) entry;
+			const char* next = hdr->nextEntry;
+			PX_FREE((void*) entry);
+			hash[i] = next;
+		}
+	}
+	PX_FREE(mNameSpace);
+}
+
+ResID	ApexResourceProvider::NameSpace::getOrCreateID(const char* &name, const char* NSName)
+{
+	/* Hash Table Entry:   | nextEntry* | ResID | name     | */
+	uint16_t h = genHash(name);
+	const char* entry = hash[h];
+
+	while (entry)
+	{
+		entryHeader* hdr = (entryHeader*) entry;
+		const char* entryName = entry + sizeof(entryHeader);
+
+		if (mArp->stringsMatch(name, entryName))
+		{
+			name = entryName;
+			return hdr->id;
+		}
+
+		entry = hdr->nextEntry;
+	}
+
+	size_t len = strlen(name);
+	size_t bufsize = len + 1 + sizeof(entryHeader);
+	char* newEntry = (char*) PX_ALLOC(bufsize, PX_DEBUG_EXP("ApexResourceProvider::NameSpace::getOrCreateID"));
+	if (newEntry)
+	{
+#if defined(WIN32)
+		strncpy_s(newEntry + sizeof(entryHeader), bufsize - sizeof(entryHeader), name, len);
+#else
+		strcpy(newEntry + sizeof(entryHeader), name);
+#endif
+		entryHeader* hdr = (entryHeader*) newEntry;
+		hdr->nextEntry = hash[h];
+		hdr->id = mArp->mResources.size();
+
+		resource res;
+		res.ptr = (void*) UnknownValue;
+		res.valueIsSet = false;
+		res.name = newEntry + sizeof(entryHeader);
+		res.nameSpace = NSName;
+		res.refCount = 0;
+		res.usedGetResource = 0;
+		mArp->mResources.pushBack(res);
+
+		hash[h] = (const char*) newEntry;
+
+		name = res.name;
+		return hdr->id;
+	}
+
+	return INVALID_RESOURCE_ID;
+}
+
+ResID ApexResourceProvider::getNSID(const char* nsName)
+{
+	physx::Hash<const char*> h;
+	ResID id = h(nsName);
+	const HashMapNSID::Entry* nsid = mNSID.find(id);
+	if (nsid)
+	{
+		PX_ASSERT(nsid->second < mNameSpaces.size() && mNameSpaces[nsid->second] != NULL);
+		if (nsid->second < mNameSpaces.size() && mNameSpaces[nsid->second] != NULL && !h.equal(nsName, mNameSpaces[nsid->second]->getNameSpace()))
+		{
+			PX_ALWAYS_ASSERT_MESSAGE("Hash collision detected for namespaces in ApexResourceProvider. Try to adjust hash function.");
+			return INVALID_RESOURCE_ID;
+		}
+	}
+	return id;
+}
+
+uint32_t ApexResourceProvider::getNSIndex(ResID nameSpace)
+{
+	PX_ASSERT(nameSpace != INVALID_RESOURCE_ID);
+	if (nameSpace == INVALID_RESOURCE_ID) return INVALID_RESOURCE_ID;
+	const HashMapNSID::Entry* ns = mNSID.find(nameSpace);
+	PX_ASSERT(ns);
+	uint32_t nsIndex = ns ? ns->second : INVALID_RESOURCE_ID;
+	PX_ASSERT(nsIndex < mNameSpaces.size());
+	return nsIndex;
+}
+
+uint16_t ApexResourceProvider::NameSpace::genHash(const char* name)
+{
+	PX_ASSERT(name != NULL);
+	/* XOR each 32bit word together */
+	uint32_t h = 0;
+	uint32_t* read32 = (uint32_t*)name;
+	size_t len = strlen(name);
+
+	/* Add remaining bytes */
+	uint8_t* read8 = (uint8_t*) read32;
+	while (len)
+	{
+		if (mArp->isCaseSensitive())
+		{
+			h ^= *read8;
+		}
+		else
+		{
+			h ^= toupper(*read8);
+		}
+		read8++;
+		len -= sizeof(uint8_t);
+	}
+
+	/* XOR fold top 16 bits over bottom 16 bits */
+	h ^= (h >> 16);
+
+	return (uint16_t)(h & (HashSize - 1));
+}
+
+void ApexResourceProvider::dumpResourceTable()
+{
+	APEX_DEBUG_INFO("ApexResourceProvider::dumpResourceTable");
+	APEX_DEBUG_INFO("namespace name refcount pointer valueIsSet");
+
+	for (uint32_t i = 0; i < mResources.size(); i++)
+	{
+		APEX_DEBUG_INFO("%s %s %d 0x%08x %d", mResources[i].nameSpace, mResources[i].name, mResources[i].refCount, mResources[i].ptr, mResources[i].valueIsSet);
+	}
+}
+
+
+void   			ApexResourceProvider::setResourceU32(const char* nameSpace, const char* name, uint32_t id, bool incRefCount)
+{
+	setResource(nameSpace, name, (void*)(size_t)id, true, incRefCount);
+}
+
+uint32_t  			ApexResourceProvider::releaseAllResourcesInNamespace(const char* nameSpace)
+{
+	uint32_t ret = 0;
+
+	for (uint32_t i = 0; i < mResources.size(); i++)
+	{
+		ApexResourceProvider::resource& res = mResources[i];
+		if (stringsMatch(res.nameSpace, nameSpace) &&  res.valueIsSet)
+		{
+			ret++;
+			PX_ASSERT(res.refCount);
+			if (res.refCount > 0)
+			{
+				res.refCount--;
+				if (res.refCount == 0 && mUserCallback &&
+				        res.valueIsSet && res.ptr != NULL)
+				{
+					mUserCallback->releaseResource(res.nameSpace, res.name, res.ptr);
+					res.ptr = (void*) UnknownValue;
+					res.valueIsSet = false;
+				}
+			}
+		}
+	}
+
+	return ret;
+}
+
+uint32_t  			ApexResourceProvider::releaseResource(const char* nameSpace, const char* name)
+{
+	uint32_t ret = 0;
+
+	PX_ASSERT(nameSpace);
+	PX_ASSERT(name);
+	uint32_t nsIndex = getNSIndex(createNameSpaceInternal(nameSpace, true));
+	if (nsIndex < mNameSpaces.size())
+	{
+		ResID id = mNameSpaces[nsIndex]->getOrCreateID(name, nameSpace);
+		PX_ASSERT(id < mResources.size());
+		if (id < mResources.size())
+		{
+			ApexResourceProvider::resource& res = mResources[id];
+			if (res.valueIsSet)
+			{
+				ret = (uint32_t)res.refCount - 1;
+				releaseResource(id);
+			}
+		}
+	}
+
+
+	return ret;
+}
+
+bool    		ApexResourceProvider::findRefCount(const char* nameSpace, const char* name, uint32_t& refCount)
+{
+	bool ret = false;
+	refCount = 0;
+	PX_ASSERT(nameSpace);
+	PX_ASSERT(name);
+	uint32_t nsIndex = getNSIndex(createNameSpaceInternal(nameSpace, true));
+	if (nsIndex < mNameSpaces.size())
+	{
+		ResID id = mNameSpaces[nsIndex]->getOrCreateID(name, nameSpace);
+		PX_ASSERT(id < mResources.size());
+		if (id < mResources.size())
+		{
+			if (mResources[id].valueIsSet)
+			{
+				ret = true;
+				refCount = mResources[id].refCount;
+			}
+		}
+	}
+
+	return ret;
+}
+
+void* 			ApexResourceProvider::findResource(const char* nameSpace, const char* name)
+{
+	void* ret = NULL;
+	PX_ASSERT(nameSpace);
+	PX_ASSERT(name);
+	uint32_t nsIndex = getNSIndex(createNameSpaceInternal(nameSpace, true));
+	if (nsIndex < mNameSpaces.size())
+	{
+		ResID id = mNameSpaces[nsIndex]->getOrCreateID(name, nameSpace);
+		PX_ASSERT(id < mResources.size());
+		if (id < mResources.size())
+		{
+			if (mResources[id].valueIsSet)
+			{
+				ret = mResources[id].ptr;
+			}
+		}
+	}
+	return ret;
+}
+
+uint32_t 			ApexResourceProvider::findResourceU32(const char* nameSpace, const char* name) // find an existing resource.
+{
+	uint32_t ret = 0;
+	PX_ASSERT(nameSpace);
+	PX_ASSERT(name);
+	uint32_t nsIndex = getNSIndex(createNameSpaceInternal(nameSpace, true));
+	if (nsIndex < mNameSpaces.size())
+	{
+		ResID id = mNameSpaces[nsIndex]->getOrCreateID(name, nameSpace);
+		PX_ASSERT(id < mResources.size());
+		if (id < mResources.size())
+		{
+			if (mResources[id].valueIsSet)
+			{
+#if PX_X64
+				uint64_t ret64 = (uint64_t)mResources[id].ptr;
+				ret = (uint32_t)ret64;
+#else
+				ret = (uint32_t)mResources[id].ptr;
+#endif
+			}
+		}
+	}
+	return ret;
+
+}
+
+void** 		ApexResourceProvider::findAllResources(const char* nameSpace, uint32_t& count) // find all resources in this namespace
+{
+	void** ret = 0;
+	count = 0;
+
+	mCharResults.clear();
+	for (uint32_t i = 0; i < mResources.size(); i++)
+	{
+		if (stringsMatch(nameSpace, mResources[i].nameSpace))
+		{
+			if (mResources[i].valueIsSet)
+			{
+				mCharResults.pushBack((const char*)mResources[i].ptr);
+			}
+		}
+	}
+	if (!mCharResults.empty())
+	{
+		ret = (void**)&mCharResults[0];
+		count = mCharResults.size();
+	}
+
+	return ret;
+}
+
+const char** 		ApexResourceProvider::findAllResourceNames(const char* nameSpace, uint32_t& count) // find all resources in this namespace
+{
+	const char** ret = 0;
+	count = 0;
+
+	mCharResults.clear();
+	for (uint32_t i = 0; i < mResources.size(); i++)
+	{
+		if (stringsMatch(nameSpace, mResources[i].nameSpace) && mResources[i].valueIsSet)
+		{
+			mCharResults.pushBack(mResources[i].name);
+		}
+	}
+	if (!mCharResults.empty())
+	{
+		ret = &mCharResults[0];
+		count = mCharResults.size();
+	}
+
+	return ret;
+}
+
+const char** 	ApexResourceProvider::findNameSpaces(uint32_t& count)
+{
+	const char** ret = 0;
+	count = 0;
+
+	mCharResults.clear();
+	for (physx::Array<NameSpace*>::Iterator i = mNameSpaces.begin(); i != mNameSpaces.end(); ++i)
+	{
+		const char* nameSpace = (*i)->getNameSpace();
+		if (nameSpace)
+		{
+			mCharResults.pushBack(nameSpace);
+		}
+	}
+
+	if (!mCharResults.empty())
+	{
+		count = mCharResults.size();
+		ret = &mCharResults[0];
+	}
+
+	return ret;
+}
+
+bool ApexResourceProvider::stringsMatch(const char* str0, const char* str1)
+{
+	if (mCaseSensitive)
+	{
+		return !nvidia::strcmp(str0, str1);
+	}
+	else
+	{
+		return !nvidia::stricmp(str0, str1);
+	}
+
+}
+
+
+}
+} // end namespace nvidia::apex
diff --git a/APEX_1.4/framework/src/ApexSDKImpl.cpp b/APEX_1.4/framework/src/ApexSDKImpl.cpp
new file mode 100644
index 00000000..c6a04972
--- /dev/null
+++ b/APEX_1.4/framework/src/ApexSDKImpl.cpp
@@ -0,0 +1,2059 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "Apex.h"
+#include "ApexUsingNamespace.h"
+#include "ApexScene.h"
+#include "ApexSDKImpl.h"
+#include "FrameworkPerfScope.h"
+#include "ApexRenderMeshAsset.h"
+#include "ApexRenderMeshActor.h"
+#include "ApexRenderMeshAssetAuthoring.h"
+#include "ApexResourceProvider.h"
+#include "PsMemoryBuffer.h"
+#include "ApexString.h"
+#include "ApexDefaultStream.h"
+#include "ApexRenderDebug.h"
+
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParamUtils.h"
+
+#include "PsMemoryBuffer.h"
+#include "PsFoundation.h"
+#include "NvDefaultTraits.h"
+
+#include "PsFileBuffer.h"
+#include "NvSerializerInternal.h"
+#include "UserOpaqueMesh.h"
+#include "ApexShape.h"
+
+#include "ApexAssetPreviewScene.h"
+#include "RenderResourceManagerWrapper.h"
+#include "PsThread.h"
+
+#include "PxProfileEventNames.h"
+#include "ApexPvdClient.h"
+
+#ifndef WITHOUT_PVD
+#include "PvdNxParamSerializer.h"
+#include "ApexStubPxProfileZone.h"
+#endif
+
+#define MAX_MSG_SIZE 65536
+#define WITH_DEBUG_ASSET 0
+
+#if PX_WINDOWS_FAMILY
+#include <windows/PsWindowsInclude.h>
+#include <cstdio>
+#include "ModuleUpdateLoader.h"
+
+#include <PxPvdImpl.h>
+
+// We require at least Visual Studio 2010 w/ SP1 to compile
+#if defined(_MSC_VER)
+#	if _MSC_VER >= 1900
+	PX_COMPILE_TIME_ASSERT(_MSC_FULL_VER >= 190000000);
+#	elif _MSC_VER >= 1800
+	PX_COMPILE_TIME_ASSERT(_MSC_FULL_VER >= 180000000);
+#	elif _MSC_VER >= 1700
+	PX_COMPILE_TIME_ASSERT(_MSC_FULL_VER >= 170000000);
+#	elif _MSC_VER >= 1600
+	PX_COMPILE_TIME_ASSERT(_MSC_FULL_VER >= 160040219);
+#	endif
+
+#	if _MSC_VER > 1900
+	#pragma message("Detected compiler newer than Visual Studio 2013, please update min version checking in ApexSDKImpl.cpp")
+	PX_COMPILE_TIME_ASSERT(_MSC_VER <= 1900);
+#	endif
+#endif
+
+#endif //PX_WINDOWS_FAMILY
+
+#if PX_OSX
+#include <mach-o/dyld.h>
+#include <libproc.h>
+#include <dlfcn.h>
+#endif
+
+#if PX_X86
+#define PTR_TO_UINT64(x) ((uint64_t)(uint32_t)(x))
+#else
+#define PTR_TO_UINT64(x) ((uint64_t)(x))
+#endif
+
+#if APEX_CUDA_SUPPORT
+#include "windows/PhysXIndicator.h"
+#endif
+
+#include "PxErrorCallback.h"
+#include "PxCudaContextManager.h"
+#include "PxCpuDispatcher.h"
+#include "PxProfileZoneManager.h"
+#ifdef PHYSX_PROFILE_SDK
+#if PX_PHYSICS_VERSION_MAJOR == 3
+#include "PxPhysics.h"
+#endif
+
+nvidia::profile::PxProfileZone *gProfileZone=NULL;
+
+#endif
+
+namespace nvidia
+{
+namespace apex
+{
+
+
+extern ApexSDKImpl* gApexSdk;
+
+#if defined(_USRDLL) || PX_OSX
+typedef Module* (NxCreateModule_FUNC)(ApexSDKIntl*, ModuleIntl**, uint32_t, uint32_t, ApexCreateError*);
+#else
+/* When modules are statically linked, the user must instantiate modules manually before they can be
+ * created via the ApexSDK::createModule() method.  Each module must supply an instantiation function.
+ */
+#endif
+
+ApexSDKImpl::ApexSDKImpl(ApexCreateError* errorCode, uint32_t /*inAPEXsdkVersion*/)
+	: mAuthorableObjects(NULL)
+	, mBatchSeedSize(128)
+	, mErrorString(NULL)
+	, mNumTempMemoriesActive(0)
+#if PX_PHYSICS_VERSION_MAJOR == 0
+	, mApexThreadPool(0)
+#endif
+	, renderResourceManager(NULL)
+	, renderResourceManagerWrapper(NULL)
+	, apexResourceProvider(NULL)
+	, cookingVersion(0)
+	, mURRdepthTLSslot(0xFFFFFFFF)
+	, mEnableApexStats(true)
+	, mEnableConcurrencyCheck(false)
+{
+	if (errorCode)
+	{
+		*errorCode = APEX_CE_NO_ERROR;
+	}
+
+#if PX_DEBUG || PX_CHECKED
+	mURRdepthTLSslot = shdfnd::TlsAlloc();
+#endif
+}
+
+AuthObjTypeID	ApexRenderMeshAsset::mObjTypeID;
+#include "ModuleFrameworkRegistration.h"
+#include "ModuleCommonRegistration.h"
+
+void ModuleFramework::init(NvParameterized::Traits* t)
+{
+	ModuleFrameworkRegistration::invokeRegistration(t);
+	ModuleCommonRegistration::invokeRegistration(t);
+}
+
+void ModuleFramework::release(NvParameterized::Traits* t)
+{
+	ModuleFrameworkRegistration::invokeUnregistration(t);
+	ModuleCommonRegistration::invokeUnregistration(t);
+}
+
+// Many things can't be initialized in the constructor since they depend on gApexSdk
+// being present.
+void ApexSDKImpl::init(const ApexSDKDesc& desc)
+{
+
+	renderResourceManager = desc.renderResourceManager;
+#if PX_DEBUG || PX_CHECKED
+	if (renderResourceManagerWrapper != NULL)
+	{
+		PX_DELETE(renderResourceManagerWrapper);
+		renderResourceManagerWrapper = NULL;
+	}
+	if (renderResourceManager != NULL)
+	{
+		renderResourceManagerWrapper = PX_NEW(RenderResourceManagerWrapper)(*renderResourceManager);
+	}
+#endif
+
+	foundation = desc.foundation;
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+	cooking = desc.cooking;
+	physXSDK = desc.physXSDK;
+	physXsdkVersion = desc.physXSDKVersion;
+#endif
+
+	mDllLoadPath = desc.dllLoadPath;
+	mCustomDllNamePostfix = desc.dllNamePostfix;
+	mWireframeMaterial = desc.wireframeMaterial;
+	mSolidShadedMaterial = desc.solidShadedMaterial;
+#if PX_WINDOWS_FAMILY
+	mAppGuid = desc.appGuid ? desc.appGuid : DEFAULT_APP_GUID;
+#endif
+	mRMALoadMaterialsLazily = desc.renderMeshActorLoadMaterialsLazily;
+
+	mEnableConcurrencyCheck = desc.enableConcurrencyCheck;
+
+	Framework::initFrameworkProfiling(this);
+
+	apexResourceProvider = PX_NEW(ApexResourceProvider)();
+	PX_ASSERT(apexResourceProvider);
+	apexResourceProvider->setCaseSensitivity(desc.resourceProviderIsCaseSensitive);
+	apexResourceProvider->registerCallback(desc.resourceCallback);
+
+	// The param traits depend on the resource provider, so do this now
+	mParameterizedTraits = new NvParameterized::DefaultTraits(NvParameterized::DefaultTraits::BehaviourFlags::DEFAULT_POLICY);
+	GetInternalApexSDK()->getInternalResourceProvider()->createNameSpace("NvParameterizedFactories", false);
+	PX_ASSERT(mParameterizedTraits);
+
+	/* create global name space of authorable asset types */
+	mObjTypeNS = apexResourceProvider->createNameSpace(APEX_AUTHORABLE_ASSETS_TYPES_NAME_SPACE, false);
+
+	/* create global name space of NvParameterized authorable asset types */
+	mNxParamObjTypeNS = apexResourceProvider->createNameSpace(APEX_NV_PARAM_AUTH_ASSETS_TYPES_NAME_SPACE, false);
+
+	/* create namespace for user materials */
+	mMaterialNS = apexResourceProvider->createNameSpace(APEX_MATERIALS_NAME_SPACE, true);
+
+	/* create namespace for user opaque meshes */
+	mOpaqueMeshNS = apexResourceProvider->createNameSpace(APEX_OPAQUE_MESH_NAME_SPACE, false);
+
+	/* create namespace for custom vertex buffer semantics */
+	mCustomVBNS = apexResourceProvider->createNameSpace(APEX_CUSTOM_VB_NAME_SPACE, true);
+
+	/* create namespace for novodex collision groups */
+	mCollGroupNS = apexResourceProvider->createNameSpace(APEX_COLLISION_GROUP_NAME_SPACE, false);
+
+	/* create namespace for 128-bit GroupsMasks */
+	mCollGroup128NS = apexResourceProvider->createNameSpace(APEX_COLLISION_GROUP_128_NAME_SPACE, false);
+
+	/* create namespace for 64-bit GroupsMasks64 */
+	mCollGroup64NS = apexResourceProvider->createNameSpace(APEX_COLLISION_GROUP_64_NAME_SPACE, false);
+
+	/* create namespace for novodex collision groups masks */
+	mCollGroupMaskNS = apexResourceProvider->createNameSpace(APEX_COLLISION_GROUP_MASK_NAME_SPACE, false);
+
+	/* create namespace for novodex Material IDs (returned by raycasts) */
+	mPhysMatNS = apexResourceProvider->createNameSpace(APEX_PHYSICS_MATERIAL_NAME_SPACE, false);
+
+	/* create namespace for RenderMeshAssets */
+	mAuthorableObjects = PX_NEW(ResourceList);
+	RenderMeshAuthorableObject* AO = PX_NEW(RenderMeshAuthorableObject)(&frameworkModule, *mAuthorableObjects, RenderMeshAssetParameters::staticClassName());
+	ApexRenderMeshAsset::mObjTypeID = AO->getResID();
+
+	frameworkModule.init(mParameterizedTraits);
+
+	/* Create mDebugColorParams */
+	void* newPtr = mParameterizedTraits->alloc(sizeof(DebugColorParamsEx));
+	mDebugColorParams = NV_PARAM_PLACEMENT_NEW(newPtr, DebugColorParamsEx)(mParameterizedTraits, this);
+
+	for (uint32_t i = 0 ; i < DescHashSize ; i++)
+	{
+		mPhysXObjDescHash[i] = 0;
+	}
+	mDescFreeList = 0;
+
+	mCachedData = PX_NEW(ApexSDKCachedDataImpl);
+
+	mBatchSeedSize = desc.physXObjDescTableAllocationIncrement;
+
+#if defined(PHYSX_PROFILE_SDK)
+	mProfileZone = 0; // &physx::profile::PxProfileZone::createProfileZone(getAllocator(), "ApexSDK"); // TODO: create a profile zone here
+	gProfileZone = mProfileZone;
+	mApexPvdClient = pvdsdk::ApexPvdClient::create(desc.pvd);
+#endif
+}
+
+
+ApexSDKImpl::~ApexSDKImpl()
+{
+#if PX_DEBUG || PX_CHECKED
+	if (mURRdepthTLSslot != 0xFFFFFFFF)
+	{
+		TlsFree(mURRdepthTLSslot);
+		mURRdepthTLSslot = 0xFFFFFFFF;
+	}
+#endif
+
+	Framework::releaseFrameworkProfiling();
+#if PHYSX_PROFILE_SDK
+	if ( mProfileZone )
+	{
+		mProfileZone->release();
+		mProfileZone = NULL;
+	}
+	if (mApexPvdClient != NULL)
+	{
+		mApexPvdClient->release();
+	}
+	mApexPvdClient = NULL;
+#endif
+}
+
+ApexActor* ApexSDKImpl::getApexActor(Actor* nxactor) const
+{
+	AuthObjTypeID type = nxactor->getOwner()->getObjTypeID();
+	if (type == ApexRenderMeshAsset::mObjTypeID)
+	{
+		return (ApexRenderMeshActor*) nxactor;
+	}
+
+	ApexActor* a = NULL;
+	for (uint32_t i = 0; i < imodules.size(); i++)
+	{
+		a = imodules[i]->getApexActor(nxactor, type);
+		if (a)
+		{
+			break;
+		}
+	}
+
+	return a;
+}
+
+Scene* ApexSDKImpl::createScene(const SceneDesc& sceneDesc)
+{
+	if (!sceneDesc.isValid())
+	{
+		return 0;
+	}
+
+	ApexScene* s = PX_NEW(ApexScene)(sceneDesc, this);
+	mScenes.pushBack(s);
+
+	// Trigger ModuleSceneIntl creation for all loaded modules
+	for (uint32_t i = 0; i < imodules.size(); i++)
+	{
+		s->moduleCreated(*imodules[i]);
+	}
+
+	return s;
+}
+
+AssetPreviewScene*   ApexSDKImpl::createAssetPreviewScene()
+{
+	ApexAssetPreviewScene* s = PX_NEW(ApexAssetPreviewScene)(this);
+	
+	return s;
+}
+
+void ApexSDKImpl::releaseScene(Scene* nxScene)
+{
+	ApexScene* scene = DYNAMIC_CAST(ApexScene*)(nxScene);
+	mScenes.findAndReplaceWithLast(scene);
+	scene->destroy();
+}
+
+void ApexSDKImpl::releaseAssetPreviewScene(AssetPreviewScene* nxScene)
+{
+	ApexAssetPreviewScene* scene = DYNAMIC_CAST(ApexAssetPreviewScene*)(nxScene);
+	scene->destroy();
+}
+
+/** Map PhysX objects back to their APEX objects, hold flags and pointers **/
+
+uint16_t ApexPhysXObjectDesc::makeHash(size_t hashable)
+{
+	return static_cast<uint16_t>(UINT16_MAX & (hashable >> 8));
+}
+
+
+PhysXObjectDescIntl* ApexSDKImpl::getGenericPhysXObjectInfo(const void* obj) const
+{
+	nvidia::Mutex::ScopedLock scopeLock(mPhysXObjDescsLock);
+
+	uint16_t h = (uint16_t)(ApexPhysXObjectDesc::makeHash(reinterpret_cast<size_t>(obj)) & (DescHashSize - 1));
+	uint32_t index = mPhysXObjDescHash[h];
+
+	while (index)
+	{
+		ApexPhysXObjectDesc* desc = const_cast<ApexPhysXObjectDesc*>(&mPhysXObjDescs[index]);
+		if ((void*) desc->mPhysXObject == obj)
+		{
+			return desc;
+		}
+		else
+		{
+			index = desc->mNext;
+		}
+	}
+	return NULL;
+}
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+
+PhysXObjectDescIntl* 	ApexSDKImpl::createObjectDesc(const Actor* apexActor, const PxActor* actor)
+{
+	return createObjectDesc(apexActor, (const void*) actor);
+}
+PhysXObjectDescIntl* 	ApexSDKImpl::createObjectDesc(const Actor* apexActor, const PxShape* shape)
+{
+	return createObjectDesc(apexActor, (const void*) shape);
+}
+PhysXObjectDescIntl* 	ApexSDKImpl::createObjectDesc(const Actor* apexActor, const PxJoint* joint)
+{
+	return createObjectDesc(apexActor, (const void*) joint);
+}
+PhysXObjectDescIntl* ApexSDKImpl::createObjectDesc(const Actor* apexActor, const PxCloth* cloth)
+{
+	return createObjectDesc(apexActor, (const void*)cloth);
+}
+PhysXObjectDescIntl* 	ApexSDKImpl::createObjectDesc(const Actor* apexActor, const PxParticleSystem* particleSystem)
+{
+	return createObjectDesc(apexActor, (const void*) particleSystem);
+}
+PhysXObjectDescIntl* ApexSDKImpl::createObjectDesc(const Actor* apexActor, const PxParticleFluid* particleFluid)
+{
+	return createObjectDesc(apexActor, (const void*)particleFluid);
+}
+const PhysXObjectDesc* ApexSDKImpl::getPhysXObjectInfo(const PxActor* actor) const
+{
+	return getGenericPhysXObjectInfo((void*)actor);
+}
+const PhysXObjectDesc* ApexSDKImpl::getPhysXObjectInfo(const PxShape* shape) const
+{
+	return getGenericPhysXObjectInfo((void*)shape);
+}
+const PhysXObjectDesc* ApexSDKImpl::getPhysXObjectInfo(const PxJoint* joint) const
+{
+	return getGenericPhysXObjectInfo((void*)joint);
+}
+const PhysXObjectDesc* ApexSDKImpl::getPhysXObjectInfo(const PxCloth* cloth) const
+{
+	return getGenericPhysXObjectInfo((void*)cloth);
+}
+const PhysXObjectDesc* ApexSDKImpl::getPhysXObjectInfo(const PxParticleSystem* particleSystem) const
+{
+	return getGenericPhysXObjectInfo((void*)particleSystem);
+}
+const PhysXObjectDesc* ApexSDKImpl::getPhysXObjectInfo(const PxParticleFluid* particleFluid) const
+{
+	return getGenericPhysXObjectInfo((void*)particleFluid);
+}
+PxPhysics* ApexSDKImpl::getPhysXSDK()
+{
+	return physXSDK;
+}
+PxCooking* ApexSDKImpl::getCookingInterface()
+{
+	return cooking;
+}
+
+#endif
+
+AuthObjTypeID ApexSDKImpl::registerAuthObjType(const char* authTypeName, ResID nsid)
+{
+	AuthObjTypeID aotid = apexResourceProvider->createResource(mObjTypeNS, authTypeName, false);
+	apexResourceProvider->setResource(APEX_AUTHORABLE_ASSETS_TYPES_NAME_SPACE,
+	                                  authTypeName,
+	                                  (void*)(size_t) nsid, false);
+	return aotid;
+}
+
+AuthObjTypeID ApexSDKImpl::registerAuthObjType(const char* authTypeName, AuthorableObjectIntl* authObjPtr)
+{
+	AuthObjTypeID aotid = apexResourceProvider->createResource(mObjTypeNS, authTypeName, false);
+	apexResourceProvider->setResource(APEX_AUTHORABLE_ASSETS_TYPES_NAME_SPACE,
+	                                  authTypeName,
+	                                  (void*) authObjPtr, false);
+	return aotid;
+}
+
+AuthObjTypeID ApexSDKImpl::registerNvParamAuthType(const char* authTypeName, AuthorableObjectIntl* authObjPtr)
+{
+	AuthObjTypeID aotid = apexResourceProvider->createResource(mNxParamObjTypeNS, authTypeName, false);
+	apexResourceProvider->setResource(APEX_NV_PARAM_AUTH_ASSETS_TYPES_NAME_SPACE,
+	                                  authTypeName,
+	                                  (void*) authObjPtr, false);
+	return aotid;
+}
+
+void ApexSDKImpl::unregisterAuthObjType(const char* authTypeName)
+{
+	apexResourceProvider->setResource(APEX_AUTHORABLE_ASSETS_TYPES_NAME_SPACE,
+	                                  authTypeName,
+	                                  (void*) NULL, false);
+}
+
+void ApexSDKImpl::unregisterNvParamAuthType(const char* authTypeName)
+{
+	apexResourceProvider->setResource(APEX_NV_PARAM_AUTH_ASSETS_TYPES_NAME_SPACE,
+	                                  authTypeName,
+	                                  (void*) NULL, false);
+}
+
+AuthorableObjectIntl*	ApexSDKImpl::getAuthorableObject(const char* authTypeName)
+{
+	if (!apexResourceProvider->checkResource(mObjTypeNS, authTypeName))
+	{
+		return NULL;
+	}
+
+	void* ao = apexResourceProvider->getResource(APEX_AUTHORABLE_ASSETS_TYPES_NAME_SPACE, authTypeName);
+
+	return static_cast<AuthorableObjectIntl*>(ao);
+}
+
+AuthorableObjectIntl*	ApexSDKImpl::getParamAuthObject(const char* paramName)
+{
+	if (!apexResourceProvider->checkResource(mNxParamObjTypeNS, paramName))
+	{
+		return NULL;
+	}
+
+	void* ao = apexResourceProvider->getResource(APEX_NV_PARAM_AUTH_ASSETS_TYPES_NAME_SPACE, paramName);
+
+	return static_cast<AuthorableObjectIntl*>(ao);
+}
+
+bool ApexSDKImpl::getAuthorableObjectNames(const char** authTypeNames, uint32_t& outCount, uint32_t inCount)
+{
+	ResID ids[128];
+
+	if (!apexResourceProvider->getResourceIDs(APEX_AUTHORABLE_ASSETS_TYPES_NAME_SPACE, ids, outCount, 128))
+	{
+		return false;
+	}
+
+	if (outCount > inCount)
+	{
+		return false;
+	}
+
+	for (uint32_t i = 0; i < outCount; i++)
+	{
+		authTypeNames[i] = apexResourceProvider->getResourceName(ids[i]);
+
+#define JUST_A_TEST 0
+#if JUST_A_TEST
+#include <stdio.h>
+		AuthorableObjectIntl* ao = (AuthorableObjectIntl*)getAuthorableObject(authTypeNames[i]);
+
+		Asset* assetList[32];
+		uint32_t retCount = 0;
+		ao->getAssetList(assetList, retCount, 32);
+
+		if (retCount)
+		{
+			printf("%s count: %d\n", authTypeNames[i], retCount);
+			const NvParameterized::Interface* p = assetList[0]->getAssetNvParameterized();
+			if (p)
+			{
+				printf(" NvParam class name: %s\n", p->className());
+			}
+		}
+#endif
+	}
+
+	return true;
+}
+
+ResID ApexSDKImpl::getApexMeshNameSpace()
+{
+	AuthorableObjectIntl* AO = getAuthorableObject(RENDER_MESH_AUTHORING_TYPE_NAME);
+	if (AO)
+	{
+		return AO->getResID();
+	}
+	else
+	{
+		return INVALID_RESOURCE_ID;
+	}
+}
+
+
+
+PhysXObjectDescIntl* 	ApexSDKImpl::createObjectDesc(const Actor* apexActor, const void* nxPtr)
+{
+	nvidia::Mutex::ScopedLock scopeLock(mPhysXObjDescsLock);
+
+	uint16_t h = (uint16_t)(ApexPhysXObjectDesc::makeHash(reinterpret_cast<size_t>(nxPtr)) & (DescHashSize - 1));
+	uint32_t index = mPhysXObjDescHash[ h ];
+
+	while (index)
+	{
+		ApexPhysXObjectDesc* desc = &mPhysXObjDescs[ index ];
+		if (desc->mPhysXObject == nxPtr)
+		{
+			APEX_DEBUG_WARNING("createObjectDesc: Object already registered");
+			bool hasActor = false;
+			for (uint32_t i = desc->mApexActors.size(); i--;)
+			{
+				if (desc->mApexActors[i] == apexActor)
+				{
+					hasActor = true;
+					break;
+				}
+			}
+			if (hasActor)
+			{
+				APEX_DEBUG_WARNING("createObjectDesc: Object already registered with the given Actor");
+			}
+			else
+			{
+				desc->mApexActors.pushBack(apexActor);
+			}
+			return desc;
+		}
+		else
+		{
+			index = desc->mNext;
+		}
+	}
+
+	// Match not found, allocate new object descriptor
+
+	if (!mDescFreeList)
+	{
+		// Free list is empty, seed it with new batch
+		uint32_t size = mPhysXObjDescs.size();
+		if (size == 0)  // special initial case, reserve entry 0
+		{
+			size = 1;
+			mPhysXObjDescs.resize(size + mBatchSeedSize);
+		}
+		else
+		{
+			PX_PROFILE_ZONE("objDescsResize", GetInternalApexSDK()->getContextId());
+
+			// Instead of doing a straight resize of mPhysXObjDescs the array is resized by swapping. Doing so removes the potential 
+			// copying/reallocating of the arrays held in ApexPhysXObjectDesc elements which is costly performance wise.
+			physx::Array<ApexPhysXObjectDesc> swapArray;
+			swapArray.swap(mPhysXObjDescs);
+
+			mPhysXObjDescs.resize(size + mBatchSeedSize);
+			ApexPhysXObjectDesc* src = swapArray.begin();
+			ApexPhysXObjectDesc* dst = mPhysXObjDescs.begin();
+			for (physx::PxU32 i = 0; i < size; i++)
+			{
+				src[i].swap(dst[i]);
+			}
+		}
+
+		for (uint32_t i = size ; i < size + mBatchSeedSize ; i++)
+		{
+			mPhysXObjDescs[i].mNext = mDescFreeList;
+			mDescFreeList = i;
+		}
+	}
+
+	index = mDescFreeList;
+	ApexPhysXObjectDesc* desc = &mPhysXObjDescs[ index ];
+	mDescFreeList = desc->mNext;
+
+	desc->mFlags = 0;
+	desc->userData = NULL;
+	desc->mApexActors.reset();
+	desc->mApexActors.pushBack(apexActor);
+	desc->mNext = mPhysXObjDescHash[ h ];
+	if (desc->mNext)
+	{
+		PX_ASSERT(mPhysXObjDescs[ desc->mNext ].mPrev == 0);
+		mPhysXObjDescs[ desc->mNext ].mPrev = index;
+	}
+	desc->mPrev = 0;
+	desc->mPhysXObject = nxPtr;
+	mPhysXObjDescHash[ h ] = index;
+
+	/* Calling function can set mFlags and userData */
+
+	return desc;
+}
+
+void ApexSDKImpl::releaseObjectDesc(void* physXObject)
+{
+	nvidia::Mutex::ScopedLock scopeLock(mPhysXObjDescsLock);
+
+	uint16_t h = (uint16_t)(ApexPhysXObjectDesc::makeHash(reinterpret_cast<size_t>(physXObject)) & (DescHashSize - 1));
+	uint32_t index = mPhysXObjDescHash[ h ];
+
+	while (index)
+	{
+		ApexPhysXObjectDesc* desc = &mPhysXObjDescs[ index ];
+
+		if (desc->mPhysXObject == physXObject)
+		{
+			if (desc->mPrev)
+			{
+				mPhysXObjDescs[ desc->mPrev ].mNext = desc->mNext;
+			}
+			else
+			{
+				mPhysXObjDescHash[ h ] = desc->mNext;
+			}
+
+			if (desc->mNext)
+			{
+				mPhysXObjDescs[ desc->mNext ].mPrev = desc->mPrev;
+			}
+
+			desc->mNext = mDescFreeList;
+			mDescFreeList = index;
+
+			desc->mApexActors.reset();
+			return;
+		}
+		else
+		{
+			index = desc->mNext;
+		}
+	}
+
+	APEX_DEBUG_WARNING("releaseObjectDesc: Unable to release object descriptor");
+}
+
+
+void ApexSDKImpl::releaseModule(Module* module)
+{
+	for (uint32_t i = 0; i < modules.size(); i++)
+	{
+		if (modules[i] != module)
+		{
+			continue;
+		}
+
+		// The module will remove its ModuleScenesIntl from each Scene
+		mCachedData->unregisterModuleDataCache(imodules[ i ]->getModuleDataCache());
+
+		ModuleIntl *im = imodules[i];
+		imodules[i] = NULL;
+		modules[i] = NULL;
+		im->destroy();
+
+//		modules.replaceWithLast(i);
+//		imodules.replaceWithLast(i);
+
+		break;
+	}
+}
+
+void ApexSDKImpl::registerModule(Module* newModule, ModuleIntl* newIModule)
+{
+	
+	uint32_t newIndex = modules.size();
+	for (uint32_t i=0; i<newIndex; i++)
+	{
+		if ( imodules[i] == NULL )
+		{
+			newIndex = i;
+			break;
+		}
+	}
+	if ( newIndex == modules.size() )
+	{
+		modules.pushBack(newModule);
+		imodules.pushBack(newIModule);
+	}
+
+	// Trigger ModuleSceneIntl creation for all existing scenes
+	for (uint32_t i = 0 ; i < mScenes.size(); i++)
+	{
+		(DYNAMIC_CAST(ApexScene*)(mScenes[i]))->moduleCreated(*newIModule);
+	}
+
+	mCachedData->registerModuleDataCache(newIModule->getModuleDataCache());
+}
+
+Module* ApexSDKImpl::createModule(const char* name, ApexCreateError* err)
+{
+	if (err)
+	{
+		*err = APEX_CE_NO_ERROR;
+	}
+
+	// Return existing module if it's already loaded
+	for (uint32_t i = 0; i < modules.size(); i++)
+	{
+		if ( modules[i] && !nvidia::strcmp(modules[ i ]->getName(), name))
+		{
+			ModuleIntl *imodule = imodules[i];
+			if( imodule->isCreateOk() )
+			{
+				return modules[ i ];
+			}
+			else
+			{
+				APEX_DEBUG_WARNING("ApexSDKImpl::createModule(%s) Not allowed.", name );
+				if (err)
+				{
+					*err = APEX_CE_CREATE_NO_ALLOWED;
+				}
+				return NULL;
+			}
+		}
+	}
+
+	Module* newModule = NULL;
+	ModuleIntl* newIModule = NULL;
+
+#if defined(_USRDLL) || PX_OSX
+	/* Dynamically linked module libraries */
+
+#if defined(WIN32)
+	ApexSimpleString dllName = mDllLoadPath + ApexSimpleString("APEX_") + ApexSimpleString(name);
+#if _DEBUG
+	// Request DEBUG DLL unless the user has explicitly asked for it
+	const size_t nameLen = strlen(name);
+	if (nameLen <= 5 || nvidia::strcmp(name + nameLen - 5, "DEBUG"))
+	{
+		dllName += ApexSimpleString("DEBUG");
+	}
+#elif PX_CHECKED
+	dllName += ApexSimpleString("CHECKED");
+#elif defined(PHYSX_PROFILE_SDK)
+	dllName += ApexSimpleString("PROFILE");
+#endif
+
+#if PX_X86
+	dllName += ApexSimpleString("_x86");
+#elif PX_X64
+	dllName += ApexSimpleString("_x64");
+#endif
+
+	dllName += mCustomDllNamePostfix;
+
+	dllName += ApexSimpleString(".dll");
+
+	HMODULE library = NULL;
+	{
+		ModuleUpdateLoader moduleLoader(UPDATE_LOADER_DLL_NAME);
+		library = moduleLoader.loadModule(dllName.c_str(), getAppGuid());
+
+		if (NULL == library)
+		{
+			dllName = ApexSimpleString("APEX/") + dllName;
+			library = moduleLoader.loadModule(dllName.c_str(), getAppGuid());
+		}
+	}
+
+	if (library)
+	{
+		NxCreateModule_FUNC* createModuleFunc = (NxCreateModule_FUNC*) GetProcAddress(library, "createModule");
+		if (createModuleFunc)
+		{
+			newModule = createModuleFunc((ApexSDKIntl*) this,
+			                             &newIModule,
+			                             APEX_SDK_VERSION,
+			                             PX_PHYSICS_VERSION,
+			                             err);
+		}
+	}
+#elif PX_OSX
+	ApexSimpleString dylibName = ApexSimpleString("libAPEX_") + ApexSimpleString(name);
+
+#if _DEBUG
+	// Request DEBUG DLL unless the user has explicitly asked for it
+	const size_t nameLen = strlen(name);
+	if (nameLen <= 5 || nvidia::strcmp(name + nameLen - 5, "DEBUG"))
+	{
+		dylibName += ApexSimpleString("DEBUG");
+	}
+#elif PX_CHECKED
+	dylibName += ApexSimpleString("CHECKED");
+#elif defined(PHYSX_PROFILE_SDK)
+	dylibName += ApexSimpleString("PROFILE");
+#endif
+
+	dylibName += mCustomDllNamePostfix;
+
+	dylibName += ApexSimpleString(".dylib");
+
+	ApexSimpleString dylibPath = mDllLoadPath + dylibName;
+
+	void* library = NULL;
+	{
+		// Check if dylib is already loaded
+		library = dlopen(dylibPath.c_str(), RTLD_NOLOAD | RTLD_LAZY | RTLD_LOCAL);
+		if (!library)
+		{
+			library = dlopen((ApexSimpleString("@rpath/") + dylibName).c_str(), RTLD_NOLOAD | RTLD_LAZY | RTLD_LOCAL);
+		}
+		if (!library)
+		{
+			// Not loaded yet, so try to open it
+			library = dlopen(dylibPath.c_str(), RTLD_LAZY | RTLD_LOCAL);
+		}
+	}
+
+	if (library)
+	{
+		NxCreateModule_FUNC* createModuleFunc = (NxCreateModule_FUNC*)dlsym(library, "createModule");
+		if (createModuleFunc)
+		{
+			newModule = createModuleFunc((ApexSDKIntl*) this,
+			                             &newIModule,
+			                             APEX_SDK_VERSION,
+			                             PX_PHYSICS_VERSION,
+			                             err);
+		}
+	}
+#else
+	/* TODO: other platform dynamic linking? */
+#endif
+
+#else
+	/* Statically linked module libraries */
+
+	/* Modules must supply an instantiation function which calls ApexSDKIntl::registerModule()
+	 * The user must call this function after creating ApexSDKImpl and before createModule().
+	 */
+#endif
+
+	// register new module and its parameters
+	if (newModule)
+	{
+		registerModule(newModule, newIModule);
+	}
+	else if (err)
+	{
+		*err = APEX_CE_NOT_FOUND;
+	}
+
+	return newModule;
+}
+
+ModuleIntl* ApexSDKImpl::getInternalModuleByName(const char* name)
+{
+	// Return existing module if it's already loaded
+	for (uint32_t i = 0; i < modules.size(); i++)
+	{
+		if (!nvidia::strcmp(modules[ i ]->getName(), name))
+		{
+			return imodules[ i ];
+		}
+	}
+	return NULL;
+}
+
+PxFileBuf* ApexSDKImpl::createStream(const char* filename, PxFileBuf::OpenMode mode)
+{
+	return PX_NEW(PsFileBuffer)(filename, mode);
+}
+
+// deprecated, use getErrorCallback instead
+PxErrorCallback* ApexSDKImpl::getOutputStream()
+{
+	return getErrorCallback();
+}
+
+PxFoundation* ApexSDKImpl::getFoundation() const
+{
+	return foundation;
+}
+
+PxErrorCallback* ApexSDKImpl::getErrorCallback() const
+{
+	PX_ASSERT(foundation);
+	return &foundation->getErrorCallback();
+}
+
+PxAllocatorCallback* ApexSDKImpl::getAllocator() const
+{
+	PX_ASSERT(foundation);
+	return &foundation->getAllocatorCallback();
+}
+
+ResourceProvider* ApexSDKImpl::getNamedResourceProvider()
+{
+	return apexResourceProvider;
+}
+
+ResourceProviderIntl* ApexSDKImpl::getInternalResourceProvider()
+{
+	return apexResourceProvider;
+}
+
+uint32_t ApexSDKImpl::getNbModules()
+{
+	uint32_t moduleCount = 0;
+	for (uint32_t i=0; i<modules.size(); i++)
+	{
+		if (modules[i] != NULL)
+		{
+			moduleCount++;
+		}
+	}
+
+	return moduleCount;
+}
+
+Module** ApexSDKImpl::getModules()
+{
+	if (modules.size() > 0)
+	{
+		moduleListForAPI.resize(0);
+		for (uint32_t i=0; i<modules.size(); i++)
+		{
+			if (modules[i] != NULL)
+			{
+				moduleListForAPI.pushBack(modules[i]);
+			}
+		}
+		
+		return &moduleListForAPI.front();
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+
+ModuleIntl** ApexSDKImpl::getInternalModules()
+{
+	if (imodules.size() > 0)
+	{
+		return &imodules.front();
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+uint32_t ApexSDKImpl::forceLoadAssets()
+{
+	uint32_t loadedAssetCount = 0;
+
+	// handle render meshes, since they don't live in a module
+	if (mAuthorableObjects != NULL)
+	{
+		for (uint32_t i = 0; i < mAuthorableObjects->getSize(); i++)
+		{
+			AuthorableObjectIntl* ao = static_cast<AuthorableObjectIntl*>(mAuthorableObjects->getResource(i));
+			loadedAssetCount += ao->forceLoadAssets();
+		}
+	}
+
+	for (uint32_t i = 0; i < imodules.size(); i++)
+	{
+		loadedAssetCount += imodules[i]->forceLoadAssets();
+	}
+
+	return loadedAssetCount;
+}
+
+
+void ApexSDKImpl::debugAsset(Asset* asset, const char* name)
+{
+	PX_UNUSED(asset);
+	PX_UNUSED(name);
+#if WITH_DEBUG_ASSET
+	if (asset)
+	{
+		const NvParameterized::Interface* pm = asset->getAssetNvParameterized();
+		if (pm)
+		{
+			NvParameterized::Serializer* s1 = internalCreateSerializer(NvParameterized::Serializer::NST_XML, mParameterizedTraits);
+			NvParameterized::Serializer* s2 = internalCreateSerializer(NvParameterized::Serializer::NST_BINARY, mParameterizedTraits);
+			if (s1 && s2)
+			{
+				nvidia::PsMemoryBuffer mb1;
+				nvidia::PsMemoryBuffer mb2;
+				s1->serialize(mb1, &pm, 1);
+				s2->serialize(mb2, &pm, 1);
+				{
+					char scratch[512];
+					nvidia::strlcpy(scratch, 512, name);
+					char* dot = NULL;
+					char* scan = scratch;
+					while (*scan)
+					{
+						if (*scan == '/')
+						{
+							*scan = '_';
+						}
+						if (*scan == '\\')
+						{
+							*scan = '_';
+						}
+						if (*scan == '.')
+						{
+							dot = scan;
+						}
+						scan++;
+					}
+
+					if (dot)
+					{
+						*dot = 0;
+					}
+
+					nvidia::strlcat(scratch, 512, ".apx");
+					FILE* fph = fopen(scratch, "wb");
+					if (fph)
+					{
+						fwrite(mb1.getWriteBuffer(), mb1.getWriteBufferSize(), 1, fph);
+						fclose(fph);
+					}
+					if (dot)
+					{
+						*dot = 0;
+					}
+
+					nvidia::strlcat(scratch, 512, ".apb");
+					fph = fopen(scratch, "wb");
+					if (fph)
+					{
+						fwrite(mb2.getWriteBuffer(), mb2.getWriteBufferSize(), 1, fph);
+						fclose(fph);
+					}
+
+				}
+				s1->release();
+				s2->release();
+			}
+		}
+	}
+#endif
+}
+
+/**
+ *	checkAssetName
+ *	-If name is NULL, we'll autogenerate one that won't collide with other names and issue a warning
+ *	-If name collides with another name, we'll issue a warning and return NULL, so as not to confuse the
+ *	 user by creating an asset authoring with a name that's different from the name specified.
+ */
+const char* ApexSDKImpl::checkAssetName(AuthorableObjectIntl& ao, const char* inName, ApexSimpleString& autoNameStorage)
+{
+	ResourceProviderIntl* iNRP = getInternalResourceProvider();
+
+	if (!inName)
+	{
+		autoNameStorage = ao.getName();
+		iNRP->generateUniqueName(ao.getResID(), autoNameStorage);
+
+		APEX_DEBUG_INFO("No name provided for asset, auto-naming <%s>.", autoNameStorage.c_str());
+		return autoNameStorage.c_str();
+	}
+
+	if (iNRP->checkResource(ao.getResID(), inName))
+	{
+		// name collides with another asset [author]
+		APEX_DEBUG_WARNING("Name provided collides with another asset in the %s namespace: <%s>, no asset created.", ao.getName().c_str(), inName);
+
+		return NULL;
+	}
+
+	return inName;
+}
+
+/**
+ *	createAsset
+ *	This method will load *any* APEX asset.
+ *  1. Read the APEX serialization header
+ *	2. Determine the correct module
+ *	3. Pass the remainder of the stream to the module along with the asset type name and asset version
+ */
+
+Asset* ApexSDKImpl::createAsset(AssetAuthoring& nxAssetAuthoring, const char* name)
+{
+	Asset* ret = NULL;
+	AuthorableObjectIntl* ao = getAuthorableObject(nxAssetAuthoring.getObjTypeName());
+	if (ao)
+	{
+		ApexSimpleString autoName;
+		name = checkAssetName(*ao, name, autoName);
+		if (!name)
+		{
+			return NULL;
+		}
+
+		ret = ao->createAsset(nxAssetAuthoring, name);
+	}
+	else
+	{
+		APEX_INTERNAL_ERROR("Unknown authorable type: %s, please load all required modules.", nxAssetAuthoring.getObjTypeName());
+	}
+	debugAsset(ret, name);
+	return ret;
+}
+
+Asset* ApexSDKImpl::createAsset(NvParameterized::Interface* params, const char* name)
+{
+	Asset* ret = NULL;
+	// params->className() will tell us the name of the parameterized struct
+	// there is a mapping of parameterized structs to
+	PX_ASSERT(params);
+	if (params)
+	{
+		AuthorableObjectIntl* ao = getParamAuthObject(params->className());
+		if (ao)
+		{
+			ApexSimpleString autoName;
+			name = checkAssetName(*ao, name, autoName);
+			if (!name)
+			{
+				return NULL;
+			}
+
+			ret = ao->createAsset(params, name);
+		}
+		else
+		{
+			APEX_INTERNAL_ERROR("Unknown authorable type: %s, please load all required modules.", params->className());
+		}
+	}
+	debugAsset(ret, name);
+	return ret;
+}
+
+AssetAuthoring* ApexSDKImpl::createAssetAuthoring(const char* aoTypeName)
+{
+	AuthorableObjectIntl* ao = getAuthorableObject(aoTypeName);
+	if (ao)
+	{
+		ApexSimpleString autoName;
+		const char* name = 0;
+		name = checkAssetName(*ao, name, autoName);
+		if (!name)
+		{
+			return NULL;
+		}
+
+
+		return ao->createAssetAuthoring(name);
+	}
+	else
+	{
+		APEX_INTERNAL_ERROR("Unknown authorable type: %s, please load all required modules.", aoTypeName);
+	}
+
+	return NULL;
+}
+
+AssetAuthoring* ApexSDKImpl::createAssetAuthoring(const char* aoTypeName, const char* name)
+{
+	AuthorableObjectIntl* ao = getAuthorableObject(aoTypeName);
+	if (ao)
+	{
+		ApexSimpleString autoName;
+		name = checkAssetName(*ao, name, autoName);
+		if (!name)
+		{
+			return NULL;
+		}
+
+		return ao->createAssetAuthoring(name);
+	}
+	else
+	{
+		APEX_INTERNAL_ERROR("Unknown authorable type: %s, please load all required modules.", aoTypeName);
+	}
+
+	return NULL;
+}
+
+AssetAuthoring* ApexSDKImpl::createAssetAuthoring(NvParameterized::Interface* params, const char* name)
+{
+	PX_ASSERT(params);
+	if (!params)
+	{
+		APEX_DEBUG_WARNING("NULL NvParameterized Interface, no asset author created.");
+		return NULL;
+	}
+
+	AuthorableObjectIntl* ao = getParamAuthObject(params->className());
+	if (ao)
+	{
+		ApexSimpleString autoName;
+		name = checkAssetName(*ao, name, autoName);
+		if (!name)
+		{
+			return NULL;
+		}
+
+		return ao->createAssetAuthoring(params, name);
+	}
+	else
+	{
+		APEX_INTERNAL_ERROR("Unknown authorable type: %s, please load all required modules.", params->className());
+	}
+
+	return NULL;
+}
+
+/**
+ *	releaseAsset
+ *
+ */
+void ApexSDKImpl::releaseAsset(Asset& nxasset)
+{
+	AuthorableObjectIntl* ao = getAuthorableObject(nxasset.getObjTypeName());
+	if (ao)
+	{
+		return ao->releaseAsset(nxasset);
+	}
+	else
+	{
+		APEX_INTERNAL_ERROR("Unknown authorable type: %s, please load all required modules.", nxasset.getObjTypeName());
+	}
+}
+
+void ApexSDKImpl::releaseAssetAuthoring(AssetAuthoring& nxAssetAuthoring)
+{
+	AuthorableObjectIntl* ao = getAuthorableObject(nxAssetAuthoring.getObjTypeName());
+	if (ao)
+	{
+		return ao->releaseAssetAuthoring(nxAssetAuthoring);
+	}
+	else
+	{
+		APEX_INTERNAL_ERROR("Unknown authorable type: %s, please load all required modules.", nxAssetAuthoring.getObjTypeName());
+	}
+}
+
+void ApexSDKImpl::reportError(PxErrorCode::Enum code, const char* file, int line, const char* functionName, const char* msgFormat, ...)
+{
+	mReportErrorLock.lock();
+
+	if (gApexSdk)
+	{
+		if (getErrorCallback())
+		{
+			if (mErrorString == NULL && code != PxErrorCode::eOUT_OF_MEMORY)
+			{
+				mErrorString = (char*) PX_ALLOC(sizeof(char) * MAX_MSG_SIZE, PX_DEBUG_EXP("char"));
+			}
+			if (mErrorString != NULL)
+			{
+				va_list va;
+				va_start(va, msgFormat);
+
+				size_t tempLength = 0;
+				if (functionName != NULL)
+				{
+					shdfnd::snprintf(mErrorString,MAX_MSG_SIZE, "%s: ", functionName);
+					tempLength = strlen(mErrorString);
+				}
+
+				vsprintf(mErrorString + tempLength, msgFormat, va);
+				va_end(va);
+				getErrorCallback()->reportError(code, mErrorString, file, line);
+			}
+			else
+			{
+				// we can't allocate any memory anymore, let's hope the stack has still a bit of space
+				char buf[ 100 ];
+				va_list va;
+				va_start(va, msgFormat);
+				vsprintf(buf, msgFormat, va);
+				va_end(va);
+				getErrorCallback()->reportError(code, buf, file, line);
+			}
+		}
+	}
+	mReportErrorLock.unlock();
+}
+
+
+
+void* ApexSDKImpl::getTempMemory(uint32_t size)
+{
+	mTempMemoryLock.lock();
+
+	if (size == 0 || mTempMemories.size() > 100)	//later growing a size 0 allocation is not handled gracefully!
+	{
+		// this is most likely a leak in temp memory consumption
+		mTempMemoryLock.unlock();
+		return NULL;
+	}
+
+	// now find the smallest one that is bigger than 'size'
+	int32_t found = -1;
+	uint32_t bestSize = 0;
+	for (uint32_t i = mNumTempMemoriesActive; i < mTempMemories.size(); i++)
+	{
+		if (mTempMemories[i].size >= size)
+		{
+			if (found == -1 || bestSize > mTempMemories[i].size)
+			{
+				found = (int32_t)i;
+				bestSize = mTempMemories[i].size;
+			}
+		}
+	}
+
+	TempMemory result;
+
+	if (found != -1)
+	{
+		// found
+		if ((uint32_t)found > mNumTempMemoriesActive)
+		{
+			// swap them
+			TempMemory temp = mTempMemories[mNumTempMemoriesActive];
+			mTempMemories[mNumTempMemoriesActive] = mTempMemories[(uint32_t)found];
+			mTempMemories[(uint32_t)found] = temp;
+		}
+		PX_ASSERT(mTempMemories[mNumTempMemoriesActive].used == 0);
+		mTempMemories[mNumTempMemoriesActive].used = size;
+		result = mTempMemories[mNumTempMemoriesActive];
+		mNumTempMemoriesActive++;
+	}
+	else if (mNumTempMemoriesActive < mTempMemories.size())
+	{
+		// not found, use last one
+
+		// swap
+		TempMemory temp = mTempMemories.back();
+		mTempMemories.back() = mTempMemories[mNumTempMemoriesActive];
+
+		void* nb = PX_ALLOC(size, PX_DEBUG_EXP("ApexSDKImpl::getTempMemory"));
+		if (nb)
+		{
+			memcpy(nb, temp.memory, PxMin(temp.size, size));
+		}
+		PX_FREE(temp.memory);
+		temp.memory = nb;
+		temp.size = size;
+		PX_ASSERT(temp.used == 0);
+		temp.used = size;
+
+		mTempMemories[mNumTempMemoriesActive] = temp;
+		result = temp;
+		mNumTempMemoriesActive++;
+	}
+	else
+	{
+		mNumTempMemoriesActive++;
+		TempMemory& newTemp = mTempMemories.insert();
+		newTemp.memory = PX_ALLOC(size, PX_DEBUG_EXP("ApexSDKImpl::getTempMemory"));
+		newTemp.size = size;
+		newTemp.used = size;
+		result = newTemp;
+	}
+	mTempMemoryLock.unlock();
+
+#ifdef _DEBUG
+	if (result.used < result.size)
+	{
+		memset((char*)result.memory + result.used, 0xfd, result.size - result.used);
+	}
+#endif
+
+	return result.memory;
+}
+
+
+void ApexSDKImpl::releaseTempMemory(void* data)
+{
+	if (data == NULL)		//this is a valid consequence of permittion 0 sized allocations.
+	{
+		return;
+	}
+
+	mTempMemoryLock.lock();
+	uint32_t numReleased = 0;
+
+	for (uint32_t i = 0; i < mNumTempMemoriesActive; i++)
+	{
+		if (mTempMemories[i].memory == data)
+		{
+			PX_ASSERT(mTempMemories[i].used > 0);
+#ifdef _DEBUG
+			if (mTempMemories[i].used < mTempMemories[i].size)
+			{
+				for (uint32_t j = mTempMemories[i].used; j < mTempMemories[i].size; j++)
+				{
+					unsigned char cur = ((unsigned char*)mTempMemories[i].memory)[j];
+					if (cur != 0xfd)
+					{
+						PX_ASSERT(cur == 0xfd);
+						break; // only hit this assert once per error
+					}
+				}
+			}
+			// you should not operate on data that has been released!
+			memset(mTempMemories[i].memory, 0xcd, mTempMemories[i].size);
+#endif
+			mTempMemories[i].used = 0;
+
+			// swap with last valid one
+			if (i < mNumTempMemoriesActive - 1)
+			{
+				TempMemory temp = mTempMemories[mNumTempMemoriesActive - 1];
+				mTempMemories[mNumTempMemoriesActive - 1] = mTempMemories[i];
+				mTempMemories[i] = temp;
+			}
+			mNumTempMemoriesActive--;
+
+			numReleased++;
+			break;
+		}
+	}
+
+	PX_ASSERT(numReleased == 1);
+
+	mTempMemoryLock.unlock();
+}
+
+
+void ApexSDKImpl::release()
+{
+	if (renderResourceManagerWrapper != NULL)
+	{
+		PX_DELETE(renderResourceManagerWrapper);
+		renderResourceManagerWrapper = NULL;
+	}
+
+	for (uint32_t i = 0; i < mScenes.size(); i++)
+	{
+		(DYNAMIC_CAST(ApexScene*)(mScenes[ i ]))->destroy();
+	}
+	mScenes.clear();
+
+	// Notify all modules that the ApexSDKImpl is getting destructed
+	for (uint32_t i = 0; i < modules.size(); i++)
+	{
+		if ( imodules[i] )
+		{
+			imodules[ i ]->notifyReleaseSDK();
+		}
+	}
+
+	// Now we destroy each module; but we make sure to null out each array element before we call the
+	// actual destruction routine so that the array of avlie/registered modules contains no pointers to deleted objects
+	for (uint32_t i = 0; i < modules.size(); i++)
+	{
+		ModuleIntl *d = imodules[i];
+		imodules[i] = NULL;
+		modules[i] = NULL;
+		if ( d )
+		{
+			d->destroy();
+		}
+	}
+	modules.clear();
+	imodules.clear();
+
+	/* Free all render meshes created from the SDK, release named resources */
+	if (mAuthorableObjects != NULL)
+	{
+		PX_DELETE(mAuthorableObjects);
+		mAuthorableObjects = NULL;
+	}
+
+	if (mDebugColorParams)
+	{
+		mDebugColorParams->destroy();
+		mDebugColorParams = NULL;
+	}
+
+	frameworkModule.release(mParameterizedTraits);
+
+	delete mParameterizedTraits;
+	mParameterizedTraits = 0;
+
+	apexResourceProvider->destroy();
+	apexResourceProvider = 0;
+
+
+	mPhysXObjDescs.clear();
+
+	for (uint32_t i = 0; i < mTempMemories.size(); i++)
+	{
+		if (mTempMemories[i].memory != NULL)
+		{
+			PX_FREE(mTempMemories[i].memory);
+			mTempMemories[i].memory = NULL;
+			mTempMemories[i].size = 0;
+		}
+	}
+	mTempMemories.clear();
+
+	PX_DELETE(mCachedData);
+	mCachedData = NULL;
+
+	if (mErrorString)
+	{
+		PX_FREE_AND_RESET(mErrorString);
+	}
+
+#if PX_PHYSICS_VERSION_MAJOR == 0
+	if (mApexThreadPool)
+	{
+		PX_DELETE(mApexThreadPool);
+		mApexThreadPool = NULL;
+	}
+	while (mUserAllocThreadPools.size())
+	{
+		releaseCpuDispatcher(*mUserAllocThreadPools[0]);
+	}
+#endif
+	
+	delete this;
+	// be very careful what goes below this line!
+
+	gApexSdk = NULL;
+
+}
+
+RenderDebugInterface* ApexSDKImpl::createApexRenderDebug(RENDER_DEBUG::RenderDebugInterface* interface, bool useRemoteDebugVisualization)
+{
+	PX_UNUSED(useRemoteDebugVisualization);
+
+#ifdef WITHOUT_DEBUG_VISUALIZE
+	return NULL;
+
+#else
+
+	return nvidia::apex::createApexRenderDebug(this, interface, useRemoteDebugVisualization);
+#endif
+}
+
+void ApexSDKImpl::releaseApexRenderDebug(RenderDebugInterface& debug)
+{
+#ifdef WITHOUT_DEBUG_VISUALIZE
+	PX_UNUSED(debug);
+#else
+	debug.release();
+#endif
+}
+
+SphereShape* ApexSDKImpl::createApexSphereShape()
+{
+	ApexSphereShape* m = PX_NEW(ApexSphereShape);
+	return static_cast< SphereShape*>(m);
+}
+
+CapsuleShape* ApexSDKImpl::createApexCapsuleShape()
+{
+	ApexCapsuleShape* m = PX_NEW(ApexCapsuleShape);
+	return static_cast< CapsuleShape*>(m);
+}
+
+BoxShape* ApexSDKImpl::createApexBoxShape()
+{
+	ApexBoxShape* m = PX_NEW(ApexBoxShape);
+	return static_cast< BoxShape*>(m);
+}
+
+HalfSpaceShape* ApexSDKImpl::createApexHalfSpaceShape()
+{
+	ApexHalfSpaceShape* m = PX_NEW(ApexHalfSpaceShape);
+	return static_cast< HalfSpaceShape*>(m);
+}
+
+void ApexSDKImpl::releaseApexShape(Shape& shape)
+{
+	shape.releaseApexShape();
+}
+
+const char* ApexSDKImpl::getWireframeMaterial()
+{
+	return mWireframeMaterial.c_str();
+}
+
+const char* ApexSDKImpl::getSolidShadedMaterial()
+{
+	return mSolidShadedMaterial.c_str();
+}
+
+pvdsdk::ApexPvdClient* ApexSDKImpl::getApexPvdClient()
+{
+#if defined(PHYSX_PROFILE_SDK)
+	return mApexPvdClient;
+#else
+	return NULL;
+#endif
+}
+
+profile::PxProfileZone * ApexSDKImpl::getProfileZone()
+{
+#if defined(PHYSX_PROFILE_SDK)
+	return mProfileZone;
+#else
+	return NULL;
+#endif
+}
+
+profile::PxProfileZoneManager * ApexSDKImpl::getProfileZoneManager()
+{
+#if defined(PHYSX_PROFILE_SDK)
+	return mProfileZone ? mProfileZone->getProfileZoneManager() : NULL;
+#else
+	return NULL;
+#endif
+}
+
+#if PX_WINDOWS_FAMILY
+const char* ApexSDKImpl::getAppGuid()
+{
+	return mAppGuid.c_str();
+}
+#endif
+
+#if APEX_CUDA_SUPPORT
+PhysXGpuIndicator* ApexSDKImpl::registerPhysXIndicatorGpuClient()
+{
+	//allocate memory for the PhysXGpuIndicator
+	PhysXGpuIndicator* gpuIndicator = static_cast<PhysXGpuIndicator*>(PX_ALLOC(sizeof(PhysXGpuIndicator), PX_DEBUG_EXP("PhysXGpuIndicator")));
+	PX_PLACEMENT_NEW(gpuIndicator, PhysXGpuIndicator);
+	
+	gpuIndicator->gpuOn();
+	return gpuIndicator;
+}
+
+void ApexSDKImpl::unregisterPhysXIndicatorGpuClient(PhysXGpuIndicator* gpuIndicator)
+{
+	if (gpuIndicator != NULL)
+	{
+		gpuIndicator->~PhysXGpuIndicator();
+		PX_FREE(gpuIndicator);
+	}
+}
+#endif
+
+void ApexSDKImpl::updateDebugColorParams(const char* color, uint32_t val)
+{
+	for (uint32_t i = 0; i < mScenes.size(); i++)
+	{
+		DYNAMIC_CAST(ApexScene*)(mScenes[ i ])->updateDebugColorParams(color, val);
+	}
+}
+
+
+bool ApexSDKImpl::getRMALoadMaterialsLazily()
+{
+	return mRMALoadMaterialsLazily;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// ApexRenderMeshAssetAuthoring
+///////////////////////////////////////////////////////////////////////////////
+
+
+Asset* RenderMeshAuthorableObject::createAsset(AssetAuthoring& author, const char* name)
+{
+	NvParameterized::Interface* newObj = NULL;
+	author.getNvParameterized()->clone(newObj);
+	return createAsset(newObj, name);
+}
+
+Asset* RenderMeshAuthorableObject::createAsset(NvParameterized::Interface* params, const char* name)
+{
+	ApexRenderMeshAsset* asset = PX_NEW(ApexRenderMeshAsset)(mAssets, name, 0);
+	if (asset)
+	{
+		asset->createFromParameters((RenderMeshAssetParameters*)params);
+		GetInternalApexSDK()->getNamedResourceProvider()->setResource(mAOTypeName.c_str(), name, asset);
+	}
+	return asset;
+}
+
+void RenderMeshAuthorableObject::releaseAsset(Asset& nxasset)
+{
+	ApexRenderMeshAsset* aa = DYNAMIC_CAST(ApexRenderMeshAsset*)(&nxasset);
+	GetInternalApexSDK()->getInternalResourceProvider()->setResource(ApexRenderMeshAsset::getClassName(), nxasset.getName(), NULL, false, false);
+	aa->destroy();
+}
+
+// this should no longer be called now that we're auto-assigning names in createAssetAuthoring()
+AssetAuthoring* RenderMeshAuthorableObject::createAssetAuthoring()
+{
+	return createAssetAuthoring("");
+}
+
+AssetAuthoring* 	RenderMeshAuthorableObject::createAssetAuthoring(NvParameterized::Interface* params, const char* name)
+{
+#ifdef WITHOUT_APEX_AUTHORING
+	PX_UNUSED(params);
+	PX_UNUSED(name);
+	return NULL;
+#else
+	ApexRenderMeshAssetAuthoring* assetAuthor = PX_NEW(ApexRenderMeshAssetAuthoring)(mAssetAuthors, (RenderMeshAssetParameters*)params, name);
+	if (assetAuthor)
+	{
+		GetInternalApexSDK()->getNamedResourceProvider()->setResource(mAOTypeName.c_str(), name, assetAuthor);
+	}
+	return assetAuthor;
+
+#endif
+}
+
+AssetAuthoring* RenderMeshAuthorableObject::createAssetAuthoring(const char* name)
+{
+#ifdef WITHOUT_APEX_AUTHORING
+	PX_UNUSED(name);
+	return NULL;
+#else
+	NvParameterized::Traits* traits = GetInternalApexSDK()->getParameterizedTraits();
+	RenderMeshAssetParameters* params = (RenderMeshAssetParameters*)traits->createNvParameterized(RenderMeshAssetParameters::staticClassName());
+	ApexRenderMeshAssetAuthoring* assetAuthor = PX_NEW(ApexRenderMeshAssetAuthoring)(mAssetAuthors, params, name);
+	if (assetAuthor)
+	{
+		GetInternalApexSDK()->getNamedResourceProvider()->setResource(mAOTypeName.c_str(), name, assetAuthor);
+	}
+	return assetAuthor;
+
+#endif
+}
+
+void RenderMeshAuthorableObject::releaseAssetAuthoring(AssetAuthoring& nxauthor)
+{
+#ifdef WITHOUT_APEX_AUTHORING
+	PX_UNUSED(nxauthor);
+#else
+	ApexRenderMeshAssetAuthoring* aa = DYNAMIC_CAST(ApexRenderMeshAssetAuthoring*)(&nxauthor);
+	GetInternalApexSDK()->getInternalResourceProvider()->setResource(mAOTypeName.c_str(), aa->getName(), NULL, false, false);
+
+	aa->destroy();
+#endif
+}
+
+
+uint32_t RenderMeshAuthorableObject::forceLoadAssets()
+{
+	uint32_t loadedAssetCount = 0;
+
+	for (uint32_t i = 0; i < mAssets.getSize(); i++)
+	{
+		ApexRenderMeshAsset* asset = DYNAMIC_CAST(ApexRenderMeshAsset*)(mAssets.getResource(i));
+		loadedAssetCount += asset->forceLoadAssets();
+	}
+	return loadedAssetCount;
+}
+
+
+// Resource methods
+void RenderMeshAuthorableObject::release()
+{
+	// test this by releasing the module before the individual assets
+
+	// remove all assets that we loaded (must do now else we cannot unregister)
+	mAssets.clear();
+	mAssetAuthors.clear();
+
+	// remove this AO's name from the authorable namespace
+	GetInternalApexSDK()->unregisterAuthObjType(mAOTypeName.c_str());
+	destroy();
+}
+
+void RenderMeshAuthorableObject::destroy()
+{
+	delete this;
+}
+
+
+/**
+Returns a PxFileBuf which reads from a buffer in memory.
+*/
+PxFileBuf* ApexSDKImpl::createMemoryReadStream(const void* mem, uint32_t len)
+{
+	PxFileBuf* ret = 0;
+
+	nvidia::PsMemoryBuffer* rb = PX_NEW(nvidia::PsMemoryBuffer)((const uint8_t*)mem, len);
+	ret = static_cast< PxFileBuf*>(rb);
+
+	return ret;
+}
+
+/**
+Returns a PxFileBuf which writes to memory.
+*/
+PxFileBuf* ApexSDKImpl::createMemoryWriteStream(uint32_t alignment)
+{
+	PxFileBuf* ret = 0;
+
+	nvidia::PsMemoryBuffer* mb = PX_NEW(nvidia::PsMemoryBuffer)(nvidia::BUFFER_SIZE_DEFAULT, alignment);
+	ret = static_cast< PxFileBuf*>(mb);
+
+	return ret;
+}
+
+/**
+Returns the address and length of the contents of a memory write buffer stream.
+*/
+const void* ApexSDKImpl::getMemoryWriteBuffer(PxFileBuf& stream, uint32_t& len)
+{
+	const void* ret = 0;
+
+	nvidia::PsMemoryBuffer* wb = static_cast< nvidia::PsMemoryBuffer*>(&stream);
+	len = wb->getWriteBufferSize();
+	ret = wb->getWriteBuffer();
+
+	return ret;
+}
+
+/**
+Releases a previously created PxFileBuf used as a write or read buffer.
+*/
+void ApexSDKImpl::releaseMemoryReadStream(PxFileBuf& stream)
+{
+	nvidia::PsMemoryBuffer* rb = static_cast< nvidia::PsMemoryBuffer*>(&stream);
+	delete rb;
+}
+
+void ApexSDKImpl::releaseMemoryWriteStream(PxFileBuf& stream)
+{
+	nvidia::PsMemoryBuffer* wb = static_cast< nvidia::PsMemoryBuffer*>(&stream);
+	delete wb;
+}
+
+
+NvParameterized::Serializer* ApexSDKImpl::createSerializer(NvParameterized::Serializer::SerializeType type)
+{
+	return NvParameterized::internalCreateSerializer(type, mParameterizedTraits);
+}
+
+NvParameterized::Serializer* ApexSDKImpl::createSerializer(NvParameterized::Serializer::SerializeType type, NvParameterized::Traits* traits)
+{
+	return NvParameterized::internalCreateSerializer(type, traits);
+}
+
+NvParameterized::Serializer::SerializeType ApexSDKImpl::getSerializeType(const void* data, uint32_t dlen)
+{
+	PsMemoryBuffer stream(data, dlen);
+	return NvParameterized::Serializer::peekSerializeType(stream);
+}
+
+NvParameterized::Serializer::SerializeType ApexSDKImpl::getSerializeType(PxFileBuf& stream)
+{
+	return NvParameterized::Serializer::peekSerializeType(stream);
+}
+
+NvParameterized::Serializer::ErrorType ApexSDKImpl::getSerializePlatform(const void* data, uint32_t dlen, NvParameterized::SerializePlatform& platform)
+{
+	if (dlen < 56)
+	{
+		APEX_INVALID_PARAMETER("At least 56 Bytes are needed to read the platform of a binary file");
+	}
+
+	PsMemoryBuffer stream(data, dlen);
+	return NvParameterized::Serializer::peekPlatform(stream, platform);
+}
+
+NvParameterized::Serializer::ErrorType ApexSDKImpl::getSerializePlatform(PxFileBuf& stream, NvParameterized::SerializePlatform& platform)
+{
+	return NvParameterized::Serializer::peekPlatform(stream, platform);
+}
+
+void ApexSDKImpl::getCurrentPlatform(NvParameterized::SerializePlatform& platform) const
+{
+	platform = NvParameterized::GetCurrentPlatform();
+}
+
+bool ApexSDKImpl::getPlatformFromString(const char* name, NvParameterized::SerializePlatform& platform) const
+{
+	return NvParameterized::GetPlatform(name, platform);
+}
+
+const char* ApexSDKImpl::getPlatformName(const NvParameterized::SerializePlatform& platform) const
+{
+	return NvParameterized::GetPlatformName(platform);
+}
+
+Asset*	ApexSDKImpl::createAsset(const char* opaqueMeshName, UserOpaqueMesh* om)
+{
+	Asset* ret = NULL;
+	NvParameterized::Interface* params = getParameterizedTraits()->createNvParameterized(RenderMeshAssetParameters::staticClassName());
+	if (params)
+	{
+		ret = this->createAsset(params, opaqueMeshName);
+		if (ret)
+		{
+			NvParameterized::setParamBool(*params, "isReferenced", false);
+			ApexRenderMeshAsset* nrma = static_cast<ApexRenderMeshAsset*>(ret);
+			nrma->setOpaqueMesh(om);
+		}
+		else
+		{
+			params->destroy();
+		}
+	}
+	return ret;
+}
+
+ModuleIntl *ApexSDKImpl::getInternalModule(Module *module)
+{
+	ModuleIntl *ret = NULL;
+
+	for (uint32_t i = 0; i < modules.size(); i++)
+	{
+		if ( modules[ i ] == module )
+		{
+			ret = imodules[i];
+			break;
+		}
+	}
+
+	return ret;
+}
+
+Module *ApexSDKImpl::getModule(ModuleIntl *module)
+{
+	Module *ret = NULL;
+
+	for (uint32_t i = 0; i < imodules.size(); i++)
+	{
+		if ( imodules[ i ] == module )
+		{
+			ret = modules[i];
+			break;
+		}
+	}
+
+	return ret;
+}
+
+
+void ApexSDKImpl::enterURR()
+{
+	if (mURRdepthTLSslot != 0xFFFFFFFF)
+	{
+		uint64_t currentDepth = PTR_TO_UINT64(TlsGet(mURRdepthTLSslot));
+		++currentDepth;
+		TlsSet(mURRdepthTLSslot, (void*)currentDepth);
+	}
+}
+
+
+void ApexSDKImpl::leaveURR()
+{
+	if (mURRdepthTLSslot != 0xFFFFFFFF)
+	{
+		uint64_t currentDepth = PTR_TO_UINT64(TlsGet(mURRdepthTLSslot));
+		if (currentDepth > 0)
+		{
+			--currentDepth;
+			TlsSet(mURRdepthTLSslot, (void*)currentDepth);
+		}
+		else
+		{
+			// if this is hit, something is wrong with the
+			// URR_SCOPE implementation
+			PX_ALWAYS_ASSERT();
+		}
+	}
+}
+
+
+void ApexSDKImpl::checkURR()
+{
+	if (mURRdepthTLSslot != 0xFFFFFFFF)
+	{
+		uint64_t currentDepth = PTR_TO_UINT64(TlsGet(mURRdepthTLSslot));
+		if (currentDepth == 0)
+		{
+			// if this assert is hit it means that
+			// - either some render resources are created where it's not allowed
+			//   (outside of updateRenderResources or prepareRenderResources)
+			//   => change the place in code where the resource is created
+			//
+			// - or the updateRenderResources call is not marked with a URR_SCOPE.
+			//   => add the macro
+			PX_ALWAYS_ASSERT();
+		}
+	}
+}
+
+}
+} // end namespace nvidia::apex
diff --git a/APEX_1.4/framework/src/ApexSDKVersionString.cpp b/APEX_1.4/framework/src/ApexSDKVersionString.cpp
new file mode 100644
index 00000000..8fe7730d
--- /dev/null
+++ b/APEX_1.4/framework/src/ApexSDKVersionString.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "ApexSDKVersionString.h"
+#include <PxPreprocessor.h>
+#include "P4Info.h"
+
+namespace nvidia
+{
+namespace apex
+{
+
+const char*	GetApexSDKVersionString(ApexSDKVersionString versionString)
+{
+	const char* result = NULL;
+	switch(versionString)
+	{
+		case VERSION:
+			result = P4_APEX_VERSION_STRING;
+		break;
+		case CHANGELIST:
+			result = PX_STRINGIZE(P4_CHANGELIST);
+		break;
+		case TOOLS_CHANGELIST:
+			result = PX_STRINGIZE(P4_TOOLS_CHANGELIST);
+		break;
+		case BRANCH:
+			result = P4_APEX_BRANCH;
+		break;
+		case BUILD_TIME:
+			result = P4_BUILD_TIME;
+		break;
+		case AUTHOR:
+			result = AUTHOR_DISTRO;
+		break;
+		case REASON:
+			result = REASON_DISTRO;
+		break;
+		default:
+		break;
+	}
+	return result;
+}
+
+}
+}
diff --git a/APEX_1.4/framework/src/ApexScene.cpp b/APEX_1.4/framework/src/ApexScene.cpp
new file mode 100644
index 00000000..9652e133
--- /dev/null
+++ b/APEX_1.4/framework/src/ApexScene.cpp
@@ -0,0 +1,1799 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "Apex.h"
+#include "ApexDefs.h"
+#include "ApexScene.h"
+#include "ApexSceneTasks.h"
+#include "ApexSDKImpl.h"
+#include "ApexActor.h"
+#include "FrameworkPerfScope.h"
+#include "ApexRenderDebug.h"
+#include "ModuleIntl.h"
+#include "ApexPvdClient.h"
+#include "PsTime.h"
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+#include "ScopedPhysXLock.h"
+#include "PxRigidActor.h"
+#include "cloth/PxCloth.h" // for PxCloth::isCloth()
+#endif
+
+#include "ApexUsingNamespace.h"
+#include "PsSync.h"
+#include "PxTask.h"
+#include "PxTaskManager.h"
+#include "PxGpuDispatcher.h"
+#include "PxCudaContextManager.h"
+#include "ApexString.h"
+
+#define USE_FILE_RENDER_DEBUG 0
+#define USE_PVD_RENDER_DEBUG 0
+
+#if USE_FILE_RENDER_DEBUG
+#include "PxFileRenderDebug.h"
+#endif
+#if USE_PVD_RENDER_DEBUG
+#include "PxPVDRenderDebug.h"
+#endif
+
+#if APEX_CUDA_SUPPORT && !defined(INSTALLER)
+#include <cuda.h>
+class IDirect3DDevice9;
+class IDirect3DResource9;
+class IDirect3DVertexBuffer9;
+#include <cudad3d9.h>
+class ID3D10Device;
+class ID3D10Resource;
+class IDXGIAdapter;
+#include <cudad3d10.h>
+
+#include "ApexCudaTest.h"
+#include "ApexCudaProfile.h"
+#endif
+
+#include "Lock.h"
+
+#if PX_X86
+#define PTR_TO_UINT64(x) ((uint64_t)(uint32_t)(x))
+#else
+#define PTR_TO_UINT64(x) ((uint64_t)(x))
+#endif
+
+namespace nvidia
+{
+namespace apex
+{
+
+double ApexScene::mQPC2MilliSeconds = 0.0;
+
+/************
+* ApexScene *
+************/
+
+ApexScene::ApexScene(const SceneDesc& sceneDesc, ApexSDKImpl* sdk)
+	: mApexSDK(sdk)
+#if PX_PHYSICS_VERSION_MAJOR == 3
+	, mPhysXScene(NULL)
+	, mPhysX3Interface(sceneDesc.physX3Interface)
+#endif
+	, mElapsedTime(0.0f)
+	, mSceneRenderDebug(NULL)
+	, mOrigSceneMaxIter(1)
+	, mOrigSceneSubstepSize(1.0f / 60.0f)
+	, mTaskManager(NULL)
+	, mSimulating(false)
+	, mUseDebugRenderable(sceneDesc.useDebugRenderable)
+	, mUsedResource(0.0f)
+	, mSumBenefit(0.0f)
+	, mPhysXSimulate(NULL)
+	, mBetweenstepTasks(NULL)
+#if APEX_DURING_TICK_TIMING_FIX
+	, mDuringTickComplete(NULL)
+#endif
+	, mCheckResults(NULL)
+	, mFetchResults(NULL)
+	, mTotalElapsedMS(0)
+	, mTimeRemainder(0.0f)
+	, mPhysXRemainder(0.0f)
+	, mPhysXSimulateTime(0.0f)
+	, mPxLastElapsedTime(0.0f)
+	, mPxAccumElapsedTime(0.0f)
+	, mPxStepWasValid(false)
+	, mFinalStep(false)
+#if APEX_CUDA_SUPPORT
+	, mUseCuda(sceneDesc.useCuda)
+#else
+	, mUseCuda(false)
+#endif	
+	, mCudaKernelCheckEnabled(false)
+	, mGravity(0)
+{
+	mSimulationComplete.set();
+
+#if APEX_CUDA_SUPPORT && !defined(INSTALLER)
+	mCudaTestManager = PX_NEW(ApexCudaTestManager)();
+	mCudaProfileManager = PX_NEW(ApexCudaProfileManager)();
+	mCudaTestManager->setInternalApexScene(this);
+	mCudaProfileManager->setInternalApexScene(this);
+#else
+	mCudaTestManager = 0;
+	mCudaProfileManager = 0;
+#endif
+
+	// APEX was ignoring the numerator from CounterFrequencyToTensOfNanos, this is OK as long as
+	// the numerator is equal to Time::sNumTensOfNanoSecondsInASecond (100,000,000)
+	//float ret = (float)((double)(t1 - t0) / (double)Time::getBootCounterFrequency().mDenominator);
+
+	// Let's see if we can use both the numerator and denominator correctly (mostly for linux)
+	const CounterFrequencyToTensOfNanos freq = Time::getBootCounterFrequency();
+	const double freqMultiplier = (double)freq.mNumerator/(double)freq.mDenominator;
+
+	mQPC2MilliSeconds = freqMultiplier * 0.00001; // from tens of nanos to milliseconds ( x / 100 / 1000)
+
+#if PX_WINDOWS_FAMILY
+	if (sceneDesc.debugVisualizeRemotely)
+	{
+#if USE_FILE_RENDER_DEBUG
+		prd = createFileRenderDebug("SceneRenderDebug.bin", false, sceneDesc.debugVisualizeLocally);
+#endif
+#if USE_PVD_RENDER_DEBUG
+		prd = createPVDRenderDebug(sceneDesc.debugVisualizeLocally);
+#endif
+	}
+#endif
+	mSceneRenderDebug = sceneDesc.debugInterface;
+
+	/* Create NvParameterized for mDebugRenderParams */
+	NvParameterized::Traits* traits = mApexSDK->getParameterizedTraits();
+	PX_ASSERT(traits);
+	mDebugRenderParams = (DebugRenderParams*)traits->createNvParameterized(DebugRenderParams::staticClassName());
+	PX_ASSERT(mDebugRenderParams);
+
+	/* Get mDebugColorParams from ApexSDKImpl */
+	mDebugColorParams = (DebugColorParams*)mApexSDK->getDebugColorParams();
+	initDebugColorParams();
+
+#if PX_PHYSICS_VERSION_MAJOR == 0
+	mTaskManager = PxTaskManager::createTaskManager(*mApexSDK->getErrorCallback(), sceneDesc.cpuDispatcher, sceneDesc.gpuDispatcher);
+	mTaskManager->setGpuDispatcher(*sceneDesc.gpuDispatcher);
+	if (sceneDesc.cpuDispatcher == NULL)
+	{
+		mTaskManager->setCpuDispatcher(*mApexSDK->getDefaultThreadPool());
+	}
+#elif PX_PHYSICS_VERSION_MAJOR == 3
+	setPhysXScene(sceneDesc.scene);
+#if APEX_CUDA_SUPPORT
+	if (sceneDesc.scene != NULL)
+	{
+		mTaskManager = sceneDesc.scene->getTaskManager();
+		if (mTaskManager->getGpuDispatcher())
+		{
+			PxCudaContextManager* ctx = mTaskManager->getGpuDispatcher()->getCudaContextManager();
+			if (ctx && ctx->supportsArchSM30())
+			{
+				ctx->setUsingConcurrentStreams(false);
+			}
+		}
+	}
+#endif
+#endif
+
+	allocateTasks();
+
+	createApexStats();
+}
+
+ApexScene::~ApexScene()
+{
+	destroyApexStats();
+
+#if APEX_CUDA_SUPPORT && !defined(INSTALLER)
+	PX_DELETE(mCudaTestManager);
+	PX_DELETE(mCudaProfileManager);
+#endif
+
+	while (mViewMatrices.size())
+	{
+		PX_FREE(mViewMatrices.popBack());
+	}
+	while (mProjMatrices.size())
+	{
+		PX_FREE(mProjMatrices.popBack());
+	}
+}
+
+// This array is still created because it is handy to have it to initialize
+// the individual scene arrays.  The string data is reduced to pointers.  This
+// could be improved with macros that do both this and the enums at the same time.
+static StatsInfo ApexStatsData[] =
+{
+	{"NumberOfActors",          StatDataType::INT,   {{0}} },
+	{"NumberOfShapes",          StatDataType::INT,   {{0}} },
+	{"NumberOfAwakeShapes",     StatDataType::INT,   {{0}} },
+	{"NumberOfCpuShapePairs",   StatDataType::INT,   {{0}} },
+	{"ApexBeforeTickTime",	    StatDataType::FLOAT, {{0}} },
+	{"ApexDuringTickTime",	    StatDataType::FLOAT, {{0}} },
+	{"ApexPostTickTime",	    StatDataType::FLOAT, {{0}} },
+	{"PhysXSimulationTime",	    StatDataType::FLOAT, {{0}} },
+	{"ClothingSimulationTime",  StatDataType::FLOAT, {{0}} },
+	{"ParticleSimulationTime",			StatDataType::FLOAT, {{0}} },
+	{"TurbulenceSimulationTime",			StatDataType::FLOAT, {{0}} },
+	{"PhysXFetchResultTime",    StatDataType::FLOAT, {{0}} },
+	{"UserDelayedFetchTime",    StatDataType::FLOAT, {{0}} },
+	{"RbThroughput(Mpair/sec)", StatDataType::FLOAT, {{0}} },
+	{"IOFX: SimulatedSpriteParticlesCount",	StatDataType::INT, {{0}} },
+	{"IOFX: SimulatedMeshParticlesCount",	StatDataType::INT, {{0}} },
+	{"VisibleDestructibleChunkCount",		StatDataType::INT, {{0}} },
+	{"DynamicDestructibleChunkIslandCount",	StatDataType::INT, {{0}} }
+};
+
+PX_COMPILE_TIME_ASSERT(sizeof(ApexStatsData) / sizeof(ApexStatsData[0]) == ApexScene::NumberOfApexStats);
+
+void ApexScene::createApexStats(void)
+{
+	mApexSceneStats.numApexStats		= NumberOfApexStats;
+	mApexSceneStats.ApexStatsInfoPtr	= (StatsInfo*)PX_ALLOC(sizeof(StatsInfo) * ApexScene::NumberOfApexStats, PX_DEBUG_EXP("StatsInfo"));
+
+	for (uint32_t i = 0; i < ApexScene::NumberOfApexStats; i++)
+	{
+		mApexSceneStats.ApexStatsInfoPtr[i] = ApexStatsData[i];
+	}
+}
+
+void ApexScene::destroyApexStats(void)
+{
+	mApexSceneStats.numApexStats = 0;
+	if (mApexSceneStats.ApexStatsInfoPtr)
+	{
+		PX_FREE_AND_RESET(mApexSceneStats.ApexStatsInfoPtr);
+	}
+}
+
+const SceneStats* ApexScene::getStats(void) const
+{
+	READ_ZONE();
+	return(&mApexSceneStats);
+}
+
+void ApexScene::setApexStatValue(int32_t index, StatValue dataVal)
+{
+	if (mApexSceneStats.ApexStatsInfoPtr)
+	{
+		mApexSceneStats.ApexStatsInfoPtr[index].StatCurrentValue = dataVal;
+	}
+}
+
+NvParameterized::Interface* ApexScene::getDebugRenderParams() const
+{
+	READ_ZONE();
+	return mDebugRenderParams;
+}
+
+//Module names are case sensitive:
+//BasicIos, Clothing, Destructible, Emitter, Iofx
+NvParameterized::Interface* ApexScene::getModuleDebugRenderParams(const char* name) const
+{
+	READ_ZONE();
+	NvParameterized::Handle handle(*mDebugRenderParams), memberHandle(*mDebugRenderParams);
+	NvParameterized::Interface* refPtr = NULL;
+	int size;
+
+	if (mDebugRenderParams->getParameterHandle("moduleName", handle) == NvParameterized::ERROR_NONE)
+	{
+		handle.getArraySize(size, 0);
+		for (int i = 0; i < size; i++)
+		{
+			if (handle.getChildHandle(i, memberHandle) == NvParameterized::ERROR_NONE)
+			{
+				memberHandle.getParamRef(refPtr);
+				if (strstr(refPtr->className(), name) != 0)
+				{
+					return refPtr;
+				}
+			}
+		}
+	}
+
+	return NULL;
+}
+
+uint32_t ApexScene::allocViewMatrix(ViewMatrixType::Enum viewType)
+{
+	WRITE_ZONE();
+	if (mViewMatrices.size() >= 1)
+	{
+		if (!mTotalElapsedMS)
+		{
+			APEX_INVALID_OPERATION("instantiating more than %d view matrices is not allowed!", mViewMatrices.size());
+		}
+	}
+	else
+	{
+		ViewMatrixProperties* v;
+
+		switch (viewType)
+		{
+		case ViewMatrixType::USER_CUSTOMIZED:
+		{
+			v = PX_NEW(ViewMatrixLookAt)(PxMat44(PxIdentity),false,true);
+		}
+		break;
+		case ViewMatrixType::LOOK_AT_RH:
+		{
+			v = PX_NEW(ViewMatrixLookAt)(PxMat44(PxIdentity), false, true);
+		}
+		break;
+		case ViewMatrixType::LOOK_AT_LH:
+		{
+			v = PX_NEW(ViewMatrixLookAt)(PxMat44(PxIdentity), false, false);
+		}
+		break;
+		default:
+			if (!mTotalElapsedMS)
+			{
+				APEX_INVALID_PARAMETER("Invalid ViewMatrixType!");
+			}
+			v = NULL;
+			break;
+		}
+		if (v)
+		{
+			mViewMatrices.pushBack(v);
+		}
+	}
+	return mViewMatrices.size() - 1;
+}
+
+uint32_t ApexScene::allocProjMatrix(ProjMatrixType::Enum projType)
+{
+	WRITE_ZONE();
+	if (mProjMatrices.size() >= 1)
+	{
+		if (!mTotalElapsedMS)
+		{
+			APEX_INVALID_OPERATION("instantiating more than %d projection matrices is not allowed!", mProjMatrices.size());
+		}
+	}
+	else
+	{
+		ProjMatrixProperties* p;
+
+		switch (projType)
+		{
+		case ProjMatrixType::USER_CUSTOMIZED:
+		{
+			p = PX_NEW(ProjMatrixUserCustomized)(PxMat44(PxIdentity), true, false, 0.1f, 10000.0f, 45.0f, 1024, 640);
+		}
+		break;
+#if 0 //lionel: work in progress
+		case ProjMatrixType::PERSPECTIVE_FOV_RH:
+		{
+			p = PX_NEW(ProjMatrixPerspectiveFOV)(PxMat44(PxIdentity), false, true, true);
+		}
+		break;
+		case ProjMatrixType::PERSPECTIVE_FOV_LH:
+		{
+			p = PX_NEW(ProjMatrixPerspectiveFOV)(PxMat44(PxIdentity), false, true, false);
+		}
+		break;
+#endif
+		default:
+			if (!mTotalElapsedMS)
+			{
+				APEX_INVALID_PARAMETER("Invalid ProjMatrixType!");
+			}
+			p = NULL;
+			break;
+		}
+		if (p)
+		{
+			mProjMatrices.pushBack(p);
+		}
+	}
+	return mProjMatrices.size() - 1;
+}
+
+uint32_t ApexScene::getNumViewMatrices() const
+{
+	READ_ZONE();
+	return mViewMatrices.size();
+}
+
+uint32_t ApexScene::getNumProjMatrices() const
+{
+	READ_ZONE();
+	return mProjMatrices.size();
+}
+
+void ApexScene::setViewMatrix(const PxMat44& viewTransform, const uint32_t viewID)
+{
+	WRITE_ZONE();
+	if (viewID >= getNumViewMatrices())
+	{
+		if (!mTotalElapsedMS)
+		{
+			APEX_INVALID_PARAMETER("view matrix for viewID %d is not initialized! see allocViewMatrix()", viewID);
+		}
+	}
+	else
+	{
+		mViewMatrices[viewID]->viewMatrix = viewTransform;
+
+		// create PVD cameras
+		pvdsdk::ApexPvdClient* client = mApexSDK->getApexPvdClient();
+		if ((client != NULL) && client->isConnected())
+		{
+			if (!mViewMatrices[viewID]->pvdCreated)
+			{
+				ApexSimpleString cameraNum;
+				ApexSimpleString::itoa(viewID, cameraNum);
+				mViewMatrices[viewID]->cameraName = "ApexCamera ";
+				mViewMatrices[viewID]->cameraName += cameraNum;
+				mViewMatrices[viewID]->pvdCreated = true;
+			}
+
+			PxVec3 gravity = getGravity();
+			gravity.normalize();
+			PxVec3 position = getEyePosition(viewID);
+			PxVec3 target = position + getEyeDirection(viewID);
+
+			//pvdBinding->getConnectionManager().setCamera(mViewMatrices[viewID]->cameraName.c_str(), position, -gravity, target);
+		}
+	}
+}
+
+PxMat44 ApexScene::getViewMatrix(const uint32_t viewID) const
+{
+	READ_ZONE();
+	if (viewID < getNumViewMatrices())
+	{
+		return mViewMatrices[viewID]->viewMatrix;
+	}
+	else
+	{
+		if (!mTotalElapsedMS)
+		{
+			APEX_INVALID_PARAMETER("view matrix for viewID %d is not initialized! see allocViewMatrix()", viewID);
+		}
+	}
+	return PxMat44(PxIdentity);
+}
+
+void ApexScene::setProjMatrix(const PxMat44& projTransform, const uint32_t projID)
+{
+	WRITE_ZONE();
+	if (projID >= getNumProjMatrices())
+	{
+		if (!mTotalElapsedMS)
+		{
+			APEX_INVALID_PARAMETER("projection matrix for projID %d is not initialized! see allocProjMatrix()", projID);
+		}
+	}
+	else
+	{
+		mProjMatrices[projID]->projMatrix = projTransform;
+	}
+}
+
+PxMat44 ApexScene::getProjMatrix(const uint32_t projID) const
+{
+	READ_ZONE();
+	if (projID < getNumProjMatrices())
+	{
+		return mProjMatrices[projID]->projMatrix;
+	}
+	else
+	{
+		if (!mTotalElapsedMS)
+		{
+			APEX_INVALID_PARAMETER("projection matrix for projID %d is not initialized! see allocProjMatrix()", projID);
+		}
+	}
+	return PxMat44(PxIdentity);
+}
+
+void ApexScene::setUseViewProjMatrix(const uint32_t viewID, const uint32_t projID)
+{
+	WRITE_ZONE();
+	if (viewID >= getNumViewMatrices())
+	{
+		if (!mTotalElapsedMS)
+		{
+			APEX_INVALID_PARAMETER("view matrix for viewID %d is not initialized! see allocViewMatrix()", viewID);
+		}
+	}
+	else
+	{
+		if (projID >= getNumProjMatrices())
+		{
+			if (!mTotalElapsedMS)
+			{
+				APEX_INVALID_PARAMETER("projection matrix for projID %d is not initialized! see allocProjMatrix()", projID);
+			}
+		}
+		else
+		{
+#if 0 //lionel: work in progress
+			getColMajColVecArray(mViewMatrices[viewID]->viewMatrix, mViewColMajColVecArray);
+			getColMajColVecArray(mProjMatrices[projID]->projMatrix, mProjColMajColVecArray);
+			multiplyColMajColVecArray(mViewColMajColVecArray, mProjColMajColVecArray, mViewProjColMajColVecArray);
+#endif
+
+#ifndef WITHOUT_DEBUG_VISUALIZE
+			if (mSceneRenderDebug)
+			{
+				RENDER_DEBUG_IFACE(mSceneRenderDebug)->setViewMatrix(mViewMatrices[viewID]->viewMatrix.front());
+				RENDER_DEBUG_IFACE(mSceneRenderDebug)->setProjectionMatrix(mProjMatrices[projID]->projMatrix.front());
+			}
+#endif
+
+#if 0 //lionel: work in progress
+			//getColVecMat44(mViewProjColMajColVecArray, mViewProjMatrix);	//lionel: need to test
+			//mCurrentViewID = viewID;		//lionel : initialize these. will need these when multiple view and prok matrices is supported
+			//mCurrentProjID = projID;
+#endif
+		}
+	}
+}
+#if 0 //lionel: work in progress
+const PxMat44& ApexScene::getViewProjMatrix() const
+{
+	static PxMat44 vp;
+	vp = vp.createIdentity();
+
+	if (mViewProjColMajColVecArray == NULL)
+	{
+		APEX_INVALID_OPERATION("view-projection matrix is not yet set! see setUseViewProjMatrix()");
+	}
+	else
+	{
+		return mViewProjMatrix;
+	}
+	return vp;
+}
+
+void ApexScene::getColMajColVecArray(const PxMat44& colVecMat44, float* const result)
+{
+	*(PxVec4*)(result + 0) = colVecMat44.column0;
+	*(PxVec4*)(result + 4) = colVecMat44.column1;
+	*(PxVec4*)(result + 8) = colVecMat44.column2;
+	*(PxVec4*)(result + 12) = colVecMat44.column3;
+}
+
+void ApexScene::getColVecMat44(const float* const colMajColVecArray, PxMat44& result)
+{
+	result.column0 = PxVec4(colMajColVecArray + 0);
+	result.column1 = PxVec4(colMajColVecArray + 4);
+	result.column2 = PxVec4(colMajColVecArray + 8);
+	result.column3 = PxVec4(colMajColVecArray + 12);
+}
+
+void ApexScene::multiplyColMajColVecArray(const float* const fromSpace, const float* const toSpace, float* const result)
+{
+	/****************************************
+	col vector -> P * V * W * vertexVector
+	row vector -> vertexVector * W * V * P
+	toSpace * fromSpace
+	result = rows of 1stMat * cols of 2ndMat
+	****************************************/
+	uint32_t id = 0;
+	for (uint32_t r = 0; r < 4; ++r)
+	{
+		for (uint32_t c = 0; c < 4; ++c)
+		{
+			float dotProduct = 0;
+			for (uint32_t k = 0; k < 4; ++k)
+			{
+				dotProduct += toSpace[k * 4 + r] * fromSpace[k + c * 4];
+			}
+			result[id++] = dotProduct;
+		}
+	}
+}
+#endif
+
+PxVec3 ApexScene::getEyePosition(const uint32_t viewID) const
+{
+	READ_ZONE();
+	if (viewID < getNumViewMatrices())
+	{
+		PxVec3 pos = (mViewMatrices[viewID]->viewMatrix.inverseRT()).column3.getXYZ();
+		return pos;
+	}
+	else
+	{
+		if (!mTotalElapsedMS)
+		{
+			APEX_INVALID_PARAMETER("view matrix for viewID %d is not initialized! see allocViewMatrix()", viewID);
+		}
+	}
+	return PxVec3(0, 0, 0);
+}
+
+PxVec3 ApexScene::getEyeDirection(const uint32_t viewID) const
+{
+	READ_ZONE();
+	if (viewID < getNumViewMatrices())
+	{
+		PxVec3 dir;
+		dir.x = mViewMatrices[viewID]->viewMatrix.column0.z;
+		dir.y = mViewMatrices[viewID]->viewMatrix.column1.z;
+		dir.z = mViewMatrices[viewID]->viewMatrix.column2.z;
+		ViewMatrixLookAt* v = static_cast<ViewMatrixLookAt*>(mViewMatrices[viewID]);
+		if (v->isRightHand)
+		{
+			dir = -1 * dir;
+		}
+		return dir;
+	}
+	else
+	{
+		APEX_INVALID_PARAMETER("invalid view matrix ID viewID %d! see allocViewMatrix()", viewID);
+	}
+	return PxVec3(0, 0, 1);
+}
+
+//**********************************
+
+void getEyeTransform(PxMat44 &xform,const PxVec3 &eye,const PxVec3 &forward,const PxVec3 &up)
+{
+	PxVec3 right = forward.cross(up);
+	right.normalize();
+	PxVec3 realUp = right.cross(forward);
+	realUp.normalize();
+	xform = PxMat44(right, realUp, -forward, eye);
+	xform = xform.inverseRT();
+}
+
+
+void ApexScene::setViewParams(const PxVec3& eyePosition, const PxVec3& eyeDirection, const PxVec3& worldUpDirection, const uint32_t viewID)
+{
+	WRITE_ZONE();
+	if (viewID >= getNumViewMatrices())
+	{
+		if (!mTotalElapsedMS)
+		{
+			APEX_INVALID_PARAMETER("view matrix for viewID %d is not initialized! see allocViewMatrix()", viewID);
+		}
+	}
+	else
+	{
+		ViewMatrixLookAt* v = static_cast<ViewMatrixLookAt*>(mViewMatrices[viewID]);
+		getEyeTransform(v->viewMatrix,eyePosition,eyeDirection,worldUpDirection);
+	}
+}
+
+void ApexScene::setProjParams(float nearPlaneDistance, float farPlaneDistance, float fieldOfViewDegree, uint32_t viewportWidth, uint32_t viewportHeight, const uint32_t projID)
+{
+	WRITE_ZONE();
+	if (projID >= getNumProjMatrices())
+	{
+		if (!mTotalElapsedMS)
+		{
+			APEX_INVALID_PARAMETER("projection matrix for projID %d is not initialized! see allocProjMatrix()", projID);
+		}
+	}
+	else
+	{
+		if (!mProjMatrices[projID]->isUserCustomized)
+		{
+			if (!mTotalElapsedMS)
+			{
+				APEX_INVALID_PARAMETER("projection matrix for projID %d is not a user-customized type! see allocProjMatrix()", projID);
+			}
+		}
+		else
+		{
+			ProjMatrixUserCustomized* p = static_cast<ProjMatrixUserCustomized*>(mProjMatrices[projID]);
+			p->nearPlaneDistance = nearPlaneDistance;
+			p->farPlaneDistance = farPlaneDistance;
+			p->fieldOfViewDegree = fieldOfViewDegree;
+			p->viewportWidth = viewportWidth;
+			p->viewportHeight = viewportHeight;
+		}
+	}
+}
+#if 0 //lionel: work in progress
+const PxMat44& ApexScene::buildViewMatrix(const uint32_t viewID)
+{
+	if (viewID >= getNumViewMatrices())
+	{
+		APEX_INVALID_PARAMETER("view matrix for viewID %d is not initialized! see allocViewMatrix()", viewID);
+	}
+	else
+	{
+		if (!mViewMatrices[viewID]->isLookAt)
+		{
+			APEX_INVALID_PARAMETER("view matrix for viewID %d is not a LookAt type! see allocViewMatrix()", viewID);
+		}
+		else
+		{
+			ViewMatrixLookAt* v = DYNAMIC_CAST(ViewMatrixLookAt*)(mViewMatrices[viewID]);
+			if (v->isRightHand)
+			{
+				//lionel: todo
+				//ensure determinant == +ve
+				//set view matrix as well?
+			}
+			else
+			{
+				//lionel: todo
+				//ensure determinant == -ve
+				//set view matrix as well?
+			}
+		}
+
+	}
+	//lionel: temp hack
+	static PxMat44 hack;
+	return hack;
+}
+
+const PxMat44& ApexScene::buildProjMatrix(const uint32_t projID)
+{
+	if (projID >= getNumProjMatrices())
+	{
+		APEX_INVALID_PARAMETER("projection matrix for projID %d is not initialized! see allocProjMatrix()", projID);
+	}
+	else
+	{
+		if (!mProjMatrices[projID]->isPerspectiveFOV)
+		{
+			APEX_INVALID_PARAMETER("projection matrix for projID %d is a not a perspective FOV type! see allocProjMatrix()", projID);
+		}
+		else
+		{
+			ProjMatrixPerspectiveFOV* p = DYNAMIC_CAST(ProjMatrixPerspectiveFOV*)(mProjMatrices[projID]);
+			if (p->isZinvert)
+			{
+				//lionel: todo
+				//set proj matrix as well?
+				//D3D projection or OGL projection?
+			}
+			else
+			{
+				//lionel: todo
+				//set proj matrix as well?
+			}
+		}
+	}
+	//lionel: temp hack
+	static PxMat44 hack;
+	return hack;
+}
+#endif
+
+void ApexScene::initDebugColorParams()
+{
+	if (mSceneRenderDebug == NULL)
+	{
+		return;
+	}
+	using RENDER_DEBUG::DebugColors;
+#ifndef WITHOUT_DEBUG_VISUALIZE
+#define INIT_COLOR(_name)																		\
+	RENDER_DEBUG_IFACE(mSceneRenderDebug)->setDebugColor(DebugColors::_name, mDebugColorParams->_name);	\
+	mColorMap.insert(#_name, DebugColors::_name);
+
+	INIT_COLOR(Default);
+	INIT_COLOR(PoseArrows);
+	INIT_COLOR(MeshStatic);
+	INIT_COLOR(MeshDynamic);
+	INIT_COLOR(Shape);
+	INIT_COLOR(Text0);
+	INIT_COLOR(Text1);
+	INIT_COLOR(ForceArrowsLow);
+	INIT_COLOR(ForceArrowsNorm);
+	INIT_COLOR(ForceArrowsHigh);
+	INIT_COLOR(Color0);
+	INIT_COLOR(Color1);
+	INIT_COLOR(Color2);
+	INIT_COLOR(Color3);
+	INIT_COLOR(Color4);
+	INIT_COLOR(Color5);
+	INIT_COLOR(Red);
+	INIT_COLOR(Green);
+	INIT_COLOR(Blue);
+	INIT_COLOR(DarkRed);
+	INIT_COLOR(DarkGreen);
+	INIT_COLOR(DarkBlue);
+	INIT_COLOR(LightRed);
+	INIT_COLOR(LightGreen);
+	INIT_COLOR(LightBlue);
+	INIT_COLOR(Purple);
+	INIT_COLOR(DarkPurple);
+	INIT_COLOR(Yellow);
+	INIT_COLOR(Orange);
+	INIT_COLOR(Gold);
+	INIT_COLOR(Emerald);
+	INIT_COLOR(White);
+	INIT_COLOR(Black);
+	INIT_COLOR(Gray);
+	INIT_COLOR(LightGray);
+	INIT_COLOR(DarkGray);
+#endif
+}
+
+void ApexScene::updateDebugColorParams(const char* color, uint32_t val)
+{
+	WRITE_ZONE();
+#ifndef WITHOUT_DEBUG_VISUALIZE
+	RENDER_DEBUG_IFACE(mSceneRenderDebug)->setDebugColor(mColorMap[color], val);
+#else
+	PX_UNUSED(color);
+	PX_UNUSED(val);
+#endif
+}
+
+// A module may call this SceneIntl interface if the module has been released.
+void ApexScene::moduleReleased(ModuleSceneIntl& moduleScene)
+{
+	for (uint32_t i = 0 ; i < mModuleScenes.size() ; i++)
+	{
+		if (mModuleScenes[i] == &moduleScene)
+		{
+			mModuleScenes.replaceWithLast(i);
+			break;
+		}
+	}
+}
+
+// ApexSDKImpl will call this for each module when ApexScene is first created, and
+// again for all new modules loaded after the scene was created.
+void ApexScene::moduleCreated(ModuleIntl& module)
+{
+	ModuleSceneIntl* ms = module.createInternalModuleScene(*this, mSceneRenderDebug);
+	if (ms)
+	{
+		mModuleScenes.pushBack(ms);
+#if PX_PHYSICS_VERSION_MAJOR == 3
+		ms->setModulePhysXScene(mPhysXScene);
+#endif
+	}
+}
+
+
+
+const PxRenderBuffer* ApexScene::getRenderBuffer() const
+{
+#if PX_PHYSICS_VERSION_MAJOR == 3
+	READ_ZONE();
+	if (mSimulating)
+	{
+		APEX_INTERNAL_ERROR("simulation is still running");
+	}
+	else
+	{
+#ifndef WITHOUT_DEBUG_VISUALIZE
+		if (mUseDebugRenderable && mSceneRenderDebug)
+		{
+			mSceneRenderDebug->getRenderBuffer(mRenderBuffer);
+		}
+#endif
+	}
+	return &mRenderBuffer;
+#else
+	return 0;
+#endif
+}
+
+const PxRenderBuffer* ApexScene::getRenderBufferScreenSpace() const
+{
+#if PX_PHYSICS_VERSION_MAJOR == 3
+	READ_ZONE();
+	if (mSimulating)
+	{
+		APEX_INTERNAL_ERROR("simulation is still running");
+	}
+	else
+	{
+#ifndef WITHOUT_DEBUG_VISUALIZE
+		if (mUseDebugRenderable && mSceneRenderDebug)
+		{
+			mSceneRenderDebug->getRenderBufferScreenSpace(mRenderBufferScreenSpace);
+		}
+#endif
+	}
+	return &mRenderBufferScreenSpace;
+#else
+	return 0;
+#endif	
+}
+
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+void ApexScene::setPhysXScene(PxScene* s)
+{
+	WRITE_ZONE();
+	if (mPhysXScene != s)
+	{
+		/* Pass along to the module scenes */
+		for (uint32_t i = 0 ; i < mModuleScenes.size() ; i++)
+		{
+			mModuleScenes[i]->setModulePhysXScene(s);
+		}
+		mPhysXScene = s;
+
+		updateGravity();
+
+
+		if (mPhysXScene)
+		{
+			mTaskManager = mPhysXScene->getTaskManager();
+		}
+		else
+		{
+			mTaskManager = NULL;
+		}
+	}
+}
+#endif
+
+
+uint32_t ApexScene::addActor(ApexActor& actor, ApexActor* actorPtr)
+{
+#if PX_PHYSICS_VERSION_MAJOR == 3
+	WRITE_ZONE();
+	{
+		SCOPED_PHYSX_LOCK_WRITE(this);
+		actor.setPhysXScene(mPhysXScene);
+	}
+#endif
+	return ApexContext::addActor(actor , actorPtr);
+}
+
+void ApexScene::removeAllActors()
+{
+	WRITE_ZONE();
+	if (mSimulating)
+	{
+		fetchResults(true, NULL);
+	}
+	ApexContext::removeAllActors();
+}
+
+void ApexScene::destroy()
+{
+	{
+
+		if (mSimulating)
+		{
+			fetchResults(true, NULL);
+		}
+
+		if (mSceneRenderDebug)
+		{
+			mSceneRenderDebug = NULL;
+		}
+
+		if (mDebugRenderParams)
+		{
+			mDebugRenderParams->destroy();
+			mDebugRenderParams = NULL;
+		}
+
+		removeAllActors();
+	}
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+
+	using namespace physx;
+
+	PxScene* physXScene = getPhysXScene();
+
+	// Clean up PhysX objects data
+	if (physXScene)
+	{
+		SCOPED_PHYSX_LOCK_WRITE(physXScene);
+
+		uint32_t zombieActorCount = 0;
+		uint32_t zombieShapeCount = 0;
+		uint32_t zombieDeformableCount = 0;
+		uint32_t zombieParticleSystemCount = 0;
+		uint32_t zombieParticleFluidCount = 0;
+
+		uint32_t	nbActors;
+		PxActor**		actorArray;
+
+		nbActors	= physXScene->getNbActors(PxActorTypeFlag::eRIGID_STATIC | PxActorTypeFlag::eRIGID_DYNAMIC);
+		if (nbActors)
+		{
+			actorArray	= (PxActor**)PX_ALLOC(sizeof(PxActor*) * nbActors, PX_DEBUG_EXP("PxActor*"));
+			physXScene->getActors(PxActorTypeFlag::eRIGID_STATIC | PxActorTypeFlag::eRIGID_DYNAMIC, actorArray, nbActors);
+			for (uint32_t actorIndex = 0; actorIndex < nbActors; ++actorIndex)
+			{
+				PxRigidActor*	actor	= actorArray[actorIndex]->is<physx::PxRigidActor>();
+
+				uint32_t	nbShapes	= actor->getNbShapes();
+				PxShape** shapeArray = (PxShape**)PX_ALLOC(sizeof(PxShape*) * nbShapes, PX_DEBUG_EXP("PxShape*"));
+				actor->getShapes(shapeArray, nbShapes);
+				for (uint32_t shapeIndex = 0; shapeIndex < nbShapes; ++shapeIndex)
+				{
+					PxShape* shape = shapeArray[shapeIndex];
+					if (mApexSDK->getPhysXObjectInfo(shape))
+					{
+						mApexSDK->releaseObjectDesc(shape);
+						++zombieShapeCount;
+					}
+				}
+				if (mApexSDK->getPhysXObjectInfo(actor))
+				{
+					mApexSDK->releaseObjectDesc(actor);
+					++zombieActorCount;
+				}
+				PX_FREE(shapeArray);
+			}
+			PX_FREE(actorArray);
+		}
+
+
+		nbActors = physXScene->getNbActors(PxActorTypeFlag::eCLOTH);
+		if (nbActors)
+		{
+			actorArray	= (PxActor**)PX_ALLOC(sizeof(PxActor*) * nbActors, PX_DEBUG_EXP("PxActor*"));
+			physXScene->getActors(PxActorTypeFlag::eCLOTH, actorArray, nbActors);
+			for (uint32_t actorIndex = 0; actorIndex < nbActors; ++actorIndex)
+			{
+				PxCloth* cloth = actorArray[actorIndex]->is<physx::PxCloth>();
+				PX_ASSERT(cloth);
+				if (mApexSDK->getPhysXObjectInfo(cloth))
+				{
+					mApexSDK->releaseObjectDesc(cloth);
+					++zombieDeformableCount;
+				}
+			}
+			PX_FREE(actorArray);
+		}
+
+
+		nbActors	= physXScene->getNbActors(PxActorTypeFlag::ePARTICLE_SYSTEM);
+		if (nbActors)
+		{
+			actorArray	= (PxActor**)PX_ALLOC(sizeof(PxActor*) * nbActors, PX_DEBUG_EXP("PxActor*"));
+			physXScene->getActors(PxActorTypeFlag::ePARTICLE_SYSTEM, actorArray, nbActors);
+			for (uint32_t actorIndex = 0; actorIndex < nbActors; ++actorIndex)
+			{
+				PxParticleSystem* particleSystem = actorArray[actorIndex]->is<physx::PxParticleSystem>();
+				PX_ASSERT(particleSystem);
+				if (mApexSDK->getPhysXObjectInfo(particleSystem))
+				{
+					mApexSDK->releaseObjectDesc(particleSystem);
+					++zombieParticleSystemCount;
+				}
+			}
+			PX_FREE(actorArray);
+		}
+
+		nbActors	= physXScene->getNbActors(PxActorTypeFlag::ePARTICLE_FLUID);
+		if (nbActors)
+		{
+			actorArray	= (PxActor**)PX_ALLOC(sizeof(PxActor*) * nbActors, PX_DEBUG_EXP("PxActor*"));
+			physXScene->getActors(PxActorTypeFlag::ePARTICLE_FLUID, actorArray, nbActors);
+			for (uint32_t actorIndex = 0; actorIndex < nbActors; ++actorIndex)
+			{
+				PxParticleFluid* particleFluid = actorArray[actorIndex]->is<physx::PxParticleFluid>();
+				PX_ASSERT(particleFluid);
+				if (mApexSDK->getPhysXObjectInfo(particleFluid))
+				{
+					mApexSDK->releaseObjectDesc(particleFluid);
+					++zombieParticleFluidCount;
+				}
+			}
+			PX_FREE(actorArray);
+		}
+
+
+		if (zombieDeformableCount)
+		{
+			APEX_DEBUG_WARNING("Removed %d physX deformable actor descriptor(s) still remaining in destroyed ApexScene.", zombieDeformableCount);
+		}
+		if (zombieParticleSystemCount)
+		{
+			APEX_DEBUG_WARNING("Removed %d physX particle system actor descriptor(s) still remaining in destroyed ApexScene.", zombieParticleSystemCount);
+		}
+		if (zombieParticleFluidCount)
+		{
+			APEX_DEBUG_WARNING("Removed %d physX particle fluid actor descriptor(s) still remaining in destroyed ApexScene.", zombieParticleFluidCount);
+		}
+		if (zombieActorCount)
+		{
+			APEX_DEBUG_WARNING("Removed %d physX actor descriptor(s) still remaining in destroyed ApexScene.", zombieActorCount);
+		}
+		if (zombieShapeCount)
+		{
+			APEX_DEBUG_WARNING("Removed %d physX shape descriptor(s) still remaining in destroyed ApexScene.", zombieShapeCount);
+		}
+
+	}
+#endif
+	while (mModuleScenes.size())
+	{
+		mModuleScenes.back()->release();
+	}
+
+
+
+	freeTasks();
+
+#if PX_PHYSICS_VERSION_MAJOR == 0
+	mTaskManager->release();
+#else
+	setPhysXScene(NULL);
+#endif
+
+	PX_DELETE(this);
+}
+
+
+void ApexScene::updateGravity()
+{
+#if PX_PHYSICS_VERSION_MAJOR == 3
+	WRITE_ZONE();
+	if (mPhysXScene == NULL)
+	{
+		return;
+	}
+	SCOPED_PHYSX_LOCK_READ(mPhysXScene);
+
+	mGravity = mPhysXScene->getGravity();
+#endif
+}
+
+
+void ApexScene::simulate(float elapsedTime, 
+						 bool finalStep, 
+						 PxBaseTask *completionTask,
+						 void* scratchMemBlock, 
+						 uint32_t scratchMemBlockSize)
+{
+	PX_UNUSED(scratchMemBlock);
+	PX_UNUSED(scratchMemBlockSize);
+
+	WRITE_ZONE();
+	if (mApexSDK->getApexPvdClient())
+		mApexSDK->getApexPvdClient()->beginFrame(this);
+
+	PX_PROFILE_ZONE("ApexScene::simulate", GetInternalApexSDK()->getContextId());
+
+	// reset the APEX simulation time timer
+	APEX_CHECK_STAT_TIMER("--------- Set mApexSimulateTickCount");
+	mApexSimulateTickCount = Time::getCurrentCounterValue();
+
+	mFinalStep = finalStep;
+
+	if (mSimulating)
+		return;
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+	if (!mPhysXScene)
+		return;
+#endif
+	{
+		updateGravity();
+	}
+
+	uint32_t manualSubsteps = 0;
+	float substepSize = elapsedTime;
+
+	// Wait for all post-fetchResults() tasks to complete before allowing the next
+	// simulation step to continue;
+	mSimulationComplete.wait();
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+	// make sure we use the apex user notify... if the application
+	// changes their custom one make sure we map to it.
+	mUserNotify.setBatchAppNotify(manualSubsteps > 1);
+#if APEX_UE4
+		// Why do we need this check if we'll return earlier in case when mPhysXScene == NULL ? Line: 1177
+	if (getPhysXScene())
+#endif
+	{
+		SCOPED_PHYSX_LOCK_WRITE(this);
+		PxSimulationEventCallback* userNotify = getPhysXScene()->getSimulationEventCallback();
+		if (userNotify != &mUserNotify)
+		{
+			mUserNotify.setApplicationNotifier(userNotify);
+			getPhysXScene()->setSimulationEventCallback(&mUserNotify);
+		}
+		PxContactModifyCallback* userContactModify = getPhysXScene()->getContactModifyCallback();
+		if (userContactModify != &mUserContactModify)
+		{
+			mUserContactModify.setApplicationContactModify(userContactModify);
+			getPhysXScene()->setContactModifyCallback(&mUserContactModify);
+		}
+	}
+#endif
+
+	mElapsedTime = elapsedTime;
+	mPhysXSimulateTime = elapsedTime;
+	mFetchResultsReady.reset();
+	mSimulationComplete.reset();
+	mSimulating = true;
+
+	for (uint32_t i = 0 ; i < mModuleScenes.size() ; i++)
+		mModuleScenes[i]->simulate(elapsedTime);
+
+	// reset dependcies after mModuleScenes[i]->simulate, so they get a chance
+	// to wait for running tasks from last frame
+	mTaskManager->resetDependencies();
+
+	/* Submit APEX scene tasks */
+	mTaskManager->submitNamedTask(mPhysXSimulate, mPhysXSimulate->getName());
+#if APEX_DURING_TICK_TIMING_FIX
+	mTaskManager->submitNamedTask(mDuringTickComplete, mDuringTickComplete->getName());
+#endif
+	mTaskManager->submitNamedTask(mCheckResults, mCheckResults->getName());
+	mTaskManager->submitNamedTask(mFetchResults, mFetchResults->getName());
+
+	mPhysXSimulate->setElapsedTime(manualSubsteps > 0 ? substepSize : elapsedTime);
+
+	for (uint32_t i = 0 ; i < mModuleScenes.size() ; i++)
+		mModuleScenes[i]->submitTasks(elapsedTime, substepSize, PxMax(manualSubsteps, 1u));
+
+	for (uint32_t i = 0 ; i < mModuleScenes.size() ; i++)
+		mModuleScenes[i]->setTaskDependencies();
+
+	/* Build scene dependency graph */
+	mCheckResults->startAfter(mPhysXSimulate->getTaskID());
+
+#if APEX_DURING_TICK_TIMING_FIX
+	/**
+	*	Tasks that run during the PhysX tick (that start after mPhysXSimulate) should 
+	*	"finishBefore" mDuringTickComplete.  
+	*/
+	mDuringTickComplete->startAfter(mPhysXSimulate->getTaskID());
+	mFetchResults->startAfter(mDuringTickComplete->getTaskID());
+#endif
+
+	mFetchResults->startAfter(mPhysXSimulate->getTaskID());
+	mFetchResults->startAfter(mCheckResults->getTaskID());
+
+	if (manualSubsteps > 1)
+	{
+		PX_ASSERT(mBetweenstepTasks != NULL);
+		mBetweenstepTasks->setSubstepSize(substepSize, manualSubsteps);
+
+		mBetweenstepTasks->setFollower(1, mCheckResults);
+		mCheckResults->addReference(); // make sure checkresults waits until the last immediate step
+	}
+	mPhysXSimulate->setFollowingTask(manualSubsteps > 1 ? mBetweenstepTasks : NULL);
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+	mPhysXSimulate->setScratchBlock(scratchMemBlock, scratchMemBlockSize);
+#endif
+	mFetchResults->setFollowingTask(completionTask);
+
+	{
+		PX_PROFILE_ZONE("ApexScene::TaskManager::startSimulation", GetInternalApexSDK()->getContextId());
+		mTaskManager->startSimulation();
+	}
+}
+
+
+struct ApexPvdClientEndFrameSender
+{
+	pvdsdk::ApexPvdClient*	mBinding;
+	void*				mInstance;
+	ApexPvdClientEndFrameSender(pvdsdk::ApexPvdClient* inBinding, void* inInst)
+		: mBinding(inBinding)
+		, mInstance(inInst)
+	{
+	}
+	~ApexPvdClientEndFrameSender()
+	{
+		if (mBinding)
+		{
+			mBinding->endFrame(mInstance);
+		}
+	}
+};
+
+
+bool ApexScene::fetchResults(bool block, uint32_t* errorState)
+{
+	WRITE_ZONE();
+#if PX_PHYSICS_VERSION_MAJOR == 3
+	if (!mPhysXScene)
+	{
+		return false;
+	}
+#endif
+
+	{
+		StatValue dataVal;
+		if (mFetchResultsReady.wait(0))
+		{
+			dataVal.Float = 0.0f;    // fetchResults was called before simulation was done
+		}
+		else
+		{
+			dataVal.Float = ApexScene::ticksToMilliseconds(mApexSimulateTickCount, Time::getCurrentCounterValue());
+		}
+		setApexStatValue(UserDelayedFetchTime, dataVal);
+	}
+
+	if (checkResults(block) == false || !mSimulating)
+	{
+		return false;
+	}
+
+	//absolutely, at function exit, ensure we send the eof marker.
+	//PVD needs the EOF marker sent *after* the last fetch results in order to associate this fetch results
+	//with this frame.
+	//If you change the order of the next two statements it will confuse PVD and your frame will look tremendously
+	//long.
+	ApexPvdClientEndFrameSender theEnsureEndFrameIsSent(mApexSDK->getApexPvdClient(), this);
+	PX_PROFILE_ZONE("ApexScene::fetchResults", GetInternalApexSDK()->getContextId());
+
+	// reset simulation timer to measure fetchResults time
+	APEX_CHECK_STAT_TIMER("--------- Set fetchTime");
+	uint64_t fetchTime = Time::getCurrentCounterValue();
+
+	// reset simulation
+	mSimulating = false;
+	if (errorState)
+	{
+		*errorState = 0;
+	}
+
+	// TODO: Post-FetchResults tasks must set this, if/when we support them.
+	mSimulationComplete.set();
+
+	for (uint32_t i = 0 ; i < mModuleScenes.size() ; i++)
+	{
+		mModuleScenes[i]->fetchResultsPreRenderLock();
+	}
+
+	for (uint32_t i = 0 ; i < mModuleScenes.size() ; i++)
+	{
+		mModuleScenes[i]->lockRenderResources();
+	}
+#if PX_PHYSICS_VERSION_MAJOR == 3
+	if (mPhysXScene != NULL)
+	{
+		PX_PROFILE_ZONE("PhysXScene::fetchResults", GetInternalApexSDK()->getContextId());
+		
+		SCOPED_PHYSX_LOCK_WRITE(this);
+		mPhysXScene->fetchResults(true);
+		// SJB TODO3.0
+		mPxStepWasValid	= true;
+		// Check if PhysX actually ran any substeps. (nbSubSteps is the amount of substeps ran during the last simulation)
+		/*float maxTimeStep;
+		uint32_t nbSubSteps, maxIter;
+		NxTimeStepMethod method;
+		mPhysXScene->getTiming(maxTimeStep, maxIter, method, &nbSubSteps);
+
+		mPxStepWasValid = (nbSubSteps > 0);*/
+
+		mPxAccumElapsedTime += mElapsedTime;
+
+		if (mPxStepWasValid)
+		{
+			mPxLastElapsedTime = mPxAccumElapsedTime;
+			mPxAccumElapsedTime = 0.0f;
+
+			if (mTimeRemainder + mPxLastElapsedTime > 0.001f)
+			{
+				uint32_t elapsedMS = (uint32_t)((1000.0f) * (mTimeRemainder + mPxLastElapsedTime));
+				mTotalElapsedMS += elapsedMS;
+				mTimeRemainder = (mTimeRemainder + mPxLastElapsedTime) - (float)elapsedMS * 0.001f;
+			}
+		}
+
+		// restore the application user callbacks.
+		mPhysXScene->setSimulationEventCallback(mUserNotify.getApplicationNotifier());
+		mPhysXScene->setContactModifyCallback(mUserContactModify.getApplicationContactModify());
+
+		mUserNotify.playBatchedNotifications();
+	}
+#endif
+
+	{
+		StatValue dataVal;
+		{
+			dataVal.Float = ApexScene::ticksToMilliseconds(fetchTime, Time::getCurrentCounterValue());
+			APEX_CHECK_STAT_TIMER("--------- PhysXFetchResultTime (fetchTime)");
+		}
+		setApexStatValue(PhysXFetchResultTime, dataVal);
+	}
+
+	// reset simulation timer to measure fetchResults time
+	APEX_CHECK_STAT_TIMER("--------- Set mApexSimulateTickCount");
+	mApexSimulateTickCount = Time::getCurrentCounterValue();
+
+	fetchPhysXStats();
+
+	for (uint32_t i = 0 ; i < mModuleScenes.size() ; i++)
+	{
+		mModuleScenes[i]->fetchResults();    // update render bounds, trigger callbacks, etc
+	}
+
+	for (uint32_t i = 0 ; i < mModuleScenes.size() ; i++)
+	{
+		mModuleScenes[i]->unlockRenderResources();
+	}
+
+	for (uint32_t i = 0 ; i < mModuleScenes.size() ; i++)
+	{
+		mModuleScenes[i]->fetchResultsPostRenderUnlock();
+	}
+
+	mTaskManager->stopSimulation();
+
+	if (mApexSDK->isApexStatsEnabled())
+	{
+		fetchApexStats();
+	}
+
+#if APEX_CUDA_SUPPORT && !defined(INSTALLER)
+	mCudaTestManager->nextFrame();
+	mCudaProfileManager->nextFrame();
+#endif
+
+	return true;
+}
+
+
+
+void ApexScene::fetchPhysXStats()
+{
+	WRITE_ZONE();
+	PX_PROFILE_ZONE("ApexScene::fetchPhysXStats", GetInternalApexSDK()->getContextId()); 
+	StatValue dataVal;
+
+	// get the number of shapes and add it to the ApexStats
+	uint32_t nbShapes = 0;
+	uint32_t nbPairs = 0;
+	uint32_t nbAwakeShapes = 0;
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+# if USE_MANUAL_ACTOR_LOOP
+	uint32_t nbActors = 0;
+	static const PxActorTypeSelectionFlags	flags = PxActorTypeSelectionFlag::eRIGID_STATIC
+		| PxActorTypeSelectionFlag::eRIGID_DYNAMIC;
+
+	if (mPhysXScene)
+	{
+		nbActors = mPhysXScene->getNbActors(flags);
+	}
+
+	if (nbActors)
+	{
+		PxActor**	actorArray	= (PxActor**)PxAlloca(sizeof(PxActor*) * nbActors);
+		mPhysXScene->getActors(flags, actorArray, nbActors);
+
+		for (uint32_t actorIndex = 0; actorIndex < nbActors; ++actorIndex)
+		{
+			PxRigidActor* rigidActor	= actorArray[actorIndex]->is<physx::PxRigidActor>();
+			if (rigidActor)
+			{
+				nbShapes += rigidActor->getNbShapes();
+			}
+
+			PxRigidDynamic*	dynamic		= actorArray[actorIndex]->is<physx::PxRigidDynamic>();
+			if (dynamic && !dynamic->isSleeping())
+			{
+				nbAwakeShapes	+= dynamic->getNbShapes();
+			}
+		}
+	}
+# else
+	physx::PxSimulationStatistics sceneStats;
+	if (mPhysXScene)
+	{
+		SCOPED_PHYSX_LOCK_READ(mPhysXScene);
+		mPhysXScene->getSimulationStatistics(sceneStats);
+		nbShapes = sceneStats.nbDynamicBodies;
+		nbAwakeShapes = sceneStats.nbActiveDynamicBodies;
+		nbPairs = 0;
+		for (PxGeometryType::Enum i = PxGeometryType::eSPHERE; i < PxGeometryType::eGEOMETRY_COUNT; i = (PxGeometryType::Enum)(i + 1))
+		{
+			nbPairs += sceneStats.getRbPairStats(physx::PxSimulationStatistics::eDISCRETE_CONTACT_PAIRS, PxGeometryType::eCONVEXMESH, i);
+		}
+	}
+# endif
+#endif
+
+	dataVal.Int = (int32_t)nbShapes;
+	setApexStatValue(NumberOfShapes, dataVal);
+
+	dataVal.Int = (int32_t)nbAwakeShapes;
+	setApexStatValue(NumberOfAwakeShapes, dataVal);
+
+	dataVal.Int = (int32_t)nbPairs;
+	setApexStatValue(NumberOfCpuShapePairs, dataVal);
+
+	dataVal.Int = 0;
+	setApexStatValue(RbThroughput, dataVal);
+}
+
+
+
+void ApexScene::fetchApexStats()
+{
+	WRITE_ZONE();
+	PX_PROFILE_ZONE("ApexScene::fetchApexStats", GetInternalApexSDK()->getContextId());
+	StatValue dataVal;
+
+	// get the number of actors and add it to the ApexStats
+	dataVal.Int = (int32_t)mActorArray.size();
+	setApexStatValue(NumberOfActors, dataVal);
+
+
+	uint64_t qpc = Time::getCurrentCounterValue();
+	dataVal.Float = ApexScene::ticksToMilliseconds(mApexSimulateTickCount, qpc);
+	APEX_CHECK_STAT_TIMER("--------- ApexPostTickTime (mApexSimulateTickCount)");
+
+	APEX_CHECK_STAT_TIMER("--------- Set mApexSimulateTickCount");
+	mApexSimulateTickCount = qpc;
+	setApexStatValue(ApexPostTickTime, dataVal);
+
+	//ModuleScenes can also generate stats. So let's collect and add those stats here.
+
+	for (uint32_t i = 0; i < mModuleScenes.size(); i++)
+	{
+		SceneStats* moduleSceneStats;
+		moduleSceneStats = mModuleScenes[i]->getStats();
+
+		if (moduleSceneStats)
+		{
+			//O(n^2), rewrite to use a hash if num stats gets much larger
+			for (uint32_t j = 0; j < moduleSceneStats->numApexStats; j++)
+			{
+				StatsInfo& moduleSceneStat = moduleSceneStats->ApexStatsInfoPtr[j];
+
+				uint32_t k = 0;
+				while (k != mApexSceneStats.numApexStats && nvidia::strcmp(mApexSceneStats.ApexStatsInfoPtr[k].StatName, moduleSceneStats->ApexStatsInfoPtr[j].StatName) != 0)
+				{
+					k++;
+				}
+				bool found = (k != mApexSceneStats.numApexStats);
+
+				if (found)
+				{
+					StatsInfo& sceneStat = mApexSceneStats.ApexStatsInfoPtr[k];
+
+					PX_ASSERT(sceneStat.StatType == moduleSceneStat.StatType);
+
+					if (sceneStat.StatType == StatDataType::FLOAT)
+					{
+						sceneStat.StatCurrentValue.Float += moduleSceneStat.StatCurrentValue.Float;
+					}
+					else if (sceneStat.StatType == StatDataType::INT)
+					{
+						sceneStat.StatCurrentValue.Int += moduleSceneStat.StatCurrentValue.Int;
+					}
+				}
+			}
+		}
+	}
+}
+
+
+
+bool ApexScene::checkResults(bool block) const
+{
+//	PX_PROFILE_ZONE("ApexScene::checkResults", GetInternalApexSDK()->getContextId());
+
+	uint32_t waitTime = block ? Sync::waitForever : 0;
+	if (!mSimulating)
+	{
+		return true;
+	}
+	else
+	{
+		return mFetchResultsReady.wait(waitTime);
+	}
+}
+
+void ApexScene::lockRenderResources()
+{
+#ifndef WITHOUT_DEBUG_VISUALIZE
+	if (mSceneRenderDebug)
+	{
+		mSceneRenderDebug->lockRenderResources();
+	}
+#endif
+	checkResults(true);
+}
+
+void ApexScene::unlockRenderResources()
+{
+#ifndef WITHOUT_DEBUG_VISUALIZE
+	if (mSceneRenderDebug)
+	{
+		mSceneRenderDebug->unlockRenderResources();
+	}
+#endif
+}
+
+void ApexScene::updateRenderResources(bool rewriteBuffers, void* userRenderData)
+{
+	URR_SCOPE;
+
+#ifdef WITHOUT_DEBUG_VISUALIZE
+	PX_UNUSED(rewriteBuffers);
+	PX_UNUSED(userRenderData);
+#else
+	visualize();
+
+	if (mSceneRenderDebug)
+	{
+		mSceneRenderDebug->updateRenderResources(rewriteBuffers, userRenderData);
+	}
+#endif
+}
+
+void ApexScene::dispatchRenderResources(UserRenderer& renderer)
+{
+#ifdef WITHOUT_DEBUG_VISUALIZE
+	PX_UNUSED(renderer);
+#else
+	if (mSceneRenderDebug)
+	{
+		mSceneRenderDebug->dispatchRenderResources(renderer);
+	}
+#endif
+}
+
+void ApexScene::visualize()
+{
+#ifndef WITHOUT_DEBUG_VISUALIZE
+	if (mSceneRenderDebug && mDebugRenderParams->Enable && mDebugRenderParams->Scale!= 0.0f)
+	{
+		const physx::PxMat44& savedPose = *RENDER_DEBUG_IFACE(mSceneRenderDebug)->getPoseTyped();
+		RENDER_DEBUG_IFACE(mSceneRenderDebug)->setIdentityPose();
+		if (mDebugRenderParams->Bounds)
+		{
+			RENDER_DEBUG_IFACE(mSceneRenderDebug)->setCurrentColor(0xFFFFFF);
+			for (uint32_t i = 0; i < mActorArray.size(); ++i)
+			{
+				ApexActor* actor = mActorArray[i];
+				RENDER_DEBUG_IFACE(mSceneRenderDebug)->debugBound(actor->getBounds());
+			}
+		}
+
+		for (ModuleSceneIntl** it = mModuleScenes.begin(); it != mModuleScenes.end(); ++it)
+		{
+			(*it)->visualize();
+		}
+		RENDER_DEBUG_IFACE(mSceneRenderDebug)->setPose(savedPose);
+	}
+#endif
+}
+
+PxBounds3 ApexScene::getBounds() const
+{
+	READ_ZONE();
+#ifdef WITHOUT_DEBUG_VISUALIZE
+	PxBounds3 bound = PxBounds3::empty();
+#else
+	PxBounds3 bound = mSceneRenderDebug->getBounds();
+#endif
+
+	return bound;
+}
+
+
+void ApexScene::allocateTasks()
+{
+	mCheckResults = PX_NEW(CheckResultsTask)(*this);
+	mPhysXSimulate = PX_NEW(PhysXSimulateTask)(*this, *mCheckResults);
+	mBetweenstepTasks = PX_NEW(PhysXBetweenStepsTask)(*this);
+#if APEX_DURING_TICK_TIMING_FIX
+	mDuringTickComplete = PX_NEW(DuringTickCompleteTask)(*this);
+#endif
+	mFetchResults = PX_NEW(FetchResultsTask)(*this);
+}
+
+void ApexScene::freeTasks()
+{
+	if (mPhysXSimulate != NULL)
+	{
+		delete mPhysXSimulate;
+		mPhysXSimulate = NULL;
+	}
+
+	if (mBetweenstepTasks != NULL)
+	{
+		delete mBetweenstepTasks;
+		mBetweenstepTasks = NULL;
+	}
+
+#if APEX_DURING_TICK_TIMING_FIX
+	if (mDuringTickComplete != NULL)
+	{
+		delete mDuringTickComplete;
+		mDuringTickComplete = NULL;
+	}
+#endif
+
+	if (mCheckResults != NULL)
+	{
+		delete mCheckResults;
+		mCheckResults = NULL;
+	}
+
+	if (mFetchResults != NULL)
+	{
+		delete mFetchResults;
+		mFetchResults = NULL;
+	}
+}
+
+void	ApexScene::setUseDebugRenderable(bool state)
+{
+	WRITE_ZONE();
+	mUseDebugRenderable = state;
+	if (mSceneRenderDebug)
+	{
+#if !defined(WITHOUT_DEBUG_VISUALIZE)
+		mSceneRenderDebug->setUseDebugRenderable(state);
+#endif
+	}
+}
+
+uint32_t ApexScene::getSeed()
+{
+	return (uint32_t)(Time::getCurrentCounterValue() & 0xFFFFFFFF );
+	//return IgnoredSeed != mSeed ? mSeed : (uint32_t)(1000 * getElapsedTime());
+}
+
+ModuleSceneIntl* ApexScene::getInternalModuleScene(const char* moduleName)
+{
+	ApexSimpleString str1(moduleName);
+	for (uint32_t i = 0; i < mModuleScenes.size(); i++)
+	{
+		ApexSimpleString str2(mModuleScenes[i]->getModule()->getName());
+		if (str1 == str2)
+		{
+			return mModuleScenes[i];
+		}
+	}
+	return NULL;
+}
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+
+void	ApexScene::addActorPair(PxActor *actor0,PxActor *actor1)
+{
+	WRITE_ZONE();
+	mPairFilter.addPair(PTR_TO_UINT64(actor0),PTR_TO_UINT64(actor1));
+}
+
+void	ApexScene::removeActorPair(PxActor *actor0,PxActor *actor1)
+{
+	WRITE_ZONE();
+	mPairFilter.removePair(PTR_TO_UINT64(actor0), PTR_TO_UINT64(actor1));
+}
+
+bool	ApexScene::findActorPair(PxActor *actor0,PxActor *actor1) const
+{
+	READ_ZONE();
+	return mPairFilter.findPair(PTR_TO_UINT64(actor0), PTR_TO_UINT64(actor1));
+}
+
+MirrorScene *ApexScene::createMirrorScene(nvidia::apex::Scene &mirrorScene,
+											MirrorScene::MirrorFilter &mirrorFilter,
+											float mirrorStaticDistance,
+											float mirrorDynamicDistance,
+											float mirrorDistanceThreshold)
+{
+	WRITE_ZONE();
+	MirrorSceneImpl *ms = PX_NEW(MirrorSceneImpl)(*getPhysXScene(),*mirrorScene.getPhysXScene(),mirrorFilter,mirrorStaticDistance,mirrorDynamicDistance,mirrorDistanceThreshold);
+	return static_cast< MirrorScene *>(ms);
+}
+
+#endif
+
+}
+} // end namespace nvidia::apex
diff --git a/APEX_1.4/framework/src/ApexSceneTasks.cpp b/APEX_1.4/framework/src/ApexSceneTasks.cpp
new file mode 100644
index 00000000..854ddfc8
--- /dev/null
+++ b/APEX_1.4/framework/src/ApexSceneTasks.cpp
@@ -0,0 +1,313 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "ApexSceneTasks.h"
+#include "FrameworkPerfScope.h"
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+#include "ScopedPhysXLock.h"
+#endif
+
+#include "PsTime.h"
+
+namespace nvidia
+{
+namespace apex
+{
+
+// --------- PhysXSimulateTask
+
+PhysXSimulateTask::PhysXSimulateTask(ApexScene& scene, CheckResultsTask& checkResultsTask) 
+: mScene(&scene)
+, mElapsedTime(0.0f)
+, mFollowingTask(NULL)
+, mCheckResultsTask(checkResultsTask) 
+#if PX_PHYSICS_VERSION_MAJOR == 3
+, mScratchBlock(NULL)
+, mScratchBlockSize(0)
+#endif
+{}
+
+PhysXSimulateTask::~PhysXSimulateTask() 
+{
+#if PX_PHYSICS_VERSION_MAJOR == 3
+	mScratchBlock = NULL;
+	mScratchBlockSize = 0;
+#endif
+}
+
+const char* PhysXSimulateTask::getName() const
+{
+	return AST_PHYSX_SIMULATE;
+}
+
+
+void PhysXSimulateTask::run()
+{
+	// record the pretick APEX time
+	StatValue dataVal;
+	uint64_t qpc = Time::getCurrentCounterValue();
+	dataVal.Float = ApexScene::ticksToMilliseconds(mScene->mApexSimulateTickCount, qpc);
+	APEX_CHECK_STAT_TIMER("--------- ApexBeforeTickTime (mApexSimulateTickCount)");
+	
+	APEX_CHECK_STAT_TIMER("--------- Set mApexSimulateTickCount");
+	mScene->mApexSimulateTickCount = qpc;
+
+	mScene->setApexStatValue(ApexScene::ApexBeforeTickTime, dataVal);
+
+	// start the PhysX simulation time timer
+	APEX_CHECK_STAT_TIMER("--------- Set mPhysXSimulateTickCount");
+	mScene->mPhysXSimulateTickCount = Time::getCurrentCounterValue();
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+	if (mScene->mPhysXScene)
+	{
+		PX_ASSERT(mElapsedTime >= 0.0f);
+		SCOPED_PHYSX_LOCK_WRITE(mScene);
+	#if APEX_UE4
+		if (mScene->mPhysXScene->getNbActors(PxActorTypeFlags(0xff)))
+			mScene->mPhysXScene->simulate(mElapsedTime, &mCheckResultsTask, mScratchBlock, mScratchBlockSize, false);
+		else
+			mCheckResultsTask.removeReference();
+	#else
+		mScene->mPhysXScene->simulate(mElapsedTime, &mCheckResultsTask, mScratchBlock, mScratchBlockSize, false);
+	#endif
+	}
+#endif
+
+#if PX_PHYSICS_VERSION_MAJOR == 0
+	if (mFollowingTask != NULL)
+	{
+		mFollowingTask->removeReference();
+	}
+#endif
+}
+
+
+
+void PhysXSimulateTask::setElapsedTime(float elapsedTime)
+{
+	PX_ASSERT(elapsedTime >= 0.0f);
+	mElapsedTime = elapsedTime;
+}
+
+
+
+void PhysXSimulateTask::setFollowingTask(PxBaseTask* following)
+{
+	mFollowingTask = following;
+}
+
+
+
+// --------- CheckResultsTask
+
+const char* CheckResultsTask::getName() const
+{
+	return AST_PHYSX_CHECK_RESULTS;
+}
+
+
+void CheckResultsTask::run()
+{
+#if !APEX_DURING_TICK_TIMING_FIX
+	{
+		// mark the end of the "during tick" simulation time
+		StatValue dataVal;
+		{
+			uint64_t qpc = Time::getCurrentCounterValue();
+			dataVal.Float = ApexScene::ticksToSeconds(mScene->mApexSimulateTickCount, qpc);
+			APEX_CHECK_STAT_TIMER("--------- ApexDuringTickTime (mApexSimulateTickCount)");
+
+			APEX_CHECK_STAT_TIMER("--------- Set mApexSimulateTickCount");
+			mScene->mApexSimulateTickCount = qpc;
+		}
+		mScene->setApexStatValue(ApexScene::ApexDuringTickTime, dataVal);
+	}
+#endif
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+	{
+		SCOPED_PHYSX_LOCK_WRITE(mScene);
+		if (mScene->mPhysXScene
+#if APEX_UE4		
+			&& mScene->mPhysXScene->getNbActors(PxActorTypeFlags(0xff))
+#endif
+		)
+			mScene->mPhysXScene->checkResults(true);
+	}
+#endif
+
+	// get the PhysX simulation time and add it to the ApexStats
+	{
+		StatValue dataVal;
+		{
+			uint64_t qpc = Time::getCurrentCounterValue();
+			dataVal.Float = ApexScene::ticksToMilliseconds(mScene->mPhysXSimulateTickCount, qpc);
+			APEX_CHECK_STAT_TIMER("--------- PhysXSimulationTime (mPhysXSimulateTickCount)");
+		}
+
+		mScene->setApexStatValue(ApexScene::PhysXSimulationTime, dataVal);
+	}
+}
+
+
+
+// --------- FetchResultsTask
+
+const char* FetchResultsTask::getName() const
+{
+	return AST_PHYSX_FETCH_RESULTS;
+}
+
+
+void FetchResultsTask::run()
+{
+}
+
+
+void FetchResultsTask::setFollowingTask(PxBaseTask* following)
+{
+	mFollowingTask = following;
+	if (mFollowingTask)
+	{
+		mFollowingTask->addReference();
+	}
+}
+
+
+
+/*
+* \brief Called by dispatcher after Task has been run.
+*
+* If you re-implement this method, you must call this base class
+* version before returning.
+*/
+void FetchResultsTask::release()
+{
+	PxTask::release();
+
+	// copy mFollowingTask into local variable, because it might be overwritten
+	// as soon as mFetchResultsReady.set() is called (and before removeReference() is called on it)
+	PxBaseTask* followingTask = mFollowingTask;
+	mFollowingTask = NULL;
+
+	// Allow ApexScene::fetchResults() to run (potentially unblocking game thread)
+	mScene->mFetchResultsReady.set();
+	
+	// remove reference to the scene completion task submitted in Scene::simulate
+	// this must be done after the scene's mFetchResultsReady event is set so that the
+	// app's completion task can be assured that fetchResults is ready to run
+	if (followingTask)
+	{
+		followingTask->removeReference();
+	}	
+}
+
+
+
+#if APEX_DURING_TICK_TIMING_FIX
+// --------- DuringTickCompleteTask
+
+const char* DuringTickCompleteTask::getName() const
+{
+	return AST_DURING_TICK_COMPLETE;
+}
+
+
+
+void DuringTickCompleteTask::run()
+{
+	// mark the end of the "during tick" simulation time
+	StatValue dataVal;
+	uint64_t qpc = Time::getCurrentCounterValue();
+	dataVal.Float = ApexScene::ticksToMilliseconds(mScene->mApexSimulateTickCount, qpc);
+	APEX_CHECK_STAT_TIMER("--------- ApexDuringTickTime (mApexSimulateTickCount)");
+
+	APEX_CHECK_STAT_TIMER("--------- Set mApexSimulateTickCount");
+	mScene->mApexSimulateTickCount = qpc;
+	
+	mScene->setApexStatValue(ApexScene::ApexDuringTickTime, dataVal);
+}
+#endif
+
+
+// --------- PhysXBetweenStepsTask
+
+const char* PhysXBetweenStepsTask::getName() const
+{
+	return AST_PHYSX_BETWEEN_STEPS;
+}
+
+
+
+void PhysXBetweenStepsTask::run()
+{
+	PX_ASSERT(mSubStepSize > 0.0f);
+	PX_ASSERT(mNumSubSteps > 0);
+#if PX_PHYSICS_VERSION_MAJOR == 3
+	PxScene* scene = mScene.getPhysXScene();
+
+	if (scene != NULL)
+	{
+		while (mSubStepNumber < mNumSubSteps)
+		{
+			PX_PROFILE_ZONE("ApexSceneManualSubstep", GetInternalApexSDK()->getContextId());
+			// fetch the first substep
+			uint32_t errorState = 0;
+			{
+				SCOPED_PHYSX_LOCK_WRITE(&mScene);
+				scene->fetchResults(true, &errorState);
+			}
+			PX_ASSERT(errorState == 0);
+
+			for (uint32_t i = 0; i < mScene.mModuleScenes.size(); i++)
+			{
+				PX_PROFILE_ZONE("ModuleSceneManualSubstep", GetInternalApexSDK()->getContextId());
+				mScene.mModuleScenes[i]->interStep(mSubStepNumber, mNumSubSteps);
+			}
+
+			// run the next substep
+			{
+				SCOPED_PHYSX_LOCK_WRITE(&mScene);
+				scene->simulate(mSubStepSize);
+			}
+
+			mSubStepNumber++;
+		}
+	}
+#endif
+
+	mLast->removeReference(); // decrement artificially high ref count that prevented checkresults from being executed
+}
+
+
+
+void PhysXBetweenStepsTask::setSubstepSize(float substepSize, uint32_t numSubSteps)
+{
+	mSubStepSize = substepSize;
+	mNumSubSteps = numSubSteps;
+}
+
+
+
+void PhysXBetweenStepsTask::setFollower(uint32_t substepNumber, PxTask* last)
+{
+	mSubStepNumber = substepNumber;
+	mLast = last;
+
+	setContinuation(last);
+}
+
+
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/ApexSceneUserNotify.cpp b/APEX_1.4/framework/src/ApexSceneUserNotify.cpp
new file mode 100644
index 00000000..12cf2469
--- /dev/null
+++ b/APEX_1.4/framework/src/ApexSceneUserNotify.cpp
@@ -0,0 +1,335 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "ApexDefs.h"
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+
+#pragma warning(push)
+#pragma warning(disable: 4324)
+
+#include <ApexSceneUserNotify.h>
+#include "PxPreprocessor.h"
+#include <PxJoint.h>
+#include <PxScene.h>
+
+namespace nvidia
+{
+namespace apex
+{
+	using namespace physx;
+
+ApexSceneUserNotify::~ApexSceneUserNotify(void)
+{
+	// All callbacks should have been removed by now... something is wrong.
+	PX_ASSERT(mModuleNotifiers.size() == 0);
+}
+
+void ApexSceneUserNotify::addModuleNotifier(PxSimulationEventCallback& notify)
+{
+	mModuleNotifiers.pushBack(&notify);
+}
+
+void ApexSceneUserNotify::removeModuleNotifier(PxSimulationEventCallback& notify)
+{
+	const uint32_t numNotifiers = mModuleNotifiers.size();
+	uint32_t found = numNotifiers;
+	for (uint32_t i = 0; i < numNotifiers; i++)
+	{
+		if (mModuleNotifiers[i] == &notify)
+		{
+			found = i;
+			break;
+		}
+	}
+	PX_ASSERT(found < numNotifiers);
+	if (found < numNotifiers)
+	{
+		mModuleNotifiers.replaceWithLast(found);
+	}
+}
+
+void ApexSceneUserNotify::playBatchedNotifications()
+{
+#if TODO_HANDLE_NEW_CONTACT_STREAM
+	// onConstraintBreak
+	{
+		for (uint32_t i = 0; i < mBatchedBreakNotifications.size(); i++)
+		{
+			physx::PxConstraintInfo& constraintInfo = mBatchedBreakNotifications[i];
+			PX_ASSERT(mAppNotify != NULL);
+			mAppNotify->onConstraintBreak(&constraintInfo, 1);
+
+			/*
+			// apan, shold we release joint? how?
+			if (releaseJoint)
+			{
+			// scene isn't running anymore, guess we need to release the joint by hand.
+			notify.breakingJoint->getScene().releaseJoint(*notify.breakingJoint);
+			}
+			*/
+		}
+		// release if the array is too big
+		if (mBatchedBreakNotifications.size() * 4 < mBatchedBreakNotifications.capacity())
+		{
+			mBatchedBreakNotifications.shrink();
+		}
+
+		mBatchedBreakNotifications.clear();
+	}
+
+
+	// onContact
+	{
+		for (uint32_t i = 0; i < mBatchedContactNotifications.size(); i++)
+		{
+			BatchedContactNotification& contact = mBatchedContactNotifications[i];
+			PX_ASSERT(contact.batchedStreamStart < mBatchedContactStreams.size());
+			contact.batchedPair.stream = (PxConstContactStream)(mBatchedContactStreams.begin() + contact.batchedStreamStart);
+
+			mAppNotify->onContact(contact.batchedPair, contact.batchedEvents);
+		}
+		mBatchedContactNotifications.clear();
+		mBatchedContactStreams.clear();
+	}
+
+	// onSleep/onWake
+	{
+		for (uint32_t i = 0; i < mBatchedSleepWakeEventBorders.size(); i++)
+		{
+			const SleepWakeBorders border = mBatchedSleepWakeEventBorders[i];
+			if (border.sleepEvents)
+			{
+				mAppNotify->onSleep(&mBatchedSleepEvents[border.start], border.count);
+			}
+			else
+			{
+				mAppNotify->onWake(&mBatchedWakeEvents[border.start], border.count);
+			}
+		}
+		mBatchedSleepWakeEventBorders.clear();
+		mBatchedSleepEvents.clear();
+		mBatchedWakeEvents.clear();
+	}
+
+	// mBatchedTriggerReports
+	{
+		for (uint32_t i = 0; i < mBatchedTriggerReports.size(); i++)
+		{
+			PxTriggerPair& triggerPair = mBatchedTriggerReports[i];
+			mAppNotify->onTrigger(&triggerPair, 1);
+		}
+		mBatchedTriggerReports.clear();
+	}
+#endif
+}
+
+void ApexSceneUserNotify::onConstraintBreak(physx::PxConstraintInfo* constraints, uint32_t count)
+{
+	for (Array<PxSimulationEventCallback*>::Iterator curr = mModuleNotifiers.begin(); curr != mModuleNotifiers.end(); ++curr)
+	{
+		(*curr)->onConstraintBreak(constraints, count);
+	}
+
+	if (mAppNotify != NULL)
+	{
+		if (mBatchAppNotify)
+		{
+			for (uint32_t i = 0 ; i < count; i++)
+			{
+				mBatchedBreakNotifications.pushBack(constraints[i]);
+			}
+		}
+		else
+		{
+			mAppNotify->onConstraintBreak(constraints, count);
+		}
+	}
+}
+
+void ApexSceneUserNotify::onWake(PxActor** actors, uint32_t count)
+{
+	for (Array<PxSimulationEventCallback*>::Iterator curr = mModuleNotifiers.begin(); curr != mModuleNotifiers.end(); ++curr)
+	{
+		(*curr)->onWake(actors, count);
+	}
+
+	if (mAppNotify != NULL)
+	{
+		if (mBatchAppNotify)
+		{
+			SleepWakeBorders border(mBatchedWakeEvents.size(), count, false);
+			mBatchedSleepWakeEventBorders.pushBack(border);
+			mBatchedWakeEvents.resize(mBatchedWakeEvents.size() + count);
+			for (uint32_t i = 0; i < count; i++)
+			{
+				mBatchedWakeEvents.pushBack(actors[i]);
+			}
+		}
+		else
+		{
+			mAppNotify->onWake(actors, count);
+		}
+	}
+}
+
+void ApexSceneUserNotify::onSleep(PxActor** actors, uint32_t count)
+{
+	for (Array<PxSimulationEventCallback*>::Iterator curr = mModuleNotifiers.begin(); curr != mModuleNotifiers.end(); ++curr)
+	{
+		(*curr)->onSleep(actors, count);
+	}
+	if (mAppNotify)
+	{
+		if (mBatchAppNotify)
+		{
+			SleepWakeBorders border(mBatchedSleepEvents.size(), count, true);
+			mBatchedSleepWakeEventBorders.pushBack(border);
+			mBatchedSleepEvents.resize(mBatchedSleepEvents.size() + count);
+			for (uint32_t i = 0; i < count; i++)
+			{
+				mBatchedSleepEvents.pushBack(actors[i]);
+			}
+		}
+		else
+		{
+			mAppNotify->onSleep(actors, count);
+		}
+	}
+}
+
+
+void ApexSceneUserNotify::onContact(const physx::PxContactPairHeader& pairHeader, const PxContactPair* pairs, uint32_t nbPairs)
+{
+	for (Array<PxSimulationEventCallback*>::Iterator curr = mModuleNotifiers.begin(); curr != mModuleNotifiers.end(); ++curr)
+	{
+		(*curr)->onContact(pairHeader, pairs, nbPairs);
+	}
+
+	if (mAppNotify)
+	{
+		if (mBatchAppNotify)
+		{
+#if TODO_HANDLE_NEW_CONTACT_STREAM
+			mBatchedContactNotifications.pushBack(BatchedContactNotification(pairHeader, pairs, nbPairs));
+			const uint32_t length = pair.contactCount; //getContactStreamLength(pair.stream);
+			for (uint32_t i = 0; i < length; i++)
+			{
+				mBatchedContactStreams.pushBack(pair.stream[i]);
+			}
+#endif
+		}
+		else
+		{
+			mAppNotify->onContact(pairHeader, pairs, nbPairs);
+		}
+	}
+}
+
+
+#if TODO_HANDLE_NEW_CONTACT_STREAM
+class ApexContactStreamIterator : public PxContactStreamIterator
+{
+public:
+	ApexContactStreamIterator( PxConstContactStream streamIt) : PxContactStreamIterator(streamIt) { }
+
+	PxConstContactStream getStreamIt()	{	return streamIt; }
+};
+#endif
+
+void ApexSceneUserNotify::onTrigger(PxTriggerPair* pairs, uint32_t count)
+{
+	if (mAppNotify != NULL)
+	{
+		if (mBatchAppNotify)
+		{
+			for (uint32_t i = 0; i < count; i++)
+			{
+				mBatchedTriggerReports.pushBack(pairs[count]);
+			}
+		}
+		else
+		{
+			mAppNotify->onTrigger(pairs, count);
+		}
+	}
+}
+
+
+void ApexSceneUserNotify::onAdvance(const PxRigidBody*const* bodyBuffer, const PxTransform* poseBuffer, const PxU32 count)
+{
+	PX_UNUSED(bodyBuffer);
+	PX_UNUSED(poseBuffer);
+	PX_UNUSED(count);
+}
+
+
+
+
+ApexSceneUserContactModify::ApexSceneUserContactModify(void)
+{
+	mAppContactModify = 0;
+}
+
+ApexSceneUserContactModify::~ApexSceneUserContactModify(void)
+{
+	// All callbacks should have been removed by now... something is wrong.
+	PX_ASSERT(mModuleContactModify.size() == 0);
+}
+
+void ApexSceneUserContactModify::addModuleContactModify(PxContactModifyCallback& contactModify)
+{
+	mModuleContactModify.pushBack(&contactModify);
+}
+
+void ApexSceneUserContactModify::removeModuleContactModify(PxContactModifyCallback& contactModify)
+{
+	const uint32_t numContactModifies = mModuleContactModify.size();
+	uint32_t       found      = numContactModifies;
+	for (uint32_t i = 0; i < numContactModifies; i++)
+	{
+		if (mModuleContactModify[i] == &contactModify)
+		{
+			found = i;
+			break;
+		}
+	}
+	PX_ASSERT(found < numContactModifies);
+	if (found < numContactModifies)
+	{
+		mModuleContactModify.replaceWithLast(found);
+	}
+}
+
+void ApexSceneUserContactModify::setApplicationContactModify(PxContactModifyCallback* contactModify)
+{
+	mAppContactModify = contactModify;
+}
+
+void ApexSceneUserContactModify::onContactModify(PxContactModifyPair* const pairs, uint32_t count)
+{
+	for (Array<PxContactModifyCallback*>::Iterator curr = mModuleContactModify.begin(); curr != mModuleContactModify.end(); curr++)
+	{
+		(*curr)->onContactModify(pairs, count);
+	}
+	if (mAppContactModify)
+	{
+		mAppContactModify->onContactModify(pairs, count);
+	}
+}
+
+
+
+}
+} // namespace nvidia::apex
+#pragma warning(pop)
+
+#endif // PX_PHYSICS_VERSION_MAJOR == 3
\ No newline at end of file
diff --git a/APEX_1.4/framework/src/ApexVertexBuffer.cpp b/APEX_1.4/framework/src/ApexVertexBuffer.cpp
new file mode 100644
index 00000000..b5cba4ba
--- /dev/null
+++ b/APEX_1.4/framework/src/ApexVertexBuffer.cpp
@@ -0,0 +1,875 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "ApexVertexBuffer.h"
+
+#include "ApexSDKIntl.h"
+
+#include "VertexFormatParameters.h"
+
+#include <ParamArray.h>
+
+#include "PsMemoryBuffer.h"
+#include "Cof44.h"
+
+#include "BufferU8x1.h"
+#include "BufferU8x2.h"
+#include "BufferU8x3.h"
+#include "BufferU8x4.h"
+#include "BufferU16x1.h"
+#include "BufferU16x2.h"
+#include "BufferU16x3.h"
+#include "BufferU16x4.h"
+#include "BufferU32x1.h"
+#include "BufferU32x2.h"
+#include "BufferU32x3.h"
+#include "BufferU32x4.h"
+#include "BufferF32x1.h"
+#include "BufferF32x2.h"
+#include "BufferF32x3.h"
+#include "BufferF32x4.h"
+
+#include "ApexPermute.h"
+
+namespace nvidia
+{
+namespace apex
+{
+
+#ifdef _DEBUG
+#define VERIFY_PARAM(_A) PX_ASSERT(_A == NvParameterized::ERROR_NONE)
+#else
+#define VERIFY_PARAM(_A) _A
+#endif
+
+// Transform Vec3 by PxMat44Legacy
+PX_INLINE void transform_FLOAT3_by_PxMat44(FLOAT3_TYPE& dst, const FLOAT3_TYPE& src, const PxMat44& m)
+{
+	(PxVec3&)dst = m.transform((const PxVec3&)src);
+}
+
+// Transform Vec3 by PxMat33
+PX_INLINE void transform_FLOAT3_by_PxMat33(FLOAT3_TYPE& dst, const FLOAT3_TYPE& src, const PxMat33& m)
+{
+	(PxVec3&)dst = m * (const PxVec3&)src;
+}
+
+// Transform Vec4 (tangent) by PxMat33, ignoring tangent.w
+PX_INLINE void transform_FLOAT4_by_PxMat33(FLOAT4_TYPE& dst, const FLOAT4_TYPE& src, const PxMat33& m)
+{
+	const PxVec4 source = (const PxVec4&)src;
+	(PxVec4&)dst = PxVec4(m * source.getXYZ(), PxSign(m.getDeterminant()) * source.w);
+}
+
+// Transform Quat by PxMat33
+PX_INLINE void transform_FLOAT4_QUAT_by_PxMat33(FLOAT4_QUAT_TYPE& dst, const FLOAT4_QUAT_TYPE& src, const PxMat33& m)
+{
+	*((PxVec3*)&dst) = m * (*(const PxVec3*)&src.x);
+}
+
+// Multiply Vec3 by scalar
+PX_INLINE void transform_FLOAT3_by_float(FLOAT3_TYPE& dst, const FLOAT3_TYPE& src, const float& s)
+{
+	(PxVec3&)dst = s * (const PxVec3&)src;
+}
+
+// Transform signed normalized byte 3-vector by PxMat44Legacy
+PX_INLINE void transform_BYTE_SNORM3_by_PxMat44(BYTE_SNORM3_TYPE& dst, const BYTE_SNORM3_TYPE& src, const PxMat44& m)
+{
+	PxVec3 v;
+	convert_FLOAT3_from_BYTE_SNORM3((FLOAT3_TYPE&)v, src);
+	transform_FLOAT3_by_PxMat44((FLOAT3_TYPE&)v, (const FLOAT3_TYPE&)v, m);
+	convert_BYTE_SNORM3_from_FLOAT3(dst, (const FLOAT3_TYPE&)v);
+}
+
+// Transform signed normalized byte 3-vector by PxMat33
+PX_INLINE void transform_BYTE_SNORM3_by_PxMat33(BYTE_SNORM3_TYPE& dst, const BYTE_SNORM3_TYPE& src, const PxMat33& m)
+{
+	PxVec3 v;
+	convert_FLOAT3_from_BYTE_SNORM3((FLOAT3_TYPE&)v, src);
+	transform_FLOAT3_by_PxMat33((FLOAT3_TYPE&)v, (const FLOAT3_TYPE&)v, m);
+	convert_BYTE_SNORM3_from_FLOAT3(dst, (const FLOAT3_TYPE&)v);
+}
+
+// Transform signed normalized byte 4-vector by PxMat33
+PX_INLINE void transform_BYTE_SNORM4_by_PxMat33(BYTE_SNORM4_TYPE& dst, const BYTE_SNORM4_TYPE& src, const PxMat33& m)
+{
+	physx::PxVec4 v;
+	convert_FLOAT4_from_BYTE_SNORM4((FLOAT4_TYPE&)v, src);
+	transform_FLOAT4_by_PxMat33((FLOAT4_TYPE&)v, (const FLOAT4_TYPE&)v, m);
+	convert_BYTE_SNORM4_from_FLOAT4(dst, (const FLOAT4_TYPE&)v);
+}
+
+// Multiply signed normalized byte 3-vector by scalar
+PX_INLINE void transform_BYTE_SNORM3_by_float(BYTE_SNORM3_TYPE& dst, const BYTE_SNORM3_TYPE& src, const float& s)
+{
+	PxVec3 v;
+	convert_FLOAT3_from_BYTE_SNORM3((FLOAT3_TYPE&)v, src);
+	transform_FLOAT3_by_float((FLOAT3_TYPE&)v, (const FLOAT3_TYPE&)v, s);
+	convert_BYTE_SNORM3_from_FLOAT3(dst, (const FLOAT3_TYPE&)v);
+}
+
+// Transform signed normalized byte quat by PxMat33
+PX_INLINE void transform_BYTE_SNORM4_QUATXYZW_by_PxMat33(BYTE_SNORM4_QUATXYZW_TYPE& dst, const BYTE_SNORM4_QUATXYZW_TYPE& src, const PxMat33& m)
+{
+	transform_BYTE_SNORM3_by_PxMat33(*(BYTE_SNORM3_TYPE*)&dst, *(const BYTE_SNORM3_TYPE*)&src, m);
+}
+
+// Transform signed normalized short 3-vector by PxMat44
+PX_INLINE void transform_SHORT_SNORM3_by_PxMat44(SHORT_SNORM3_TYPE& dst, const SHORT_SNORM3_TYPE& src, const PxMat44& m)
+{
+	PxVec3 v;
+	convert_FLOAT3_from_SHORT_SNORM3((FLOAT3_TYPE&)v, src);
+	transform_FLOAT3_by_PxMat44((FLOAT3_TYPE&)v, (const FLOAT3_TYPE&)v, m);
+	convert_SHORT_SNORM3_from_FLOAT3(dst, (const FLOAT3_TYPE&)v);
+}
+
+// Transform signed normalized short 3-vector by PxMat33
+PX_INLINE void transform_SHORT_SNORM3_by_PxMat33(SHORT_SNORM3_TYPE& dst, const SHORT_SNORM3_TYPE& src, const PxMat33& m)
+{
+	PxVec3 v;
+	convert_FLOAT3_from_SHORT_SNORM3((FLOAT3_TYPE&)v, src);
+	transform_FLOAT3_by_PxMat33((FLOAT3_TYPE&)v, (const FLOAT3_TYPE&)v, m);
+	convert_SHORT_SNORM3_from_FLOAT3(dst, (const FLOAT3_TYPE&)v);
+}
+
+// Transform signed normalized short 4-vector by PxMat33
+PX_INLINE void transform_SHORT_SNORM4_by_PxMat33(SHORT_SNORM4_TYPE& dst, const SHORT_SNORM4_TYPE& src, const PxMat33& m)
+{
+	physx::PxVec4 v;
+	convert_FLOAT4_from_SHORT_SNORM4((FLOAT4_TYPE&)v, src);
+	transform_FLOAT4_by_PxMat33((FLOAT4_TYPE&)v, (const FLOAT4_TYPE&)v, m);
+	convert_SHORT_SNORM4_from_FLOAT4(dst, (const FLOAT4_TYPE&)v);
+}
+
+// Multiply signed normalized short 3-vector by scalar
+PX_INLINE void transform_SHORT_SNORM3_by_float(SHORT_SNORM3_TYPE& dst, const SHORT_SNORM3_TYPE& src, const float& s)
+{
+	PxVec3 v;
+	convert_FLOAT3_from_SHORT_SNORM3((FLOAT3_TYPE&)v, src);
+	transform_FLOAT3_by_float((FLOAT3_TYPE&)v, (const FLOAT3_TYPE&)v, s);
+	convert_SHORT_SNORM3_from_FLOAT3(dst, (const FLOAT3_TYPE&)v);
+}
+
+// Transform signed normalized short quat by PxMat33
+PX_INLINE void transform_SHORT_SNORM4_QUATXYZW_by_PxMat33(SHORT_SNORM4_QUATXYZW_TYPE& dst, const SHORT_SNORM4_QUATXYZW_TYPE& src, const PxMat33& m)
+{
+	transform_SHORT_SNORM3_by_PxMat33(*(SHORT_SNORM3_TYPE*)&dst, *(const SHORT_SNORM3_TYPE*)&src, m);
+}
+
+#define SAME(x) x
+
+#define HANDLE_TRANSFORM( _DataType, _OpType ) \
+	case RenderDataFormat::SAME(_DataType): \
+	while( numVertices-- ) \
+	{ \
+		transform_##_DataType##_by_##_OpType( *(_DataType##_TYPE*)dst, *(const _DataType##_TYPE*)src, op ); \
+		((uint8_t*&)dst) += sizeof( _DataType##_TYPE ); \
+		((const uint8_t*&)src) += sizeof( _DataType##_TYPE ); \
+	} \
+	return;
+
+void transformRenderBuffer(void* dst, const void* src, RenderDataFormat::Enum format, uint32_t numVertices, const PxMat44& op)
+{
+	switch (format)
+	{
+		// Put transform handlers here
+		HANDLE_TRANSFORM(FLOAT3, PxMat44)
+		HANDLE_TRANSFORM(BYTE_SNORM3, PxMat44)
+		HANDLE_TRANSFORM(SHORT_SNORM3, PxMat44)
+	default:
+		break;
+	}
+
+	PX_ALWAYS_ASSERT();	// Unhandled format
+}
+
+void transformRenderBuffer(void* dst, const void* src, RenderDataFormat::Enum format, uint32_t numVertices, const PxMat33& op)
+{
+	switch (format)
+	{
+		// Put transform handlers here
+		HANDLE_TRANSFORM(FLOAT3, PxMat33)
+		HANDLE_TRANSFORM(FLOAT4, PxMat33)
+		HANDLE_TRANSFORM(FLOAT4_QUAT, PxMat33)
+		HANDLE_TRANSFORM(BYTE_SNORM3, PxMat33)
+		HANDLE_TRANSFORM(BYTE_SNORM4, PxMat33)
+		HANDLE_TRANSFORM(BYTE_SNORM4_QUATXYZW, PxMat33)
+		HANDLE_TRANSFORM(SHORT_SNORM3, PxMat33)
+		HANDLE_TRANSFORM(SHORT_SNORM4, PxMat33)
+		HANDLE_TRANSFORM(SHORT_SNORM4_QUATXYZW, PxMat33)
+	default:
+		break;
+	}
+
+	PX_ALWAYS_ASSERT();	// Unhandled format
+}
+
+void transformRenderBuffer(void* dst, const void* src, RenderDataFormat::Enum format, uint32_t numVertices, const float& op)
+{
+	switch (format)
+	{
+		// Put transform handlers here
+		HANDLE_TRANSFORM(FLOAT3, float)
+		HANDLE_TRANSFORM(BYTE_SNORM3, float)
+	default:
+		break;
+	}
+
+	PX_ALWAYS_ASSERT();	// Unhandled format
+}
+
+
+ApexVertexBuffer::ApexVertexBuffer() : mParams(NULL), mFormat(NULL)
+{
+}
+
+ApexVertexBuffer::~ApexVertexBuffer()
+{
+	PX_ASSERT(mParams == NULL);
+}
+
+void ApexVertexBuffer::build(const VertexFormat& format, uint32_t vertexCount)
+{
+	const ApexVertexFormat* apexVertexFormat = DYNAMIC_CAST(const ApexVertexFormat*)(&format);
+	if (apexVertexFormat)
+	{
+		mFormat.copy(*apexVertexFormat);
+	}
+
+	NvParameterized::Handle handle(*mParams);
+	VERIFY_PARAM(mParams->getParameterHandle("buffers", handle));
+	VERIFY_PARAM(mParams->resizeArray(handle, mFormat.mParams->bufferFormats.arraySizes[0]));
+
+	resize(vertexCount);
+}
+
+void ApexVertexBuffer::applyTransformation(const PxMat44& transformation)
+{
+	RenderDataFormat::Enum format;
+	void* buf;
+	uint32_t index;
+
+	// Positions
+	index = (uint32_t)getFormat().getBufferIndexFromID(getFormat().getSemanticID(RenderVertexSemantic::POSITION));
+	buf = getBuffer(index);
+	if (buf)
+	{
+		format = getFormat().getBufferFormat(index);
+		transformRenderBuffer(buf, buf, format, getVertexCount(), transformation);
+	}
+
+	// Normals
+	index = (uint32_t)getFormat().getBufferIndexFromID(getFormat().getSemanticID(RenderVertexSemantic::NORMAL));
+	buf = getBuffer(index);
+	if (buf)
+	{
+		// PH: the Cofactor matrix now also handles negative determinants, so it does the same as multiplying with the inverse transpose of transformation.M.
+		const Cof44 cof(transformation);
+		format = getFormat().getBufferFormat(index);
+		transformRenderBuffer(buf, buf, format, getVertexCount(), cof.getBlock33());
+	}
+
+	// Tangents
+	index = (uint32_t)getFormat().getBufferIndexFromID(getFormat().getSemanticID(RenderVertexSemantic::TANGENT));
+	buf = getBuffer(index);
+	if (buf)
+	{
+		format = getFormat().getBufferFormat(index);
+		const PxMat33 tm(transformation.column0.getXYZ(),
+								transformation.column1.getXYZ(),
+								transformation.column2.getXYZ());
+		transformRenderBuffer(buf, buf, format, getVertexCount(), tm);
+	}
+
+	// Binormals
+	index = (uint32_t)getFormat().getBufferIndexFromID(getFormat().getSemanticID(RenderVertexSemantic::BINORMAL));
+	buf = getBuffer(index);
+	if (buf)
+	{
+		format = getFormat().getBufferFormat(index);
+		const PxMat33 tm(transformation.column0.getXYZ(),
+								transformation.column1.getXYZ(),
+								transformation.column2.getXYZ());
+		transformRenderBuffer(buf, buf, format, getVertexCount(), tm);
+	}
+}
+
+
+
+void ApexVertexBuffer::applyScale(float scale)
+{
+	uint32_t index = (uint32_t)getFormat().getBufferIndexFromID(getFormat().getSemanticID(RenderVertexSemantic::POSITION));
+	void* buf = getBuffer(index);
+	RenderDataFormat::Enum format = getFormat().getBufferFormat(index);
+	transformRenderBuffer(buf, buf, format, getVertexCount(), scale);
+}
+
+
+
+bool ApexVertexBuffer::mergeBinormalsIntoTangents()
+{
+	const uint32_t numBuffers = mFormat.getBufferCount();
+
+	int32_t normalBufferIndex = -1;
+	int32_t tangentBufferIndex = -1;
+	int32_t binormalBufferIndex = -1;
+	for (uint32_t i = 0; i < numBuffers; i++)
+	{
+		const RenderVertexSemantic::Enum semantic  = mFormat.getBufferSemantic(i);
+		const RenderDataFormat::Enum format = mFormat.getBufferFormat(i);
+		if (semantic == RenderVertexSemantic::NORMAL && format == RenderDataFormat::FLOAT3)
+		{
+			normalBufferIndex = (int32_t)i;
+		}
+		else if (semantic == RenderVertexSemantic::TANGENT && format == RenderDataFormat::FLOAT3)
+		{
+			tangentBufferIndex = (int32_t)i;
+		}
+		else if (semantic == RenderVertexSemantic::BINORMAL && format == RenderDataFormat::FLOAT3)
+		{
+			binormalBufferIndex = (int32_t)i;
+		}
+	}
+
+	if (normalBufferIndex != -1 && tangentBufferIndex != -1 && binormalBufferIndex != -1)
+	{
+		// PH: This gets dirty. modifying the parameterized object directly
+		BufferF32x3* normalsBuffer = static_cast<BufferF32x3*>(mParams->buffers.buf[normalBufferIndex]);
+		BufferF32x3* oldTangentsBuffer = static_cast<BufferF32x3*>(mParams->buffers.buf[tangentBufferIndex]);
+		BufferF32x3* oldBinormalsBuffer = static_cast<BufferF32x3*>(mParams->buffers.buf[binormalBufferIndex]);
+		BufferF32x4* newTangentsBuffer = static_cast<BufferF32x4*>(GetInternalApexSDK()->getParameterizedTraits()->createNvParameterized("BufferF32x4"));
+
+		if (normalsBuffer != NULL && oldTangentsBuffer != NULL && oldBinormalsBuffer != NULL && newTangentsBuffer != NULL)
+		{
+			const uint32_t numElements = (uint32_t)oldTangentsBuffer->data.arraySizes[0];
+
+			PX_ASSERT(oldTangentsBuffer->data.arraySizes[0] == oldBinormalsBuffer->data.arraySizes[0]);
+			{
+				// resize the array
+				NvParameterized::Handle handle(*newTangentsBuffer, "data");
+				PX_ASSERT(handle.isValid());
+				handle.resizeArray((int32_t)numElements);
+			}
+			PX_ASSERT(oldTangentsBuffer->data.arraySizes[0] == newTangentsBuffer->data.arraySizes[0]);
+
+			const PxVec3* normals = normalsBuffer->data.buf;
+			const PxVec3* oldTangents = oldTangentsBuffer->data.buf;
+			const PxVec3* oldBinormals = oldBinormalsBuffer->data.buf;
+			PxVec4* newTangents = (PxVec4*)newTangentsBuffer->data.buf;
+
+			for (uint32_t i = 0; i < numElements; i++)
+			{
+				const float binormal = PxSign(normals[i].cross(oldTangents[i]).dot(oldBinormals[i]));
+				newTangents[i] = PxVec4(oldTangents[i], binormal);
+			}
+
+			// Ok, real dirty now
+			mParams->buffers.buf[(uint32_t)tangentBufferIndex] = newTangentsBuffer;
+			for (uint32_t i = (uint32_t)binormalBufferIndex + 1; i < numBuffers; i++)
+			{
+				mParams->buffers.buf[i - 1] = mParams->buffers.buf[i];
+			}
+			mParams->buffers.buf[numBuffers - 1] = NULL;
+			{
+				NvParameterized::Handle handle(*mParams, "buffers");
+				PX_ASSERT(handle.isValid());
+				handle.resizeArray((int32_t)numBuffers - 1);
+			}
+			oldTangentsBuffer->destroy();
+			oldBinormalsBuffer->destroy();
+
+			// and make same change to the format too
+			VertexFormatParameters* format = static_cast<VertexFormatParameters*>(mParams->vertexFormat);
+			PX_ASSERT(format->bufferFormats.buf[tangentBufferIndex].semantic == RenderVertexSemantic::TANGENT);
+			PX_ASSERT(format->bufferFormats.buf[tangentBufferIndex].format == RenderDataFormat::FLOAT3);
+			format->bufferFormats.buf[tangentBufferIndex].format = RenderDataFormat::FLOAT4;
+
+			VertexFormatParametersNS::BufferFormat_Type binormalBuffer = format->bufferFormats.buf[binormalBufferIndex];
+			for (uint32_t i = (uint32_t)binormalBufferIndex + 1; i < numBuffers; i++)
+			{
+				format->bufferFormats.buf[i - 1] = format->bufferFormats.buf[i];
+			}
+
+			// swap it to the last such that it gets released properly
+			format->bufferFormats.buf[numBuffers - 1] = binormalBuffer;
+			{
+				NvParameterized::Handle handle(*format, "bufferFormats");
+				PX_ASSERT(handle.isValid());
+				handle.resizeArray((int32_t)numBuffers - 1);
+			}
+
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+void ApexVertexBuffer::copy(uint32_t dstIndex, uint32_t srcIndex, ApexVertexBuffer* srcBufferPtr)
+{
+	ApexVertexBuffer& srcVB = srcBufferPtr != NULL ? *srcBufferPtr : *this;
+	ApexVertexFormat& srcVF = srcVB.mFormat;
+
+	if (mParams->buffers.arraySizes[0] != srcVB.mParams->buffers.arraySizes[0])
+	{
+		PX_ALWAYS_ASSERT();
+		return;
+	}
+
+	for (uint32_t i = 0; i < (uint32_t)mParams->buffers.arraySizes[0]; i++)
+	{
+		RenderDataFormat::Enum dstFormat = mFormat.getBufferFormat(i);
+		VertexFormat::BufferID id = mFormat.getBufferID(i);
+		const int32_t srcBufferIndex = srcVF.getBufferIndexFromID(id);
+		if (srcBufferIndex >= 0)
+		{
+			RenderDataFormat::Enum srcFormat = srcVF.getBufferFormat((uint32_t)srcBufferIndex);
+			NvParameterized::Interface* dstInterface = mParams->buffers.buf[i];
+			NvParameterized::Interface* srcInterface = srcVB.mParams->buffers.buf[(uint32_t)srcBufferIndex];
+			// BRG: Using PH's reasoning: Technically all those CustomBuffer* classes should have the same struct, so I just use the first one
+			BufferU8x1& srcBuffer = *static_cast<BufferU8x1*>(srcInterface);
+			BufferU8x1& dstBuffer = *static_cast<BufferU8x1*>(dstInterface);
+			PX_ASSERT(dstIndex < (uint32_t)dstBuffer.data.arraySizes[0]);
+			PX_ASSERT(srcIndex < (uint32_t)srcBuffer.data.arraySizes[0]);
+			copyRenderVertexData(dstBuffer.data.buf, dstFormat, dstIndex, srcBuffer.data.buf, srcFormat, srcIndex);
+		}
+	}
+}
+
+void ApexVertexBuffer::resize(uint32_t vertexCount)
+{
+	mParams->vertexCount = vertexCount;
+
+	NvParameterized::Handle handle(*mParams);
+
+	VERIFY_PARAM(mParams->getParameterHandle("buffers", handle));
+	int32_t buffersSize = 0;
+	VERIFY_PARAM(mParams->getArraySize(handle, buffersSize));
+
+	for (int32_t i = 0; i < buffersSize; i++)
+	{
+		RenderDataFormat::Enum outFormat = mFormat.getBufferFormat((uint32_t)i);
+
+		NvParameterized::Handle elementHandle(*mParams);
+		VERIFY_PARAM(handle.getChildHandle(i, elementHandle));
+
+		NvParameterized::Interface* currentReference = NULL;
+		VERIFY_PARAM(mParams->getParamRef(elementHandle, currentReference));
+
+		// BUFFER_FORMAT_ADD This is just a bookmark for places where to add buffer formats
+		if (currentReference == NULL && vertexCount > 0)
+		{
+			const char* className = NULL;
+
+			switch (outFormat)
+			{
+			case RenderDataFormat::UBYTE1:
+			case RenderDataFormat::BYTE_UNORM1:
+			case RenderDataFormat::BYTE_SNORM1:
+				className = BufferU8x1::staticClassName();
+				break;
+			case RenderDataFormat::UBYTE2:
+			case RenderDataFormat::BYTE_UNORM2:
+			case RenderDataFormat::BYTE_SNORM2:
+				className = BufferU8x2::staticClassName();
+				break;
+			case RenderDataFormat::UBYTE3:
+			case RenderDataFormat::BYTE_UNORM3:
+			case RenderDataFormat::BYTE_SNORM3:
+				className = BufferU8x3::staticClassName();
+				break;
+			case RenderDataFormat::UBYTE4:
+			case RenderDataFormat::BYTE_UNORM4:
+			case RenderDataFormat::BYTE_SNORM4:
+			case RenderDataFormat::R8G8B8A8:
+			case RenderDataFormat::B8G8R8A8:
+				className = BufferU8x4::staticClassName();
+				break;
+			case RenderDataFormat::SHORT1:
+			case RenderDataFormat::USHORT1:
+			case RenderDataFormat::SHORT_UNORM1:
+			case RenderDataFormat::SHORT_SNORM1:
+			case RenderDataFormat::HALF1:
+				className = BufferU16x1::staticClassName();
+				break;
+			case RenderDataFormat::SHORT2:
+			case RenderDataFormat::USHORT2:
+			case RenderDataFormat::SHORT_UNORM2:
+			case RenderDataFormat::SHORT_SNORM2:
+			case RenderDataFormat::HALF2:
+				className = BufferU16x2::staticClassName();
+				break;
+			case RenderDataFormat::SHORT3:
+			case RenderDataFormat::USHORT3:
+			case RenderDataFormat::SHORT_UNORM3:
+			case RenderDataFormat::SHORT_SNORM3:
+			case RenderDataFormat::HALF3:
+				className = BufferU16x3::staticClassName();
+				break;
+			case RenderDataFormat::SHORT4:
+			case RenderDataFormat::USHORT4:
+			case RenderDataFormat::SHORT_UNORM4:
+			case RenderDataFormat::SHORT_SNORM4:
+			case RenderDataFormat::HALF4:
+				className = BufferU16x4::staticClassName();
+				break;
+			case RenderDataFormat::UINT1:
+				className = BufferU32x1::staticClassName();
+				break;
+			case RenderDataFormat::UINT2:
+				className = BufferU32x2::staticClassName();
+				break;
+			case RenderDataFormat::UINT3:
+				className = BufferU32x3::staticClassName();
+				break;
+			case RenderDataFormat::UINT4:
+				className = BufferU32x4::staticClassName();
+				break;
+			case RenderDataFormat::FLOAT1:
+				className = BufferF32x1::staticClassName();
+				break;
+			case RenderDataFormat::FLOAT2:
+				className = BufferF32x2::staticClassName();
+				break;
+			case RenderDataFormat::FLOAT3:
+				className = BufferF32x3::staticClassName();
+				break;
+			case RenderDataFormat::FLOAT4:
+			case RenderDataFormat::R32G32B32A32_FLOAT:
+			case RenderDataFormat::B32G32R32A32_FLOAT:
+				className = BufferF32x4::staticClassName();
+				break;
+			default:
+				PX_ALWAYS_ASSERT();
+				break;
+			}
+
+			if (className != NULL)
+			{
+				currentReference = GetInternalApexSDK()->getParameterizedTraits()->createNvParameterized(className);
+			}
+
+			if (currentReference != NULL)
+			{
+				NvParameterized::Handle arrayHandle(*currentReference);
+				VERIFY_PARAM(currentReference->getParameterHandle("data", arrayHandle));
+				PX_ASSERT(arrayHandle.isValid());
+				VERIFY_PARAM(arrayHandle.resizeArray((int32_t)vertexCount));
+
+				mParams->setParamRef(elementHandle, currentReference);
+			}
+		}
+		else if (vertexCount > 0)
+		{
+			NvParameterized::Interface* oldReference = currentReference;
+			PX_ASSERT(oldReference != NULL);
+			currentReference = GetInternalApexSDK()->getParameterizedTraits()->createNvParameterized(oldReference->className());
+			if (currentReference != NULL)
+			{
+				VERIFY_PARAM(currentReference->copy(*oldReference));
+
+				NvParameterized::Handle arrayHandle(*currentReference);
+				VERIFY_PARAM(currentReference->getParameterHandle("data", arrayHandle));
+				VERIFY_PARAM(arrayHandle.resizeArray((int32_t)vertexCount));
+			}
+			VERIFY_PARAM(mParams->setParamRef(elementHandle, currentReference));
+			oldReference->destroy();
+		}
+		else if (vertexCount == 0)
+		{
+			VERIFY_PARAM(mParams->setParamRef(elementHandle, NULL));
+
+			if (currentReference != NULL)
+			{
+				currentReference->destroy();
+			}
+		}
+	}
+}
+
+
+
+void ApexVertexBuffer::preSerialize(void*)
+{
+	PX_ASSERT((int32_t)mFormat.getBufferCount() == mParams->buffers.arraySizes[0]);
+	ParamArray<NvParameterized::Interface*> buffers(mParams, "buffers", reinterpret_cast<ParamDynamicArrayStruct*>(&mParams->buffers));
+	for (uint32_t i = 0; i < mFormat.getBufferCount(); i++)
+	{
+		if (!mFormat.getBufferSerialize(i))
+		{
+			// [i] no longer needs to be destroyed because the resize will handle it
+			buffers.replaceWithLast(i);
+			mFormat.bufferReplaceWithLast(i);
+			i--;
+		}
+	}
+
+	PX_ASSERT((int32_t)mFormat.getBufferCount() == mParams->buffers.arraySizes[0]);
+}
+
+bool ApexVertexBuffer::getBufferData(void* dstBuffer, nvidia::RenderDataFormat::Enum dstBufferFormat, uint32_t dstBufferStride, uint32_t bufferIndex,
+                                     uint32_t startIndex, uint32_t elementCount) const
+{
+	const void* data = getBuffer(bufferIndex);
+	if (data == NULL)
+	{
+		return false;
+	}
+	nvidia::RenderDataFormat::Enum srcFormat = getFormat().getBufferFormat(bufferIndex);
+	return copyRenderVertexBuffer(dstBuffer, dstBufferFormat, dstBufferStride, 0, data, srcFormat, RenderDataFormat::getFormatDataSize(srcFormat), startIndex, elementCount);
+}
+
+void* ApexVertexBuffer::getBuffer(uint32_t bufferIndex)
+{
+	if (bufferIndex < (uint32_t)mParams->buffers.arraySizes[0])
+	{
+		NvParameterized::Interface* buffer = mParams->buffers.buf[bufferIndex];
+		if (buffer != NULL)
+		{
+			BufferU8x1* particularBuffer = DYNAMIC_CAST(BufferU8x1*)(buffer);
+			return particularBuffer->data.buf;
+		}
+	}
+
+	return NULL;
+}
+
+uint32_t ApexVertexBuffer::getAllocationSize() const
+{
+	uint32_t size = sizeof(ApexVertexBuffer);
+
+	for (uint32_t index = 0; (int32_t)index < mParams->buffers.arraySizes[0]; ++index)
+	{
+		PX_ASSERT(index < getFormat().getBufferCount());
+		if (index >= getFormat().getBufferCount())
+		{
+			break;
+		}
+		const uint32_t dataSize = RenderDataFormat::getFormatDataSize(getFormat().getBufferFormat(index));
+		NvParameterized::Interface* buffer = mParams->buffers.buf[index];
+		if (buffer != NULL)
+		{
+			BufferU8x1* particularBuffer = DYNAMIC_CAST(BufferU8x1*)(buffer);
+			size += particularBuffer->data.arraySizes[0] * dataSize;
+		}
+	}
+
+	return size;
+}
+
+void ApexVertexBuffer::setParams(VertexBufferParameters* param)
+{
+	if (mParams != param)
+	{
+		if (mParams != NULL)
+		{
+			mParams->setSerializationCallback(NULL);
+		}
+
+		mParams = param;
+
+		if (mParams != NULL)
+		{
+			NvParameterized::Traits* traits = GetInternalApexSDK()->getParameterizedTraits();
+			if (mParams->vertexFormat != NULL)
+			{
+				if (mFormat.mParams && mFormat.mParams != (VertexFormatParameters*)mParams->vertexFormat)
+				{
+					mFormat.mParams->destroy();
+				}
+			}
+			else
+			{
+				mParams->vertexFormat = DYNAMIC_CAST(VertexFormatParameters*)(traits->createNvParameterized(VertexFormatParameters::staticClassName()));
+			}
+		}
+
+		mFormat.mParams = mParams != NULL ? static_cast<VertexFormatParameters*>(mParams->vertexFormat) : NULL;
+		mFormat.mOwnsParams = false;
+
+		if (mParams != NULL)
+		{
+			mParams->setSerializationCallback(this);
+		}
+	}
+}
+
+namespace 
+{
+	class PxMat34Legacy
+	{
+		float f[12];
+	};
+}
+
+void ApexVertexBuffer::applyPermutation(const Array<uint32_t>& permutation)
+{
+	const uint32_t numVertices = mParams->vertexCount;
+	PX_ASSERT(numVertices == permutation.size());
+	for (uint32_t i = 0; i < (uint32_t)mParams->buffers.arraySizes[0]; i++)
+	{
+		NvParameterized::Interface* bufferInterface = mParams->buffers.buf[i];
+		RenderDataFormat::Enum format = getFormat().getBufferFormat(i);
+		switch(format)
+		{
+			// all 1 byte
+		case RenderDataFormat::UBYTE1:
+		case RenderDataFormat::BYTE_UNORM1:
+		case RenderDataFormat::BYTE_SNORM1:
+			{
+				BufferU8x1* byte1 = static_cast<BufferU8x1*>(bufferInterface);
+				PX_ASSERT(numVertices == (uint32_t)byte1->data.arraySizes[0]);
+				ApexPermute(byte1->data.buf, permutation.begin(), numVertices);
+			}
+			break;
+
+			// all 2 byte
+		case RenderDataFormat::UBYTE2:
+		case RenderDataFormat::USHORT1:
+		case RenderDataFormat::SHORT1:
+		case RenderDataFormat::BYTE_UNORM2:
+		case RenderDataFormat::SHORT_UNORM1:
+		case RenderDataFormat::BYTE_SNORM2:
+		case RenderDataFormat::SHORT_SNORM1:
+		case RenderDataFormat::HALF1:
+			{
+				BufferU16x1* short1 = static_cast<BufferU16x1*>(bufferInterface);
+				PX_ASSERT(numVertices == (uint32_t)short1->data.arraySizes[0]);
+				ApexPermute(short1->data.buf, permutation.begin(), numVertices);
+			}
+			break;
+
+			// all 3 byte
+		case RenderDataFormat::UBYTE3:
+		case RenderDataFormat::BYTE_UNORM3:
+		case RenderDataFormat::BYTE_SNORM3:
+			{
+				BufferU8x3* byte3 = static_cast<BufferU8x3*>(bufferInterface);
+				PX_ASSERT(numVertices == (uint32_t)byte3->data.arraySizes[0]);
+				ApexPermute(byte3->data.buf, permutation.begin(), numVertices);
+			}
+			break;
+
+			// all 4 byte
+		case RenderDataFormat::UBYTE4:
+		case RenderDataFormat::USHORT2:
+		case RenderDataFormat::SHORT2:
+		case RenderDataFormat::UINT1:
+		case RenderDataFormat::R8G8B8A8:
+		case RenderDataFormat::B8G8R8A8:
+		case RenderDataFormat::BYTE_UNORM4:
+		case RenderDataFormat::SHORT_UNORM2:
+		case RenderDataFormat::BYTE_SNORM4:
+		case RenderDataFormat::SHORT_SNORM2:
+		case RenderDataFormat::HALF2:
+		case RenderDataFormat::FLOAT1:
+		case RenderDataFormat::BYTE_SNORM4_QUATXYZW:
+		case RenderDataFormat::SHORT_SNORM4_QUATXYZW:
+			{
+				BufferU32x1* int1 = static_cast<BufferU32x1*>(bufferInterface);
+				PX_ASSERT(numVertices == (uint32_t)int1->data.arraySizes[0]);
+				ApexPermute(int1->data.buf, permutation.begin(), numVertices);
+			}
+			break;
+
+			// all 6 byte
+		case RenderDataFormat::USHORT3:
+		case RenderDataFormat::SHORT3:
+		case RenderDataFormat::SHORT_UNORM3:
+		case RenderDataFormat::SHORT_SNORM3:
+		case RenderDataFormat::HALF3:
+			{
+				BufferU16x3* short3 = static_cast<BufferU16x3*>(bufferInterface);
+				PX_ASSERT(numVertices == (uint32_t)short3->data.arraySizes[0]);
+				ApexPermute(short3->data.buf, permutation.begin(), numVertices);
+			}
+			break;
+
+			// all 8 byte
+		case RenderDataFormat::USHORT4:
+		case RenderDataFormat::SHORT4:
+		case RenderDataFormat::SHORT_UNORM4:
+		case RenderDataFormat::SHORT_SNORM4:
+		case RenderDataFormat::UINT2:
+		case RenderDataFormat::HALF4:
+		case RenderDataFormat::FLOAT2:
+			{
+				BufferU32x2* int2 = static_cast<BufferU32x2*>(bufferInterface);
+				PX_ASSERT(numVertices == (uint32_t)int2->data.arraySizes[0]);
+				ApexPermute(int2->data.buf, permutation.begin(), numVertices);
+			}
+			break;
+
+			// all 12 byte
+		case RenderDataFormat::UINT3:
+		case RenderDataFormat::FLOAT3:
+			{
+				BufferU32x3* int3 = static_cast<BufferU32x3*>(bufferInterface);
+				PX_ASSERT(numVertices == (uint32_t)int3->data.arraySizes[0]);
+				ApexPermute(int3->data.buf, permutation.begin(), numVertices);
+			}
+			break;
+
+			// all 16 byte
+		case RenderDataFormat::UINT4:
+		case RenderDataFormat::R32G32B32A32_FLOAT:
+		case RenderDataFormat::B32G32R32A32_FLOAT:
+		case RenderDataFormat::FLOAT4:
+		case RenderDataFormat::FLOAT4_QUAT:
+			{
+				BufferU32x4* int4 = static_cast<BufferU32x4*>(bufferInterface);
+				PX_ASSERT(numVertices == (uint32_t)int4->data.arraySizes[0]);
+				ApexPermute(int4->data.buf, permutation.begin(), numVertices);
+			}
+			break;
+
+			// all 36 byte
+		case RenderDataFormat::FLOAT3x3:
+			{
+				BufferF32x1* float1 = static_cast<BufferF32x1*>(bufferInterface);
+				PX_ASSERT(numVertices == (uint32_t)float1->data.arraySizes[0]);
+				ApexPermute((PxMat33*)float1->data.buf, permutation.begin(), numVertices);
+			}
+			break;
+
+			// all 48 byte
+		case RenderDataFormat::FLOAT3x4:
+			{
+				BufferF32x1* float1 = static_cast<BufferF32x1*>(bufferInterface);
+				PX_ASSERT(numVertices == (uint32_t)float1->data.arraySizes[0]);
+				ApexPermute((PxMat34Legacy*)float1->data.buf, permutation.begin(), numVertices);
+				
+			}
+			break;
+
+			// all 64 byte
+		case RenderDataFormat::FLOAT4x4:
+			{
+				BufferF32x1* float1 = static_cast<BufferF32x1*>(bufferInterface);
+				PX_ASSERT(numVertices == (uint32_t)float1->data.arraySizes[0]);
+				ApexPermute((PxMat44*)float1->data.buf, permutation.begin(), numVertices);
+			}
+			break;
+
+		// fix gcc warnings
+		case RenderDataFormat::UNSPECIFIED:
+		case RenderDataFormat::NUM_FORMATS:
+			break;
+		}
+	}
+}
+
+
+
+}
+} // end namespace nvidia::apex
diff --git a/APEX_1.4/framework/src/ApexVertexFormat.cpp b/APEX_1.4/framework/src/ApexVertexFormat.cpp
new file mode 100644
index 00000000..17d0ef48
--- /dev/null
+++ b/APEX_1.4/framework/src/ApexVertexFormat.cpp
@@ -0,0 +1,404 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "ApexVertexFormat.h"
+#include "ApexSDKIntl.h"
+
+#include <ParamArray.h>
+
+namespace nvidia
+{
+namespace apex
+{
+
+// Local functions and definitions
+
+PX_INLINE char* apex_strdup(const char* input)
+{
+	if (input == NULL)
+	{
+		return NULL;
+	}
+
+	size_t len = strlen(input);
+
+	char* result = (char*)PX_ALLOC(sizeof(char) * (len + 1), PX_DEBUG_EXP("apex_strdup"));
+#ifdef WIN32
+	strncpy_s(result, len + 1, input, len);
+#else
+	strncpy(result, input, len);
+#endif
+
+	return result;
+}
+
+PX_INLINE uint32_t hash(const char* string)
+{
+	// "DJB" string hash
+	uint32_t h = 5381;
+	char c;
+	while ((c = *string++) != '\0')
+	{
+		h = ((h << 5) + h) ^ c;
+	}
+	return h;
+}
+
+struct SemanticNameAndID
+{
+	SemanticNameAndID(const char* name, VertexFormat::BufferID id) : m_name(name), m_id(id)
+	{
+		PX_ASSERT(m_id != 0 || nvidia::strcmp(m_name, "SEMANTIC_INVALID") == 0);
+	}
+	const char*					m_name;
+	VertexFormat::BufferID	m_id;
+};
+
+#define SEMANTIC_NAME_AND_ID( name )	SemanticNameAndID( name, (VertexFormat::BufferID)hash( name ) )
+
+static const SemanticNameAndID sSemanticNamesAndIDs[] =
+{
+	SEMANTIC_NAME_AND_ID("SEMANTIC_POSITION"),
+	SEMANTIC_NAME_AND_ID("SEMANTIC_NORMAL"),
+	SEMANTIC_NAME_AND_ID("SEMANTIC_TANGENT"),
+	SEMANTIC_NAME_AND_ID("SEMANTIC_BINORMAL"),
+	SEMANTIC_NAME_AND_ID("SEMANTIC_COLOR"),
+	SEMANTIC_NAME_AND_ID("SEMANTIC_TEXCOORD0"),
+	SEMANTIC_NAME_AND_ID("SEMANTIC_TEXCOORD1"),
+	SEMANTIC_NAME_AND_ID("SEMANTIC_TEXCOORD2"),
+	SEMANTIC_NAME_AND_ID("SEMANTIC_TEXCOORD3"),
+	SEMANTIC_NAME_AND_ID("SEMANTIC_BONE_INDEX"),
+	SEMANTIC_NAME_AND_ID("SEMANTIC_BONE_WEIGHT"),
+	SEMANTIC_NAME_AND_ID("SEMANTIC_DISPLACEMENT_TEXCOORD"),
+	SEMANTIC_NAME_AND_ID("SEMANTIC_DISPLACEMENT_FLAGS"),
+
+	SemanticNameAndID("SEMANTIC_INVALID", (VertexFormat::BufferID)0)
+};
+
+
+// VertexFormat implementation
+void ApexVertexFormat::reset()
+{
+	if (mParams != NULL)
+	{
+		mParams->winding = 0;
+		mParams->hasSeparateBoneBuffer = 0;
+	}
+	clearBuffers();
+}
+
+void ApexVertexFormat::setWinding(RenderCullMode::Enum winding)
+{
+	mParams->winding = winding;
+}
+
+void ApexVertexFormat::setHasSeparateBoneBuffer(bool hasSeparateBoneBuffer)
+{
+	mParams->hasSeparateBoneBuffer = hasSeparateBoneBuffer;
+}
+
+RenderCullMode::Enum ApexVertexFormat::getWinding() const
+{
+	return (RenderCullMode::Enum)mParams->winding;
+}
+
+bool ApexVertexFormat::hasSeparateBoneBuffer() const
+{
+	return mParams->hasSeparateBoneBuffer;
+}
+
+const char* ApexVertexFormat::getSemanticName(RenderVertexSemantic::Enum semantic) const
+{
+	PX_ASSERT((uint32_t)semantic < RenderVertexSemantic::NUM_SEMANTICS);
+	return (uint32_t)semantic < RenderVertexSemantic::NUM_SEMANTICS ? sSemanticNamesAndIDs[semantic].m_name : NULL;
+}
+
+VertexFormat::BufferID ApexVertexFormat::getSemanticID(RenderVertexSemantic::Enum semantic) const
+{
+	PX_ASSERT((uint32_t)semantic < RenderVertexSemantic::NUM_SEMANTICS);
+	return (uint32_t)semantic < RenderVertexSemantic::NUM_SEMANTICS ? sSemanticNamesAndIDs[semantic].m_id : (BufferID)0;
+}
+
+VertexFormat::BufferID ApexVertexFormat::getID(const char* name) const
+{
+	if (name == NULL)
+	{
+		return (BufferID)0;
+	}
+	const BufferID id = hash(name);
+	return id ? id : (BufferID)1;	// We reserve 0 for an invalid ID
+}
+
+int32_t ApexVertexFormat::addBuffer(const char* name)
+{
+	if (name == NULL)
+	{
+		return -1;
+	}
+
+	const BufferID id = getID(name);
+
+	int32_t index = getBufferIndexFromID(id);
+	if (index >= 0)
+	{
+		return index;
+	}
+
+	int32_t semantic = 0;
+	for (; semantic < RenderVertexSemantic::NUM_SEMANTICS; ++semantic)
+	{
+		if (getSemanticID((RenderVertexSemantic::Enum)semantic) == id)
+		{
+			break;
+		}
+	}
+	if (semantic == RenderVertexSemantic::NUM_SEMANTICS)
+	{
+		semantic = RenderVertexSemantic::CUSTOM;
+	}
+
+	NvParameterized::Handle handle(*mParams);
+	mParams->getParameterHandle("bufferFormats", handle);
+
+	mParams->getArraySize(handle, index);
+
+	mParams->resizeArray(handle, index + 1);
+
+	NvParameterized::Handle elementHandle(*mParams);
+	handle.getChildHandle(index, elementHandle);
+	NvParameterized::Handle subElementHandle(*mParams);
+	elementHandle.getChildHandle(mParams, "name", subElementHandle);
+	mParams->setParamString(subElementHandle, name);
+	elementHandle.getChildHandle(mParams, "semantic", subElementHandle);
+	mParams->setParamI32(subElementHandle, semantic);
+	elementHandle.getChildHandle(mParams, "id", subElementHandle);
+	mParams->setParamU32(subElementHandle, (uint32_t)id);
+	elementHandle.getChildHandle(mParams, "format", subElementHandle);
+	mParams->setParamU32(subElementHandle, (uint32_t)RenderDataFormat::UNSPECIFIED);
+	elementHandle.getChildHandle(mParams, "access", subElementHandle);
+	mParams->setParamU32(subElementHandle, (uint32_t)RenderDataAccess::STATIC);
+	elementHandle.getChildHandle(mParams, "serialize", subElementHandle);
+	mParams->setParamBool(subElementHandle, true);
+
+	return index;
+}
+
+bool ApexVertexFormat::bufferReplaceWithLast(uint32_t index)
+{
+	PX_ASSERT((int32_t)index < mParams->bufferFormats.arraySizes[0]);
+	if ((int32_t)index < mParams->bufferFormats.arraySizes[0])
+	{
+		ParamArray<VertexFormatParametersNS::BufferFormat_Type> bufferFormats(mParams, "bufferFormats", reinterpret_cast<ParamDynamicArrayStruct*>(&mParams->bufferFormats));
+		bufferFormats.replaceWithLast(index);
+		return true;
+	}
+
+	return false;
+}
+
+bool ApexVertexFormat::setBufferFormat(uint32_t index, RenderDataFormat::Enum format)
+{
+	if (index < getBufferCount())
+	{
+		mParams->bufferFormats.buf[index].format = format;
+		return true;
+	}
+
+	return false;
+}
+
+bool ApexVertexFormat::setBufferAccess(uint32_t index, RenderDataAccess::Enum access)
+{
+	if (index < getBufferCount())
+	{
+		mParams->bufferFormats.buf[index].access = access;
+		return true;
+	}
+
+	return false;
+}
+
+bool ApexVertexFormat::setBufferSerialize(uint32_t index, bool serialize)
+{
+	if (index < getBufferCount())
+	{
+		mParams->bufferFormats.buf[index].serialize = serialize;
+		return true;
+	}
+
+	return false;
+}
+
+const char* ApexVertexFormat::getBufferName(uint32_t index) const
+{
+	return index < getBufferCount() ? (const char*)mParams->bufferFormats.buf[index].name : NULL;
+}
+
+RenderVertexSemantic::Enum ApexVertexFormat::getBufferSemantic(uint32_t index) const
+{
+	return index < getBufferCount() ? (RenderVertexSemantic::Enum)mParams->bufferFormats.buf[index].semantic : RenderVertexSemantic::NUM_SEMANTICS;
+}
+
+VertexFormat::BufferID ApexVertexFormat::getBufferID(uint32_t index) const
+{
+	return index < getBufferCount() ? (BufferID)mParams->bufferFormats.buf[index].id : (BufferID)0;
+}
+
+RenderDataFormat::Enum ApexVertexFormat::getBufferFormat(uint32_t index) const
+{
+	return index < getBufferCount() ? (RenderDataFormat::Enum)mParams->bufferFormats.buf[index].format : RenderDataFormat::UNSPECIFIED;
+}
+
+RenderDataAccess::Enum ApexVertexFormat::getBufferAccess(uint32_t index) const
+{
+	return index < getBufferCount() ? (RenderDataAccess::Enum)mParams->bufferFormats.buf[index].access : RenderDataAccess::ACCESS_TYPE_COUNT;
+}
+
+bool ApexVertexFormat::getBufferSerialize(uint32_t index) const
+{
+	return index < getBufferCount() ? mParams->bufferFormats.buf[index].serialize : false;
+}
+
+uint32_t ApexVertexFormat::getBufferCount() const
+{
+	return (uint32_t)mParams->bufferFormats.arraySizes[0];
+}
+
+uint32_t ApexVertexFormat::getCustomBufferCount() const
+{
+	PX_ASSERT(mParams != NULL);
+	uint32_t customBufferCount = 0;
+	for (int32_t i = 0; i < mParams->bufferFormats.arraySizes[0]; ++i)
+	{
+		if (mParams->bufferFormats.buf[i].semantic == RenderVertexSemantic::CUSTOM)
+		{
+			++customBufferCount;
+		}
+	}
+	return customBufferCount;
+}
+
+int32_t ApexVertexFormat::getBufferIndexFromID(BufferID id) const
+{
+	for (int32_t i = 0; i < mParams->bufferFormats.arraySizes[0]; ++i)
+	{
+		if (mParams->bufferFormats.buf[i].id == (uint32_t)id)
+		{
+			return i;
+		}
+	}
+
+	return -1;
+}
+
+
+
+// ApexVertexFormat functions
+
+ApexVertexFormat::ApexVertexFormat()
+{
+	NvParameterized::Traits* traits = GetInternalApexSDK()->getParameterizedTraits();
+	mParams = DYNAMIC_CAST(VertexFormatParameters*)(traits->createNvParameterized(VertexFormatParameters::staticClassName()));
+	mOwnsParams = mParams != NULL;
+}
+
+ApexVertexFormat::ApexVertexFormat(VertexFormatParameters* params) : mParams(params), mOwnsParams(false)
+{
+}
+
+ApexVertexFormat::ApexVertexFormat(const ApexVertexFormat& f) : VertexFormat(f)
+{
+	NvParameterized::Traits* traits = GetInternalApexSDK()->getParameterizedTraits();
+	mParams = DYNAMIC_CAST(VertexFormatParameters*)(traits->createNvParameterized(VertexFormatParameters::staticClassName()));
+	mOwnsParams = mParams != NULL;
+	if (mParams)
+	{
+		copy(f);
+	}
+}
+
+ApexVertexFormat::~ApexVertexFormat()
+{
+	if (mOwnsParams && mParams != NULL)
+	{
+		mParams->destroy();
+	}
+}
+
+bool ApexVertexFormat::operator == (const VertexFormat& format) const
+{
+	if (getWinding() != format.getWinding())
+	{
+		return false;
+	}
+
+	if (hasSeparateBoneBuffer() != format.hasSeparateBoneBuffer())
+	{
+		return false;
+	}
+
+	if (getBufferCount() != format.getBufferCount())
+	{
+		return false;
+	}
+
+	for (uint32_t thisIndex = 0; thisIndex < getBufferCount(); ++thisIndex)
+	{
+		BufferID id = getBufferID(thisIndex);
+		const int32_t thatIndex = format.getBufferIndexFromID(id);
+		if (thatIndex < 0)
+		{
+			return false;
+		}
+		if (getBufferFormat(thisIndex) != format.getBufferFormat((uint32_t)thatIndex))
+		{
+			return false;
+		}
+		if (getBufferAccess(thisIndex) != format.getBufferAccess((uint32_t)thatIndex))
+		{
+			return false;
+		}
+	}
+
+	return true;
+}
+
+void ApexVertexFormat::copy(const ApexVertexFormat& other)
+{
+	reset();
+
+	setWinding(other.getWinding());
+	setHasSeparateBoneBuffer(other.hasSeparateBoneBuffer());
+
+	for (uint32_t i = 0; i < other.getBufferCount(); ++i)
+	{
+		const char* name = other.getBufferName(i);
+		const uint32_t index = (uint32_t)addBuffer(name);
+		setBufferFormat(index, other.getBufferFormat(i));
+		setBufferAccess(index, other.getBufferAccess(i));
+		setBufferSerialize(index, other.getBufferSerialize(i));
+	}
+}
+
+void ApexVertexFormat::clearBuffers()
+{
+	if (mParams)
+	{
+		NvParameterized::Handle handle(*mParams);
+
+		mParams->getParameterHandle("bufferFormats", handle);
+		handle.resizeArray(0);
+	}
+}
+
+
+}
+} // end namespace nvidia::apex
diff --git a/APEX_1.4/framework/src/FrameworkProfile.cpp b/APEX_1.4/framework/src/FrameworkProfile.cpp
new file mode 100644
index 00000000..73688a65
--- /dev/null
+++ b/APEX_1.4/framework/src/FrameworkProfile.cpp
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "ApexDefs.h"
+#include "ApexSDKImpl.h"
+#include "FrameworkPerfScope.h"
+
+namespace Framework
+{
+
+void initFrameworkProfiling(nvidia::apex::ApexSDKImpl*) {}
+void releaseFrameworkProfiling() {}
+
+} // end namespace Framework
diff --git a/APEX_1.4/framework/src/MirrorSceneImpl.cpp b/APEX_1.4/framework/src/MirrorSceneImpl.cpp
new file mode 100644
index 00000000..d3ac9db1
--- /dev/null
+++ b/APEX_1.4/framework/src/MirrorSceneImpl.cpp
@@ -0,0 +1,648 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "MirrorSceneImpl.h"
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+
+#include "PxScene.h"
+#include "PxRigidDynamic.h"
+#include "PxMaterial.h"
+#include "PxSphereGeometry.h"
+#include "PxRigidDynamic.h"
+#include "PxRigidStatic.h"
+#include "PxShape.h"
+#include "ApexSDKIntl.h"
+#include "PsInlineArray.h"
+#include "PxPhysics.h"
+
+#pragma warning(disable:4100)
+
+namespace nvidia
+{
+
+namespace apex
+{
+
+	using namespace physx;
+
+bool copyStaticProperties(PxRigidActor& to, const PxRigidActor& from,MirrorScene::MirrorFilter &mirrorFilter)
+{
+	shdfnd::InlineArray<PxShape*, 64> shapes;
+	shapes.resize(from.getNbShapes());
+
+	uint32_t shapeCount = from.getNbShapes();
+	from.getShapes(shapes.begin(), shapeCount);
+
+	shdfnd::InlineArray<PxMaterial*, 64> materials;
+	for(uint32_t i = 0; i < shapeCount; i++)
+	{
+		PxShape* s = shapes[i];
+
+		if ( mirrorFilter.shouldMirror(*s) )
+		{
+			uint32_t materialCount = s->getNbMaterials();
+			materials.resize(materialCount);
+			s->getMaterials(materials.begin(), materialCount);
+			PxShape* shape = to.createShape(s->getGeometry().any(), materials.begin(), static_cast<uint16_t>(materialCount));
+			shape->setLocalPose( s->getLocalPose());
+			shape->setContactOffset(s->getContactOffset());
+			shape->setRestOffset(s->getRestOffset());
+			shape->setFlags(s->getFlags());
+			shape->setSimulationFilterData(s->getSimulationFilterData());
+			shape->setQueryFilterData(s->getQueryFilterData());
+			mirrorFilter.reviseMirrorShape(*shape);
+		}
+	}
+
+	to.setActorFlags(from.getActorFlags());
+	to.setOwnerClient(from.getOwnerClient());
+	to.setDominanceGroup(from.getDominanceGroup());
+
+	if ( to.getNbShapes() )
+	{
+		mirrorFilter.reviseMirrorActor(to);
+	}
+
+	return to.getNbShapes() != 0;
+}
+
+PxRigidStatic* CloneStatic(PxPhysics& physicsSDK, 
+							 const PxTransform& transform, 
+							 const PxRigidActor& from,
+							 MirrorScene::MirrorFilter &mirrorFilter)
+{
+	PxRigidStatic* to = physicsSDK.createRigidStatic(transform);
+	if(!to)
+		return NULL;
+
+	if ( !copyStaticProperties(*to, from,mirrorFilter) )
+	{
+		to->release();
+		to = NULL;
+	}
+
+	return to;
+}
+
+PxRigidDynamic* CloneDynamic(PxPhysics& physicsSDK, 
+							   const PxTransform& transform,
+							   const PxRigidDynamic& from,
+							   MirrorScene::MirrorFilter &mirrorFilter)
+{
+	PxRigidDynamic* to = physicsSDK.createRigidDynamic(transform);
+	if(!to)
+		return NULL;
+
+	if ( !copyStaticProperties(*to, from, mirrorFilter) )
+	{
+		to->release();
+		to = NULL;
+		return NULL;
+	}
+
+	to->setRigidBodyFlags(from.getRigidBodyFlags());
+
+	to->setMass(from.getMass());
+	to->setMassSpaceInertiaTensor(from.getMassSpaceInertiaTensor());
+	to->setCMassLocalPose(from.getCMassLocalPose());
+
+	if ( !(to->getRigidBodyFlags() & PxRigidBodyFlag::eKINEMATIC) )
+	{
+		to->setLinearVelocity(from.getLinearVelocity());
+		to->setAngularVelocity(from.getAngularVelocity());
+	}
+
+	to->setLinearDamping(from.getAngularDamping());
+	to->setAngularDamping(from.getAngularDamping());
+
+	to->setMaxAngularVelocity(from.getMaxAngularVelocity());
+
+	uint32_t posIters, velIters;
+	from.getSolverIterationCounts(posIters, velIters);
+	to->setSolverIterationCounts(posIters, velIters);
+
+	to->setSleepThreshold(from.getSleepThreshold());
+
+	to->setContactReportThreshold(from.getContactReportThreshold());
+
+	return to;
+}
+
+
+MirrorSceneImpl::MirrorSceneImpl(physx::PxScene &primaryScene,
+	physx::PxScene &mirrorScene,
+	MirrorScene::MirrorFilter &mirrorFilter,
+	float mirrorStaticDistance,
+	float mirrorDynamicDistance,
+	float mirrorDistanceThreshold) 
+	: mPrimaryScene(primaryScene)
+	, mMirrorScene(mirrorScene)
+	, mMirrorFilter(mirrorFilter)
+	, mMirrorStaticDistance(mirrorStaticDistance)
+	, mMirrorDynamicDistance(mirrorDynamicDistance)
+	, mMirrorDistanceThreshold(mirrorDistanceThreshold*mirrorDistanceThreshold)
+	, mTriggerActor(NULL)
+	, mTriggerMaterial(NULL)
+	, mTriggerShapeStatic(NULL)
+	, mTriggerShapeDynamic(NULL)
+	, mSimulationEventCallback(NULL)
+{
+	mLastCameraLocation = PxVec3(1e9,1e9,1e9);
+	primaryScene.getPhysics().registerDeletionListener(*this,physx::PxDeletionEventFlag::eMEMORY_RELEASE | physx::PxDeletionEventFlag::eUSER_RELEASE);
+}
+
+MirrorSceneImpl::~MirrorSceneImpl(void)
+{
+	if ( mTriggerActor )
+	{
+		mPrimaryScene.lockWrite(__FILE__,__LINE__);
+		mTriggerActor->release();
+		mPrimaryScene.unlockWrite();
+	}
+	if ( mTriggerMaterial )
+	{
+		mTriggerMaterial->release();
+	}
+	mPrimaryScene.getPhysics().unregisterDeletionListener(*this);
+}
+
+void MirrorSceneImpl::createTriggerActor(const PxVec3 &cameraPosition)
+{
+	PX_ASSERT( mTriggerActor == NULL );
+	mTriggerActor = mPrimaryScene.getPhysics().createRigidDynamic( PxTransform(cameraPosition) );
+	PX_ASSERT(mTriggerActor);
+	if ( mTriggerActor )
+	{
+		mTriggerActor->setRigidBodyFlag(physx::PxRigidBodyFlag::eKINEMATIC,true);
+		physx::PxSphereGeometry staticSphere;
+		physx::PxSphereGeometry dynamicSphere;
+		staticSphere.radius = mMirrorStaticDistance;
+		dynamicSphere.radius = mMirrorDynamicDistance;
+		mTriggerMaterial = mPrimaryScene.getPhysics().createMaterial(1,1,1);
+		PX_ASSERT(mTriggerMaterial);
+		if ( mTriggerMaterial )
+		{
+			mTriggerShapeStatic = mTriggerActor->createShape(staticSphere,*mTriggerMaterial);
+			mTriggerShapeDynamic = mTriggerActor->createShape(dynamicSphere,*mTriggerMaterial);
+			PX_ASSERT(mTriggerShapeStatic);
+			PX_ASSERT(mTriggerShapeDynamic);
+			if ( mTriggerShapeStatic && mTriggerShapeDynamic )
+			{
+				mPrimaryScene.lockWrite(__FILE__,__LINE__);
+
+				mTriggerActor->setOwnerClient(0);
+				mTriggerShapeStatic->setFlag(physx::PxShapeFlag::eSCENE_QUERY_SHAPE,false);
+				mTriggerShapeStatic->setFlag(physx::PxShapeFlag::eSIMULATION_SHAPE,false);
+				mTriggerShapeStatic->setFlag(physx::PxShapeFlag::eTRIGGER_SHAPE,true);
+
+				mTriggerShapeDynamic->setFlag(physx::PxShapeFlag::eSCENE_QUERY_SHAPE,false);
+				mTriggerShapeDynamic->setFlag(physx::PxShapeFlag::eSIMULATION_SHAPE,false);
+				mTriggerShapeDynamic->setFlag(physx::PxShapeFlag::eTRIGGER_SHAPE,true);
+
+				mSimulationEventCallback = mPrimaryScene.getSimulationEventCallback(); // get a copy of the original callback
+				mPrimaryScene.setSimulationEventCallback(this,0);
+				mPrimaryScene.addActor(*mTriggerActor);
+
+				mPrimaryScene.unlockWrite();
+			}
+		}
+	}
+}
+
+// Each frame, we do a shape query for static and dynamic objects
+// If this is the first time the synchronize has been called, then we create
+// a trigger actor with two spheres in the primary scene.  This trigger
+// actor is used to detect when objects move in and outside of the static and dynamic
+// mirror range specified.
+void MirrorSceneImpl::synchronizePrimaryScene(const PxVec3 &cameraPos)
+{
+	PxVec3 diff = cameraPos - mLastCameraLocation;
+	float dist = diff.magnitudeSquared();
+	if ( dist > mMirrorDistanceThreshold )
+	{
+		mLastCameraLocation = cameraPos;
+		if ( mTriggerActor == NULL )
+		{
+			createTriggerActor(cameraPos);	// Create the scene mirroring trigger actor 
+		}
+		if ( mTriggerActor )
+		{
+			mPrimaryScene.lockWrite(__FILE__,__LINE__);
+			mTriggerActor->setKinematicTarget( PxTransform(cameraPos) );	// Update the position of the trigger actor to be the current camera location
+			mPrimaryScene.unlockWrite();
+		}
+	}
+	// Now, iterate on all of the current actors which are being mirrored
+	// Only the primary scene after modifies this hash, so it is safe to do this
+	// without any concerns of thread locking.
+	// The mirrored scene thread does access the contents of this hash (MirrorActor)
+	{
+		mPrimaryScene.lockRead(__FILE__,__LINE__);
+		for (ActorHash::Iterator i=mActors.getIterator(); !i.done(); ++i)
+		{
+			MirrorActor *ma = i->second;
+			ma->synchronizePose();	// check to see if the position of this object in the primary
+			// scene has changed.  If it has, then we create a command for the mirror scene to update
+			// it's mirror actor to that new position.
+		}
+		mPrimaryScene.unlockRead();
+	}
+}
+
+// When the mirrored scene is synchronized, we grab the mirror command buffer
+// And then despool all of the create/release/update commands that got posted previously by the
+// primary scene thread.  A mutex is used to safe brief access to the command buffer.
+// A copy of the command buffer is made so that we only grab the mutex for the shorted period
+// of time possible.
+void MirrorSceneImpl::synchronizeMirrorScene(void)
+{
+	MirrorCommandArray temp;
+	mMirrorCommandMutex.lock();
+	temp = mMirrorCommands;
+	mMirrorCommands.clear();
+	mMirrorCommandMutex.unlock();
+	if ( !temp.empty() )
+	{
+		mMirrorScene.lockWrite(__FILE__,__LINE__);
+		for (uint32_t i=0; i<temp.size(); i++)
+		{
+			MirrorCommand &mc = temp[i];
+			switch ( mc.mType )
+			{
+				case MCT_CREATE_ACTOR:
+					{
+						mc.mMirrorActor->createActor(mMirrorScene);
+					}
+					break;
+				case MCT_RELEASE_ACTOR:
+					{
+						delete mc.mMirrorActor;
+					}
+					break;
+				case MCT_UPDATE_POSE:
+					{
+						mc.mMirrorActor->updatePose(mc.mPose);
+					}
+					break;
+				default:
+					break;
+			}
+		}
+		mMirrorScene.unlockWrite();
+	}
+}
+
+void MirrorSceneImpl::release(void)
+{
+	delete this;
+}
+
+
+/**
+\brief This is called when a breakable constraint breaks.
+
+\note The user should not release the constraint shader inside this call!
+
+\param[in] constraints - The constraints which have been broken.
+\param[in] count       - The number of constraints
+
+@see PxConstraint PxConstraintDesc.linearBreakForce PxConstraintDesc.angularBreakForce
+*/
+void MirrorSceneImpl::onConstraintBreak(PxConstraintInfo* constraints, uint32_t count)
+{
+	if ( mSimulationEventCallback )
+	{
+		mSimulationEventCallback->onConstraintBreak(constraints,count);
+	}
+}
+
+/**
+\brief This is called during PxScene::fetchResults with the actors which have just been woken up.
+
+\note Only supported by rigid bodies yet.
+\note Only called on actors for which the PxActorFlag eSEND_SLEEP_NOTIFIES has been set.
+
+\param[in] actors - The actors which just woke up.
+\param[in] count  - The number of actors
+
+@see PxScene.setSimulationEventCallback() PxSceneDesc.simulationEventCallback PxActorFlag PxActor.setActorFlag()
+*/
+void MirrorSceneImpl::onWake(PxActor** actors, uint32_t count)
+{
+	if ( mSimulationEventCallback )
+	{
+		mSimulationEventCallback->onWake(actors,count);
+	}
+}
+
+/**
+\brief This is called during PxScene::fetchResults with the actors which have just been put to sleep.
+
+\note Only supported by rigid bodies yet.
+\note Only called on actors for which the PxActorFlag eSEND_SLEEP_NOTIFIES has been set.  
+
+\param[in] actors - The actors which have just been put to sleep.
+\param[in] count  - The number of actors
+
+@see PxScene.setSimulationEventCallback() PxSceneDesc.simulationEventCallback PxActorFlag PxActor.setActorFlag()
+*/
+void MirrorSceneImpl::onSleep(PxActor** actors, uint32_t count)
+{
+	if ( mSimulationEventCallback )
+	{
+		mSimulationEventCallback->onSleep(actors,count);
+	}
+
+}
+
+/**
+\brief The user needs to implement this interface class in order to be notified when
+certain contact events occur.
+
+The method will be called for a pair of actors if one of the colliding shape pairs requested contact notification.
+You request which events are reported using the filter shader/callback mechanism (see #PxSimulationFilterShader,
+#PxSimulationFilterCallback, #PxPairFlag).
+
+Do not keep references to the passed objects, as they will be 
+invalid after this function returns.
+
+\param[in] pairHeader Information on the two actors whose shapes triggered a contact report.
+\param[in] pairs The contact pairs of two actors for which contact reports have been requested. See #PxContactPair.
+\param[in] nbPairs The number of provided contact pairs.
+
+@see PxScene.setSimulationEventCallback() PxSceneDesc.simulationEventCallback PxContactPair PxPairFlag PxSimulationFilterShader PxSimulationFilterCallback
+*/
+void MirrorSceneImpl::onContact(const PxContactPairHeader& pairHeader, const PxContactPair* pairs, uint32_t nbPairs)
+{
+	if ( mSimulationEventCallback )
+	{
+		mSimulationEventCallback->onContact(pairHeader,pairs,nbPairs);
+	}
+
+}
+
+/*
+\brief This is called during PxScene::fetchResults with the current trigger pair events.
+
+Shapes which have been marked as triggers using PxShapeFlag::eTRIGGER_SHAPE will send events
+according to the pair flag specification in the filter shader (see #PxPairFlag, #PxSimulationFilterShader).
+
+\param[in] pairs - The trigger pairs which caused events.
+\param[in] count - The number of trigger pairs.
+
+@see PxScene.setSimulationEventCallback() PxSceneDesc.simulationEventCallback PxPairFlag PxSimulationFilterShader PxShapeFlag PxShape.setFlag()
+*/
+void MirrorSceneImpl::onTrigger(PxTriggerPair* pairs, uint32_t count)
+{
+	mTriggerPairs.clear();
+	for (uint32_t i=0; i<count; i++)
+	{
+		PxTriggerPair &tp = pairs[i];
+
+		if ( ( tp.triggerShape == mTriggerShapeStatic ) || ( tp.triggerShape == mTriggerShapeDynamic ) )
+		{
+			if ( tp.flags & PxTriggerPairFlag::eREMOVED_SHAPE_OTHER ) // actor was deleted!
+			{
+				// handle shape release..
+				mirrorShape(tp);
+			}
+			else
+			{
+				PxActor *actor = tp.otherActor;
+				if( mMirrorFilter.shouldMirror(*actor) ) // let the application telll us whether this is an actor we want to mirror or not
+				{
+					if ( tp.triggerShape == mTriggerShapeStatic ) 
+					{
+						if ( actor->getType() == PxActorType::eRIGID_STATIC )
+						{
+							mirrorShape(tp);
+						}
+					}
+					else if ( tp.triggerShape == mTriggerShapeDynamic )
+					{
+						if ( actor->getType() == PxActorType::eRIGID_DYNAMIC )
+						{
+							mirrorShape(tp);
+						}
+					}
+				}
+			}
+		}
+		else
+		{
+			mTriggerPairs.pushBack(tp);
+		}
+	}
+	if ( !mTriggerPairs.empty() ) // If some of the triggers were for the application; then we pass them on
+	{
+		mSimulationEventCallback->onTrigger(&mTriggerPairs[0],mTriggerPairs.size());
+	}
+}
+
+void MirrorSceneImpl::onAdvance(const PxRigidBody*const* bodyBuffer, const PxTransform* poseBuffer, const PxU32 count)
+{
+	PX_UNUSED(bodyBuffer);
+	PX_UNUSED(poseBuffer);
+	PX_UNUSED(count);
+}
+
+void MirrorSceneImpl::mirrorShape(const PxTriggerPair &tp)
+{
+	size_t hash = (size_t)tp.otherShape;
+	const ShapeHash::Entry *found = mShapes.find(hash);
+	MirrorActor *ma = found ? found->second : NULL;
+	if ( tp.flags & PxTriggerPairFlag::eREMOVED_SHAPE_OTHER )
+	{
+		if ( found )
+		{
+			bool kill = ma->removeShape();
+			mShapes.erase(hash);
+			if ( kill )
+			{
+				ma->release();
+				mActors.erase( ma->mActorHash );
+			}
+		}
+	}
+	else if ( tp.status == PxPairFlag::eNOTIFY_TOUCH_FOUND )
+	{
+		PX_ASSERT( found == NULL );
+		size_t actorHash = (size_t) &tp.otherActor;
+		const ActorHash::Entry *foundActor = mActors.find(actorHash);
+		if ( foundActor == NULL )
+		{
+			ma = PX_NEW(MirrorActor)(actorHash,*tp.otherActor,*this);
+			mActors[actorHash] = ma;
+		}
+		else
+		{
+			ma = foundActor->second;
+		}
+		ma->addShape();
+		mShapes[hash] = ma;
+	}
+	else if ( tp.status == PxPairFlag::eNOTIFY_TOUCH_LOST )
+	{
+		PX_ASSERT( found );
+		if ( ma )
+		{
+			bool kill = ma->removeShape();
+			mShapes.erase(hash);
+			if ( kill )
+			{
+				mActors.erase( ma->mActorHash );
+				ma->release();
+ 			}
+		}
+	}
+
+}
+
+void MirrorSceneImpl::postCommand(const MirrorCommand &mc)
+{
+	mMirrorCommandMutex.lock();
+	mMirrorCommands.pushBack(mc);
+	mMirrorCommandMutex.unlock();
+}
+
+MirrorActor::MirrorActor(size_t actorHash,
+						 physx::PxRigidActor &actor,
+						 MirrorSceneImpl &mirrorScene) : mMirrorScene(mirrorScene), mPrimaryActor(&actor), mActorHash(actorHash) 
+{
+	mReleasePosted = false;
+	mMirrorActor = NULL;
+	mShapeCount = 0;
+	PxScene *scene = actor.getScene();
+	PX_ASSERT(scene);
+	if ( scene )
+	{
+		scene->lockWrite(__FILE__,__LINE__);
+		mPrimaryGlobalPose = actor.getGlobalPose();
+		PxPhysics *sdk = &scene->getPhysics();
+		if ( actor.getType() == physx::PxActorType::eRIGID_STATIC )
+		{
+			mMirrorActor = CloneStatic(*sdk,actor.getGlobalPose(),actor, mirrorScene.getMirrorFilter());
+		}
+		else
+		{
+			physx::PxRigidDynamic *rd = static_cast< physx::PxRigidDynamic *>(&actor);
+			mMirrorActor = CloneDynamic(*sdk,actor.getGlobalPose(),*rd, mirrorScene.getMirrorFilter());
+			if ( mMirrorActor )
+			{
+				rd = static_cast< physx::PxRigidDynamic *>(mMirrorActor);
+				rd->setRigidBodyFlag(physx::PxRigidBodyFlag::eKINEMATIC,true);
+			}
+		}
+		scene->unlockWrite();
+		if ( mMirrorActor )
+		{
+			MirrorCommand mc(MCT_CREATE_ACTOR,this);
+			mMirrorScene.postCommand(mc);
+		}
+	}
+}
+
+MirrorActor::~MirrorActor(void)
+{
+	if ( mMirrorActor )
+	{
+		mMirrorActor->release();
+	}
+}
+
+void MirrorActor::release(void)
+{
+	PX_ASSERT( mReleasePosted == false );
+	if ( !mReleasePosted )
+	{
+		if ( mPrimaryActor )
+		{
+		}
+		MirrorCommand mc(MCT_RELEASE_ACTOR,this);
+		mMirrorScene.postCommand(mc);
+		mReleasePosted = true;
+	}
+}
+
+void MirrorActor::createActor(PxScene &scene)
+{
+	if ( mMirrorActor )
+	{
+		scene.addActor(*mMirrorActor);
+	}
+}
+
+static bool sameTransform(const PxTransform &a,const PxTransform &b)
+{
+	if ( a.p == b.p && 
+		 a.q.x == b.q.x && 
+		 a.q.y == b.q.y &&
+		 a.q.z == b.q.z &&
+		 a.q.w == b.q.w )
+	{
+		return true;
+	}
+	return false;
+}
+
+void MirrorActor::synchronizePose(void)
+{
+	if ( mPrimaryActor )
+	{
+		PxTransform p = mPrimaryActor->getGlobalPose();
+		if ( !sameTransform(p,mPrimaryGlobalPose) )
+		{
+			mPrimaryGlobalPose = p;
+			MirrorCommand mc(MCT_UPDATE_POSE,this,p);
+			mMirrorScene.postCommand(mc);
+		}
+	}
+}
+
+void MirrorActor::updatePose(const PxTransform &pose)
+{
+	if ( mMirrorActor )
+	{
+		if ( mMirrorActor->getType() == PxActorType::eRIGID_STATIC )
+		{
+			PxRigidStatic *p = static_cast< PxRigidStatic *>(mMirrorActor);
+			p->setGlobalPose(pose);
+		}
+		else
+		{
+			PxRigidDynamic *p = static_cast< PxRigidDynamic *>(mMirrorActor);
+			p->setKinematicTarget(pose);
+		}
+	}
+}
+
+void MirrorSceneImpl::onRelease(const PxBase* observed,
+					   void* /*userData*/,
+					   PxDeletionEventFlag::Enum /*deletionEvent*/)
+{
+	const physx::PxRigidActor *a = observed->is<PxRigidActor>();
+	if ( a )
+	{
+		size_t actorHash = (size_t)a;
+		const ActorHash::Entry *foundActor = mActors.find(actorHash);
+		if ( foundActor != NULL )
+		{
+			MirrorActor *ma = foundActor->second;
+			ma->mPrimaryActor = NULL;
+		}
+	}
+}
+
+}; // end apex namespace
+}; // end physx namespace
+
+#endif
diff --git a/APEX_1.4/framework/src/ThreadPool.cpp b/APEX_1.4/framework/src/ThreadPool.cpp
new file mode 100644
index 00000000..1e138231
--- /dev/null
+++ b/APEX_1.4/framework/src/ThreadPool.cpp
@@ -0,0 +1,295 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#include "ApexDefs.h"
+#if PX_PHYSICS_VERSION_MAJOR == 0
+
+#include "ApexSDK.h"
+
+#include "PsThread.h"
+#include "PsSList.h"
+#include "PsSync.h"
+#include "PsString.h"
+#include "PsUserAllocated.h"
+#include "PsAllocator.h"
+
+#include "ThreadPool.h"
+#include "ProfilerCallback.h"
+
+#if PX_WINDOWS_FAMILY
+#define PROFILE_TASKS 1
+#else
+#define PROFILE_TASKS 1
+#endif
+
+namespace nvidia
+{
+namespace apex
+{
+
+PxCpuDispatcher* createDefaultThreadPool(unsigned int numThreads)
+{
+	if (numThreads == 0)
+	{
+#if PX_WINDOWS_FAMILY
+		numThreads = 4;
+#elif PX_APPLE_FAMILY
+		numThreads = 2;
+#endif
+	}
+	return PX_NEW(DefaultCpuDispatcher)(numThreads, 0);
+}
+
+DefaultCpuDispatcher::DefaultCpuDispatcher(uint32_t numThreads, uint32_t* affinityMasks)
+	: mQueueEntryPool(TASK_QUEUE_ENTRY_POOL_SIZE), mNumThreads(numThreads), mShuttingDown(false)
+{
+	uint32_t defaultAffinityMask = 0;
+
+	// initialize threads first, then start
+
+	mWorkerThreads = reinterpret_cast<CpuWorkerThread*>(PX_ALLOC(numThreads * sizeof(CpuWorkerThread), PX_DEBUG_EXP("CpuWorkerThread")));
+	if (mWorkerThreads)
+	{
+		for (uint32_t i = 0; i < numThreads; ++i)
+		{
+			PX_PLACEMENT_NEW(mWorkerThreads + i, CpuWorkerThread)();
+			mWorkerThreads[i].initialize(this);
+		}
+
+		for (uint32_t i = 0; i < numThreads; ++i)
+		{
+			mWorkerThreads[i].start(shdfnd::Thread::getDefaultStackSize());
+			if (affinityMasks)
+			{
+				mWorkerThreads[i].setAffinityMask(affinityMasks[i]);
+			}
+			else
+			{
+				mWorkerThreads[i].setAffinityMask(defaultAffinityMask);
+			}
+
+			char threadName[32];
+			shdfnd::snprintf(threadName, 32, "PxWorker%02d", i);
+			mWorkerThreads[i].setName(threadName);
+		}
+	}
+	else
+	{
+		mNumThreads = 0;
+	}
+}
+
+
+DefaultCpuDispatcher::~DefaultCpuDispatcher()
+{
+	for (uint32_t i = 0; i < mNumThreads; ++i)
+	{
+		mWorkerThreads[i].signalQuit();
+	}
+
+	mShuttingDown = true;
+	mWorkReady.set();
+	for (uint32_t i = 0; i < mNumThreads; ++i)
+	{
+		mWorkerThreads[i].waitForQuit();
+	}
+
+	for (uint32_t i = 0; i < mNumThreads; ++i)
+	{
+		mWorkerThreads[i].~CpuWorkerThread();
+	}
+
+	PX_FREE(mWorkerThreads);
+}
+
+
+void DefaultCpuDispatcher::submitTask(PxBaseTask& task)
+{
+	shdfnd::Thread::Id currentThread = shdfnd::Thread::getId();
+
+	// TODO: Could use TLS to make this more efficient
+	for (uint32_t i = 0; i < mNumThreads; ++i)
+		if (mWorkerThreads[i].tryAcceptJobToLocalQueue(task, currentThread))
+		{
+			return mWorkReady.set();
+		}
+
+	SharedQueueEntry* entry = mQueueEntryPool.getEntry(&task);
+	if (entry)
+	{
+		mJobList.push(*entry);
+		mWorkReady.set();
+	}
+}
+
+void DefaultCpuDispatcher::flush( PxBaseTask& task, int32_t targetRef)
+{
+	// TODO: implement
+	PX_ALWAYS_ASSERT();
+	PX_UNUSED(task);
+	PX_UNUSED(targetRef);
+}
+
+uint32_t DefaultCpuDispatcher::getWorkerCount() const
+{
+	return mNumThreads;
+}
+
+void DefaultCpuDispatcher::release()
+{
+	GetApexSDK()->releaseCpuDispatcher(*this);
+}
+
+
+PxBaseTask* DefaultCpuDispatcher::getJob(void)
+{
+	return TaskQueueHelper::fetchTask(mJobList, mQueueEntryPool);
+}
+
+
+PxBaseTask* DefaultCpuDispatcher::stealJob()
+{
+	PxBaseTask* ret = NULL;
+
+	for (uint32_t i = 0; i < mNumThreads; ++i)
+	{
+		ret = mWorkerThreads[i].giveUpJob();
+
+		if (ret != NULL)
+		{
+			break;
+		}
+	}
+
+	return ret;
+}
+
+
+void DefaultCpuDispatcher::resetWakeSignal()
+{
+	mWorkReady.reset();
+
+	// The code below is necessary to avoid deadlocks on shut down.
+	// A thread usually loops as follows:
+	// while quit is not signaled
+	// 1)  reset wake signal
+	// 2)  fetch work
+	// 3)  if work -> process
+	// 4)  else -> wait for wake signal
+	//
+	// If a thread reaches 1) after the thread pool signaled wake up,
+	// the wake up sync gets reset and all other threads which have not
+	// passed 4) already will wait forever.
+	// The code below makes sure that on shutdown, the wake up signal gets
+	// sent again after it was reset
+	//
+	if (mShuttingDown)
+	{
+		mWorkReady.set();
+	}
+}
+
+
+CpuWorkerThread::CpuWorkerThread()
+	:	mQueueEntryPool(TASK_QUEUE_ENTRY_POOL_SIZE)
+	,	mThreadId(0)
+{
+}
+
+
+CpuWorkerThread::~CpuWorkerThread()
+{
+}
+
+
+void CpuWorkerThread::initialize(DefaultCpuDispatcher* ownerDispatcher)
+{
+	mOwner = ownerDispatcher;
+}
+
+
+bool CpuWorkerThread::tryAcceptJobToLocalQueue(PxBaseTask& task, shdfnd::Thread::Id taskSubmitionThread)
+{
+	if (taskSubmitionThread == mThreadId)
+	{
+		SharedQueueEntry* entry = mQueueEntryPool.getEntry(&task);
+		if (entry)
+		{
+			mLocalJobList.push(*entry);
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
+
+	return false;
+}
+
+
+PxBaseTask* CpuWorkerThread::giveUpJob()
+{
+	return TaskQueueHelper::fetchTask(mLocalJobList, mQueueEntryPool);
+}
+
+
+void CpuWorkerThread::execute()
+{
+	mThreadId = getId();
+
+	while (!quitIsSignalled())
+	{
+		mOwner->resetWakeSignal();
+
+		PxBaseTask* task = TaskQueueHelper::fetchTask(mLocalJobList, mQueueEntryPool);
+
+		if (!task)
+		{
+			task = mOwner->getJob();
+		}
+
+		if (!task)
+		{
+			task = mOwner->stealJob();
+		}
+
+		if (task)
+		{
+#if PHYSX_PROFILE_SDK
+			if (mApexPvdClient!=NULL)
+			{
+				task->runProfiled();
+			}
+			else
+			{
+				task->run();
+			}
+#else
+			task->run();
+#endif
+			task->release();
+		}
+		else
+		{
+			mOwner->waitForWork();
+		}
+	}
+
+	quit();
+};
+
+
+
+} // end pxtask namespace
+} // end physx namespace
+
+#endif // PX_PHYSICS_VERSION_MAJOR == 0
diff --git a/APEX_1.4/framework/src/autogen/BufferF32x1.cpp b/APEX_1.4/framework/src/autogen/BufferF32x1.cpp
new file mode 100644
index 00000000..4f4b2f36
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/BufferF32x1.cpp
@@ -0,0 +1,346 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "BufferF32x1.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace BufferF32x1NS;
+
+const char* const BufferF32x1Factory::vptr =
+    NvParameterized::getVptr<BufferF32x1, BufferF32x1::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->data), CHILDREN(1), 1 }, // data
+	{ TYPE_F32, false, 1 * sizeof(float), NULL, 0 }, // data[]
+};
+
+
+bool BufferF32x1::mBuiltFlag = false;
+NvParameterized::MutexType BufferF32x1::mBuiltFlagMutex;
+
+BufferF32x1::BufferF32x1(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &BufferF32x1FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+BufferF32x1::~BufferF32x1()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void BufferF32x1::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~BufferF32x1();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* BufferF32x1::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* BufferF32x1::getParameterDefinitionTree(void) const
+{
+	BufferF32x1* tmpParam = const_cast<BufferF32x1*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType BufferF32x1::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType BufferF32x1::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void BufferF32x1::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<BufferF32x1::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void BufferF32x1::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void BufferF32x1::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="data"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("data", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for FLOAT1 formats", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="data[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("data", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for FLOAT1 formats", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="data"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void BufferF32x1::initStrings(void)
+{
+}
+
+void BufferF32x1::initDynamicArrays(void)
+{
+	data.buf = NULL;
+	data.isAllocated = true;
+	data.elementSize = sizeof(float);
+	data.arraySizes[0] = 0;
+}
+
+void BufferF32x1::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void BufferF32x1::initReferences(void)
+{
+}
+
+void BufferF32x1::freeDynamicArrays(void)
+{
+	if (data.isAllocated && data.buf)
+	{
+		mParameterizedTraits->free(data.buf);
+	}
+}
+
+void BufferF32x1::freeStrings(void)
+{
+}
+
+void BufferF32x1::freeReferences(void)
+{
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/BufferF32x2.cpp b/APEX_1.4/framework/src/autogen/BufferF32x2.cpp
new file mode 100644
index 00000000..16afe051
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/BufferF32x2.cpp
@@ -0,0 +1,401 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "BufferF32x2.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace BufferF32x2NS;
+
+const char* const BufferF32x2Factory::vptr =
+    NvParameterized::getVptr<BufferF32x2, BufferF32x2::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->data), CHILDREN(1), 1 }, // data
+	{ TYPE_STRUCT, false, 1 * sizeof(F32x2_Type), CHILDREN(2), 2 }, // data[]
+	{ TYPE_F32, false, (size_t)(&((F32x2_Type*)0)->x), NULL, 0 }, // data[].x
+	{ TYPE_F32, false, (size_t)(&((F32x2_Type*)0)->y), NULL, 0 }, // data[].y
+};
+
+
+bool BufferF32x2::mBuiltFlag = false;
+NvParameterized::MutexType BufferF32x2::mBuiltFlagMutex;
+
+BufferF32x2::BufferF32x2(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &BufferF32x2FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+BufferF32x2::~BufferF32x2()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void BufferF32x2::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~BufferF32x2();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* BufferF32x2::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* BufferF32x2::getParameterDefinitionTree(void) const
+{
+	BufferF32x2* tmpParam = const_cast<BufferF32x2*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType BufferF32x2::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType BufferF32x2::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void BufferF32x2::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<BufferF32x2::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void BufferF32x2::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void BufferF32x2::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="data"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("data", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for FLOAT2 formats", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="data[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("data", TYPE_STRUCT, "F32x2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for FLOAT2 formats", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="data[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "X", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="data[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Y", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="data"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="data[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void BufferF32x2::initStrings(void)
+{
+}
+
+void BufferF32x2::initDynamicArrays(void)
+{
+	data.buf = NULL;
+	data.isAllocated = true;
+	data.elementSize = sizeof(F32x2_Type);
+	data.arraySizes[0] = 0;
+}
+
+void BufferF32x2::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void BufferF32x2::initReferences(void)
+{
+}
+
+void BufferF32x2::freeDynamicArrays(void)
+{
+	if (data.isAllocated && data.buf)
+	{
+		mParameterizedTraits->free(data.buf);
+	}
+}
+
+void BufferF32x2::freeStrings(void)
+{
+}
+
+void BufferF32x2::freeReferences(void)
+{
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/BufferF32x3.cpp b/APEX_1.4/framework/src/autogen/BufferF32x3.cpp
new file mode 100644
index 00000000..d6866511
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/BufferF32x3.cpp
@@ -0,0 +1,346 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "BufferF32x3.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace BufferF32x3NS;
+
+const char* const BufferF32x3Factory::vptr =
+    NvParameterized::getVptr<BufferF32x3, BufferF32x3::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->data), CHILDREN(1), 1 }, // data
+	{ TYPE_VEC3, false, 1 * sizeof(physx::PxVec3), NULL, 0 }, // data[]
+};
+
+
+bool BufferF32x3::mBuiltFlag = false;
+NvParameterized::MutexType BufferF32x3::mBuiltFlagMutex;
+
+BufferF32x3::BufferF32x3(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &BufferF32x3FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+BufferF32x3::~BufferF32x3()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void BufferF32x3::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~BufferF32x3();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* BufferF32x3::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* BufferF32x3::getParameterDefinitionTree(void) const
+{
+	BufferF32x3* tmpParam = const_cast<BufferF32x3*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType BufferF32x3::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType BufferF32x3::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void BufferF32x3::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<BufferF32x3::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void BufferF32x3::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void BufferF32x3::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="data"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("data", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for FLOAT3 formats", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="data[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("data", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for FLOAT3 formats", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="data"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void BufferF32x3::initStrings(void)
+{
+}
+
+void BufferF32x3::initDynamicArrays(void)
+{
+	data.buf = NULL;
+	data.isAllocated = true;
+	data.elementSize = sizeof(physx::PxVec3);
+	data.arraySizes[0] = 0;
+}
+
+void BufferF32x3::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void BufferF32x3::initReferences(void)
+{
+}
+
+void BufferF32x3::freeDynamicArrays(void)
+{
+	if (data.isAllocated && data.buf)
+	{
+		mParameterizedTraits->free(data.buf);
+	}
+}
+
+void BufferF32x3::freeStrings(void)
+{
+}
+
+void BufferF32x3::freeReferences(void)
+{
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/BufferF32x4.cpp b/APEX_1.4/framework/src/autogen/BufferF32x4.cpp
new file mode 100644
index 00000000..7aeb3f3b
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/BufferF32x4.cpp
@@ -0,0 +1,453 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "BufferF32x4.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace BufferF32x4NS;
+
+const char* const BufferF32x4Factory::vptr =
+    NvParameterized::getVptr<BufferF32x4, BufferF32x4::ClassAlignment>();
+
+const uint32_t NumParamDefs = 7;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5, 6,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->data), CHILDREN(1), 1 }, // data
+	{ TYPE_STRUCT, false, 1 * sizeof(F32x4_Type), CHILDREN(2), 4 }, // data[]
+	{ TYPE_F32, false, (size_t)(&((F32x4_Type*)0)->x), NULL, 0 }, // data[].x
+	{ TYPE_F32, false, (size_t)(&((F32x4_Type*)0)->y), NULL, 0 }, // data[].y
+	{ TYPE_F32, false, (size_t)(&((F32x4_Type*)0)->z), NULL, 0 }, // data[].z
+	{ TYPE_F32, false, (size_t)(&((F32x4_Type*)0)->w), NULL, 0 }, // data[].w
+};
+
+
+bool BufferF32x4::mBuiltFlag = false;
+NvParameterized::MutexType BufferF32x4::mBuiltFlagMutex;
+
+BufferF32x4::BufferF32x4(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &BufferF32x4FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+BufferF32x4::~BufferF32x4()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void BufferF32x4::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~BufferF32x4();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* BufferF32x4::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* BufferF32x4::getParameterDefinitionTree(void) const
+{
+	BufferF32x4* tmpParam = const_cast<BufferF32x4*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType BufferF32x4::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType BufferF32x4::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void BufferF32x4::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<BufferF32x4::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void BufferF32x4::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void BufferF32x4::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="data"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("data", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for FLOAT4 formats", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+		ParamDefTable[1].setAlignment(16);
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="data[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("data", TYPE_STRUCT, "F32x4", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for FLOAT4 formats", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+		ParamDefTable[2].setAlignment(16);
+		ParamDefTable[2].setPadding(16);
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="data[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "X", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+		ParamDefTable[3].setAlignment(16);
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="data[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Y", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="data[].z"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("z", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Z", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="data[].w"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("w", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "W", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="data"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="data[]"
+	{
+		static Definition* Children[4];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+		Children[2] = PDEF_PTR(5);
+		Children[3] = PDEF_PTR(6);
+
+		ParamDefTable[2].setChildren(Children, 4);
+	}
+
+	mBuiltFlag = true;
+
+}
+void BufferF32x4::initStrings(void)
+{
+}
+
+void BufferF32x4::initDynamicArrays(void)
+{
+	data.buf = NULL;
+	data.isAllocated = true;
+	data.elementSize = sizeof(F32x4_Type);
+	data.arraySizes[0] = 0;
+}
+
+void BufferF32x4::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void BufferF32x4::initReferences(void)
+{
+}
+
+void BufferF32x4::freeDynamicArrays(void)
+{
+	if (data.isAllocated && data.buf)
+	{
+		mParameterizedTraits->free(data.buf);
+	}
+}
+
+void BufferF32x4::freeStrings(void)
+{
+}
+
+void BufferF32x4::freeReferences(void)
+{
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/BufferU16x1.cpp b/APEX_1.4/framework/src/autogen/BufferU16x1.cpp
new file mode 100644
index 00000000..04d3b5ce
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/BufferU16x1.cpp
@@ -0,0 +1,346 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "BufferU16x1.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace BufferU16x1NS;
+
+const char* const BufferU16x1Factory::vptr =
+    NvParameterized::getVptr<BufferU16x1, BufferU16x1::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->data), CHILDREN(1), 1 }, // data
+	{ TYPE_U16, false, 1 * sizeof(uint16_t), NULL, 0 }, // data[]
+};
+
+
+bool BufferU16x1::mBuiltFlag = false;
+NvParameterized::MutexType BufferU16x1::mBuiltFlagMutex;
+
+BufferU16x1::BufferU16x1(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &BufferU16x1FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+BufferU16x1::~BufferU16x1()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void BufferU16x1::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~BufferU16x1();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* BufferU16x1::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* BufferU16x1::getParameterDefinitionTree(void) const
+{
+	BufferU16x1* tmpParam = const_cast<BufferU16x1*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType BufferU16x1::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType BufferU16x1::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void BufferU16x1::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<BufferU16x1::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void BufferU16x1::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void BufferU16x1::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="data"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("data", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for SHORT1 formats", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="data[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("data", TYPE_U16, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for SHORT1 formats", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="data"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void BufferU16x1::initStrings(void)
+{
+}
+
+void BufferU16x1::initDynamicArrays(void)
+{
+	data.buf = NULL;
+	data.isAllocated = true;
+	data.elementSize = sizeof(uint16_t);
+	data.arraySizes[0] = 0;
+}
+
+void BufferU16x1::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void BufferU16x1::initReferences(void)
+{
+}
+
+void BufferU16x1::freeDynamicArrays(void)
+{
+	if (data.isAllocated && data.buf)
+	{
+		mParameterizedTraits->free(data.buf);
+	}
+}
+
+void BufferU16x1::freeStrings(void)
+{
+}
+
+void BufferU16x1::freeReferences(void)
+{
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/BufferU16x2.cpp b/APEX_1.4/framework/src/autogen/BufferU16x2.cpp
new file mode 100644
index 00000000..cb680641
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/BufferU16x2.cpp
@@ -0,0 +1,401 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "BufferU16x2.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace BufferU16x2NS;
+
+const char* const BufferU16x2Factory::vptr =
+    NvParameterized::getVptr<BufferU16x2, BufferU16x2::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->data), CHILDREN(1), 1 }, // data
+	{ TYPE_STRUCT, false, 1 * sizeof(U16x2_Type), CHILDREN(2), 2 }, // data[]
+	{ TYPE_U16, false, (size_t)(&((U16x2_Type*)0)->x), NULL, 0 }, // data[].x
+	{ TYPE_U16, false, (size_t)(&((U16x2_Type*)0)->y), NULL, 0 }, // data[].y
+};
+
+
+bool BufferU16x2::mBuiltFlag = false;
+NvParameterized::MutexType BufferU16x2::mBuiltFlagMutex;
+
+BufferU16x2::BufferU16x2(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &BufferU16x2FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+BufferU16x2::~BufferU16x2()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void BufferU16x2::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~BufferU16x2();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* BufferU16x2::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* BufferU16x2::getParameterDefinitionTree(void) const
+{
+	BufferU16x2* tmpParam = const_cast<BufferU16x2*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType BufferU16x2::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType BufferU16x2::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void BufferU16x2::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<BufferU16x2::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void BufferU16x2::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void BufferU16x2::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="data"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("data", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for SHORT2 formats", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="data[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("data", TYPE_STRUCT, "U16x2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for SHORT2 formats", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="data[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("x", TYPE_U16, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "X", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="data[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("y", TYPE_U16, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Y", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="data"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="data[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void BufferU16x2::initStrings(void)
+{
+}
+
+void BufferU16x2::initDynamicArrays(void)
+{
+	data.buf = NULL;
+	data.isAllocated = true;
+	data.elementSize = sizeof(U16x2_Type);
+	data.arraySizes[0] = 0;
+}
+
+void BufferU16x2::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void BufferU16x2::initReferences(void)
+{
+}
+
+void BufferU16x2::freeDynamicArrays(void)
+{
+	if (data.isAllocated && data.buf)
+	{
+		mParameterizedTraits->free(data.buf);
+	}
+}
+
+void BufferU16x2::freeStrings(void)
+{
+}
+
+void BufferU16x2::freeReferences(void)
+{
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/BufferU16x3.cpp b/APEX_1.4/framework/src/autogen/BufferU16x3.cpp
new file mode 100644
index 00000000..b96bedda
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/BufferU16x3.cpp
@@ -0,0 +1,425 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "BufferU16x3.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace BufferU16x3NS;
+
+const char* const BufferU16x3Factory::vptr =
+    NvParameterized::getVptr<BufferU16x3, BufferU16x3::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->data), CHILDREN(1), 1 }, // data
+	{ TYPE_STRUCT, false, 1 * sizeof(U16x3_Type), CHILDREN(2), 3 }, // data[]
+	{ TYPE_U16, false, (size_t)(&((U16x3_Type*)0)->x), NULL, 0 }, // data[].x
+	{ TYPE_U16, false, (size_t)(&((U16x3_Type*)0)->y), NULL, 0 }, // data[].y
+	{ TYPE_U16, false, (size_t)(&((U16x3_Type*)0)->z), NULL, 0 }, // data[].z
+};
+
+
+bool BufferU16x3::mBuiltFlag = false;
+NvParameterized::MutexType BufferU16x3::mBuiltFlagMutex;
+
+BufferU16x3::BufferU16x3(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &BufferU16x3FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+BufferU16x3::~BufferU16x3()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void BufferU16x3::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~BufferU16x3();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* BufferU16x3::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* BufferU16x3::getParameterDefinitionTree(void) const
+{
+	BufferU16x3* tmpParam = const_cast<BufferU16x3*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType BufferU16x3::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType BufferU16x3::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void BufferU16x3::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<BufferU16x3::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void BufferU16x3::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void BufferU16x3::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="data"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("data", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for SHORT3 formats", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="data[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("data", TYPE_STRUCT, "U16x3", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for SHORT3 formats", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="data[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("x", TYPE_U16, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "X", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="data[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("y", TYPE_U16, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Y", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="data[].z"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("z", TYPE_U16, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Z", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="data"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="data[]"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+		Children[2] = PDEF_PTR(5);
+
+		ParamDefTable[2].setChildren(Children, 3);
+	}
+
+	mBuiltFlag = true;
+
+}
+void BufferU16x3::initStrings(void)
+{
+}
+
+void BufferU16x3::initDynamicArrays(void)
+{
+	data.buf = NULL;
+	data.isAllocated = true;
+	data.elementSize = sizeof(U16x3_Type);
+	data.arraySizes[0] = 0;
+}
+
+void BufferU16x3::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void BufferU16x3::initReferences(void)
+{
+}
+
+void BufferU16x3::freeDynamicArrays(void)
+{
+	if (data.isAllocated && data.buf)
+	{
+		mParameterizedTraits->free(data.buf);
+	}
+}
+
+void BufferU16x3::freeStrings(void)
+{
+}
+
+void BufferU16x3::freeReferences(void)
+{
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/BufferU16x4.cpp b/APEX_1.4/framework/src/autogen/BufferU16x4.cpp
new file mode 100644
index 00000000..ef45641b
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/BufferU16x4.cpp
@@ -0,0 +1,449 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "BufferU16x4.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace BufferU16x4NS;
+
+const char* const BufferU16x4Factory::vptr =
+    NvParameterized::getVptr<BufferU16x4, BufferU16x4::ClassAlignment>();
+
+const uint32_t NumParamDefs = 7;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5, 6,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->data), CHILDREN(1), 1 }, // data
+	{ TYPE_STRUCT, false, 1 * sizeof(U16x4_Type), CHILDREN(2), 4 }, // data[]
+	{ TYPE_U16, false, (size_t)(&((U16x4_Type*)0)->x), NULL, 0 }, // data[].x
+	{ TYPE_U16, false, (size_t)(&((U16x4_Type*)0)->y), NULL, 0 }, // data[].y
+	{ TYPE_U16, false, (size_t)(&((U16x4_Type*)0)->z), NULL, 0 }, // data[].z
+	{ TYPE_U16, false, (size_t)(&((U16x4_Type*)0)->w), NULL, 0 }, // data[].w
+};
+
+
+bool BufferU16x4::mBuiltFlag = false;
+NvParameterized::MutexType BufferU16x4::mBuiltFlagMutex;
+
+BufferU16x4::BufferU16x4(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &BufferU16x4FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+BufferU16x4::~BufferU16x4()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void BufferU16x4::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~BufferU16x4();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* BufferU16x4::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* BufferU16x4::getParameterDefinitionTree(void) const
+{
+	BufferU16x4* tmpParam = const_cast<BufferU16x4*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType BufferU16x4::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType BufferU16x4::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void BufferU16x4::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<BufferU16x4::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void BufferU16x4::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void BufferU16x4::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="data"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("data", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for SHORT4 formats", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="data[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("data", TYPE_STRUCT, "U16x4", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for SHORT4 formats", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="data[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("x", TYPE_U16, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "X", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="data[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("y", TYPE_U16, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Y", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="data[].z"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("z", TYPE_U16, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Z", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="data[].w"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("w", TYPE_U16, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "W", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="data"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="data[]"
+	{
+		static Definition* Children[4];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+		Children[2] = PDEF_PTR(5);
+		Children[3] = PDEF_PTR(6);
+
+		ParamDefTable[2].setChildren(Children, 4);
+	}
+
+	mBuiltFlag = true;
+
+}
+void BufferU16x4::initStrings(void)
+{
+}
+
+void BufferU16x4::initDynamicArrays(void)
+{
+	data.buf = NULL;
+	data.isAllocated = true;
+	data.elementSize = sizeof(U16x4_Type);
+	data.arraySizes[0] = 0;
+}
+
+void BufferU16x4::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void BufferU16x4::initReferences(void)
+{
+}
+
+void BufferU16x4::freeDynamicArrays(void)
+{
+	if (data.isAllocated && data.buf)
+	{
+		mParameterizedTraits->free(data.buf);
+	}
+}
+
+void BufferU16x4::freeStrings(void)
+{
+}
+
+void BufferU16x4::freeReferences(void)
+{
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/BufferU32x1.cpp b/APEX_1.4/framework/src/autogen/BufferU32x1.cpp
new file mode 100644
index 00000000..347d460b
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/BufferU32x1.cpp
@@ -0,0 +1,346 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "BufferU32x1.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace BufferU32x1NS;
+
+const char* const BufferU32x1Factory::vptr =
+    NvParameterized::getVptr<BufferU32x1, BufferU32x1::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->data), CHILDREN(1), 1 }, // data
+	{ TYPE_U32, false, 1 * sizeof(uint32_t), NULL, 0 }, // data[]
+};
+
+
+bool BufferU32x1::mBuiltFlag = false;
+NvParameterized::MutexType BufferU32x1::mBuiltFlagMutex;
+
+BufferU32x1::BufferU32x1(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &BufferU32x1FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+BufferU32x1::~BufferU32x1()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void BufferU32x1::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~BufferU32x1();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* BufferU32x1::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* BufferU32x1::getParameterDefinitionTree(void) const
+{
+	BufferU32x1* tmpParam = const_cast<BufferU32x1*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType BufferU32x1::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType BufferU32x1::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void BufferU32x1::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<BufferU32x1::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void BufferU32x1::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void BufferU32x1::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="data"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("data", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for INT1 formats", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="data[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("data", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for INT1 formats", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="data"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void BufferU32x1::initStrings(void)
+{
+}
+
+void BufferU32x1::initDynamicArrays(void)
+{
+	data.buf = NULL;
+	data.isAllocated = true;
+	data.elementSize = sizeof(uint32_t);
+	data.arraySizes[0] = 0;
+}
+
+void BufferU32x1::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void BufferU32x1::initReferences(void)
+{
+}
+
+void BufferU32x1::freeDynamicArrays(void)
+{
+	if (data.isAllocated && data.buf)
+	{
+		mParameterizedTraits->free(data.buf);
+	}
+}
+
+void BufferU32x1::freeStrings(void)
+{
+}
+
+void BufferU32x1::freeReferences(void)
+{
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/BufferU32x2.cpp b/APEX_1.4/framework/src/autogen/BufferU32x2.cpp
new file mode 100644
index 00000000..6a62dd05
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/BufferU32x2.cpp
@@ -0,0 +1,401 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "BufferU32x2.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace BufferU32x2NS;
+
+const char* const BufferU32x2Factory::vptr =
+    NvParameterized::getVptr<BufferU32x2, BufferU32x2::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->data), CHILDREN(1), 1 }, // data
+	{ TYPE_STRUCT, false, 1 * sizeof(U32x2_Type), CHILDREN(2), 2 }, // data[]
+	{ TYPE_U32, false, (size_t)(&((U32x2_Type*)0)->x), NULL, 0 }, // data[].x
+	{ TYPE_U32, false, (size_t)(&((U32x2_Type*)0)->y), NULL, 0 }, // data[].y
+};
+
+
+bool BufferU32x2::mBuiltFlag = false;
+NvParameterized::MutexType BufferU32x2::mBuiltFlagMutex;
+
+BufferU32x2::BufferU32x2(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &BufferU32x2FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+BufferU32x2::~BufferU32x2()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void BufferU32x2::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~BufferU32x2();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* BufferU32x2::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* BufferU32x2::getParameterDefinitionTree(void) const
+{
+	BufferU32x2* tmpParam = const_cast<BufferU32x2*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType BufferU32x2::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType BufferU32x2::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void BufferU32x2::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<BufferU32x2::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void BufferU32x2::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void BufferU32x2::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="data"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("data", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for INT2 formats", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="data[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("data", TYPE_STRUCT, "U32x2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for INT2 formats", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="data[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("x", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "X", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="data[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("y", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Y", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="data"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="data[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void BufferU32x2::initStrings(void)
+{
+}
+
+void BufferU32x2::initDynamicArrays(void)
+{
+	data.buf = NULL;
+	data.isAllocated = true;
+	data.elementSize = sizeof(U32x2_Type);
+	data.arraySizes[0] = 0;
+}
+
+void BufferU32x2::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void BufferU32x2::initReferences(void)
+{
+}
+
+void BufferU32x2::freeDynamicArrays(void)
+{
+	if (data.isAllocated && data.buf)
+	{
+		mParameterizedTraits->free(data.buf);
+	}
+}
+
+void BufferU32x2::freeStrings(void)
+{
+}
+
+void BufferU32x2::freeReferences(void)
+{
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/BufferU32x3.cpp b/APEX_1.4/framework/src/autogen/BufferU32x3.cpp
new file mode 100644
index 00000000..ccec68f0
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/BufferU32x3.cpp
@@ -0,0 +1,425 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "BufferU32x3.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace BufferU32x3NS;
+
+const char* const BufferU32x3Factory::vptr =
+    NvParameterized::getVptr<BufferU32x3, BufferU32x3::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->data), CHILDREN(1), 1 }, // data
+	{ TYPE_STRUCT, false, 1 * sizeof(U32x3_Type), CHILDREN(2), 3 }, // data[]
+	{ TYPE_U32, false, (size_t)(&((U32x3_Type*)0)->x), NULL, 0 }, // data[].x
+	{ TYPE_U32, false, (size_t)(&((U32x3_Type*)0)->y), NULL, 0 }, // data[].y
+	{ TYPE_U32, false, (size_t)(&((U32x3_Type*)0)->z), NULL, 0 }, // data[].z
+};
+
+
+bool BufferU32x3::mBuiltFlag = false;
+NvParameterized::MutexType BufferU32x3::mBuiltFlagMutex;
+
+BufferU32x3::BufferU32x3(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &BufferU32x3FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+BufferU32x3::~BufferU32x3()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void BufferU32x3::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~BufferU32x3();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* BufferU32x3::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* BufferU32x3::getParameterDefinitionTree(void) const
+{
+	BufferU32x3* tmpParam = const_cast<BufferU32x3*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType BufferU32x3::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType BufferU32x3::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void BufferU32x3::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<BufferU32x3::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void BufferU32x3::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void BufferU32x3::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="data"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("data", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for INT3 formats", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="data[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("data", TYPE_STRUCT, "U32x3", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for INT3 formats", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="data[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("x", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "X", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="data[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("y", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Y", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="data[].z"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("z", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Z", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="data"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="data[]"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+		Children[2] = PDEF_PTR(5);
+
+		ParamDefTable[2].setChildren(Children, 3);
+	}
+
+	mBuiltFlag = true;
+
+}
+void BufferU32x3::initStrings(void)
+{
+}
+
+void BufferU32x3::initDynamicArrays(void)
+{
+	data.buf = NULL;
+	data.isAllocated = true;
+	data.elementSize = sizeof(U32x3_Type);
+	data.arraySizes[0] = 0;
+}
+
+void BufferU32x3::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void BufferU32x3::initReferences(void)
+{
+}
+
+void BufferU32x3::freeDynamicArrays(void)
+{
+	if (data.isAllocated && data.buf)
+	{
+		mParameterizedTraits->free(data.buf);
+	}
+}
+
+void BufferU32x3::freeStrings(void)
+{
+}
+
+void BufferU32x3::freeReferences(void)
+{
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/BufferU32x4.cpp b/APEX_1.4/framework/src/autogen/BufferU32x4.cpp
new file mode 100644
index 00000000..26d43552
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/BufferU32x4.cpp
@@ -0,0 +1,449 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "BufferU32x4.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace BufferU32x4NS;
+
+const char* const BufferU32x4Factory::vptr =
+    NvParameterized::getVptr<BufferU32x4, BufferU32x4::ClassAlignment>();
+
+const uint32_t NumParamDefs = 7;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5, 6,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->data), CHILDREN(1), 1 }, // data
+	{ TYPE_STRUCT, false, 1 * sizeof(U32x4_Type), CHILDREN(2), 4 }, // data[]
+	{ TYPE_U32, false, (size_t)(&((U32x4_Type*)0)->x), NULL, 0 }, // data[].x
+	{ TYPE_U32, false, (size_t)(&((U32x4_Type*)0)->y), NULL, 0 }, // data[].y
+	{ TYPE_U32, false, (size_t)(&((U32x4_Type*)0)->z), NULL, 0 }, // data[].z
+	{ TYPE_U32, false, (size_t)(&((U32x4_Type*)0)->w), NULL, 0 }, // data[].w
+};
+
+
+bool BufferU32x4::mBuiltFlag = false;
+NvParameterized::MutexType BufferU32x4::mBuiltFlagMutex;
+
+BufferU32x4::BufferU32x4(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &BufferU32x4FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+BufferU32x4::~BufferU32x4()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void BufferU32x4::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~BufferU32x4();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* BufferU32x4::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* BufferU32x4::getParameterDefinitionTree(void) const
+{
+	BufferU32x4* tmpParam = const_cast<BufferU32x4*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType BufferU32x4::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType BufferU32x4::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void BufferU32x4::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<BufferU32x4::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void BufferU32x4::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void BufferU32x4::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="data"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("data", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for INT4 formats", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="data[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("data", TYPE_STRUCT, "U32x4", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for INT4 formats", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="data[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("x", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "X", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="data[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("y", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Y", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="data[].z"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("z", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Z", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="data[].w"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("w", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "W", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="data"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="data[]"
+	{
+		static Definition* Children[4];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+		Children[2] = PDEF_PTR(5);
+		Children[3] = PDEF_PTR(6);
+
+		ParamDefTable[2].setChildren(Children, 4);
+	}
+
+	mBuiltFlag = true;
+
+}
+void BufferU32x4::initStrings(void)
+{
+}
+
+void BufferU32x4::initDynamicArrays(void)
+{
+	data.buf = NULL;
+	data.isAllocated = true;
+	data.elementSize = sizeof(U32x4_Type);
+	data.arraySizes[0] = 0;
+}
+
+void BufferU32x4::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void BufferU32x4::initReferences(void)
+{
+}
+
+void BufferU32x4::freeDynamicArrays(void)
+{
+	if (data.isAllocated && data.buf)
+	{
+		mParameterizedTraits->free(data.buf);
+	}
+}
+
+void BufferU32x4::freeStrings(void)
+{
+}
+
+void BufferU32x4::freeReferences(void)
+{
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/BufferU8x1.cpp b/APEX_1.4/framework/src/autogen/BufferU8x1.cpp
new file mode 100644
index 00000000..c187331a
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/BufferU8x1.cpp
@@ -0,0 +1,346 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "BufferU8x1.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace BufferU8x1NS;
+
+const char* const BufferU8x1Factory::vptr =
+    NvParameterized::getVptr<BufferU8x1, BufferU8x1::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->data), CHILDREN(1), 1 }, // data
+	{ TYPE_U8, false, 1 * sizeof(uint8_t), NULL, 0 }, // data[]
+};
+
+
+bool BufferU8x1::mBuiltFlag = false;
+NvParameterized::MutexType BufferU8x1::mBuiltFlagMutex;
+
+BufferU8x1::BufferU8x1(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &BufferU8x1FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+BufferU8x1::~BufferU8x1()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void BufferU8x1::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~BufferU8x1();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* BufferU8x1::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* BufferU8x1::getParameterDefinitionTree(void) const
+{
+	BufferU8x1* tmpParam = const_cast<BufferU8x1*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType BufferU8x1::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType BufferU8x1::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void BufferU8x1::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<BufferU8x1::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void BufferU8x1::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void BufferU8x1::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="data"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("data", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for BYTE1 formats", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="data[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("data", TYPE_U8, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for BYTE1 formats", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="data"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void BufferU8x1::initStrings(void)
+{
+}
+
+void BufferU8x1::initDynamicArrays(void)
+{
+	data.buf = NULL;
+	data.isAllocated = true;
+	data.elementSize = sizeof(uint8_t);
+	data.arraySizes[0] = 0;
+}
+
+void BufferU8x1::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void BufferU8x1::initReferences(void)
+{
+}
+
+void BufferU8x1::freeDynamicArrays(void)
+{
+	if (data.isAllocated && data.buf)
+	{
+		mParameterizedTraits->free(data.buf);
+	}
+}
+
+void BufferU8x1::freeStrings(void)
+{
+}
+
+void BufferU8x1::freeReferences(void)
+{
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/BufferU8x2.cpp b/APEX_1.4/framework/src/autogen/BufferU8x2.cpp
new file mode 100644
index 00000000..627ff879
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/BufferU8x2.cpp
@@ -0,0 +1,401 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "BufferU8x2.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace BufferU8x2NS;
+
+const char* const BufferU8x2Factory::vptr =
+    NvParameterized::getVptr<BufferU8x2, BufferU8x2::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->data), CHILDREN(1), 1 }, // data
+	{ TYPE_STRUCT, false, 1 * sizeof(U8x2_Type), CHILDREN(2), 2 }, // data[]
+	{ TYPE_U8, false, (size_t)(&((U8x2_Type*)0)->x), NULL, 0 }, // data[].x
+	{ TYPE_U8, false, (size_t)(&((U8x2_Type*)0)->y), NULL, 0 }, // data[].y
+};
+
+
+bool BufferU8x2::mBuiltFlag = false;
+NvParameterized::MutexType BufferU8x2::mBuiltFlagMutex;
+
+BufferU8x2::BufferU8x2(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &BufferU8x2FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+BufferU8x2::~BufferU8x2()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void BufferU8x2::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~BufferU8x2();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* BufferU8x2::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* BufferU8x2::getParameterDefinitionTree(void) const
+{
+	BufferU8x2* tmpParam = const_cast<BufferU8x2*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType BufferU8x2::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType BufferU8x2::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void BufferU8x2::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<BufferU8x2::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void BufferU8x2::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void BufferU8x2::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="data"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("data", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for BYTE2 formats", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="data[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("data", TYPE_STRUCT, "U8x2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for BYTE2 formats", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="data[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("x", TYPE_U8, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "X", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="data[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("y", TYPE_U8, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Y", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="data"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="data[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void BufferU8x2::initStrings(void)
+{
+}
+
+void BufferU8x2::initDynamicArrays(void)
+{
+	data.buf = NULL;
+	data.isAllocated = true;
+	data.elementSize = sizeof(U8x2_Type);
+	data.arraySizes[0] = 0;
+}
+
+void BufferU8x2::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void BufferU8x2::initReferences(void)
+{
+}
+
+void BufferU8x2::freeDynamicArrays(void)
+{
+	if (data.isAllocated && data.buf)
+	{
+		mParameterizedTraits->free(data.buf);
+	}
+}
+
+void BufferU8x2::freeStrings(void)
+{
+}
+
+void BufferU8x2::freeReferences(void)
+{
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/BufferU8x3.cpp b/APEX_1.4/framework/src/autogen/BufferU8x3.cpp
new file mode 100644
index 00000000..274b14cf
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/BufferU8x3.cpp
@@ -0,0 +1,425 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "BufferU8x3.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace BufferU8x3NS;
+
+const char* const BufferU8x3Factory::vptr =
+    NvParameterized::getVptr<BufferU8x3, BufferU8x3::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->data), CHILDREN(1), 1 }, // data
+	{ TYPE_STRUCT, false, 1 * sizeof(U8x3_Type), CHILDREN(2), 3 }, // data[]
+	{ TYPE_U8, false, (size_t)(&((U8x3_Type*)0)->x), NULL, 0 }, // data[].x
+	{ TYPE_U8, false, (size_t)(&((U8x3_Type*)0)->y), NULL, 0 }, // data[].y
+	{ TYPE_U8, false, (size_t)(&((U8x3_Type*)0)->z), NULL, 0 }, // data[].z
+};
+
+
+bool BufferU8x3::mBuiltFlag = false;
+NvParameterized::MutexType BufferU8x3::mBuiltFlagMutex;
+
+BufferU8x3::BufferU8x3(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &BufferU8x3FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+BufferU8x3::~BufferU8x3()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void BufferU8x3::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~BufferU8x3();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* BufferU8x3::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* BufferU8x3::getParameterDefinitionTree(void) const
+{
+	BufferU8x3* tmpParam = const_cast<BufferU8x3*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType BufferU8x3::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType BufferU8x3::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void BufferU8x3::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<BufferU8x3::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void BufferU8x3::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void BufferU8x3::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="data"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("data", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for BYTE3 formats", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="data[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("data", TYPE_STRUCT, "U8x3", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for BYTE3 formats", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="data[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("x", TYPE_U8, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "X", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="data[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("y", TYPE_U8, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Y", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="data[].z"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("z", TYPE_U8, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Z", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="data"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="data[]"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+		Children[2] = PDEF_PTR(5);
+
+		ParamDefTable[2].setChildren(Children, 3);
+	}
+
+	mBuiltFlag = true;
+
+}
+void BufferU8x3::initStrings(void)
+{
+}
+
+void BufferU8x3::initDynamicArrays(void)
+{
+	data.buf = NULL;
+	data.isAllocated = true;
+	data.elementSize = sizeof(U8x3_Type);
+	data.arraySizes[0] = 0;
+}
+
+void BufferU8x3::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void BufferU8x3::initReferences(void)
+{
+}
+
+void BufferU8x3::freeDynamicArrays(void)
+{
+	if (data.isAllocated && data.buf)
+	{
+		mParameterizedTraits->free(data.buf);
+	}
+}
+
+void BufferU8x3::freeStrings(void)
+{
+}
+
+void BufferU8x3::freeReferences(void)
+{
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/BufferU8x4.cpp b/APEX_1.4/framework/src/autogen/BufferU8x4.cpp
new file mode 100644
index 00000000..5881b86c
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/BufferU8x4.cpp
@@ -0,0 +1,449 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "BufferU8x4.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace BufferU8x4NS;
+
+const char* const BufferU8x4Factory::vptr =
+    NvParameterized::getVptr<BufferU8x4, BufferU8x4::ClassAlignment>();
+
+const uint32_t NumParamDefs = 7;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5, 6,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->data), CHILDREN(1), 1 }, // data
+	{ TYPE_STRUCT, false, 1 * sizeof(U8x4_Type), CHILDREN(2), 4 }, // data[]
+	{ TYPE_U8, false, (size_t)(&((U8x4_Type*)0)->x), NULL, 0 }, // data[].x
+	{ TYPE_U8, false, (size_t)(&((U8x4_Type*)0)->y), NULL, 0 }, // data[].y
+	{ TYPE_U8, false, (size_t)(&((U8x4_Type*)0)->z), NULL, 0 }, // data[].z
+	{ TYPE_U8, false, (size_t)(&((U8x4_Type*)0)->w), NULL, 0 }, // data[].w
+};
+
+
+bool BufferU8x4::mBuiltFlag = false;
+NvParameterized::MutexType BufferU8x4::mBuiltFlagMutex;
+
+BufferU8x4::BufferU8x4(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &BufferU8x4FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+BufferU8x4::~BufferU8x4()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void BufferU8x4::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~BufferU8x4();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* BufferU8x4::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* BufferU8x4::getParameterDefinitionTree(void) const
+{
+	BufferU8x4* tmpParam = const_cast<BufferU8x4*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType BufferU8x4::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType BufferU8x4::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void BufferU8x4::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<BufferU8x4::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void BufferU8x4::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void BufferU8x4::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="data"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("data", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for BYTE4 formats", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="data[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("data", TYPE_STRUCT, "U8x4", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Container for BYTE4 formats", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="data[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("x", TYPE_U8, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "X", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="data[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("y", TYPE_U8, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Y", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="data[].z"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("z", TYPE_U8, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Z", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="data[].w"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("w", TYPE_U8, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "W", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="data"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="data[]"
+	{
+		static Definition* Children[4];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+		Children[2] = PDEF_PTR(5);
+		Children[3] = PDEF_PTR(6);
+
+		ParamDefTable[2].setChildren(Children, 4);
+	}
+
+	mBuiltFlag = true;
+
+}
+void BufferU8x4::initStrings(void)
+{
+}
+
+void BufferU8x4::initDynamicArrays(void)
+{
+	data.buf = NULL;
+	data.isAllocated = true;
+	data.elementSize = sizeof(U8x4_Type);
+	data.arraySizes[0] = 0;
+}
+
+void BufferU8x4::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void BufferU8x4::initReferences(void)
+{
+}
+
+void BufferU8x4::freeDynamicArrays(void)
+{
+	if (data.isAllocated && data.buf)
+	{
+		mParameterizedTraits->free(data.buf);
+	}
+}
+
+void BufferU8x4::freeStrings(void)
+{
+}
+
+void BufferU8x4::freeReferences(void)
+{
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/RenderMeshAssetParameters.cpp b/APEX_1.4/framework/src/autogen/RenderMeshAssetParameters.cpp
new file mode 100644
index 00000000..17e27f95
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/RenderMeshAssetParameters.cpp
@@ -0,0 +1,621 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "RenderMeshAssetParameters.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace RenderMeshAssetParametersNS;
+
+const char* const RenderMeshAssetParametersFactory::vptr =
+    NvParameterized::getVptr<RenderMeshAssetParameters, RenderMeshAssetParameters::ClassAlignment>();
+
+const uint32_t NumParamDefs = 11;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 3, 5, 7, 8, 9, 10, 2, 4, 6,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 7 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->submeshes), CHILDREN(7), 1 }, // submeshes
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // submeshes[]
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->materialNames), CHILDREN(8), 1 }, // materialNames
+	{ TYPE_STRING, false, 1 * sizeof(NvParameterized::DummyStringStruct), NULL, 0 }, // materialNames[]
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->partBounds), CHILDREN(9), 1 }, // partBounds
+	{ TYPE_BOUNDS3, false, 1 * sizeof(physx::PxBounds3), NULL, 0 }, // partBounds[]
+	{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->textureUVOrigin), NULL, 0 }, // textureUVOrigin
+	{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->boneCount), NULL, 0 }, // boneCount
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->deleteStaticBuffersAfterUse), NULL, 0 }, // deleteStaticBuffersAfterUse
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->isReferenced), NULL, 0 }, // isReferenced
+};
+
+
+bool RenderMeshAssetParameters::mBuiltFlag = false;
+NvParameterized::MutexType RenderMeshAssetParameters::mBuiltFlagMutex;
+
+RenderMeshAssetParameters::RenderMeshAssetParameters(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &RenderMeshAssetParametersFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+RenderMeshAssetParameters::~RenderMeshAssetParameters()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void RenderMeshAssetParameters::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~RenderMeshAssetParameters();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* RenderMeshAssetParameters::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* RenderMeshAssetParameters::getParameterDefinitionTree(void) const
+{
+	RenderMeshAssetParameters* tmpParam = const_cast<RenderMeshAssetParameters*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType RenderMeshAssetParameters::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType RenderMeshAssetParameters::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void RenderMeshAssetParameters::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<RenderMeshAssetParameters::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [0] - submeshes (not an array of structs) */
+/* [0] - materialNames (not an array of structs) */
+
+void RenderMeshAssetParameters::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void RenderMeshAssetParameters::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="submeshes"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("submeshes", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "This is the array of submeshes which comprise the mesh.  Triangles are grouped\ninto submeshes, which correspond to a unique material name.  The distinction\nneed not be just material; this grouping may distinguish any render state which\nrequires a separate draw call.\n", true);
+		HintTable[2].init("shortDescription", "Array of submeshes", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "SubmeshParameters" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="submeshes[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("submeshes", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "This is the array of submeshes which comprise the mesh.  Triangles are grouped\ninto submeshes, which correspond to a unique material name.  The distinction\nneed not be just material; this grouping may distinguish any render state which\nrequires a separate draw call.\n", true);
+		HintTable[2].init("shortDescription", "Array of submeshes", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "SubmeshParameters" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="materialNames"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("materialNames", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "The material names which distinguish the submeshes (see submeshes).", true);
+		HintTable[1].init("shortDescription", "Array of material names", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="materialNames[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("materialNames", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "The material names which distinguish the submeshes (see submeshes).", true);
+		HintTable[1].init("shortDescription", "Array of material names", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="partBounds"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("partBounds", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "Array of axis-aligned bounding boxes for each part.  The bounds for part i are in partBounds[i].", true);
+		HintTable[1].init("shortDescription", "The AABBs of each mesh part", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="partBounds[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("partBounds", TYPE_BOUNDS3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "Array of axis-aligned bounding boxes for each part.  The bounds for part i are in partBounds[i].", true);
+		HintTable[1].init("shortDescription", "The AABBs of each mesh part", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="textureUVOrigin"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("textureUVOrigin", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "The texture origin convention to use for this mesh.  See TextureUVOrigin.", true);
+		HintTable[1].init("shortDescription", "Texture origin convention", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="boneCount"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("boneCount", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "The number of mesh-skinning bones.  For destructible assets, this is the same as the number of parts.", true);
+		HintTable[1].init("shortDescription", "The number of mesh-skinning bones", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="deleteStaticBuffersAfterUse"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("deleteStaticBuffersAfterUse", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "If set, static data buffers will be deleted after they are used in createRenderResources.", true);
+		HintTable[1].init("shortDescription", "If set, static data buffers will be deleted after they are used in createRenderResources.", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="isReferenced"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("isReferenced", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Is the render mesh asset referenced in other assets", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[7];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(3);
+		Children[2] = PDEF_PTR(5);
+		Children[3] = PDEF_PTR(7);
+		Children[4] = PDEF_PTR(8);
+		Children[5] = PDEF_PTR(9);
+		Children[6] = PDEF_PTR(10);
+
+		ParamDefTable[0].setChildren(Children, 7);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="submeshes"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="materialNames"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(4);
+
+		ParamDefTable[3].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=5, longName="partBounds"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(6);
+
+		ParamDefTable[5].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void RenderMeshAssetParameters::initStrings(void)
+{
+}
+
+void RenderMeshAssetParameters::initDynamicArrays(void)
+{
+	submeshes.buf = NULL;
+	submeshes.isAllocated = true;
+	submeshes.elementSize = sizeof(NvParameterized::Interface*);
+	submeshes.arraySizes[0] = 0;
+	materialNames.buf = NULL;
+	materialNames.isAllocated = true;
+	materialNames.elementSize = sizeof(NvParameterized::DummyStringStruct);
+	materialNames.arraySizes[0] = 0;
+	partBounds.buf = NULL;
+	partBounds.isAllocated = true;
+	partBounds.elementSize = sizeof(physx::PxBounds3);
+	partBounds.arraySizes[0] = 0;
+}
+
+void RenderMeshAssetParameters::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	textureUVOrigin = uint32_t(0);
+	boneCount = uint32_t(0);
+	deleteStaticBuffersAfterUse = bool(false);
+	isReferenced = bool(false);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void RenderMeshAssetParameters::initReferences(void)
+{
+}
+
+void RenderMeshAssetParameters::freeDynamicArrays(void)
+{
+	if (submeshes.isAllocated && submeshes.buf)
+	{
+		mParameterizedTraits->free(submeshes.buf);
+	}
+	if (materialNames.isAllocated && materialNames.buf)
+	{
+		mParameterizedTraits->free(materialNames.buf);
+	}
+	if (partBounds.isAllocated && partBounds.buf)
+	{
+		mParameterizedTraits->free(partBounds.buf);
+	}
+}
+
+void RenderMeshAssetParameters::freeStrings(void)
+{
+
+	for (int i = 0; i < materialNames.arraySizes[0]; ++i)
+	{
+		if (materialNames.buf[i].isAllocated && materialNames.buf[i].buf)
+		{
+			mParameterizedTraits->strfree((char*)materialNames.buf[i].buf);
+		}
+	}
+}
+
+void RenderMeshAssetParameters::freeReferences(void)
+{
+
+	for (int i = 0; i < submeshes.arraySizes[0]; ++i)
+	{
+		if (submeshes.buf[i])
+		{
+			submeshes.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/SubmeshParameters.cpp b/APEX_1.4/framework/src/autogen/SubmeshParameters.cpp
new file mode 100644
index 00000000..dd404888
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/SubmeshParameters.cpp
@@ -0,0 +1,595 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "SubmeshParameters.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace SubmeshParametersNS;
+
+const char* const SubmeshParametersFactory::vptr =
+    NvParameterized::getVptr<SubmeshParameters, SubmeshParameters::ClassAlignment>();
+
+const uint32_t NumParamDefs = 10;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 4, 6, 8, 3, 5, 7, 9,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 5 },
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->vertexBuffer), NULL, 0 }, // vertexBuffer
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->indexBuffer), CHILDREN(5), 1 }, // indexBuffer
+	{ TYPE_U32, false, 1 * sizeof(uint32_t), NULL, 0 }, // indexBuffer[]
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->vertexPartition), CHILDREN(6), 1 }, // vertexPartition
+	{ TYPE_U32, false, 1 * sizeof(uint32_t), NULL, 0 }, // vertexPartition[]
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->indexPartition), CHILDREN(7), 1 }, // indexPartition
+	{ TYPE_U32, false, 1 * sizeof(uint32_t), NULL, 0 }, // indexPartition[]
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->smoothingGroups), CHILDREN(8), 1 }, // smoothingGroups
+	{ TYPE_U32, false, 1 * sizeof(uint32_t), NULL, 0 }, // smoothingGroups[]
+};
+
+
+bool SubmeshParameters::mBuiltFlag = false;
+NvParameterized::MutexType SubmeshParameters::mBuiltFlagMutex;
+
+SubmeshParameters::SubmeshParameters(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &SubmeshParametersFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+SubmeshParameters::~SubmeshParameters()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void SubmeshParameters::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~SubmeshParameters();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* SubmeshParameters::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* SubmeshParameters::getParameterDefinitionTree(void) const
+{
+	SubmeshParameters* tmpParam = const_cast<SubmeshParameters*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType SubmeshParameters::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType SubmeshParameters::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void SubmeshParameters::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<SubmeshParameters::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void SubmeshParameters::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void SubmeshParameters::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="vertexBuffer"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("vertexBuffer", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "This is the vertex buffer included with this submesh.  The submesh is defined\nby a vertex buffer and an index buffer (see indexBuffer).  The vertices for\ndifferent mesh parts are stored in contiguous subsets of the whole vertex buffer.\nThe vertexPartition array holds the offsets into the vertexBuffer for each part.\n", true);
+		HintTable[2].init("shortDescription", "The vertex buffer for this submesh", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "VertexBufferParameters" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="indexBuffer"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("indexBuffer", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("NOPVD", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("NOPVD", uint64_t(1), true);
+		HintTable[1].init("longDescription", "This is the vertex buffer included with this submesh.  The submesh is defined\nby a index buffer and an vertex buffer (see vertexBuffer).  The indices for\ndifferent mesh parts are stored in contiguous subsets of the whole index buffer.\nThe indexPartition array holds the offsets into the indexBuffer for each part.\n", true);
+		HintTable[2].init("shortDescription", "The index buffer for this submesh", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="indexBuffer[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("indexBuffer", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("NOPVD", uint64_t(1), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("NOPVD", uint64_t(1), true);
+		HintTable[1].init("longDescription", "This is the vertex buffer included with this submesh.  The submesh is defined\nby a index buffer and an vertex buffer (see vertexBuffer).  The indices for\ndifferent mesh parts are stored in contiguous subsets of the whole index buffer.\nThe indexPartition array holds the offsets into the indexBuffer for each part.\n", true);
+		HintTable[2].init("shortDescription", "The index buffer for this submesh", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="vertexPartition"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("vertexPartition", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "Index offset into vertexBuffer for each part.  The first vertex index for part\ni is vertexPartition[i]. The vertexPartition array size is N+1, where N = the\nnumber of mesh parts, and vertexPartition[N] = vertexBuffer.vertexCount (the\nsize of the vertex buffer). This way, the number of vertices for part i can be\nalways be obtained with vertexPartition[i+1]-vertexPartition[i].\n", true);
+		HintTable[1].init("shortDescription", "Part lookup into vertexBuffer", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="vertexPartition[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("vertexPartition", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "Index offset into vertexBuffer for each part.  The first vertex index for part\ni is vertexPartition[i]. The vertexPartition array size is N+1, where N = the\nnumber of mesh parts, and vertexPartition[N] = vertexBuffer.vertexCount (the\nsize of the vertex buffer). This way, the number of vertices for part i can be\nalways be obtained with vertexPartition[i+1]-vertexPartition[i].\n", true);
+		HintTable[1].init("shortDescription", "Part lookup into vertexBuffer", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="indexPartition"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("indexPartition", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "Index offset into indexBuffer for each part.  The first index location in\nindexPartition for part i is indexPartition[i].  The indexPartition array\nsize is N+1, where N = the number of mesh parts, and indexPartition[N] =\nthe size of the indexBuffer.  This way, the number of indices for part i\ncan be always be obtained with indexPartition[i+1]-indexPartition[i].\n", true);
+		HintTable[1].init("shortDescription", "Part lookup into indexBuffer", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="indexPartition[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("indexPartition", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "Index offset into indexBuffer for each part.  The first index location in\nindexPartition for part i is indexPartition[i].  The indexPartition array\nsize is N+1, where N = the number of mesh parts, and indexPartition[N] =\nthe size of the indexBuffer.  This way, the number of indices for part i\ncan be always be obtained with indexPartition[i+1]-indexPartition[i].\n", true);
+		HintTable[1].init("shortDescription", "Part lookup into indexBuffer", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="smoothingGroups"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("smoothingGroups", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "Per-triangle smoothing group masks", true);
+		HintTable[1].init("shortDescription", "Per-triangle smoothing group masks", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="smoothingGroups[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("smoothingGroups", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "Per-triangle smoothing group masks", true);
+		HintTable[1].init("shortDescription", "Per-triangle smoothing group masks", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[5];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(4);
+		Children[3] = PDEF_PTR(6);
+		Children[4] = PDEF_PTR(8);
+
+		ParamDefTable[0].setChildren(Children, 5);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="indexBuffer"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="vertexPartition"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(5);
+
+		ParamDefTable[4].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=6, longName="indexPartition"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(7);
+
+		ParamDefTable[6].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=8, longName="smoothingGroups"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(9);
+
+		ParamDefTable[8].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void SubmeshParameters::initStrings(void)
+{
+}
+
+void SubmeshParameters::initDynamicArrays(void)
+{
+	indexBuffer.buf = NULL;
+	indexBuffer.isAllocated = true;
+	indexBuffer.elementSize = sizeof(uint32_t);
+	indexBuffer.arraySizes[0] = 0;
+	vertexPartition.buf = NULL;
+	vertexPartition.isAllocated = true;
+	vertexPartition.elementSize = sizeof(uint32_t);
+	vertexPartition.arraySizes[0] = 0;
+	indexPartition.buf = NULL;
+	indexPartition.isAllocated = true;
+	indexPartition.elementSize = sizeof(uint32_t);
+	indexPartition.arraySizes[0] = 0;
+	smoothingGroups.buf = NULL;
+	smoothingGroups.isAllocated = true;
+	smoothingGroups.elementSize = sizeof(uint32_t);
+	smoothingGroups.arraySizes[0] = 0;
+}
+
+void SubmeshParameters::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void SubmeshParameters::initReferences(void)
+{
+	vertexBuffer = NULL;
+
+}
+
+void SubmeshParameters::freeDynamicArrays(void)
+{
+	if (indexBuffer.isAllocated && indexBuffer.buf)
+	{
+		mParameterizedTraits->free(indexBuffer.buf);
+	}
+	if (vertexPartition.isAllocated && vertexPartition.buf)
+	{
+		mParameterizedTraits->free(vertexPartition.buf);
+	}
+	if (indexPartition.isAllocated && indexPartition.buf)
+	{
+		mParameterizedTraits->free(indexPartition.buf);
+	}
+	if (smoothingGroups.isAllocated && smoothingGroups.buf)
+	{
+		mParameterizedTraits->free(smoothingGroups.buf);
+	}
+}
+
+void SubmeshParameters::freeStrings(void)
+{
+}
+
+void SubmeshParameters::freeReferences(void)
+{
+	if (vertexBuffer)
+	{
+		vertexBuffer->destroy();
+	}
+
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/SurfaceBufferParameters.cpp b/APEX_1.4/framework/src/autogen/SurfaceBufferParameters.cpp
new file mode 100644
index 00000000..e50ac12d
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/SurfaceBufferParameters.cpp
@@ -0,0 +1,404 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "SurfaceBufferParameters.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace SurfaceBufferParametersNS;
+
+const char* const SurfaceBufferParametersFactory::vptr =
+    NvParameterized::getVptr<SurfaceBufferParameters, SurfaceBufferParameters::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 4 },
+	{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->width), NULL, 0 }, // width
+	{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->height), NULL, 0 }, // height
+	{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->surfaceFormat), NULL, 0 }, // surfaceFormat
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->buffer), NULL, 0 }, // buffer
+};
+
+
+bool SurfaceBufferParameters::mBuiltFlag = false;
+NvParameterized::MutexType SurfaceBufferParameters::mBuiltFlagMutex;
+
+SurfaceBufferParameters::SurfaceBufferParameters(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &SurfaceBufferParametersFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+SurfaceBufferParameters::~SurfaceBufferParameters()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void SurfaceBufferParameters::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~SurfaceBufferParameters();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* SurfaceBufferParameters::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* SurfaceBufferParameters::getParameterDefinitionTree(void) const
+{
+	SurfaceBufferParameters* tmpParam = const_cast<SurfaceBufferParameters*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType SurfaceBufferParameters::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType SurfaceBufferParameters::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void SurfaceBufferParameters::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<SurfaceBufferParameters::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void SurfaceBufferParameters::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void SurfaceBufferParameters::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="width"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("width", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Number of point in U-dimension", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="height"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("height", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Number of point in V-dimension", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="surfaceFormat"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("surfaceFormat", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Attributes of the vertex buffer", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="buffer"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("buffer", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "This is the buffer data according to the description in the SurfaceFormat", true);
+		HintTable[2].init("shortDescription", "The data buffer", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "BufferU8x1", "BufferU8x2", "BufferU8x3", "BufferU8x4", "BufferU16x1", "BufferU16x2", "BufferU16x3", "BufferU16x4", "BufferU32x1", "BufferU32x2", "BufferU32x3", "BufferU32x4", "BufferF32x1", "BufferF32x2", "BufferF32x3", "BufferF32x4" };
+		ParamDefTable[4].setRefVariantVals((const char**)RefVariantVals, 16);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[4];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+		Children[3] = PDEF_PTR(4);
+
+		ParamDefTable[0].setChildren(Children, 4);
+	}
+
+	mBuiltFlag = true;
+
+}
+void SurfaceBufferParameters::initStrings(void)
+{
+}
+
+void SurfaceBufferParameters::initDynamicArrays(void)
+{
+}
+
+void SurfaceBufferParameters::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	width = uint32_t(0);
+	height = uint32_t(0);
+	surfaceFormat = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void SurfaceBufferParameters::initReferences(void)
+{
+	buffer = NULL;
+
+}
+
+void SurfaceBufferParameters::freeDynamicArrays(void)
+{
+}
+
+void SurfaceBufferParameters::freeStrings(void)
+{
+}
+
+void SurfaceBufferParameters::freeReferences(void)
+{
+	if (buffer)
+	{
+		buffer->destroy();
+	}
+
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/VertexBufferParameters.cpp b/APEX_1.4/framework/src/autogen/VertexBufferParameters.cpp
new file mode 100644
index 00000000..b13f3e34
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/VertexBufferParameters.cpp
@@ -0,0 +1,446 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "VertexBufferParameters.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace VertexBufferParametersNS;
+
+const char* const VertexBufferParametersFactory::vptr =
+    NvParameterized::getVptr<VertexBufferParameters, VertexBufferParameters::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->vertexCount), NULL, 0 }, // vertexCount
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->vertexFormat), NULL, 0 }, // vertexFormat
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->buffers), CHILDREN(3), 1 }, // buffers
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // buffers[]
+};
+
+
+bool VertexBufferParameters::mBuiltFlag = false;
+NvParameterized::MutexType VertexBufferParameters::mBuiltFlagMutex;
+
+VertexBufferParameters::VertexBufferParameters(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &VertexBufferParametersFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+VertexBufferParameters::~VertexBufferParameters()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void VertexBufferParameters::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~VertexBufferParameters();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* VertexBufferParameters::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* VertexBufferParameters::getParameterDefinitionTree(void) const
+{
+	VertexBufferParameters* tmpParam = const_cast<VertexBufferParameters*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType VertexBufferParameters::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType VertexBufferParameters::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void VertexBufferParameters::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<VertexBufferParameters::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [0] - buffers (not an array of structs) */
+
+void VertexBufferParameters::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void VertexBufferParameters::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="vertexCount"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("vertexCount", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "The number of vertices in the verrtex buffer.  All vertex data channels (positions, normals, etc.) will contain this many items.", true);
+		HintTable[1].init("shortDescription", "Number of vertices", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="vertexFormat"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("vertexFormat", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "This describes the data channels which exist per vertex, the vertex winding order, custom buffers, etc.  See VertexFormatParameters.", true);
+		HintTable[2].init("shortDescription", "Attributes of the vertex buffer", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "VertexFormatParameters" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="buffers"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("buffers", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("NOPVD", uint64_t(1), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("NOPVD", uint64_t(1), true);
+		HintTable[2].init("longDescription", "This is the buffer data according to the description in the VertexFormat", true);
+		HintTable[3].init("shortDescription", "The data buffers for standard and custom semantics", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "BufferU8x1", "BufferU8x2", "BufferU8x3", "BufferU8x4", "BufferU16x1", "BufferU16x2", "BufferU16x3", "BufferU16x4", "BufferU32x1", "BufferU32x2", "BufferU32x3", "BufferU32x4", "BufferF32x1", "BufferF32x2", "BufferF32x3", "BufferF32x4" };
+		ParamDefTable[3].setRefVariantVals((const char**)RefVariantVals, 16);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="buffers[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("buffers", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("NOPVD", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("NOPVD", uint64_t(1), true);
+		HintTable[2].init("longDescription", "This is the buffer data according to the description in the VertexFormat", true);
+		HintTable[3].init("shortDescription", "The data buffers for standard and custom semantics", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "BufferU8x1", "BufferU8x2", "BufferU8x3", "BufferU8x4", "BufferU16x1", "BufferU16x2", "BufferU16x3", "BufferU16x4", "BufferU32x1", "BufferU32x2", "BufferU32x3", "BufferU32x4", "BufferF32x1", "BufferF32x2", "BufferF32x3", "BufferF32x4" };
+		ParamDefTable[4].setRefVariantVals((const char**)RefVariantVals, 16);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="buffers"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(4);
+
+		ParamDefTable[3].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void VertexBufferParameters::initStrings(void)
+{
+}
+
+void VertexBufferParameters::initDynamicArrays(void)
+{
+	buffers.buf = NULL;
+	buffers.isAllocated = true;
+	buffers.elementSize = sizeof(NvParameterized::Interface*);
+	buffers.arraySizes[0] = 0;
+}
+
+void VertexBufferParameters::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	vertexCount = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void VertexBufferParameters::initReferences(void)
+{
+	vertexFormat = NULL;
+
+}
+
+void VertexBufferParameters::freeDynamicArrays(void)
+{
+	if (buffers.isAllocated && buffers.buf)
+	{
+		mParameterizedTraits->free(buffers.buf);
+	}
+}
+
+void VertexBufferParameters::freeStrings(void)
+{
+}
+
+void VertexBufferParameters::freeReferences(void)
+{
+	if (vertexFormat)
+	{
+		vertexFormat->destroy();
+	}
+
+
+	for (int i = 0; i < buffers.arraySizes[0]; ++i)
+	{
+		if (buffers.buf[i])
+		{
+			buffers.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/autogen/VertexFormatParameters.cpp b/APEX_1.4/framework/src/autogen/VertexFormatParameters.cpp
new file mode 100644
index 00000000..2d90d3de
--- /dev/null
+++ b/APEX_1.4/framework/src/autogen/VertexFormatParameters.cpp
@@ -0,0 +1,569 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "VertexFormatParameters.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace apex
+{
+
+using namespace VertexFormatParametersNS;
+
+const char* const VertexFormatParametersFactory::vptr =
+    NvParameterized::getVptr<VertexFormatParameters, VertexFormatParameters::ClassAlignment>();
+
+const uint32_t NumParamDefs = 11;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->winding), NULL, 0 }, // winding
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->hasSeparateBoneBuffer), NULL, 0 }, // hasSeparateBoneBuffer
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->bufferFormats), CHILDREN(3), 1 }, // bufferFormats
+	{ TYPE_STRUCT, false, 1 * sizeof(BufferFormat_Type), CHILDREN(4), 6 }, // bufferFormats[]
+	{ TYPE_STRING, false, (size_t)(&((BufferFormat_Type*)0)->name), NULL, 0 }, // bufferFormats[].name
+	{ TYPE_I32, false, (size_t)(&((BufferFormat_Type*)0)->semantic), NULL, 0 }, // bufferFormats[].semantic
+	{ TYPE_U32, false, (size_t)(&((BufferFormat_Type*)0)->id), NULL, 0 }, // bufferFormats[].id
+	{ TYPE_U32, false, (size_t)(&((BufferFormat_Type*)0)->format), NULL, 0 }, // bufferFormats[].format
+	{ TYPE_U32, false, (size_t)(&((BufferFormat_Type*)0)->access), NULL, 0 }, // bufferFormats[].access
+	{ TYPE_BOOL, false, (size_t)(&((BufferFormat_Type*)0)->serialize), NULL, 0 }, // bufferFormats[].serialize
+};
+
+
+bool VertexFormatParameters::mBuiltFlag = false;
+NvParameterized::MutexType VertexFormatParameters::mBuiltFlagMutex;
+
+VertexFormatParameters::VertexFormatParameters(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &VertexFormatParametersFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+VertexFormatParameters::~VertexFormatParameters()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void VertexFormatParameters::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~VertexFormatParameters();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* VertexFormatParameters::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* VertexFormatParameters::getParameterDefinitionTree(void) const
+{
+	VertexFormatParameters* tmpParam = const_cast<VertexFormatParameters*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType VertexFormatParameters::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType VertexFormatParameters::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void VertexFormatParameters::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<VertexFormatParameters::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [1,0] - bufferFormats.name */
+
+void VertexFormatParameters::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void VertexFormatParameters::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="winding"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("winding", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "This value defines which vertex winding orders will be rendered.  See RenderCullMode.", true);
+		HintTable[1].init("shortDescription", "Vertex orders to be rendered", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="hasSeparateBoneBuffer"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("hasSeparateBoneBuffer", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "Whether or not there exists a separate bone buffer.", true);
+		HintTable[1].init("shortDescription", "Whether or not there exists a separate bone buffer", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="bufferFormats"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("bufferFormats", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "This includes Semantics/Names and Vertex Format for each buffer.", true);
+		HintTable[1].init("shortDescription", "Format of all buffers.", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[2] = { 1, 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 2);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="bufferFormats[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("bufferFormats", TYPE_STRUCT, "BufferFormat", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "This includes Semantics/Names and Vertex Format for each buffer.", true);
+		HintTable[1].init("shortDescription", "Format of all buffers.", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="bufferFormats[].name"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("name", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "Name by which this buffer is referenced, for custom semantics. For standard semantics, VertexFormat::getSemanticName() is used", true);
+		HintTable[1].init("shortDescription", "Name by which this buffer is referenced", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="bufferFormats[].semantic"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("semantic", TYPE_I32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "This buffer's semantic. If it's a custom buffer, it will be RenderVertexSemantic::CUSTOM.", true);
+		HintTable[1].init("shortDescription", "This buffer's semantic.", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="bufferFormats[].id"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("id", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "This buffer's id. See VertexFormat::getSemanticID and VertexFormat::getID.", true);
+		HintTable[1].init("shortDescription", "This buffer's id.", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="bufferFormats[].format"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("format", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "The format of this buffer. Must be one of the RenderDataFormat::Enum values.", true);
+		HintTable[1].init("shortDescription", "The format of this buffer", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="bufferFormats[].access"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("access", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "The access type for this buffer. Must be one of the VertexDataAccess::Enum values.", true);
+		HintTable[1].init("shortDescription", "The access type for this buffer", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="bufferFormats[].serialize"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("serialize", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("longDescription", "This is only needed if this buffer needs to be rendered, clothing custom buffer MAX_DISTANCE for example doesn't need it.", true);
+		HintTable[1].init("shortDescription", "Serialize this buffer", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="bufferFormats"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(4);
+
+		ParamDefTable[3].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="bufferFormats[]"
+	{
+		static Definition* Children[6];
+		Children[0] = PDEF_PTR(5);
+		Children[1] = PDEF_PTR(6);
+		Children[2] = PDEF_PTR(7);
+		Children[3] = PDEF_PTR(8);
+		Children[4] = PDEF_PTR(9);
+		Children[5] = PDEF_PTR(10);
+
+		ParamDefTable[4].setChildren(Children, 6);
+	}
+
+	mBuiltFlag = true;
+
+}
+void VertexFormatParameters::initStrings(void)
+{
+}
+
+void VertexFormatParameters::initDynamicArrays(void)
+{
+	bufferFormats.buf = NULL;
+	bufferFormats.isAllocated = true;
+	bufferFormats.elementSize = sizeof(BufferFormat_Type);
+	bufferFormats.arraySizes[0] = 0;
+}
+
+void VertexFormatParameters::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	winding = uint32_t(0);
+	hasSeparateBoneBuffer = bool(false);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void VertexFormatParameters::initReferences(void)
+{
+}
+
+void VertexFormatParameters::freeDynamicArrays(void)
+{
+	if (bufferFormats.isAllocated && bufferFormats.buf)
+	{
+		mParameterizedTraits->free(bufferFormats.buf);
+	}
+}
+
+void VertexFormatParameters::freeStrings(void)
+{
+
+	for (int i = 0; i < bufferFormats.arraySizes[0]; ++i)
+	{
+		if (bufferFormats.buf[i].name.isAllocated && bufferFormats.buf[i].name.buf)
+		{
+			mParameterizedTraits->strfree((char*)bufferFormats.buf[i].name.buf);
+		}
+	}
+}
+
+void VertexFormatParameters::freeReferences(void)
+{
+}
+
+} // namespace apex
+} // namespace nvidia
diff --git a/APEX_1.4/framework/src/windows/AgMMFile.cpp b/APEX_1.4/framework/src/windows/AgMMFile.cpp
new file mode 100644
index 00000000..2b637772
--- /dev/null
+++ b/APEX_1.4/framework/src/windows/AgMMFile.cpp
@@ -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.
+ */
+
+// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
+// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
+
+#include "AgMMFile.h"
+
+using namespace nvidia;
+
+AgMMFile::AgMMFile():
+mAddr(0), mSize(0), mFileH(0)
+{}
+
+AgMMFile::AgMMFile(char *name, unsigned int size, bool &alreadyExists)
+{
+	this->create(name, size, alreadyExists);
+}
+
+void AgMMFile::create(char *name, unsigned int size, bool &alreadyExists)
+{
+	alreadyExists = false;
+	mSize = size;
+
+	mFileH = CreateFileMapping(INVALID_HANDLE_VALUE,	// use paging file
+		NULL,											// default security
+		PAGE_READWRITE,									// read/write access
+		0,												// buffer size (upper 32bits)
+		mSize,											// buffer size (lower 32bits)
+		name);											// name of mapping object
+	if (mFileH == NULL || mFileH == INVALID_HANDLE_VALUE)
+	{
+		mSize=0;
+		mAddr=0;
+		return;
+	}
+
+	if (ERROR_ALREADY_EXISTS == GetLastError())
+	{
+		alreadyExists = true;
+	}
+
+	mAddr = MapViewOfFile(mFileH,		// handle to map object
+		FILE_MAP_READ|FILE_MAP_WRITE,	// read/write permission
+		0,                   
+		0,                   
+		mSize);
+
+	if (mFileH == NULL || mAddr == NULL)
+	{
+		mSize=0;
+		mAddr=0;
+		return;
+	}
+}
+
+void AgMMFile::destroy()
+{
+	if (!mAddr || !mFileH || !mSize)
+		return;
+
+	UnmapViewOfFile(mAddr);
+	CloseHandle(mFileH);
+
+	mAddr = 0;
+	mFileH = 0;
+	mSize = 0;
+}
+
+AgMMFile::~AgMMFile()
+{
+	destroy();
+}
diff --git a/APEX_1.4/framework/src/windows/AgMMFile.h b/APEX_1.4/framework/src/windows/AgMMFile.h
new file mode 100644
index 00000000..ca2ddd73
--- /dev/null
+++ b/APEX_1.4/framework/src/windows/AgMMFile.h
@@ -0,0 +1,39 @@
+/*
+ * 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.
+ */
+
+// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
+// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
+
+#ifndef AG_MMFILE_H
+#define AG_MMFILE_H
+
+#include "windows/PsWindowsInclude.h"
+
+namespace nvidia
+{
+	class AgMMFile
+	{
+	public:
+		AgMMFile();
+		AgMMFile(char *name, unsigned int size, bool &alreadyExists);
+		void create(char *name, unsigned int size, bool &alreadyExists);
+		unsigned int getSize() {return mSize;};
+		void * getAddr() {return mAddr;};
+		void destroy();
+		~AgMMFile();
+
+	private:
+		void *mAddr;
+		unsigned int mSize;
+		HANDLE mFileH;
+	};
+}
+
+#endif	// __AG_MM_FILE__
diff --git a/APEX_1.4/framework/src/windows/PhysXIndicator.cpp b/APEX_1.4/framework/src/windows/PhysXIndicator.cpp
new file mode 100644
index 00000000..0ea99185
--- /dev/null
+++ b/APEX_1.4/framework/src/windows/PhysXIndicator.cpp
@@ -0,0 +1,166 @@
+/*
+ * 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.
+ */
+
+// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
+// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
+
+#include "PhysXIndicator.h"
+#include "AgMMFile.h"
+
+#include <windows.h>
+#if _MSC_VER >= 1800
+#include <VersionHelpers.h>	// for IsWindowsVistaOrGreater
+#endif
+#include <stdio.h>
+
+using namespace nvidia;
+using namespace physx;
+
+// Scope-based to indicate to NV driver that CPU PhysX is happening
+PhysXCpuIndicator::PhysXCpuIndicator() :
+	mPhysXDataPtr(NULL)
+{
+	bool alreadyExists = false;
+	
+	mPhysXDataPtr = (physx::NvPhysXToDrv_Data_V1*)PhysXCpuIndicator::createIndicatorBlock(mSharedMemConfig, alreadyExists);
+	
+	if (!mPhysXDataPtr)
+	{
+		return;
+	}
+	
+	if (!alreadyExists)
+	{
+		mPhysXDataPtr->bGpuPhysicsPresent = 0;
+		mPhysXDataPtr->bCpuPhysicsPresent = 1;
+	}
+	else
+	{
+		mPhysXDataPtr->bCpuPhysicsPresent++;
+	}
+
+	// init header last to prevent race conditions
+	// this must be done because the driver may have already created the shared memory block,
+	// thus alreadyExists may be true, even if PhysX hasn't been initialized
+	NvPhysXToDrv_Header_Init(mPhysXDataPtr->header);
+}
+
+PhysXCpuIndicator::~PhysXCpuIndicator()
+{
+	if (!mPhysXDataPtr)
+	{
+		return;
+	}
+	
+	mPhysXDataPtr->bCpuPhysicsPresent--;
+	
+	mPhysXDataPtr = NULL;
+	mSharedMemConfig.destroy();
+}
+
+void* PhysXCpuIndicator::createIndicatorBlock(AgMMFile &mmfile, bool &alreadyExists)
+{
+	char configName[128];
+
+    // Get the windows version (we can only create Global\\ namespace objects in XP)
+#if _MSC_VER >= 1800
+	// Windows 8.1 SDK, which comes with VS2013, deprecated the GetVersionEx function
+	// Windows 8.1 SDK added the IsWindowsVistaOrGreater helper function which we use instead
+	BOOL bIsVistaOrGreater = IsWindowsVistaOrGreater();
+#else
+	OSVERSIONINFOEX windowsVersionInfo;
+
+	/**
+		Operating system		Version number
+		----------------		--------------
+		Windows 7				6.1
+		Windows Server 2008 R2	6.1
+		Windows Server 2008		6.0
+		Windows Vista			6.0
+		Windows Server 2003 R2	5.2
+		Windows Server 2003		5.2
+		Windows XP				5.1
+		Windows 2000			5.0
+	**/
+	windowsVersionInfo.dwOSVersionInfoSize = sizeof(windowsVersionInfo);
+	GetVersionEx((LPOSVERSIONINFO)&windowsVersionInfo);
+
+	bool bIsVistaOrGreater = (windowsVersionInfo.dwMajorVersion >= 6);
+#endif
+
+	if (bIsVistaOrGreater)
+	{
+		NvPhysXToDrv_Build_SectionName((uint32_t)GetCurrentProcessId(), configName);
+	}
+	else
+	{
+		NvPhysXToDrv_Build_SectionNameXP((uint32_t)GetCurrentProcessId(), configName);
+	}
+
+	mmfile.create(configName, sizeof(physx::NvPhysXToDrv_Data_V1), alreadyExists);
+
+	return mmfile.getAddr();
+}
+
+//-----------------------------------------------------------------------------------------------------------
+
+PhysXGpuIndicator::PhysXGpuIndicator() :
+	mPhysXDataPtr(NULL),
+	mAlreadyExists(false),
+	mGpuTrigger(false)
+{
+	mPhysXDataPtr = (physx::NvPhysXToDrv_Data_V1*)PhysXCpuIndicator::createIndicatorBlock(mSharedMemConfig, mAlreadyExists);
+	
+	// init header last to prevent race conditions
+	// this must be done because the driver may have already created the shared memory block,
+	// thus alreadyExists may be true, even if PhysX hasn't been initialized
+	NvPhysXToDrv_Header_Init(mPhysXDataPtr->header);
+}
+
+PhysXGpuIndicator::~PhysXGpuIndicator()
+{
+	gpuOff();
+	
+	mPhysXDataPtr = NULL;
+	mSharedMemConfig.destroy();
+}
+
+// Explicit set functions to indicate to NV driver that GPU PhysX is happening
+void PhysXGpuIndicator::gpuOn()
+{
+	if (!mPhysXDataPtr || mGpuTrigger)
+	{
+		return;
+	}
+
+	if (!mAlreadyExists)
+	{
+		mPhysXDataPtr->bGpuPhysicsPresent = 1;
+		mPhysXDataPtr->bCpuPhysicsPresent = 0;
+	}
+	else
+	{
+		mPhysXDataPtr->bGpuPhysicsPresent++;
+	}
+
+	mGpuTrigger = true;
+}
+
+void PhysXGpuIndicator::gpuOff()
+{
+	if (!mPhysXDataPtr || !mGpuTrigger)
+	{
+		return;
+	}
+
+	mPhysXDataPtr->bGpuPhysicsPresent--;
+
+	mGpuTrigger = false;
+}
diff --git a/APEX_1.4/framework/src/windows/PhysXIndicator.h b/APEX_1.4/framework/src/windows/PhysXIndicator.h
new file mode 100644
index 00000000..155dd4a8
--- /dev/null
+++ b/APEX_1.4/framework/src/windows/PhysXIndicator.h
@@ -0,0 +1,53 @@
+/*
+ * 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.
+ */
+
+// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
+// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
+
+#ifndef PHYS_XINDICATOR_H
+#define PHYS_XINDICATOR_H
+
+#include "AgMMFile.h"
+#include "nvPhysXtoDrv.h"
+
+namespace nvidia
+{
+	class PhysXCpuIndicator
+	{
+	public:
+		PhysXCpuIndicator();
+		~PhysXCpuIndicator();
+
+		static void* createIndicatorBlock(AgMMFile &mmfile, bool &alreadyExists);
+
+	private:
+		AgMMFile mSharedMemConfig;
+		physx::NvPhysXToDrv_Data_V1* mPhysXDataPtr;
+	};
+
+	class PhysXGpuIndicator
+	{
+	public:
+		PhysXGpuIndicator();
+		~PhysXGpuIndicator();
+
+		void gpuOn();
+		void gpuOff();
+
+	private:
+		AgMMFile mSharedMemConfig;
+		physx::NvPhysXToDrv_Data_V1* mPhysXDataPtr;
+		bool mAlreadyExists;
+		bool mGpuTrigger;
+
+	};
+}
+
+#endif	// __PHYSXINDICATOR_H__
diff --git a/APEX_1.4/framework/src/windows/nvPhysXtoDrv.h b/APEX_1.4/framework/src/windows/nvPhysXtoDrv.h
new file mode 100644
index 00000000..047763a1
--- /dev/null
+++ b/APEX_1.4/framework/src/windows/nvPhysXtoDrv.h
@@ -0,0 +1,77 @@
+/*
+ * 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.
+ */
+
+// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
+// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
+
+#ifndef NV_PHYS_XTO_DRV_H
+#define NV_PHYS_XTO_DRV_H
+
+// The puprose of this interface is to provide graphics drivers with information 
+// about PhysX state to draw PhysX visual indicator 
+
+// We share information between modules using a memory section object. PhysX creates 
+// such object, graphics drivers try to open it. The name of the object has 
+// fixed part (NvPhysXToDrv_SectionName) followed by the process id. This allows 
+// each process to have its own communication channel. 
+
+namespace physx
+{
+
+#define NvPhysXToDrv_SectionName "PH71828182845_" 
+
+// Vista apps cannot create stuff in Global\\ namespace when NOT elevated, so use local scope
+#define NvPhysXToDrv_Build_SectionName(PID, buf) sprintf(buf, NvPhysXToDrv_SectionName "%x", PID) 
+#define NvPhysXToDrv_Build_SectionNameXP(PID, buf) sprintf(buf, "Global\\" NvPhysXToDrv_SectionName "%x", PID) 
+
+typedef struct NvPhysXToDrv_Header_ 
+{ 
+    int signature; // header interface signature 
+    int version; // version of the interface 
+    int size; // size of the structure 
+    int reserved; // reserved, must be zero 
+}	NvPhysXToDrv_Header; 
+
+// this structure describes layout of data in the shared memory section 
+typedef struct NvPhysXToDrv_Data_V1_ 
+{ 
+    NvPhysXToDrv_Header header; // keep this member first in all versions of the interface. 
+
+    int bCpuPhysicsPresent; // nonzero if cpu physics is initialized 
+    int bGpuPhysicsPresent; // nonzero if gpu physics is initialized 
+
+}	NvPhysXToDrv_Data_V1; 
+
+// some random magic number as our interface signature 
+#define NvPhysXToDrv_Header_Signature 0xA7AB 
+
+// use the macro to setup the header to the latest version of the interface 
+// update the macro when a new verson of the interface is added 
+#define NvPhysXToDrv_Header_Init(header)               \
+{                                                      \
+    header.signature = NvPhysXToDrv_Header_Signature;  \
+    header.version = 1;                                \
+    header.size = sizeof(NvPhysXToDrv_Data_V1);        \
+    header.reserved = 0;                               \
+} 
+
+// validate the header against all known interface versions 
+// add validation checks when new interfaces are added 
+#define NvPhysXToDrv_Header_Validate(header, curVersion)   \
+  (                                                        \
+   (header.signature == NvPhysXToDrv_Header_Signature) &&  \
+   (header.version   == curVersion) &&                     \
+   (curVersion  == 1) &&                                   \
+   (header.size == sizeof(NvPhysXToDrv_Data_V1))           \
+  )
+
+}
+
+#endif	// __NVPHYSXTODRV_H__