Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

15 files changed, 5558 insertions, 0 deletions

diff --git a/APEX_1.4/module/forcefield/src/ForceFieldActorImpl.cpp b/APEX_1.4/module/forcefield/src/ForceFieldActorImpl.cpp
new file mode 100644
index 00000000..070594f5
--- /dev/null
+++ b/APEX_1.4/module/forcefield/src/ForceFieldActorImpl.cpp
@@ -0,0 +1,442 @@
+/*
+ * 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 "Apex.h"
+#include "ForceFieldActorImpl.h"
+#include "ForceFieldAssetImpl.h"
+#include "ForceFieldScene.h"
+#include "ApexSDKIntl.h"
+#include "SceneIntl.h"
+#include "ModuleForceField.h"
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+ForceFieldActorImpl::ForceFieldActorImpl(const ForceFieldActorDesc& desc, ForceFieldAssetImpl& asset, ResourceList& list, ForceFieldScene& scene):
+	mForceFieldScene(&scene),
+	mName(desc.actorName),
+	mAsset(&asset),
+	mEnable(true),
+	mElapsedTime(0)
+{
+	//not actually used
+	//mScale = desc.scale * mAsset->getDefaultScale();
+
+	list.add(*this);			// Add self to asset's list of actors
+	addSelfToContext(*scene.mApexScene->getApexContext());    // Add self to ApexScene
+	addSelfToContext(scene);	// Add self to FieldBoundaryScene's list of actors
+
+	initActorParams(desc.initialPose);
+	initFieldSampler(desc);
+}
+
+ForceFieldShapeType::Enum getIncludeShapeType(const ForceFieldAssetParams& assetParams)
+{
+	NvParameterized::Handle hEnum(assetParams);
+	assetParams.getParameterHandle("includeShapeParameters.shape", hEnum);
+	PX_ASSERT(hEnum.isValid());
+
+	// assuming that enums in ForceFieldAssetParamSchema line up with ForceFieldShapeType::Enum
+	int32_t shapeInt = hEnum.parameterDefinition()->enumValIndex(assetParams.includeShapeParameters.shape);
+	if (-1 != shapeInt)
+	{
+		return (ForceFieldShapeType::Enum)shapeInt;
+	}
+	return ForceFieldShapeType::NONE;
+}
+
+ForceFieldCoordinateSystemType::Enum getCoordinateSystemType(const GenericForceFieldKernelParams& assetParams)
+{
+	NvParameterized::Handle hEnum(assetParams);
+	assetParams.getParameterHandle("coordinateSystemParameters.type", hEnum);
+	PX_ASSERT(hEnum.isValid());
+
+	// assuming that enums in ForceFieldAssetParamSchema line up with ForceFieldShapeType::Enum
+	int32_t shapeInt = hEnum.parameterDefinition()->enumValIndex(assetParams.coordinateSystemParameters.type);
+	if (-1 != shapeInt)
+	{
+		return (ForceFieldCoordinateSystemType::Enum)shapeInt;
+	}
+	return ForceFieldCoordinateSystemType::CARTESIAN;
+}
+
+void ForceFieldActorImpl::initActorParams(const PxMat44& initialPose)
+{
+	mLifetime = mAsset->mParams->lifetime;
+
+	//ForceFieldFSKernelParams initialization
+	{
+		ForceFieldFSKernelParams& params = mKernelParams.getForceFieldFSKernelParams();
+		params.pose = initialPose;
+		params.strength = mAsset->mParams->strength;
+		params.includeShape.dimensions = mAsset->mParams->includeShapeParameters.dimensions;
+		params.includeShape.forceFieldToShape = mAsset->mParams->includeShapeParameters.forceFieldToShape;
+		params.includeShape.type = getIncludeShapeType(*mAsset->mParams);
+	}
+
+	if (mAsset->mGenericParams)
+	{
+		mKernelParams.kernelType = ForceFieldKernelType::GENERIC;
+		GenericForceFieldFSKernelParams& params = mKernelParams.getGenericForceFieldFSKernelParams();
+		
+		params.cs.torusRadius = mAsset->mGenericParams->coordinateSystemParameters.torusRadius;
+		params.cs.type = getCoordinateSystemType(*mAsset->mGenericParams);
+		params.constant = mAsset->mGenericParams->constant;
+		params.positionMultiplier = mAsset->mGenericParams->positionMultiplier;
+		params.positionTarget = mAsset->mGenericParams->positionTarget;
+		params.velocityMultiplier = mAsset->mGenericParams->velocityMultiplier;
+		params.velocityTarget = mAsset->mGenericParams->velocityTarget;
+		params.noise = mAsset->mGenericParams->noise;
+		params.falloffLinear = mAsset->mGenericParams->falloffLinear;
+		params.falloffQuadratic = mAsset->mGenericParams->falloffQuadratic;
+	}
+	else if (mAsset->mRadialParams)
+	{
+		mKernelParams.kernelType = ForceFieldKernelType::RADIAL;
+		RadialForceFieldFSKernelParams& params = mKernelParams.getRadialForceFieldFSKernelParams();
+		
+		// falloff parameters TODO: these should move to  mAsset->mRadialParams->parameters()
+		params.falloffTable.multiplier = mAsset->mFalloffParams->multiplier;
+		params.falloffTable.x1 = mAsset->mFalloffParams->start;
+		params.falloffTable.x2 = mAsset->mFalloffParams->end;
+		setRadialFalloffType(mAsset->mFalloffParams->type);
+
+		// noise parameters TODO: these should move to  mAsset->mRadialParams->parameters()
+		params.noiseParams.strength = mAsset->mNoiseParams->strength;
+		params.noiseParams.spaceScale = mAsset->mNoiseParams->spaceScale;
+		params.noiseParams.timeScale = mAsset->mNoiseParams->timeScale;
+		params.noiseParams.octaves = mAsset->mNoiseParams->octaves;
+
+		params.radius = mAsset->mRadialParams->radius;
+		PX_ASSERT(params.radius > 0.9e-3f);
+	}
+	else
+	{
+		PX_ASSERT(0 && "Invalid geometry type for APEX turbulence source.");
+		return;
+	}
+
+	//do first copy of double buffered params
+	memcpy(&mKernelExecutionParams, &mKernelParams, sizeof(ForceFieldFSKernelParamsUnion));
+}
+
+
+void ForceFieldActorImpl::setPhysXScene(PxScene* /*scene*/)
+{
+}
+
+PxScene* ForceFieldActorImpl::getPhysXScene() const
+{
+	return NULL;
+}
+
+void ForceFieldActorImpl::getLodRange(float& min, float& max, bool& intOnly) const
+{
+	READ_ZONE();
+	PX_UNUSED(min);
+	PX_UNUSED(max);
+	PX_UNUSED(intOnly);
+	APEX_INVALID_OPERATION("not implemented");
+}
+
+float ForceFieldActorImpl::getActiveLod() const
+{
+	READ_ZONE();
+	APEX_INVALID_OPERATION("ForceFieldActor does not support this operation");
+	return -1.0f;
+}
+
+void ForceFieldActorImpl::forceLod(float lod)
+{
+	WRITE_ZONE();
+	PX_UNUSED(lod);
+	APEX_INVALID_OPERATION("not implemented");
+}
+
+/* Must be defined inside CPP file, since they require knowledge of asset class */
+Asset* ForceFieldActorImpl::getOwner() const
+{
+	READ_ZONE();
+	return (Asset*)mAsset;
+}
+
+ForceFieldAsset* ForceFieldActorImpl::getForceFieldAsset() const
+{
+	READ_ZONE();
+	return mAsset;
+}
+
+void ForceFieldActorImpl::release()
+{
+	if (mInRelease)
+	{
+		return;
+	}
+	destroy();
+}
+
+void ForceFieldActorImpl::destroy()
+{
+	ApexActor::destroy();
+	setPhysXScene(NULL);
+	releaseFieldSampler();
+	delete this;
+}
+
+bool ForceFieldActorImpl::enable()
+{
+	WRITE_ZONE();
+	if (mEnable)
+	{
+		return true;
+	}
+	mEnable = true;
+	mFieldSamplerChanged = true;
+	return true;
+}
+
+bool ForceFieldActorImpl::disable()
+{
+	WRITE_ZONE();
+	if (!mEnable)
+	{
+		return true;
+	}
+	mEnable = false;
+	mFieldSamplerChanged = true;
+	return true;
+}
+
+PxMat44 ForceFieldActorImpl::getPose() const
+{
+	READ_ZONE();
+	const ForceFieldFSKernelParams& kernelParams = mKernelParams.getForceFieldFSKernelParams();
+	return kernelParams.pose;
+}
+
+void ForceFieldActorImpl::setPose(const PxMat44& pose)
+{
+	WRITE_ZONE();
+	ForceFieldFSKernelParams& kernelParams = mKernelParams.getForceFieldFSKernelParams();
+	kernelParams.pose = pose;
+	mFieldSamplerChanged = true;
+}
+
+//deprecated, has no effect
+void ForceFieldActorImpl::setScale(float)
+{
+	WRITE_ZONE();
+}
+
+void ForceFieldActorImpl::setStrength(const float strength)
+{
+	WRITE_ZONE();
+	ForceFieldFSKernelParams& kernelParams = mKernelParams.getForceFieldFSKernelParams();
+	kernelParams.strength = strength;
+	mFieldSamplerChanged = true;
+}
+
+void ForceFieldActorImpl::setLifetime(const float lifetime)
+{
+	WRITE_ZONE();
+	mLifetime = lifetime;
+	mFieldSamplerChanged = true;
+}
+
+//deprecated
+void ForceFieldActorImpl::setFalloffType(const char* type)
+{
+	WRITE_ZONE();
+	if (mKernelParams.kernelType == ForceFieldKernelType::RADIAL)
+	{
+		setRadialFalloffType(type);
+	}
+}
+
+//deprecated
+void ForceFieldActorImpl::setFalloffMultiplier(const float multiplier)
+{
+	WRITE_ZONE();
+	if (mKernelParams.kernelType == ForceFieldKernelType::RADIAL)
+	{
+		setRadialFalloffMultiplier(multiplier);
+	}
+}
+
+void ForceFieldActorImpl::setRadialFalloffType(const char* type)
+{
+	WRITE_ZONE();
+	PX_ASSERT(mKernelParams.kernelType == ForceFieldKernelType::RADIAL);
+	RadialForceFieldFSKernelParams& kernelParams = mKernelParams.getRadialForceFieldFSKernelParams();
+
+	ForceFieldFalloffType::Enum falloffType;
+
+	NvParameterized::Handle hEnum(mAsset->mFalloffParams);
+	mAsset->mFalloffParams->getParameterHandle("type", hEnum);
+	PX_ASSERT(hEnum.isValid());
+
+	// assuming that enums in ForceFieldAssetParamSchema line up with ForceFieldFalloffType::Enum
+	int32_t typeInt = hEnum.parameterDefinition()->enumValIndex(type);
+	if (-1 != typeInt)
+	{
+		falloffType = (ForceFieldFalloffType::Enum)typeInt;
+	}
+	else
+	{
+		falloffType = ForceFieldFalloffType::NONE;
+	}
+
+	switch (falloffType)
+	{
+	case ForceFieldFalloffType::LINEAR:
+		{
+			kernelParams.falloffTable.applyStoredTable(TableName::LINEAR);
+			break;
+		}
+	case ForceFieldFalloffType::STEEP:
+		{
+			kernelParams.falloffTable.applyStoredTable(TableName::STEEP);
+			break;
+		}
+	case ForceFieldFalloffType::SCURVE:
+		{
+			kernelParams.falloffTable.applyStoredTable(TableName::SCURVE);
+			break;
+		}
+	case ForceFieldFalloffType::CUSTOM:
+		{
+			kernelParams.falloffTable.applyStoredTable(TableName::CUSTOM);
+			break;
+		}
+	case ForceFieldFalloffType::NONE:
+		{
+			kernelParams.falloffTable.applyStoredTable(TableName::CUSTOM);	// all-1 stored table
+		}
+	}
+
+	kernelParams.falloffTable.buildTable();
+	mFieldSamplerChanged = true;
+}
+
+void ForceFieldActorImpl::setRadialFalloffMultiplier(const float multiplier)
+{
+	PX_ASSERT(mKernelParams.kernelType == ForceFieldKernelType::RADIAL);
+	RadialForceFieldFSKernelParams& kernelParams = mKernelParams.getRadialForceFieldFSKernelParams();
+
+	kernelParams.falloffTable.multiplier = multiplier;
+	kernelParams.falloffTable.buildTable();
+	mFieldSamplerChanged = true;
+}
+
+void ForceFieldActorImpl::updateForceField(float dt)
+{
+	mElapsedTime += dt;
+
+	if (mLifetime > 0.0f && mElapsedTime > mLifetime)
+	{
+		disable();
+	}
+}
+
+// Called by ForceFieldScene::fetchResults()
+void ForceFieldActorImpl::updatePoseAndBounds()
+{
+}
+
+void ForceFieldActorImpl::visualize()
+{
+#ifndef WITHOUT_DEBUG_VISUALIZE
+	if ( !mEnableDebugVisualization ) return;
+	if (mEnable)
+	{
+		visualizeIncludeShape();
+	}
+#endif
+}
+
+void ForceFieldActorImpl::visualizeIncludeShape()
+{
+#ifndef WITHOUT_DEBUG_VISUALIZE
+	if (mEnable)
+	{
+		const physx::PxMat44& savedPose = *RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->getPoseTyped();
+		RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->setIdentityPose();
+		RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->pushRenderState();
+		RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->setCurrentColor(0xFF0000);
+
+		ForceFieldFSKernelParams& kernelParams = mKernelParams.getForceFieldFSKernelParams();
+		PxMat44 debugPose = kernelParams.includeShape.forceFieldToShape * kernelParams.pose;
+
+		switch (kernelParams.includeShape.type)
+		{
+		case ForceFieldShapeType::SPHERE:
+			{
+				RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->setPose(debugPose);
+				RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->debugSphere(PxVec3(0.0f), kernelParams.includeShape.dimensions.x, 2);
+				RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->setPose(PxIdentity);
+				break;
+			}
+		case ForceFieldShapeType::CAPSULE:
+			{
+				RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->setPose(debugPose);
+				RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->debugCapsule(kernelParams.includeShape.dimensions.x, kernelParams.includeShape.dimensions.y * 2, 2);
+				RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->setPose(PxIdentity);
+				break;
+			}
+		case ForceFieldShapeType::CYLINDER:
+			{
+				RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->setPose(debugPose);
+				RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->debugCylinder(kernelParams.includeShape.dimensions.x, kernelParams.includeShape.dimensions.y * 2, true, 2);
+				RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->setPose(PxIdentity);
+				break;
+			}
+		case ForceFieldShapeType::CONE:
+			{
+				// using a cylinder to approximate a cone for debug rendering
+				// TODO: draw a cone using lines
+				RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->setPose(debugPose);
+				RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->debugCylinder(kernelParams.includeShape.dimensions.x, kernelParams.includeShape.dimensions.y * 2, true, 2);
+				RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->setPose(PxIdentity);
+				break;
+			}
+		case ForceFieldShapeType::BOX:
+			{
+				RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->setPose(debugPose);
+				RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->debugBound(PxBounds3(PxVec3(0.0f), kernelParams.includeShape.dimensions * 2));
+				RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->setPose(PxIdentity);
+				break;
+			}
+		default:
+			{
+			}
+		}
+
+		RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->setPose(savedPose);
+		RENDER_DEBUG_IFACE(mForceFieldScene->mRenderDebug)->popRenderState();
+	}
+#endif
+}
+
+void ForceFieldActorImpl::visualizeForces()
+{
+#ifndef WITHOUT_DEBUG_VISUALIZE
+	if (mEnable)
+	{
+	}
+#endif
+}
+
+}
+} // end namespace nvidia
+
diff --git a/APEX_1.4/module/forcefield/src/ForceFieldAssetImpl.cpp b/APEX_1.4/module/forcefield/src/ForceFieldAssetImpl.cpp
new file mode 100644
index 00000000..52acde7c
--- /dev/null
+++ b/APEX_1.4/module/forcefield/src/ForceFieldAssetImpl.cpp
@@ -0,0 +1,297 @@
+/*
+ * 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 "Apex.h"
+#include "ForceFieldAssetPreviewImpl.h"
+#include "ForceFieldAssetImpl.h"
+#include "ForceFieldActorImpl.h"
+#include "ModuleForceFieldImpl.h"
+#include "ForceFieldScene.h"
+#include "ApexResourceHelper.h"
+#include "AssetPreviewScene.h"
+
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+ForceFieldAssetImpl::ForceFieldAssetImpl(ModuleForceFieldImpl* module, ResourceList& list, const char* name) :
+	mModule(module),
+	mName(name),
+	mDefaultActorParams(NULL),
+	mDefaultPreviewParams(NULL)
+{
+	NvParameterized::Traits* traits = GetInternalApexSDK()->getParameterizedTraits();
+	mParams = (ForceFieldAssetParams*)traits->createNvParameterized(ForceFieldAssetParams::staticClassName());
+
+	initializeAssetNameTable();
+
+	list.add(*this);
+}
+
+ForceFieldAssetImpl::ForceFieldAssetImpl(ModuleForceFieldImpl* module, ResourceList& list, NvParameterized::Interface* params, const char* name) :
+	mModule(module),
+	mName(name),
+	mParams((ForceFieldAssetParams*)params),
+	mDefaultActorParams(NULL),
+	mDefaultPreviewParams(NULL)
+{
+	initializeAssetNameTable();
+
+	list.add(*this);
+}
+
+ForceFieldAssetImpl::~ForceFieldAssetImpl()
+{
+}
+
+void ForceFieldAssetImpl::destroy()
+{
+	if (mDefaultActorParams)
+	{
+		mDefaultActorParams->destroy();
+		mDefaultActorParams = 0;
+	}
+
+	if (mDefaultPreviewParams)
+	{
+		mDefaultPreviewParams->destroy();
+		mDefaultPreviewParams = 0;
+	}
+	if (mParams)
+	{
+		mParams->destroy();
+		mParams = NULL;
+	}
+	/* Assets that were forceloaded or loaded by actors will be automatically
+	 * released by the ApexAssetTracker member destructors.
+	 */
+
+	/* Actors are automatically cleaned up on deletion by ResourceList dtor */
+	delete this;
+}
+
+uint32_t ForceFieldAssetImpl::forceLoadAssets()
+{
+	WRITE_ZONE();
+	// Is there anything to be done here?
+	return NULL;
+}
+
+void ForceFieldAssetImpl::initializeAssetNameTable()
+{
+	ApexSimpleString tmpStr;
+	NvParameterized::Handle h(*mParams);
+	NvParameterized::Interface* refPtr;
+
+	if (mParams->forceFieldKernelType == NULL)
+	{
+		NvParameterized::Handle h(mParams);
+		h.getParameter("forceFieldKernelType");
+		h.initParamRef(h.parameterDefinition()->refVariantVal(0), true);
+	}
+
+	mParams->getParameterHandle("forceFieldKernelType", h);
+	mParams->getParamRef(h, refPtr);
+	PX_ASSERT(refPtr);
+	if (!refPtr)
+	{
+		APEX_INTERNAL_ERROR("No force field kernel specified");
+		return;
+	}
+
+	tmpStr = refPtr->className();
+
+	mGenericParams = NULL;
+	mRadialParams = NULL;
+	mFalloffParams = NULL;
+	mNoiseParams = NULL;
+
+	if (tmpStr == GenericForceFieldKernelParams::staticClassName())
+	{
+		mGenericParams = static_cast<GenericForceFieldKernelParams*>(refPtr);
+	}
+	else if (tmpStr == RadialForceFieldKernelParams::staticClassName())
+	{
+		mRadialParams = static_cast<RadialForceFieldKernelParams*>(refPtr);
+
+		NvParameterized::Handle h(*mRadialParams);
+
+		mRadialParams->getParameterHandle("falloffParameters", h);
+		mRadialParams->getParamRef(h, refPtr);
+		PX_ASSERT(refPtr);
+		
+		mFalloffParams = static_cast<ForceFieldFalloffParams*>(refPtr);
+		
+		mRadialParams->getParameterHandle("noiseParameters", h);
+		mRadialParams->getParamRef(h, refPtr);
+		PX_ASSERT(refPtr);
+
+		mNoiseParams = static_cast<ForceFieldNoiseParams*>(refPtr);		
+	}
+	else
+	{
+		PX_ASSERT(0 && "Invalid force field kernel type for APEX_ForceField.");
+		return;
+	}
+}
+
+NvParameterized::Interface* ForceFieldAssetImpl::getDefaultActorDesc()
+{
+	WRITE_ZONE();
+	NvParameterized::Traits* traits = GetInternalApexSDK()->getParameterizedTraits();
+	PX_ASSERT(traits);
+	if (!traits)
+	{
+		return NULL;
+	}
+
+	// create if not yet created
+	if (!mDefaultActorParams)
+	{
+		NvParameterized::ErrorType error = NvParameterized::ERROR_NONE;
+		PX_UNUSED(error);
+
+		const char* className = ForceFieldActorParams::staticClassName();
+		NvParameterized::Interface* param = traits->createNvParameterized(className);
+		NvParameterized::Handle h(param);
+		mDefaultActorParams = static_cast<ForceFieldActorParams*>(param);
+
+		PX_ASSERT(param);
+		if (!param)
+		{
+			return NULL;
+		}
+	}
+
+	return mDefaultActorParams;
+}
+
+
+NvParameterized::Interface* ForceFieldAssetImpl::getDefaultAssetPreviewDesc()
+{
+	WRITE_ZONE();
+	NvParameterized::Traits* traits = GetInternalApexSDK()->getParameterizedTraits();
+	PX_ASSERT(traits);
+	if (!traits)
+	{
+		return NULL;
+	}
+
+	// create if not yet created
+	if (!mDefaultPreviewParams)
+	{
+		const char* className = ForceFieldAssetPreviewParams::staticClassName();
+		NvParameterized::Interface* param = traits->createNvParameterized(className);
+		mDefaultPreviewParams = static_cast<ForceFieldAssetPreviewParams*>(param);
+
+		PX_ASSERT(param);
+		if (!param)
+		{
+			return NULL;
+		}
+	}
+	else
+	{
+		mDefaultPreviewParams->initDefaults();
+	}
+
+	return mDefaultPreviewParams;
+}
+
+Actor* ForceFieldAssetImpl::createApexActor(const NvParameterized::Interface& parms, Scene& apexScene)
+{
+	WRITE_ZONE();
+	if (!isValidForActorCreation(parms, apexScene))
+	{
+		return NULL;
+	}
+
+	Actor* ret = 0;
+
+	if (nvidia::strcmp(parms.className(), ForceFieldActorParams::staticClassName()) == 0)
+	{
+		ForceFieldActorDesc desc;
+
+		const ForceFieldActorParams* pDesc = static_cast<const ForceFieldActorParams*>(&parms);
+		desc.initialPose		= pDesc->initialPose;
+		desc.scale				= pDesc->scale;
+		desc.samplerFilterData  = ApexResourceHelper::resolveCollisionGroup128(pDesc->fieldSamplerFilterDataName ? pDesc->fieldSamplerFilterDataName : mParams->fieldSamplerFilterDataName);
+		desc.boundaryFilterData = ApexResourceHelper::resolveCollisionGroup128(pDesc->fieldBoundaryFilterDataName ? pDesc->fieldBoundaryFilterDataName : mParams->fieldBoundaryFilterDataName);
+
+		ForceFieldScene* es = mModule->getForceFieldScene(apexScene);
+		ret = es->createForceFieldActor(desc, *this, mForceFieldActors);
+	}
+
+	return ret;
+}
+
+AssetPreview* ForceFieldAssetImpl::createApexAssetPreview(const NvParameterized::Interface& parms, AssetPreviewScene* previewScene)
+{
+	WRITE_ZONE();
+	AssetPreview* ret = 0;
+
+	const char* className = parms.className();
+	if (nvidia::strcmp(className, ForceFieldAssetPreviewParams::staticClassName()) == 0)
+	{
+		ForceFieldPreviewDesc desc;
+		const ForceFieldAssetPreviewParams* pDesc = static_cast<const ForceFieldAssetPreviewParams*>(&parms);
+
+		desc.mPose	= pDesc->pose;
+		desc.mIconScale = pDesc->iconScale;
+		desc.mPreviewDetail = 0;
+		if (pDesc->drawIcon)
+		{
+			desc.mPreviewDetail |= APEX_FORCEFIELD::FORCEFIELD_DRAW_ICON;
+		}
+		if (pDesc->drawBoundaries)
+		{
+			desc.mPreviewDetail |= APEX_FORCEFIELD::FORCEFIELD_DRAW_BOUNDARIES;
+		}
+		if (pDesc->drawBold)
+		{
+			desc.mPreviewDetail |= APEX_FORCEFIELD::FORCEFIELD_DRAW_WITH_CYLINDERS;
+		}
+
+		ret = createForceFieldPreview(desc, previewScene);
+	}
+
+	return ret;
+}
+
+void ForceFieldAssetImpl::releaseForceFieldActor(ForceFieldActor& nxactor)
+{
+	WRITE_ZONE();
+	ForceFieldActorImpl* actor = DYNAMIC_CAST(ForceFieldActorImpl*)(&nxactor);
+	actor->destroy();
+}
+
+ForceFieldPreview* ForceFieldAssetImpl::createForceFieldPreview(const ForceFieldPreviewDesc& desc, AssetPreviewScene* previewScene)
+{
+	return(createForceFieldPreviewImpl(desc, this, previewScene));
+}
+
+ForceFieldPreview* ForceFieldAssetImpl::createForceFieldPreviewImpl(const ForceFieldPreviewDesc& desc, ForceFieldAssetImpl* forceFieldAsset, AssetPreviewScene* previewScene)
+{
+	return(PX_NEW(ForceFieldAssetPreviewImpl)(desc, mModule->mSdk, forceFieldAsset, previewScene));
+}
+
+void ForceFieldAssetImpl::releaseForceFieldPreview(ForceFieldPreview& nxpreview)
+{
+	ForceFieldAssetPreviewImpl* preview = DYNAMIC_CAST(ForceFieldAssetPreviewImpl*)(&nxpreview);
+	preview->destroy();
+}
+
+}
+} // end namespace nvidia
+
diff --git a/APEX_1.4/module/forcefield/src/ForceFieldAssetPreviewImpl.cpp b/APEX_1.4/module/forcefield/src/ForceFieldAssetPreviewImpl.cpp
new file mode 100644
index 00000000..fca99815
--- /dev/null
+++ b/APEX_1.4/module/forcefield/src/ForceFieldAssetPreviewImpl.cpp
@@ -0,0 +1,328 @@
+/*
+ * 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 "ForceFieldPreview.h"
+#include "ForceFieldAssetPreviewImpl.h"
+#include "ModulePerfScope.h"
+#include "ApexUsingNamespace.h"
+#include "PxProfiler.h"
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+using namespace APEX_FORCEFIELD;
+
+#ifndef WITHOUT_DEBUG_VISUALIZE
+
+static const ForceFieldAssetPreviewImpl::point2 iconFrame[] =
+{
+	{ -0.50f, -0.50f}, { +0.50f, -0.50f}, { +0.50f, +0.50f}, { -0.50f, 0.50f}, { -0.50f, -0.50f}
+};
+
+static const ForceFieldAssetPreviewImpl::point2 iconBombCircle[] =
+{
+	{ +0.35000f, +0.00000f}, { +0.33807f, +0.09059f}, { +0.30311f, +0.17500f}, { +0.24749f, +0.24749f}, { +0.17500f, +0.30311f},
+	{ +0.09059f, +0.33807f}, { +0.00000f, +0.35000f}, { -0.09059f, +0.33807f}, { -0.17500f, +0.30311f}, { -0.24749f, +0.24749f},
+	{ -0.30311f, +0.17500f}, { -0.33807f, +0.09059f}, { -0.35000f, +0.00000f}, { -0.33807f, -0.09059f}, { -0.30311f, -0.17500f},
+	{ -0.24749f, -0.24749f}, { -0.17500f, -0.30311f}, { -0.09059f, -0.33807f}, { +0.00000f, -0.35000f}, { +0.09059f, -0.33807f},
+	{ +0.17500f, -0.30311f}, { +0.24749f, -0.24749f}, { +0.30311f, -0.17500f}, { +0.33807f, -0.09059f}, { +0.35000f, +0.00000f}
+};
+
+static const ForceFieldAssetPreviewImpl::point2 iconFuse[] =
+{
+	{ +0.00000f, +0.35000f}, { +0.00000f, +0.36500f}, { +0.00500f, +0.38000f}, { +0.02500f, +0.41000f}, { +0.05000f, +0.41500f}
+};
+static const ForceFieldAssetPreviewImpl::point2 iconSpark1[] =
+{
+	{ +0.0500f, +0.4300f}, { +0.0500f, +0.4550f}
+};
+static const ForceFieldAssetPreviewImpl::point2 iconSpark2[] =
+{
+	{ +0.0650f, +0.4150f}, { +0.0900f, +0.4150f}
+};
+static const ForceFieldAssetPreviewImpl::point2 iconSpark3[] =
+{
+	{ +0.0500f, +0.4000f}, { +0.0500f, +0.3700f}
+};
+static const ForceFieldAssetPreviewImpl::point2 iconSpark4[] =
+{
+	{ +0.0350f, +0.4300f}, { +0.0200f, +0.4400f}
+};
+static const ForceFieldAssetPreviewImpl::point2 iconSpark5[] =
+{
+	{ +0.0600f, +0.4300f}, { +0.0750f, +0.4450f}
+};
+static const ForceFieldAssetPreviewImpl::point2 iconSpark6[] =
+{
+	{ +0.0600f, +0.4000f}, { +0.0750f, +0.3850f}
+};
+static const ForceFieldAssetPreviewImpl::point2 iconSpark7[] =
+{
+	{ +0.0350f, +0.4000f}, { +0.0200f, +0.3850f}
+};
+
+#endif
+
+void ForceFieldAssetPreviewImpl::drawMultilinePoint2(const point2* pts, uint32_t numPoints, uint32_t color)
+{
+	uint32_t i;
+	PxVec3 p1, p2;
+
+	PX_ASSERT(numPoints > 1);
+	RENDER_DEBUG_IFACE(mApexRenderDebug)->pushRenderState();
+
+	for (i = 0; i < numPoints - 1; i++)
+	{
+		p1.x = -pts->x;
+		p1.y = 0.0f;
+		p1.z = pts->y;
+		pts++;
+		p2.x = -pts->x;
+		p2.y = 0.0f;
+		p2.z = pts->y;
+
+		RENDER_DEBUG_IFACE(mApexRenderDebug)->setCurrentColor(color);
+
+		if (mDrawWithCylinder)
+		{
+			//draw with cylinders - makes it look BOLD.
+			RENDER_DEBUG_IFACE(mApexRenderDebug)->addToCurrentState(RENDER_DEBUG::DebugRenderState::SolidShaded);
+			RENDER_DEBUG_IFACE(mApexRenderDebug)->debugCylinder(p1, p2, .01f);
+			RENDER_DEBUG_IFACE(mApexRenderDebug)->removeFromCurrentState(RENDER_DEBUG::DebugRenderState::SolidShaded);
+		}
+		else
+		{
+			RENDER_DEBUG_IFACE(mApexRenderDebug)->debugLine(p1, p2);
+		}
+	}
+	RENDER_DEBUG_IFACE(mApexRenderDebug)->popRenderState();
+}
+
+void ForceFieldAssetPreviewImpl::drawIcon(void)
+{
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
+	PX_PROFILE_ZONE("ForceFieldDrawIcon", GetInternalApexSDK()->getContextId());
+#ifndef WITHOUT_DEBUG_VISUALIZE
+	using RENDER_DEBUG::DebugColors;
+	drawMultilinePoint2(iconFrame,		ARRAY_SIZE(iconFrame),		RENDER_DEBUG_IFACE(mApexRenderDebug)->getDebugColor(DebugColors::White));
+	drawMultilinePoint2(iconBombCircle,	ARRAY_SIZE(iconBombCircle),	RENDER_DEBUG_IFACE(mApexRenderDebug)->getDebugColor(DebugColors::Black));
+	drawMultilinePoint2(iconFuse,		ARRAY_SIZE(iconFuse),		RENDER_DEBUG_IFACE(mApexRenderDebug)->getDebugColor(DebugColors::Black));
+	drawMultilinePoint2(iconSpark1,		ARRAY_SIZE(iconSpark1),		RENDER_DEBUG_IFACE(mApexRenderDebug)->getDebugColor(DebugColors::Red));
+	drawMultilinePoint2(iconSpark2,		ARRAY_SIZE(iconSpark2),		RENDER_DEBUG_IFACE(mApexRenderDebug)->getDebugColor(DebugColors::Red));
+	drawMultilinePoint2(iconSpark3,		ARRAY_SIZE(iconSpark3),		RENDER_DEBUG_IFACE(mApexRenderDebug)->getDebugColor(DebugColors::Red));
+	drawMultilinePoint2(iconSpark4,		ARRAY_SIZE(iconSpark4),		RENDER_DEBUG_IFACE(mApexRenderDebug)->getDebugColor(DebugColors::Red));
+	drawMultilinePoint2(iconSpark5,		ARRAY_SIZE(iconSpark5),		RENDER_DEBUG_IFACE(mApexRenderDebug)->getDebugColor(DebugColors::Red));
+	drawMultilinePoint2(iconSpark6,		ARRAY_SIZE(iconSpark6),		RENDER_DEBUG_IFACE(mApexRenderDebug)->getDebugColor(DebugColors::Red));
+	drawMultilinePoint2(iconSpark7,		ARRAY_SIZE(iconSpark7),		RENDER_DEBUG_IFACE(mApexRenderDebug)->getDebugColor(DebugColors::Red));
+#endif
+}
+
+void ForceFieldAssetPreviewImpl::drawForceFieldPreviewIcon(void)
+{
+#ifndef WITHOUT_DEBUG_VISUALIZE
+	if (!mApexRenderDebug)
+	{
+		return;
+	}
+
+	//asset preview init
+	if (mDrawGroupIconScaled == 0)
+	{
+		mDrawGroupIconScaled =  (uint32_t)RENDER_DEBUG_IFACE(mApexRenderDebug)->beginDrawGroup(PxMat44(PxIdentity));
+		drawIcon();
+		RENDER_DEBUG_IFACE(mApexRenderDebug)->endDrawGroup();
+	}
+
+	toggleDrawPreview();
+	setDrawGroupsPoseScaled();
+#endif
+}
+
+void	ForceFieldAssetPreviewImpl::setDrawGroupsPoseScaled()
+{
+			PxMat44 scaledPose;	// scaling pose for the preview rendering items that need to be scaled
+			PxMat44 scaleMatrix;
+
+			//set scale
+			{
+				scaledPose = mPose;
+				scaleMatrix = PxMat44(PxVec4(mIconScale,		0.0f,			0.0f,		0.0f),
+											 PxVec4(0.0f,			mIconScale,		0.0f,		0.0f),
+											 PxVec4(0.0f,			0.0f,			mIconScale,	0.0f),
+											 PxVec4(0.0f,			0.0f,			0.0f,		1.0f));
+				//scaledPose.t.y = 2.0f; - what it was supposed to do?
+				scaledPose = scaledPose * scaleMatrix;
+			}
+
+			RENDER_DEBUG_IFACE(mApexRenderDebug)->setDrawGroupPose((int32_t)mDrawGroupIconScaled, scaledPose);
+}
+
+
+void	ForceFieldAssetPreviewImpl::toggleDrawPreview()
+{
+		if (mPreviewDetail & FORCEFIELD_DRAW_ICON)
+		{
+			RENDER_DEBUG_IFACE(mApexRenderDebug)->setDrawGroupVisible((int32_t)mDrawGroupIconScaled, true);
+		}
+		else
+		{
+			RENDER_DEBUG_IFACE(mApexRenderDebug)->setDrawGroupVisible((int32_t)mDrawGroupIconScaled, false);
+		}
+}
+
+
+void	ForceFieldAssetPreviewImpl::setDetailLevel(uint32_t detail)
+{
+	if(detail != mPreviewDetail)
+	{
+		mPreviewDetail = detail;
+		toggleDrawPreview();
+	}
+};
+
+
+void	ForceFieldAssetPreviewImpl::setIconScale(float scale)
+{
+	mIconScale = scale;
+	drawForceFieldPreview();
+};
+
+
+void	ForceFieldAssetPreviewImpl::setPose(PxMat44 pose)
+{
+	WRITE_ZONE();
+	mPose = pose;
+	drawForceFieldPreview();
+};
+	
+
+void ForceFieldAssetPreviewImpl::drawForceFieldBoundaries(void)
+{
+}
+
+void ForceFieldAssetPreviewImpl::drawForceFieldWithCylinder()
+{
+}
+
+void ForceFieldAssetPreviewImpl::drawForceFieldPreview(void)
+{
+	PX_PROFILE_ZONE("ForceFieldDrawForceFieldPreview", GetInternalApexSDK()->getContextId());
+	mDrawWithCylinder = true;
+
+	if(mPreviewDetail & FORCEFIELD_DRAW_ICON)
+	{
+		drawForceFieldPreviewIcon();
+	}
+
+	if(mPreviewDetail & FORCEFIELD_DRAW_BOUNDARIES)
+	{
+		drawForceFieldBoundaries();
+	}
+
+	if(mPreviewDetail & FORCEFIELD_DRAW_WITH_CYLINDERS)
+	{
+		drawForceFieldWithCylinder();
+	}
+}
+
+ForceFieldAssetPreviewImpl::~ForceFieldAssetPreviewImpl(void)
+{
+}
+
+void ForceFieldAssetPreviewImpl::setPose(const PxMat44& pose)
+{
+	WRITE_ZONE();
+	mPose = pose;
+	setDrawGroupsPoseScaled();
+}
+
+const PxMat44 ForceFieldAssetPreviewImpl::getPose() const
+{
+	READ_ZONE();
+	return  mPose;
+}
+
+// from RenderDataProvider
+void ForceFieldAssetPreviewImpl::lockRenderResources(void)
+{
+	ApexRenderable::renderDataLock();
+}
+
+void ForceFieldAssetPreviewImpl::unlockRenderResources(void)
+{
+	ApexRenderable::renderDataUnLock();
+}
+
+void ForceFieldAssetPreviewImpl::updateRenderResources(bool /*rewriteBuffers*/, void* /*userRenderData*/)
+{
+	if (mApexRenderDebug)
+	{
+		mApexRenderDebug->updateRenderResources();
+	}
+}
+
+// from Renderable.h
+void ForceFieldAssetPreviewImpl::dispatchRenderResources(UserRenderer& renderer)
+{
+	if (mApexRenderDebug)
+	{
+		mApexRenderDebug->dispatchRenderResources(renderer);
+	}
+}
+
+PxBounds3 ForceFieldAssetPreviewImpl::getBounds(void) const
+{
+	if (mApexRenderDebug)
+	{
+		return mApexRenderDebug->getBounds();
+	}
+	else
+	{
+		PxBounds3 b;
+		b.setEmpty();
+		return b;
+	}
+}
+
+void ForceFieldAssetPreviewImpl::destroy(void)
+{
+	delete this;
+}
+
+void ForceFieldAssetPreviewImpl::release(void)
+{
+	if (mInRelease)
+	{
+		return;
+	}
+	mAsset->releaseForceFieldPreview(*this);
+}
+
+ForceFieldAssetPreviewImpl::ForceFieldAssetPreviewImpl(const ForceFieldPreviewDesc& PreviewDesc, ApexSDK* myApexSDK, ForceFieldAssetImpl* myForceFieldAsset, AssetPreviewScene* previewScene) :
+	mPose(PreviewDesc.mPose),
+	mApexSDK(myApexSDK),
+	mAsset(myForceFieldAsset),
+	mPreviewScene(previewScene),
+	mDrawGroupIconScaled(0),
+	mDrawGroupCylinder(0),
+	mPreviewDetail(PreviewDesc.mPreviewDetail),
+	mIconScale(1.0f),
+	mApexRenderDebug(0)
+{
+	drawForceFieldPreview();
+};
+
+}
+} // end namespace nvidia
+
diff --git a/APEX_1.4/module/forcefield/src/ForceFieldFSActor.cpp b/APEX_1.4/module/forcefield/src/ForceFieldFSActor.cpp
new file mode 100644
index 00000000..fe0d8808
--- /dev/null
+++ b/APEX_1.4/module/forcefield/src/ForceFieldFSActor.cpp
@@ -0,0 +1,171 @@
+/*
+ * 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 "ForceFieldActorImpl.h"
+#include "ForceFieldAssetImpl.h"
+#include "ForceFieldScene.h"
+#include "FieldSamplerManagerIntl.h"
+#include "ApexResourceHelper.h"
+#include "ApexUsingNamespace.h"
+
+#include "SceneIntl.h"
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+void ForceFieldActorImpl::initFieldSampler(const ForceFieldActorDesc& desc)
+{
+	FieldSamplerManagerIntl* fieldSamplerManager = mForceFieldScene->getInternalFieldSamplerManager();
+	if (fieldSamplerManager != 0)
+	{
+		FieldSamplerDescIntl fieldSamplerDesc;
+		fieldSamplerDesc.type = FieldSamplerTypeIntl::FORCE;
+		fieldSamplerDesc.gridSupportType = FieldSamplerGridSupportTypeIntl::SINGLE_VELOCITY;
+
+		fieldSamplerDesc.samplerFilterData = desc.samplerFilterData;
+		fieldSamplerDesc.boundaryFilterData = desc.boundaryFilterData;
+		
+		fieldSamplerManager->registerFieldSampler(this, fieldSamplerDesc, mForceFieldScene);
+		mFieldSamplerChanged = true;
+	}
+}
+
+void ForceFieldActorImpl::releaseFieldSampler()
+{
+	FieldSamplerManagerIntl* fieldSamplerManager = mForceFieldScene->getInternalFieldSamplerManager();
+	if (fieldSamplerManager != 0)
+	{
+		fieldSamplerManager->unregisterFieldSampler(this);
+	}
+}
+
+bool ForceFieldActorImpl::updateFieldSampler(FieldShapeDescIntl& shapeDesc, bool& isEnabled)
+{
+	isEnabled = mEnable;
+	if (mFieldSamplerChanged)
+	{
+		shapeDesc.type = FieldShapeTypeIntl::NONE;	//not using field sampler include shape (force field has its own implementation for shapes)
+
+		//copy to buffered kernel data for execution
+		memcpy(&mKernelExecutionParams, &mKernelParams, sizeof(ForceFieldFSKernelParamsUnion));
+		mFieldSamplerChanged = false;
+		return true;
+	}
+	return false;
+}
+
+/******************************** CPU Version ********************************/
+
+ForceFieldActorCPU::ForceFieldActorCPU(const ForceFieldActorDesc& desc, ForceFieldAssetImpl& asset, ResourceList& list, ForceFieldScene& scene)
+	: ForceFieldActorImpl(desc, asset, list, scene)
+{
+}
+
+ForceFieldActorCPU::~ForceFieldActorCPU()
+{
+}
+
+void ForceFieldActorCPU::executeFieldSampler(const ExecuteData& data)
+{
+	// totalElapsedMS is always 0 in PhysX 3
+	uint32_t totalElapsedMS = mForceFieldScene->getApexScene().getTotalElapsedMS();
+
+	if (mKernelParams.kernelType == ForceFieldKernelType::RADIAL)
+	{
+		for (uint32_t iter = 0; iter < data.count; ++iter)
+		{
+			uint32_t i = data.indices[iter & data.indicesMask] + (iter & ~data.indicesMask);
+			PxVec3* pos = (PxVec3*)((uint8_t*)data.position + i * data.positionStride);
+			data.resultField[iter] = executeForceFieldFS(mKernelExecutionParams.getRadialForceFieldFSKernelParams(), *pos, totalElapsedMS);
+		}
+	}
+	else if (mKernelParams.kernelType == ForceFieldKernelType::GENERIC)
+	{
+		for (uint32_t iter = 0; iter < data.count; ++iter)
+		{
+			uint32_t i = data.indices[iter & data.indicesMask] + (iter & ~data.indicesMask);
+			PxVec3* pos = (PxVec3*)((uint8_t*)data.position + i * data.positionStride);
+			PxVec3* vel = (PxVec3*)((uint8_t*)data.velocity + i * data.velocityStride);
+
+			data.resultField[iter] = executeForceFieldFS(mKernelExecutionParams.getGenericForceFieldFSKernelParams(), *pos, *vel, totalElapsedMS);
+		}
+	}
+}
+
+/******************************** GPU Version ********************************/
+
+#if APEX_CUDA_SUPPORT
+
+ForceFieldActorGPU::ForceFieldActorGPU(const ForceFieldActorDesc& desc, ForceFieldAssetImpl& asset, ResourceList& list, ForceFieldScene& scene)
+	: ForceFieldActorCPU(desc, asset, list, scene)
+	, mConstMemGroup(CUDA_OBJ(fieldSamplerStorage))
+{
+}
+
+ForceFieldActorGPU::~ForceFieldActorGPU()
+{
+}
+
+bool ForceFieldActorGPU::updateFieldSampler(FieldShapeDescIntl& shapeDesc, bool& isEnabled)
+{
+	if (ForceFieldActorImpl::updateFieldSampler(shapeDesc, isEnabled))
+	{
+		APEX_CUDA_CONST_MEM_GROUP_SCOPE(mConstMemGroup);
+
+		if (mParamsHandle.isNull())
+		{
+			mParamsHandle.alloc(_storage_);
+		}
+		
+		if (mKernelParams.kernelType == ForceFieldKernelType::GENERIC)
+		{
+			mParamsHandle.update(_storage_, mKernelExecutionParams.getGenericForceFieldFSKernelParams());
+		}
+		else if (mKernelParams.kernelType == ForceFieldKernelType::RADIAL)
+		{
+			mParamsHandle.update(_storage_, mKernelExecutionParams.getRadialForceFieldFSKernelParams());
+		}
+		else
+		{
+			PX_ASSERT("Wrong kernel type");
+		}
+		
+		return true;
+	}
+	return false;
+}
+
+void ForceFieldActorGPU::getFieldSamplerCudaExecuteInfo(CudaExecuteInfo& info) const
+{
+	if (mKernelParams.kernelType == ForceFieldKernelType::GENERIC)
+	{
+		info.executeType = 1;
+	}
+	else if (mKernelParams.kernelType == ForceFieldKernelType::RADIAL)
+	{
+		info.executeType = 2;
+	}
+	else
+	{
+		PX_ASSERT("Wrong kernel type");
+		info.executeType = 0;
+	}
+	info.executeParamsHandle = mParamsHandle;
+}
+
+#endif
+
+}
+} // namespace nvidia::apex
+
diff --git a/APEX_1.4/module/forcefield/src/ForceFieldScene.cpp b/APEX_1.4/module/forcefield/src/ForceFieldScene.cpp
new file mode 100644
index 00000000..6d8e7774
--- /dev/null
+++ b/APEX_1.4/module/forcefield/src/ForceFieldScene.cpp
@@ -0,0 +1,250 @@
+/*
+ * 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 "Apex.h"
+#include "ApexUsingNamespace.h"
+#include "ScopedPhysXLock.h"
+
+#include "ForceFieldScene.h"
+#include "ForceFieldActorImpl.h"
+#include "SceneIntl.h"
+#include "ModulePerfScope.h"
+#include "ModuleFieldSamplerIntl.h"
+
+#if APEX_CUDA_SUPPORT
+#include "ApexCudaSource.h"
+#endif
+
+#pragma warning(disable: 4355) // 'this' : used in base member initializer list
+
+#include "Lock.h"
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+ForceFieldScene::ForceFieldScene(ModuleForceFieldImpl& module, SceneIntl& scene, RenderDebugInterface* renderDebug, ResourceList& list)
+	: mRenderDebug(renderDebug)
+	, mFieldSamplerManager(NULL)
+	, mUpdateTask(*this)
+{
+	mModule = &module;
+	mApexScene = &scene;
+	mPhysXScene = NULL;
+	list.add(*this);		// Add self to module's list of ForceFieldScenes
+
+	/* Initialize reference to ForceFieldDebugRenderParams */
+	mDebugRenderParams = DYNAMIC_CAST(DebugRenderParams*)(mApexScene->getDebugRenderParams());
+	PX_ASSERT(mDebugRenderParams);
+	NvParameterized::Handle handle(*mDebugRenderParams), memberHandle(*mDebugRenderParams);
+	int size;
+
+	if (mDebugRenderParams->getParameterHandle("moduleName", handle) == NvParameterized::ERROR_NONE)
+	{
+		handle.getArraySize(size, 0);
+		handle.resizeArray(size + 1);
+		if (handle.getChildHandle(size, memberHandle) == NvParameterized::ERROR_NONE)
+		{
+			memberHandle.initParamRef(ForceFieldDebugRenderParams::staticClassName(), true);
+		}
+	}
+
+	/* Load reference to ForceFieldDebugRenderParams */
+	NvParameterized::Interface* refPtr = NULL;
+	memberHandle.getParamRef(refPtr);
+	mForceFieldDebugRenderParams = DYNAMIC_CAST(ForceFieldDebugRenderParams*)(refPtr);
+	PX_ASSERT(mForceFieldDebugRenderParams);
+}
+
+ForceFieldScene::~ForceFieldScene()
+{
+}
+
+// Called by scene task graph between LOD and PhysX::simulate()
+void ForceFieldScene::TaskUpdate::run()
+{
+	setProfileStat((uint16_t) mOwner.mActorArray.size());
+	float dt = mOwner.mApexScene->getElapsedTime();
+	mOwner.updateActors(dt);
+}
+
+// Called by updateTask between LOD and PhysX simulate.  Any writes
+// to render data must be protected by acquiring the actor's render data lock
+void ForceFieldScene::updateActors(float dt)
+{
+	SCOPED_PHYSX_LOCK_WRITE(mApexScene);
+	for (uint32_t i = 0 ; i < mActorArray.size() ; i++)
+	{
+		ForceFieldActorImpl* actor = DYNAMIC_CAST(ForceFieldActorImpl*)(mActorArray[i]);
+		actor->updateForceField(dt);
+	}
+}
+
+// submit the task that updates the explosion actors
+// called from ApexScene::simulate()
+void ForceFieldScene::submitTasks(float /*elapsedTime*/, float /*substepSize*/, uint32_t /*numSubSteps*/)
+{
+	PxTaskManager* tm;
+	{
+		READ_LOCK(*mApexScene);
+		tm = mApexScene->getTaskManager();
+	}
+	tm->submitUnnamedTask(mUpdateTask);
+	mUpdateTask.startAfter(tm->getNamedTask(FSST_PHYSX_MONITOR_LOAD));
+	mUpdateTask.finishBefore(tm->getNamedTask(FSST_PHYSX_MONITOR_FETCH));
+}
+
+void ForceFieldScene::setTaskDependencies()
+{
+}
+
+// Called by ApexScene::fetchResults() with all actors render data locked.
+void ForceFieldScene::fetchResults()
+{
+	PX_PROFILE_ZONE("ForceFieldSceneFetchResults", GetInternalApexSDK()->getContextId());
+
+	for (uint32_t i = 0 ; i < mActorArray.size() ; i++)
+	{
+		ForceFieldActorImpl* actor = DYNAMIC_CAST(ForceFieldActorImpl*)(mActorArray[i]);
+		actor->updatePoseAndBounds();
+	}
+}
+
+void ForceFieldScene::visualize()
+{
+#ifndef WITHOUT_DEBUG_VISUALIZE
+	if (!mForceFieldDebugRenderParams->VISUALIZE_FORCEFIELD_ACTOR)
+	{
+		return;
+	}
+
+	RENDER_DEBUG_IFACE(mRenderDebug)->pushRenderState();
+	for (uint32_t i = 0 ; i < mActorArray.size() ; i++)
+	{
+		ForceFieldActorImpl* actor = DYNAMIC_CAST(ForceFieldActorImpl*)(mActorArray[i]);
+		actor->visualize();
+	}
+	RENDER_DEBUG_IFACE(mRenderDebug)->popRenderState();
+#endif
+}
+
+void ForceFieldScene::visualizeForceFieldForces()
+{
+}
+
+void ForceFieldScene::visualizeForceFieldForceFields()
+{
+}
+
+void ForceFieldScene::destroy()
+{
+	removeAllActors();
+	mApexScene->moduleReleased(*this);
+	delete this;
+}
+
+void ForceFieldScene::setModulePhysXScene(PxScene* pxScene)
+{
+	if (pxScene)
+	{
+		for (uint32_t i = 0 ; i < mActorArray.size() ; i++)
+		{
+			ForceFieldActorImpl* actor = DYNAMIC_CAST(ForceFieldActorImpl*)(mActorArray[i]);
+			actor->setPhysXScene(pxScene);
+		}
+	}
+	else
+	{
+		for (uint32_t i = 0 ; i < mActorArray.size() ; i++)
+		{
+			ForceFieldActorImpl* actor = DYNAMIC_CAST(ForceFieldActorImpl*)(mActorArray[i]);
+			actor->setPhysXScene(NULL);
+		}
+	}
+
+	mPhysXScene = pxScene;
+}
+
+FieldSamplerManagerIntl* ForceFieldScene::getInternalFieldSamplerManager()
+{
+	if (mFieldSamplerManager == NULL)
+	{
+		ModuleFieldSamplerIntl* moduleFieldSampler = mModule->getInternalModuleFieldSampler();
+		if (moduleFieldSampler != NULL)
+		{
+			mFieldSamplerManager = moduleFieldSampler->getInternalFieldSamplerManager(*mApexScene);
+			PX_ASSERT(mFieldSamplerManager != NULL);
+		}
+	}
+	return mFieldSamplerManager;
+}
+
+/******************************** CPU Version ********************************/
+
+ForceFieldSceneCPU::ForceFieldSceneCPU(ModuleForceFieldImpl& module, SceneIntl& scene, RenderDebugInterface* renderDebug, ResourceList& list) :
+	ForceFieldScene(module, scene, renderDebug, list)
+{
+}
+
+ForceFieldSceneCPU::~ForceFieldSceneCPU()
+{
+}
+
+ForceFieldActorImpl* ForceFieldSceneCPU::createForceFieldActor(const ForceFieldActorDesc& desc, ForceFieldAssetImpl& asset, ResourceList& list)
+{
+	return PX_NEW(ForceFieldActorCPU)(desc, asset, list, *this);
+}
+
+/******************************** GPU Version ********************************/
+
+#if APEX_CUDA_SUPPORT
+
+ForceFieldSceneGPU::ForceFieldSceneGPU(ModuleForceFieldImpl& module, SceneIntl& scene, RenderDebugInterface* renderDebug, ResourceList& list)
+	: ForceFieldScene(module, scene, renderDebug, list)
+	, CudaModuleScene(scene, *mModule, APEX_CUDA_TO_STR(APEX_CUDA_MODULE_PREFIX))
+{
+	{
+		PxGpuDispatcher* gd = mApexScene->getTaskManager()->getGpuDispatcher();
+		PX_ASSERT(gd != NULL);
+		mCtxMgr = gd->getCudaContextManager();
+		PxScopedCudaLock _lock_(*mCtxMgr);
+
+//CUDA module objects
+#include "../cuda/include/ForceField.h"
+	}
+}
+
+ForceFieldSceneGPU::~ForceFieldSceneGPU()
+{
+	CudaModuleScene::destroy(*mApexScene);
+}
+
+ForceFieldActorImpl* ForceFieldSceneGPU::createForceFieldActor(const ForceFieldActorDesc& desc, ForceFieldAssetImpl& asset, ResourceList& list)
+{
+	return PX_NEW(ForceFieldActorGPU)(desc, asset, list, *this);
+}
+
+ApexCudaConstStorage* ForceFieldSceneGPU::getFieldSamplerCudaConstStorage()
+{
+	return &APEX_CUDA_OBJ_NAME(fieldSamplerStorage);
+}
+
+bool ForceFieldSceneGPU::launchFieldSamplerCudaKernel(const nvidia::fieldsampler::FieldSamplerKernelLaunchDataIntl& launchData)
+{
+	LAUNCH_FIELD_SAMPLER_KERNEL(launchData);
+}
+
+#endif
+
+}
+} // end namespace nvidia
diff --git a/APEX_1.4/module/forcefield/src/ModuleForceFieldImpl.cpp b/APEX_1.4/module/forcefield/src/ModuleForceFieldImpl.cpp
new file mode 100644
index 00000000..6915007e
--- /dev/null
+++ b/APEX_1.4/module/forcefield/src/ModuleForceFieldImpl.cpp
@@ -0,0 +1,330 @@
+/*
+ * 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 "ModuleForceFieldImpl.h"
+#include "ModuleForceFieldRegistration.h"
+#include "ForceFieldScene.h"
+#include "ForceFieldAssetImpl.h"
+#include "SceneIntl.h"
+#include "PsMemoryBuffer.h"
+#include "ModulePerfScope.h"
+#include "ModuleFieldSamplerIntl.h"
+using namespace forcefield;
+
+#include "Apex.h"
+#include "ApexSDKIntl.h"
+#include "ApexUsingNamespace.h"
+
+#include "Lock.h"
+
+namespace nvidia
+{
+namespace apex
+{
+
+#if defined(_USRDLL)
+
+/* Modules don't have to link against the framework, they keep their own */
+ApexSDKIntl* gApexSdk = 0;
+ApexSDK* GetApexSDK()
+{
+	return gApexSdk;
+}
+ApexSDKIntl* GetInternalApexSDK()
+{
+	return gApexSdk;
+}
+
+APEX_API Module*  CALL_CONV createModule(
+    ApexSDKIntl* inSdk,
+    ModuleIntl** niRef,
+    uint32_t APEXsdkVersion,
+    uint32_t PhysXsdkVersion,
+    ApexCreateError* errorCode)
+{
+	if (APEXsdkVersion != APEX_SDK_VERSION)
+	{
+		if (errorCode)
+		{
+			*errorCode = APEX_CE_WRONG_VERSION;
+		}
+		return NULL;
+	}
+
+	if (PhysXsdkVersion != PX_PHYSICS_VERSION)
+	{
+		if (errorCode)
+		{
+			*errorCode = APEX_CE_WRONG_VERSION;
+		}
+		return NULL;
+	}
+
+	gApexSdk = inSdk;
+	ModuleForceFieldImpl* impl = PX_NEW(ModuleForceField)(inSdk);
+	*niRef  = (ModuleIntl*) impl;
+	return (Module*) impl;
+}
+
+#else
+/* Statically linking entry function */
+void instantiateModuleForceField()
+{
+#if SDK_VERSION_NUMBER >= MIN_PHYSX_SDK_VERSION_REQUIRED
+	ApexSDKIntl* sdk = GetInternalApexSDK();
+	nvidia::forcefield::ModuleForceFieldImpl* impl = PX_NEW(nvidia::forcefield::ModuleForceFieldImpl)(sdk);
+	sdk->registerExternalModule((Module*) impl, (ModuleIntl*) impl);
+#endif
+}
+#endif // `defined(_USRDLL)
+}
+
+namespace forcefield
+{
+/* === ModuleForceFieldImpl Implementation === */
+
+AuthObjTypeID ForceFieldAssetImpl::mAssetTypeID;  // Static class member of ForceFieldAssetImpl
+#ifdef WITHOUT_APEX_AUTHORING
+
+class ForceFieldAssetDummyAuthoring : public AssetAuthoring, public UserAllocated
+{
+public:
+	ForceFieldAssetDummyAuthoring(ModuleForceFieldImpl* module, ResourceList& list, NvParameterized::Interface* params, const char* name)
+	{
+		PX_UNUSED(module);
+		PX_UNUSED(list);
+		PX_UNUSED(params);
+		PX_UNUSED(name);
+	}
+
+	ForceFieldAssetDummyAuthoring(ModuleForceFieldImpl* module, ResourceList& list, const char* name)
+	{
+		PX_UNUSED(module);
+		PX_UNUSED(list);
+		PX_UNUSED(name);
+	}
+
+	ForceFieldAssetDummyAuthoring(ModuleForceFieldImpl* module, ResourceList& list)
+	{
+		PX_UNUSED(module);
+		PX_UNUSED(list);
+	}
+
+	virtual void setToolString(const char* /*toolName*/, const char* /*toolVersion*/, uint32_t /*toolChangelist*/)
+	{
+
+	}
+
+
+	virtual void release()
+	{
+		destroy();
+	}
+
+	// internal
+	void destroy()
+	{
+		delete this;
+	}
+
+	const char* getName(void) const
+	{
+		return NULL;
+	}
+
+	/**
+	* \brief Returns the name of this APEX authorable object type
+	*/
+	virtual const char* getObjTypeName() const
+	{
+		return ForceFieldAssetImpl::getClassName();
+	}
+
+	/**
+	 * \brief Prepares a fully authored Asset Authoring object for a specified platform
+	*/
+	virtual bool prepareForPlatform(nvidia::apex::PlatformTag)
+	{
+		PX_ASSERT(0);
+		return false;
+	}
+
+	/**
+	* \brief Save asset's NvParameterized interface, may return NULL
+	*/
+	virtual NvParameterized::Interface* getNvParameterized()
+	{
+		PX_ASSERT(0);
+		return NULL;
+	}
+
+	virtual NvParameterized::Interface* releaseAndReturnNvParameterizedInterface(void)
+	{
+		PX_ALWAYS_ASSERT();
+		return NULL;
+	}
+};
+
+typedef ApexAuthorableObject<ModuleForceFieldImpl, ForceFieldAssetImpl, ForceFieldAssetDummyAuthoring> ForceFieldAO;
+
+#else
+typedef ApexAuthorableObject<ModuleForceFieldImpl, ForceFieldAssetImpl, ForceFieldAssetAuthoringImpl> ForceFieldAO;
+#endif
+
+ModuleForceFieldImpl::ModuleForceFieldImpl(ApexSDKIntl* inSdk)
+{
+	mName = "ForceField";
+	mSdk = inSdk;
+	mApiProxy = this;
+	mModuleParams = NULL;
+	mFieldSamplerModule = NULL;
+
+	/* Register asset type and create a namespace for its assets */
+	const char* pName = ForceFieldAssetParams::staticClassName();
+	ForceFieldAO* eAO = PX_NEW(ForceFieldAO)(this, mAuthorableObjects, pName);
+	ForceFieldAssetImpl::mAssetTypeID = eAO->getResID();
+
+	/* Register the NvParameterized factories */
+	NvParameterized::Traits* traits = mSdk->getParameterizedTraits();
+	ModuleForceFieldRegistration::invokeRegistration(traits);
+}
+
+ModuleForceFieldImpl::~ModuleForceFieldImpl()
+{
+}
+
+void ModuleForceFieldImpl::destroy()
+{
+	// release the NvParameterized factory
+	NvParameterized::Traits* traits = mSdk->getParameterizedTraits();
+
+	if (mModuleParams)
+	{
+		mModuleParams->destroy();
+		mModuleParams = NULL;
+	}
+
+	ModuleBase::destroy();
+
+	if (traits)
+	{
+		ModuleForceFieldRegistration::invokeUnregistration(traits);
+	}
+	delete this;
+}
+
+NvParameterized::Interface* ModuleForceFieldImpl::getDefaultModuleDesc()
+{
+	NvParameterized::Traits* traits = mSdk->getParameterizedTraits();
+
+	if (!mModuleParams)
+	{
+		mModuleParams = DYNAMIC_CAST(ForceFieldModuleParams*)
+		                (traits->createNvParameterized("ForceFieldModuleParams"));
+		PX_ASSERT(mModuleParams);
+	}
+	else
+	{
+		mModuleParams->initDefaults();
+	}
+
+	return mModuleParams;
+}
+
+void ModuleForceFieldImpl::init(const ModuleForceFieldDesc& expDesc)
+{
+	PX_PROFILE_ZONE("ForceFieldModuleInit", GetInternalApexSDK()->getContextId());  // profile this function
+	mModuleValue = expDesc.moduleValue;
+}
+
+AuthObjTypeID ModuleForceFieldImpl::getForceFieldAssetTypeID() const
+{
+	return ForceFieldAssetImpl::mAssetTypeID;
+}
+AuthObjTypeID ModuleForceFieldImpl::getModuleID() const
+{
+	return ForceFieldAssetImpl::mAssetTypeID;
+}
+
+
+/* == ForceField Scene methods == */
+ModuleSceneIntl* ModuleForceFieldImpl::createInternalModuleScene(SceneIntl& scene, RenderDebugInterface* renderDebug)
+{
+#if APEX_CUDA_SUPPORT
+	READ_LOCK(scene);
+	if (scene.getTaskManager()->getGpuDispatcher())
+	{
+		return PX_NEW(ForceFieldSceneGPU)(*this, scene, renderDebug, mForceFieldScenes);
+	}
+	else
+#endif
+		return PX_NEW(ForceFieldSceneCPU)(*this, scene, renderDebug, mForceFieldScenes);
+}
+
+void ModuleForceFieldImpl::releaseModuleSceneIntl(ModuleSceneIntl& scene)
+{
+	ForceFieldScene* es = DYNAMIC_CAST(ForceFieldScene*)(&scene);
+	es->destroy();
+}
+
+uint32_t ModuleForceFieldImpl::forceLoadAssets()
+{
+	uint32_t loadedAssetCount = 0;
+	for (uint32_t i = 0; i < mAuthorableObjects.getSize(); i++)
+	{
+		AuthorableObjectIntl* ao = static_cast<AuthorableObjectIntl*>(mAuthorableObjects.getResource(i));
+		loadedAssetCount += ao->forceLoadAssets();
+	}
+	return loadedAssetCount;
+}
+
+ForceFieldScene* ModuleForceFieldImpl::getForceFieldScene(const Scene& apexScene)
+{
+	for (uint32_t i = 0 ; i < mForceFieldScenes.getSize() ; i++)
+	{
+		ForceFieldScene* es = DYNAMIC_CAST(ForceFieldScene*)(mForceFieldScenes.getResource(i));
+		if (es->mApexScene == &apexScene)
+		{
+			return es;
+		}
+	}
+
+	PX_ASSERT(!"Unable to locate an appropriate ForceFieldScene");
+	return NULL;
+}
+
+RenderableIterator* ModuleForceFieldImpl::createRenderableIterator(const Scene& apexScene)
+{
+	ForceFieldScene* es = getForceFieldScene(apexScene);
+	if (es)
+	{
+		return es->createRenderableIterator();
+	}
+
+	return NULL;
+}
+
+ModuleFieldSamplerIntl* ModuleForceFieldImpl::getInternalModuleFieldSampler()
+{
+	if (!mFieldSamplerModule)
+	{
+		ModuleIntl* nim = mSdk->getInternalModuleByName("FieldSampler");
+		if (nim)
+		{
+			mFieldSamplerModule = DYNAMIC_CAST(ModuleFieldSamplerIntl*)(nim);
+		}
+	}
+	return mFieldSamplerModule;
+}
+
+}
+} // end namespace nvidia
diff --git a/APEX_1.4/module/forcefield/src/autogen/ForceFieldActorParams.cpp b/APEX_1.4/module/forcefield/src/autogen/ForceFieldActorParams.cpp
new file mode 100644
index 00000000..b6b760b8
--- /dev/null
+++ b/APEX_1.4/module/forcefield/src/autogen/ForceFieldActorParams.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 "ForceFieldActorParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+using namespace ForceFieldActorParamsNS;
+
+const char* const ForceFieldActorParamsFactory::vptr =
+    NvParameterized::getVptr<ForceFieldActorParams, ForceFieldActorParams::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_TRANSFORM, false, (size_t)(&((ParametersStruct*)0)->initialPose), NULL, 0 }, // initialPose
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->scale), NULL, 0 }, // scale
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->fieldBoundaryFilterDataName), NULL, 0 }, // fieldBoundaryFilterDataName
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->fieldSamplerFilterDataName), NULL, 0 }, // fieldSamplerFilterDataName
+};
+
+
+bool ForceFieldActorParams::mBuiltFlag = false;
+NvParameterized::MutexType ForceFieldActorParams::mBuiltFlagMutex;
+
+ForceFieldActorParams::ForceFieldActorParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ForceFieldActorParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ForceFieldActorParams::~ForceFieldActorParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ForceFieldActorParams::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->~ForceFieldActorParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ForceFieldActorParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ForceFieldActorParams::getParameterDefinitionTree(void) const
+{
+	ForceFieldActorParams* tmpParam = const_cast<ForceFieldActorParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ForceFieldActorParams::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 ForceFieldActorParams::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 ForceFieldActorParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ForceFieldActorParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ForceFieldActorParams::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 ForceFieldActorParams::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="initialPose"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("initialPose", TYPE_TRANSFORM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The initial pose where the forcefield actor will be put into the scene", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("scale", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Forcefield actor scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="fieldBoundaryFilterDataName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("fieldBoundaryFilterDataName", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The filter data name for AttractorFS vs Field Boundaries interaction. Overrides asset's value.", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="fieldSamplerFilterDataName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("fieldSamplerFilterDataName", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The filter data name for AttractorFS vs other Field Samplers interaction. Overrides asset's value.", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[4];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+		Children[3] = PDEF_PTR(4);
+
+		ParamDefTable[0].setChildren(Children, 4);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ForceFieldActorParams::initStrings(void)
+{
+	fieldBoundaryFilterDataName.isAllocated = true;
+	fieldBoundaryFilterDataName.buf = NULL;
+	fieldSamplerFilterDataName.isAllocated = true;
+	fieldSamplerFilterDataName.buf = NULL;
+}
+
+void ForceFieldActorParams::initDynamicArrays(void)
+{
+}
+
+void ForceFieldActorParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	initialPose = physx::PxTransform(physx::PxIdentity);
+	scale = float(1.0f);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ForceFieldActorParams::initReferences(void)
+{
+}
+
+void ForceFieldActorParams::freeDynamicArrays(void)
+{
+}
+
+void ForceFieldActorParams::freeStrings(void)
+{
+
+	if (fieldBoundaryFilterDataName.isAllocated && fieldBoundaryFilterDataName.buf)
+	{
+		mParameterizedTraits->strfree((char*)fieldBoundaryFilterDataName.buf);
+	}
+
+	if (fieldSamplerFilterDataName.isAllocated && fieldSamplerFilterDataName.buf)
+	{
+		mParameterizedTraits->strfree((char*)fieldSamplerFilterDataName.buf);
+	}
+}
+
+void ForceFieldActorParams::freeReferences(void)
+{
+}
+
+} // namespace forcefield
+} // namespace nvidia
diff --git a/APEX_1.4/module/forcefield/src/autogen/ForceFieldAssetParams.cpp b/APEX_1.4/module/forcefield/src/autogen/ForceFieldAssetParams.cpp
new file mode 100644
index 00000000..bad0adcc
--- /dev/null
+++ b/APEX_1.4/module/forcefield/src/autogen/ForceFieldAssetParams.cpp
@@ -0,0 +1,573 @@
+// 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 "ForceFieldAssetParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+using namespace ForceFieldAssetParamsNS;
+
+const char* const ForceFieldAssetParamsFactory::vptr =
+    NvParameterized::getVptr<ForceFieldAssetParams, ForceFieldAssetParams::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, 9, 10, 6, 7, 8,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 7 },
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->forceFieldKernelType), NULL, 0 }, // forceFieldKernelType
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->defScale), NULL, 0 }, // defScale
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->strength), NULL, 0 }, // strength
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->lifetime), NULL, 0 }, // lifetime
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->includeShapeParameters), CHILDREN(7), 3 }, // includeShapeParameters
+	{ TYPE_ENUM, false, (size_t)(&((IncludeShapeParameters_Type*)0)->shape), NULL, 0 }, // includeShapeParameters.shape
+	{ TYPE_MAT44, false, (size_t)(&((IncludeShapeParameters_Type*)0)->forceFieldToShape), NULL, 0 }, // includeShapeParameters.forceFieldToShape
+	{ TYPE_VEC3, false, (size_t)(&((IncludeShapeParameters_Type*)0)->dimensions), NULL, 0 }, // includeShapeParameters.dimensions
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->fieldBoundaryFilterDataName), NULL, 0 }, // fieldBoundaryFilterDataName
+	{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->fieldSamplerFilterDataName), NULL, 0 }, // fieldSamplerFilterDataName
+};
+
+
+bool ForceFieldAssetParams::mBuiltFlag = false;
+NvParameterized::MutexType ForceFieldAssetParams::mBuiltFlagMutex;
+
+ForceFieldAssetParams::ForceFieldAssetParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ForceFieldAssetParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ForceFieldAssetParams::~ForceFieldAssetParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ForceFieldAssetParams::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->~ForceFieldAssetParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ForceFieldAssetParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ForceFieldAssetParams::getParameterDefinitionTree(void) const
+{
+	ForceFieldAssetParams* tmpParam = const_cast<ForceFieldAssetParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ForceFieldAssetParams::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 ForceFieldAssetParams::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 ForceFieldAssetParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ForceFieldAssetParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ForceFieldAssetParams::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 ForceFieldAssetParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the asset properties for ForceField.", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="forceFieldKernelType"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("forceFieldKernelType", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Specify which force field kernel type will be used.", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "GenericForceFieldKernelParams", "RadialForceFieldKernelParams" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 2);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="defScale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("defScale", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Default scale of the force field", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="strength"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("strength", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Constant part of force field function", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="lifetime"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("lifetime", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Lifetime of force field", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="includeShapeParameters"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("includeShapeParameters", TYPE_STRUCT, "IncludeShapeParameters", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="includeShapeParameters.shape"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("shape", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Include shape type for force field", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "sphere", "capsule", "cylinder", "cone", "box", "none" };
+		ParamDefTable[6].setEnumVals((const char**)EnumVals, 6);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="includeShapeParameters.forceFieldToShape"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("forceFieldToShape", TYPE_MAT44, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Transform to convert force field to local shape coordinates", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="includeShapeParameters.dimensions"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("dimensions", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "x,y,z values dependent on shape type", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="fieldBoundaryFilterDataName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("fieldBoundaryFilterDataName", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The filter data name for ForceField vs Field Boundaries interaction. Overrides asset's value.", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="fieldSamplerFilterDataName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("fieldSamplerFilterDataName", TYPE_STRING, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The filter data name for ForceField vs other Field Samplers interaction. Overrides asset's value.", 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(2);
+		Children[2] = PDEF_PTR(3);
+		Children[3] = PDEF_PTR(4);
+		Children[4] = PDEF_PTR(5);
+		Children[5] = PDEF_PTR(9);
+		Children[6] = PDEF_PTR(10);
+
+		ParamDefTable[0].setChildren(Children, 7);
+	}
+
+	// SetChildren for: nodeIndex=5, longName="includeShapeParameters"
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(6);
+		Children[1] = PDEF_PTR(7);
+		Children[2] = PDEF_PTR(8);
+
+		ParamDefTable[5].setChildren(Children, 3);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ForceFieldAssetParams::initStrings(void)
+{
+	fieldBoundaryFilterDataName.isAllocated = true;
+	fieldBoundaryFilterDataName.buf = NULL;
+	fieldSamplerFilterDataName.isAllocated = true;
+	fieldSamplerFilterDataName.buf = NULL;
+}
+
+void ForceFieldAssetParams::initDynamicArrays(void)
+{
+}
+
+void ForceFieldAssetParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	defScale = float(1);
+	strength = float(0);
+	lifetime = float(0);
+	includeShapeParameters.shape = (const char*)"sphere";
+	includeShapeParameters.forceFieldToShape = physx::PxMat44(init(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1));
+	includeShapeParameters.dimensions = physx::PxVec3(init(1, 1, 1));
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ForceFieldAssetParams::initReferences(void)
+{
+	forceFieldKernelType = NULL;
+
+}
+
+void ForceFieldAssetParams::freeDynamicArrays(void)
+{
+}
+
+void ForceFieldAssetParams::freeStrings(void)
+{
+
+	if (fieldBoundaryFilterDataName.isAllocated && fieldBoundaryFilterDataName.buf)
+	{
+		mParameterizedTraits->strfree((char*)fieldBoundaryFilterDataName.buf);
+	}
+
+	if (fieldSamplerFilterDataName.isAllocated && fieldSamplerFilterDataName.buf)
+	{
+		mParameterizedTraits->strfree((char*)fieldSamplerFilterDataName.buf);
+	}
+}
+
+void ForceFieldAssetParams::freeReferences(void)
+{
+	if (forceFieldKernelType)
+	{
+		forceFieldKernelType->destroy();
+	}
+
+}
+
+} // namespace forcefield
+} // namespace nvidia
diff --git a/APEX_1.4/module/forcefield/src/autogen/ForceFieldAssetPreviewParams.cpp b/APEX_1.4/module/forcefield/src/autogen/ForceFieldAssetPreviewParams.cpp
new file mode 100644
index 00000000..15d93af1
--- /dev/null
+++ b/APEX_1.4/module/forcefield/src/autogen/ForceFieldAssetPreviewParams.cpp
@@ -0,0 +1,408 @@
+// 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 "ForceFieldAssetPreviewParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+using namespace ForceFieldAssetPreviewParamsNS;
+
+const char* const ForceFieldAssetPreviewParamsFactory::vptr =
+    NvParameterized::getVptr<ForceFieldAssetPreviewParams, ForceFieldAssetPreviewParams::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), 5 },
+	{ TYPE_MAT44, false, (size_t)(&((ParametersStruct*)0)->pose), NULL, 0 }, // pose
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->iconScale), NULL, 0 }, // iconScale
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->drawIcon), NULL, 0 }, // drawIcon
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->drawBoundaries), NULL, 0 }, // drawBoundaries
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->drawBold), NULL, 0 }, // drawBold
+};
+
+
+bool ForceFieldAssetPreviewParams::mBuiltFlag = false;
+NvParameterized::MutexType ForceFieldAssetPreviewParams::mBuiltFlagMutex;
+
+ForceFieldAssetPreviewParams::ForceFieldAssetPreviewParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ForceFieldAssetPreviewParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ForceFieldAssetPreviewParams::~ForceFieldAssetPreviewParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ForceFieldAssetPreviewParams::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->~ForceFieldAssetPreviewParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ForceFieldAssetPreviewParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ForceFieldAssetPreviewParams::getParameterDefinitionTree(void) const
+{
+	ForceFieldAssetPreviewParams* tmpParam = const_cast<ForceFieldAssetPreviewParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ForceFieldAssetPreviewParams::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 ForceFieldAssetPreviewParams::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 ForceFieldAssetPreviewParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ForceFieldAssetPreviewParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ForceFieldAssetPreviewParams::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 ForceFieldAssetPreviewParams::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="pose"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("pose", TYPE_MAT44, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The preview actor's position and rotation", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="iconScale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("iconScale", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The preview actor's icon scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="drawIcon"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("drawIcon", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Draw the icon", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="drawBoundaries"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("drawBoundaries", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Draw the explosion field boundaries", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="drawBold"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("drawBold", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Draw everything using thick lines", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#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(3);
+		Children[3] = PDEF_PTR(4);
+		Children[4] = PDEF_PTR(5);
+
+		ParamDefTable[0].setChildren(Children, 5);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ForceFieldAssetPreviewParams::initStrings(void)
+{
+}
+
+void ForceFieldAssetPreviewParams::initDynamicArrays(void)
+{
+}
+
+void ForceFieldAssetPreviewParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	pose = physx::PxMat44(init(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1));
+	iconScale = float(1);
+	drawIcon = bool(1);
+	drawBoundaries = bool(0);
+	drawBold = bool(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ForceFieldAssetPreviewParams::initReferences(void)
+{
+}
+
+void ForceFieldAssetPreviewParams::freeDynamicArrays(void)
+{
+}
+
+void ForceFieldAssetPreviewParams::freeStrings(void)
+{
+}
+
+void ForceFieldAssetPreviewParams::freeReferences(void)
+{
+}
+
+} // namespace forcefield
+} // namespace nvidia
diff --git a/APEX_1.4/module/forcefield/src/autogen/ForceFieldDebugRenderParams.cpp b/APEX_1.4/module/forcefield/src/autogen/ForceFieldDebugRenderParams.cpp
new file mode 100644
index 00000000..3102a8dd
--- /dev/null
+++ b/APEX_1.4/module/forcefield/src/autogen/ForceFieldDebugRenderParams.cpp
@@ -0,0 +1,308 @@
+// 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 "ForceFieldDebugRenderParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+using namespace ForceFieldDebugRenderParamsNS;
+
+const char* const ForceFieldDebugRenderParamsFactory::vptr =
+    NvParameterized::getVptr<ForceFieldDebugRenderParams, ForceFieldDebugRenderParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->VISUALIZE_FORCEFIELD_ACTOR), NULL, 0 }, // VISUALIZE_FORCEFIELD_ACTOR
+};
+
+
+bool ForceFieldDebugRenderParams::mBuiltFlag = false;
+NvParameterized::MutexType ForceFieldDebugRenderParams::mBuiltFlagMutex;
+
+ForceFieldDebugRenderParams::ForceFieldDebugRenderParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ForceFieldDebugRenderParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ForceFieldDebugRenderParams::~ForceFieldDebugRenderParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ForceFieldDebugRenderParams::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->~ForceFieldDebugRenderParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ForceFieldDebugRenderParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ForceFieldDebugRenderParams::getParameterDefinitionTree(void) const
+{
+	ForceFieldDebugRenderParams* tmpParam = const_cast<ForceFieldDebugRenderParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ForceFieldDebugRenderParams::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 ForceFieldDebugRenderParams::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 ForceFieldDebugRenderParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ForceFieldDebugRenderParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ForceFieldDebugRenderParams::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 ForceFieldDebugRenderParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="VISUALIZE_FORCEFIELD_ACTOR"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("VISUALIZE_FORCEFIELD_ACTOR", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Draws the include shape of the forcefield actor.", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ForceFieldDebugRenderParams::initStrings(void)
+{
+}
+
+void ForceFieldDebugRenderParams::initDynamicArrays(void)
+{
+}
+
+void ForceFieldDebugRenderParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	VISUALIZE_FORCEFIELD_ACTOR = bool(true);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ForceFieldDebugRenderParams::initReferences(void)
+{
+}
+
+void ForceFieldDebugRenderParams::freeDynamicArrays(void)
+{
+}
+
+void ForceFieldDebugRenderParams::freeStrings(void)
+{
+}
+
+void ForceFieldDebugRenderParams::freeReferences(void)
+{
+}
+
+} // namespace forcefield
+} // namespace nvidia
diff --git a/APEX_1.4/module/forcefield/src/autogen/ForceFieldFalloffParams.cpp b/APEX_1.4/module/forcefield/src/autogen/ForceFieldFalloffParams.cpp
new file mode 100644
index 00000000..325ca666
--- /dev/null
+++ b/APEX_1.4/module/forcefield/src/autogen/ForceFieldFalloffParams.cpp
@@ -0,0 +1,385 @@
+// 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 "ForceFieldFalloffParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+using namespace ForceFieldFalloffParamsNS;
+
+const char* const ForceFieldFalloffParamsFactory::vptr =
+    NvParameterized::getVptr<ForceFieldFalloffParams, ForceFieldFalloffParams::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_ENUM, false, (size_t)(&((ParametersStruct*)0)->type), NULL, 0 }, // type
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->multiplier), NULL, 0 }, // multiplier
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->start), NULL, 0 }, // start
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->end), NULL, 0 }, // end
+};
+
+
+bool ForceFieldFalloffParams::mBuiltFlag = false;
+NvParameterized::MutexType ForceFieldFalloffParams::mBuiltFlagMutex;
+
+ForceFieldFalloffParams::ForceFieldFalloffParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ForceFieldFalloffParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ForceFieldFalloffParams::~ForceFieldFalloffParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ForceFieldFalloffParams::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->~ForceFieldFalloffParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ForceFieldFalloffParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ForceFieldFalloffParams::getParameterDefinitionTree(void) const
+{
+	ForceFieldFalloffParams* tmpParam = const_cast<ForceFieldFalloffParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ForceFieldFalloffParams::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 ForceFieldFalloffParams::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 ForceFieldFalloffParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ForceFieldFalloffParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ForceFieldFalloffParams::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 ForceFieldFalloffParams::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="type"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("type", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Falloff type for force field", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "linear", "steep", "scurve", "custom", "none" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 5);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="multiplier"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("multiplier", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Falloff multiplier value", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="start"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("start", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Falloff start value", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="end"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("end", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Falloff end value", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[4];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+		Children[3] = PDEF_PTR(4);
+
+		ParamDefTable[0].setChildren(Children, 4);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ForceFieldFalloffParams::initStrings(void)
+{
+}
+
+void ForceFieldFalloffParams::initDynamicArrays(void)
+{
+}
+
+void ForceFieldFalloffParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	type = (const char*)"linear";
+	multiplier = float(0);
+	start = float(0);
+	end = float(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ForceFieldFalloffParams::initReferences(void)
+{
+}
+
+void ForceFieldFalloffParams::freeDynamicArrays(void)
+{
+}
+
+void ForceFieldFalloffParams::freeStrings(void)
+{
+}
+
+void ForceFieldFalloffParams::freeReferences(void)
+{
+}
+
+} // namespace forcefield
+} // namespace nvidia
diff --git a/APEX_1.4/module/forcefield/src/autogen/ForceFieldModuleParams.cpp b/APEX_1.4/module/forcefield/src/autogen/ForceFieldModuleParams.cpp
new file mode 100644
index 00000000..58672278
--- /dev/null
+++ b/APEX_1.4/module/forcefield/src/autogen/ForceFieldModuleParams.cpp
@@ -0,0 +1,308 @@
+// 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 "ForceFieldModuleParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+using namespace ForceFieldModuleParamsNS;
+
+const char* const ForceFieldModuleParamsFactory::vptr =
+    NvParameterized::getVptr<ForceFieldModuleParams, ForceFieldModuleParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->unused), NULL, 0 }, // unused
+};
+
+
+bool ForceFieldModuleParams::mBuiltFlag = false;
+NvParameterized::MutexType ForceFieldModuleParams::mBuiltFlagMutex;
+
+ForceFieldModuleParams::ForceFieldModuleParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ForceFieldModuleParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ForceFieldModuleParams::~ForceFieldModuleParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ForceFieldModuleParams::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->~ForceFieldModuleParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ForceFieldModuleParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ForceFieldModuleParams::getParameterDefinitionTree(void) const
+{
+	ForceFieldModuleParams* tmpParam = const_cast<ForceFieldModuleParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ForceFieldModuleParams::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 ForceFieldModuleParams::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 ForceFieldModuleParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ForceFieldModuleParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ForceFieldModuleParams::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 ForceFieldModuleParams::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="unused"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("unused", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "No parameters necessary", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ForceFieldModuleParams::initStrings(void)
+{
+}
+
+void ForceFieldModuleParams::initDynamicArrays(void)
+{
+}
+
+void ForceFieldModuleParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	unused = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ForceFieldModuleParams::initReferences(void)
+{
+}
+
+void ForceFieldModuleParams::freeDynamicArrays(void)
+{
+}
+
+void ForceFieldModuleParams::freeStrings(void)
+{
+}
+
+void ForceFieldModuleParams::freeReferences(void)
+{
+}
+
+} // namespace forcefield
+} // namespace nvidia
diff --git a/APEX_1.4/module/forcefield/src/autogen/ForceFieldNoiseParams.cpp b/APEX_1.4/module/forcefield/src/autogen/ForceFieldNoiseParams.cpp
new file mode 100644
index 00000000..8ce9fda5
--- /dev/null
+++ b/APEX_1.4/module/forcefield/src/autogen/ForceFieldNoiseParams.cpp
@@ -0,0 +1,383 @@
+// 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 "ForceFieldNoiseParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+using namespace ForceFieldNoiseParamsNS;
+
+const char* const ForceFieldNoiseParamsFactory::vptr =
+    NvParameterized::getVptr<ForceFieldNoiseParams, ForceFieldNoiseParams::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_F32, false, (size_t)(&((ParametersStruct*)0)->strength), NULL, 0 }, // strength
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->spaceScale), NULL, 0 }, // spaceScale
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->timeScale), NULL, 0 }, // timeScale
+	{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->octaves), NULL, 0 }, // octaves
+};
+
+
+bool ForceFieldNoiseParams::mBuiltFlag = false;
+NvParameterized::MutexType ForceFieldNoiseParams::mBuiltFlagMutex;
+
+ForceFieldNoiseParams::ForceFieldNoiseParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ForceFieldNoiseParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ForceFieldNoiseParams::~ForceFieldNoiseParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ForceFieldNoiseParams::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->~ForceFieldNoiseParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ForceFieldNoiseParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ForceFieldNoiseParams::getParameterDefinitionTree(void) const
+{
+	ForceFieldNoiseParams* tmpParam = const_cast<ForceFieldNoiseParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ForceFieldNoiseParams::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 ForceFieldNoiseParams::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 ForceFieldNoiseParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ForceFieldNoiseParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ForceFieldNoiseParams::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 ForceFieldNoiseParams::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="strength"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("strength", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Noise strength value", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="spaceScale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("spaceScale", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Noise space scale value", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="timeScale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("timeScale", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Noise time scale value", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="octaves"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("octaves", 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 noise octaves", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[4];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+		Children[3] = PDEF_PTR(4);
+
+		ParamDefTable[0].setChildren(Children, 4);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ForceFieldNoiseParams::initStrings(void)
+{
+}
+
+void ForceFieldNoiseParams::initDynamicArrays(void)
+{
+}
+
+void ForceFieldNoiseParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	strength = float(0);
+	spaceScale = float(0);
+	timeScale = float(0);
+	octaves = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ForceFieldNoiseParams::initReferences(void)
+{
+}
+
+void ForceFieldNoiseParams::freeDynamicArrays(void)
+{
+}
+
+void ForceFieldNoiseParams::freeStrings(void)
+{
+}
+
+void ForceFieldNoiseParams::freeReferences(void)
+{
+}
+
+} // namespace forcefield
+} // namespace nvidia
diff --git a/APEX_1.4/module/forcefield/src/autogen/GenericForceFieldKernelParams.cpp b/APEX_1.4/module/forcefield/src/autogen/GenericForceFieldKernelParams.cpp
new file mode 100644
index 00000000..19c48d6f
--- /dev/null
+++ b/APEX_1.4/module/forcefield/src/autogen/GenericForceFieldKernelParams.cpp
@@ -0,0 +1,572 @@
+// 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 "GenericForceFieldKernelParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+using namespace GenericForceFieldKernelParamsNS;
+
+const char* const GenericForceFieldKernelParamsFactory::vptr =
+    NvParameterized::getVptr<GenericForceFieldKernelParams, GenericForceFieldKernelParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 12;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 4, 5, 6, 7, 8, 9, 10, 11, 2, 3,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 9 },
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->coordinateSystemParameters), CHILDREN(9), 2 }, // coordinateSystemParameters
+	{ TYPE_ENUM, false, (size_t)(&((CoordinateSystemParameters_Type*)0)->type), NULL, 0 }, // coordinateSystemParameters.type
+	{ TYPE_F32, false, (size_t)(&((CoordinateSystemParameters_Type*)0)->torusRadius), NULL, 0 }, // coordinateSystemParameters.torusRadius
+	{ TYPE_VEC3, false, (size_t)(&((ParametersStruct*)0)->constant), NULL, 0 }, // constant
+	{ TYPE_MAT33, false, (size_t)(&((ParametersStruct*)0)->positionMultiplier), NULL, 0 }, // positionMultiplier
+	{ TYPE_VEC3, false, (size_t)(&((ParametersStruct*)0)->positionTarget), NULL, 0 }, // positionTarget
+	{ TYPE_MAT33, false, (size_t)(&((ParametersStruct*)0)->velocityMultiplier), NULL, 0 }, // velocityMultiplier
+	{ TYPE_VEC3, false, (size_t)(&((ParametersStruct*)0)->velocityTarget), NULL, 0 }, // velocityTarget
+	{ TYPE_VEC3, false, (size_t)(&((ParametersStruct*)0)->noise), NULL, 0 }, // noise
+	{ TYPE_VEC3, false, (size_t)(&((ParametersStruct*)0)->falloffLinear), NULL, 0 }, // falloffLinear
+	{ TYPE_VEC3, false, (size_t)(&((ParametersStruct*)0)->falloffQuadratic), NULL, 0 }, // falloffQuadratic
+};
+
+
+bool GenericForceFieldKernelParams::mBuiltFlag = false;
+NvParameterized::MutexType GenericForceFieldKernelParams::mBuiltFlagMutex;
+
+GenericForceFieldKernelParams::GenericForceFieldKernelParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &GenericForceFieldKernelParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+GenericForceFieldKernelParams::~GenericForceFieldKernelParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void GenericForceFieldKernelParams::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->~GenericForceFieldKernelParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* GenericForceFieldKernelParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* GenericForceFieldKernelParams::getParameterDefinitionTree(void) const
+{
+	GenericForceFieldKernelParams* tmpParam = const_cast<GenericForceFieldKernelParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType GenericForceFieldKernelParams::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 GenericForceFieldKernelParams::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 GenericForceFieldKernelParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<GenericForceFieldKernelParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void GenericForceFieldKernelParams::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 GenericForceFieldKernelParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Generic force field kernel is needed for backward compatibility with ForceFieldKernel (PhysX 2.8.4).", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="coordinateSystemParameters"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("coordinateSystemParameters", TYPE_STRUCT, "CoordinateSystemParameters", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="coordinateSystemParameters.type"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("type", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Coordinate system type", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "CARTESIAN", "SPHERICAL", "CYLINDRICAL", "TOROIDAL" };
+		ParamDefTable[2].setEnumVals((const char**)EnumVals, 4);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="coordinateSystemParameters.torusRadius"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("torusRadius", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Radius for toroidal type coordinates. For other types of coordinates not used.", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="constant"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("constant", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Constant part of force field function", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="positionMultiplier"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("positionMultiplier", TYPE_MAT33, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Coefficient of force field function position term", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="positionTarget"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("positionTarget", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Force field position target", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="velocityMultiplier"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("velocityMultiplier", TYPE_MAT33, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Coefficient of force field function velocity term", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="velocityTarget"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("velocityTarget", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Force field velocity target", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="noise"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("noise", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Noise scaling", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=10, longName="falloffLinear"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
+		ParamDef->init("falloffLinear", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Linear term in magnitude falloff factor. Range (each component): [0, inf)", true);
+		ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=11, longName="falloffQuadratic"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11];
+		ParamDef->init("falloffQuadratic", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Quadratic term in magnitude falloff factor. Range (each component): [0, inf)", true);
+		ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[9];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(4);
+		Children[2] = PDEF_PTR(5);
+		Children[3] = PDEF_PTR(6);
+		Children[4] = PDEF_PTR(7);
+		Children[5] = PDEF_PTR(8);
+		Children[6] = PDEF_PTR(9);
+		Children[7] = PDEF_PTR(10);
+		Children[8] = PDEF_PTR(11);
+
+		ParamDefTable[0].setChildren(Children, 9);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="coordinateSystemParameters"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(2);
+		Children[1] = PDEF_PTR(3);
+
+		ParamDefTable[1].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void GenericForceFieldKernelParams::initStrings(void)
+{
+}
+
+void GenericForceFieldKernelParams::initDynamicArrays(void)
+{
+}
+
+void GenericForceFieldKernelParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	coordinateSystemParameters.type = (const char*)"CARTESIAN";
+	coordinateSystemParameters.torusRadius = float(1);
+	constant = physx::PxVec3(init(0, 0, 0));
+	positionMultiplier = physx::PxMat33(init( 0, 0, 0, 0, 0, 0, 0, 0, 0));
+	positionTarget = physx::PxVec3(init(0, 0, 0));
+	velocityMultiplier = physx::PxMat33(init( 0, 0, 0, 0, 0, 0, 0, 0, 0));
+	velocityTarget = physx::PxVec3(init(0, 0, 0));
+	noise = physx::PxVec3(init(0, 0, 0));
+	falloffLinear = physx::PxVec3(init(0, 0, 0));
+	falloffQuadratic = physx::PxVec3(init(0, 0, 0));
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void GenericForceFieldKernelParams::initReferences(void)
+{
+}
+
+void GenericForceFieldKernelParams::freeDynamicArrays(void)
+{
+}
+
+void GenericForceFieldKernelParams::freeStrings(void)
+{
+}
+
+void GenericForceFieldKernelParams::freeReferences(void)
+{
+}
+
+} // namespace forcefield
+} // namespace nvidia
diff --git a/APEX_1.4/module/forcefield/src/autogen/RadialForceFieldKernelParams.cpp b/APEX_1.4/module/forcefield/src/autogen/RadialForceFieldKernelParams.cpp
new file mode 100644
index 00000000..8ae35f2a
--- /dev/null
+++ b/APEX_1.4/module/forcefield/src/autogen/RadialForceFieldKernelParams.cpp
@@ -0,0 +1,402 @@
+// 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 "RadialForceFieldKernelParams.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+using namespace RadialForceFieldKernelParamsNS;
+
+const char* const RadialForceFieldKernelParamsFactory::vptr =
+    NvParameterized::getVptr<RadialForceFieldKernelParams, RadialForceFieldKernelParams::ClassAlignment>();
+
+const uint32_t NumParamDefs = 4;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->falloffParameters), NULL, 0 }, // falloffParameters
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->noiseParameters), NULL, 0 }, // noiseParameters
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->radius), NULL, 0 }, // radius
+};
+
+
+bool RadialForceFieldKernelParams::mBuiltFlag = false;
+NvParameterized::MutexType RadialForceFieldKernelParams::mBuiltFlagMutex;
+
+RadialForceFieldKernelParams::RadialForceFieldKernelParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &RadialForceFieldKernelParamsFactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+RadialForceFieldKernelParams::~RadialForceFieldKernelParams()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void RadialForceFieldKernelParams::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->~RadialForceFieldKernelParams();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* RadialForceFieldKernelParams::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* RadialForceFieldKernelParams::getParameterDefinitionTree(void) const
+{
+	RadialForceFieldKernelParams* tmpParam = const_cast<RadialForceFieldKernelParams*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType RadialForceFieldKernelParams::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 RadialForceFieldKernelParams::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 RadialForceFieldKernelParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<RadialForceFieldKernelParams::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void RadialForceFieldKernelParams::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 RadialForceFieldKernelParams::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Radial force field kernel correspond to APEX 1.3 Force Field implementation", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="falloffParameters"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("falloffParameters", 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[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ForceFieldFalloffParams" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="noiseParameters"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("noiseParameters", 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[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ForceFieldNoiseParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="radius"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("radius", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("gameScale", "true", true);
+		HintTable[1].init("min", double(0.001), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("gameScale", "true", true);
+		HintTable[1].init("min", double(0.001), true);
+		HintTable[2].init("shortDescription", "Sphere Radius", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	mBuiltFlag = true;
+
+}
+void RadialForceFieldKernelParams::initStrings(void)
+{
+}
+
+void RadialForceFieldKernelParams::initDynamicArrays(void)
+{
+}
+
+void RadialForceFieldKernelParams::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	radius = float(1.0f);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void RadialForceFieldKernelParams::initReferences(void)
+{
+	falloffParameters = NULL;
+
+	noiseParameters = NULL;
+
+}
+
+void RadialForceFieldKernelParams::freeDynamicArrays(void)
+{
+}
+
+void RadialForceFieldKernelParams::freeStrings(void)
+{
+}
+
+void RadialForceFieldKernelParams::freeReferences(void)
+{
+	if (falloffParameters)
+	{
+		falloffParameters->destroy();
+	}
+
+	if (noiseParameters)
+	{
+		noiseParameters->destroy();
+	}
+
+}
+
+} // namespace forcefield
+} // namespace nvidia