Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

35 files changed, 9500 insertions, 0 deletions

diff --git a/APEX_1.4/module/forcefield/cuda/include/common.h b/APEX_1.4/module/forcefield/cuda/include/common.h
new file mode 100644
index 00000000..6647dd97
--- /dev/null
+++ b/APEX_1.4/module/forcefield/cuda/include/common.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#ifndef __COMMON_H__
+#define __COMMON_H__
+
+#define APEX_CUDA_MODULE_PREFIX ForceField_
+
+#include "ApexCuda.h"
+#include "../include/ForceFieldFSCommon.h"
+
+#define FIELD_SAMPLER_POINTS_KERNEL_CONFIG ()
+#define FIELD_SAMPLER_GRID_KERNEL_CONFIG ()
+
+namespace nvidia
+{
+namespace apex
+{
+
+}
+} // namespace nvidia::apex
+
+#endif
diff --git a/APEX_1.4/module/forcefield/cuda/include/forcefield.h b/APEX_1.4/module/forcefield/cuda/include/forcefield.h
new file mode 100644
index 00000000..7682ee92
--- /dev/null
+++ b/APEX_1.4/module/forcefield/cuda/include/forcefield.h
@@ -0,0 +1,14 @@
+/*
+ * 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.
+ */
+
+
+APEX_CUDA_STORAGE(fieldSamplerStorage)
+
+#include "../../fieldsampler/cuda/include/fieldsamplerInc.h"
diff --git a/APEX_1.4/module/forcefield/include/ForceFieldActorImpl.h b/APEX_1.4/module/forcefield/include/ForceFieldActorImpl.h
new file mode 100644
index 00000000..eefc5f7e
--- /dev/null
+++ b/APEX_1.4/module/forcefield/include/ForceFieldActorImpl.h
@@ -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.
+ */
+
+
+#ifndef __FORCEFIELD_ACTOR_IMPL_H__
+#define __FORCEFIELD_ACTOR_IMPL_H__
+
+#include "Apex.h"
+
+#include "ForceFieldAsset.h"
+#include "ForceFieldActor.h"
+#include "ForceFieldAssetImpl.h"
+#include "ApexActor.h"
+#include "ApexString.h"
+#include "ApexRWLockable.h"
+#include "ReadCheck.h"
+#include "WriteCheck.h"
+#include "FieldSamplerIntl.h"
+
+#if APEX_CUDA_SUPPORT
+#include "ApexCudaWrapper.h"
+#endif
+
+#include "ForceFieldFSCommon.h"
+
+class ForceFieldAssetParams;
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+/*
+PX_INLINE bool operator != (const GroupsMask64& d1, const GroupsMask64& d2)
+{
+	return d1.bits0 != d2.bits0 || d1.bits1 != d2.bits1;
+}*/
+PX_INLINE bool operator != (const physx::PxFilterData& d1, const physx::PxFilterData& d2)
+{
+	//if (d1.word3 != d2.word3) return d1.word3 < d2.word3;
+	//if (d1.word2 != d2.word2) return d1.word2 < d2.word2;
+	//if (d1.word1 != d2.word1) return d1.word1 < d2.word1;
+	return d1.word0 != d2.word0 || d1.word1 != d2.word1 || d1.word2 != d2.word2 || d1.word3 != d2.word3;
+}
+
+class ForceFieldAssetImpl;
+class ForceFieldScene;
+
+/**
+Union class to hold all kernel parameter types. Avoided the use of templates 
+for the getters, as that resulting code using traits for type safty 
+was about the same amount as the non-templated one.
+*/
+class ForceFieldFSKernelParamsUnion
+{
+public:
+	ForceFieldFSKernelParams& getForceFieldFSKernelParams()
+	{
+		return reinterpret_cast<ForceFieldFSKernelParams&>(params);
+	}
+
+	const ForceFieldFSKernelParams& getForceFieldFSKernelParams() const
+	{
+		return reinterpret_cast<const ForceFieldFSKernelParams&>(params);
+	}
+
+	const RadialForceFieldFSKernelParams& getRadialForceFieldFSKernelParams() const
+	{
+		PX_ASSERT(kernelType == ForceFieldKernelType::RADIAL);
+		return reinterpret_cast<const RadialForceFieldFSKernelParams&>(params);
+	}
+
+	RadialForceFieldFSKernelParams& getRadialForceFieldFSKernelParams()
+	{
+		PX_ASSERT(kernelType == ForceFieldKernelType::RADIAL);
+		return reinterpret_cast<RadialForceFieldFSKernelParams&>(params);
+	}
+
+	GenericForceFieldFSKernelParams& getGenericForceFieldFSKernelParams()
+	{
+		PX_ASSERT(kernelType == ForceFieldKernelType::GENERIC);
+		return reinterpret_cast<GenericForceFieldFSKernelParams&>(params);
+	}
+
+	const GenericForceFieldFSKernelParams& getGenericForceFieldFSKernelParams() const
+	{
+		PX_ASSERT(kernelType == ForceFieldKernelType::GENERIC);
+		return reinterpret_cast<const GenericForceFieldFSKernelParams&>(params);
+	}
+
+	ForceFieldKernelType::Enum kernelType;
+
+private:
+
+	union
+	{
+		void* alignment; //makes data aligned to pointer size
+		uint8_t radial[sizeof(RadialForceFieldFSKernelParams)];
+		uint8_t generic[sizeof(GenericForceFieldFSKernelParams)];
+	} params;
+};
+
+class ForceFieldActorImpl : public ForceFieldActor, public ApexRWLockable, public ApexActor, public ApexActorSource, public ApexResourceInterface, public ApexResource, public FieldSamplerIntl
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	/* ForceFieldActorImpl methods */
+	ForceFieldActorImpl(const ForceFieldActorDesc&, ForceFieldAssetImpl&, ResourceList&, ForceFieldScene&);
+	~ForceFieldActorImpl() {}
+	ForceFieldAsset* 	getForceFieldAsset() const;
+
+	bool				disable();
+	bool				enable();
+	bool				isEnable()
+	{
+		READ_ZONE();
+		return mEnable;
+	}
+	PxMat44		getPose() const;
+	void				setPose(const PxMat44& pose);
+
+	float	getCurrentScale(void) const
+	{
+		READ_ZONE();
+		return getScale();
+	}
+
+	void setCurrentScale(float scale)
+	{
+		WRITE_ZONE();
+		setScale(scale);
+	}
+
+	PX_DEPRECATED float		getScale() const
+	{
+		READ_ZONE();
+		return 0.0f;
+	}
+
+	PX_DEPRECATED void				setScale(float scale);
+
+	const char*			getName() const
+	{
+		READ_ZONE();
+		return mName.c_str();
+	}
+	void				setName(const char* name)
+	{
+		WRITE_ZONE();
+		mName = name;
+	}
+
+	void				setStrength(const float strength);
+	void				setLifetime(const float lifetime);
+
+	//kernel specific functionality
+	void				setRadialFalloffType(const char* type);
+	void				setRadialFalloffMultiplier(const float multiplier);
+
+	// deprecated
+	void				setFalloffType(const char* type);
+	void				setFalloffMultiplier(const float multiplier);
+
+	void                updatePoseAndBounds();  // Called by ExampleScene::fetchResults()
+
+	/* ApexResourceInterface, ApexResource */
+	void				release();
+	uint32_t		getListIndex() const
+	{
+		return m_listIndex;
+	}
+	void				setListIndex(class ResourceList& list, uint32_t index)
+	{
+		m_list = &list;
+		m_listIndex = index;
+	}
+
+	/* Actor, ApexActor */
+	void                destroy();
+	Asset*		getOwner() const;
+
+	/* PhysX scene management */
+	void				setPhysXScene(PxScene*);
+	PxScene*			getPhysXScene() const;
+
+	void				getLodRange(float& min, float& max, bool& intOnly) const;
+	float		getActiveLod() const;
+	void				forceLod(float lod);
+	/**
+	\brief Selectively enables/disables debug visualization of a specific APEX actor.  Default value it true.
+	*/
+	virtual void setEnableDebugVisualization(bool state)
+	{
+		WRITE_ZONE();
+		ApexActor::setEnableDebugVisualization(state);
+	}
+
+	/* FieldSamplerIntl */
+	virtual bool		updateFieldSampler(FieldShapeDescIntl& shapeDesc, bool& isEnabled);
+
+	virtual PxVec3 queryFieldSamplerVelocity() const
+	{
+		return PxVec3(0.0f);
+	}
+
+protected:
+	void				updateForceField(float dt);
+	void				releaseForceField();
+
+protected:
+	ForceFieldScene*		mForceFieldScene;
+	
+	//not used, setters and getters deprecated
+	//float			mScale;
+
+	uint32_t			mFlags;
+
+	ApexSimpleString		mName;
+
+	ForceFieldAssetImpl*		mAsset;
+
+	bool					mEnable;
+	float			mElapsedTime;
+
+	/* Force field actor parameters */
+	float			mLifetime;
+	void					initActorParams(const PxMat44& initialPose);
+
+	/* Field Sampler Stuff */
+	bool					mFieldSamplerChanged;
+	void					initFieldSampler(const ForceFieldActorDesc& desc);
+	void					releaseFieldSampler();
+
+	/* Debug Rendering Stuff */
+	void					visualize();
+	void					visualizeIncludeShape();
+	void					visualizeForces();
+
+	ForceFieldFSKernelParamsUnion mKernelParams;
+	ForceFieldFSKernelParamsUnion mKernelExecutionParams; //buffered data
+
+	friend class ForceFieldScene;
+};
+
+class ForceFieldActorCPU : public ForceFieldActorImpl
+{
+public:
+	ForceFieldActorCPU(const ForceFieldActorDesc& desc, ForceFieldAssetImpl& asset, ResourceList& list, ForceFieldScene& scene);
+	~ForceFieldActorCPU();
+
+	/* FieldSamplerIntl */
+	virtual void executeFieldSampler(const ExecuteData& data);
+
+	/**
+	\brief Selectively enables/disables debug visualization of a specific APEX actor.  Default value it true.
+	*/
+	virtual void setEnableDebugVisualization(bool state)
+	{
+		ApexActor::setEnableDebugVisualization(state);
+	}
+
+
+private:
+};
+
+#if APEX_CUDA_SUPPORT
+
+class ForceFieldActorGPU : public ForceFieldActorCPU
+{
+public:
+	ForceFieldActorGPU(const ForceFieldActorDesc& desc, ForceFieldAssetImpl& asset, ResourceList& list, ForceFieldScene& scene);
+	~ForceFieldActorGPU();
+
+	/* FieldSamplerIntl */
+	virtual bool updateFieldSampler(FieldShapeDescIntl& shapeDesc, bool& isEnabled);
+
+	virtual void getFieldSamplerCudaExecuteInfo(CudaExecuteInfo& info) const;
+
+private:
+	ApexCudaConstMemGroup				mConstMemGroup;
+	InplaceHandle<RadialForceFieldFSKernelParams>	mParamsHandle;
+};
+
+#endif
+
+}
+} // end namespace nvidia
+
+#endif
diff --git a/APEX_1.4/module/forcefield/include/ForceFieldAssetImpl.h b/APEX_1.4/module/forcefield/include/ForceFieldAssetImpl.h
new file mode 100644
index 00000000..2d3adfec
--- /dev/null
+++ b/APEX_1.4/module/forcefield/include/ForceFieldAssetImpl.h
@@ -0,0 +1,310 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#ifndef FORCEFIELD_ASSET_IMPL_H
+#define FORCEFIELD_ASSET_IMPL_H
+
+#include "Apex.h"
+#include "ApexUsingNamespace.h"
+#include "ForceFieldAsset.h"
+#include "ForceFieldActor.h"
+#include "ForceFieldPreview.h"
+#include "ApexSDKHelpers.h"
+#include "ModuleForceFieldImpl.h"
+#include "ApexAssetAuthoring.h"
+#include "ApexString.h"
+#include "ApexAssetTracker.h"
+#include "ApexAuthorableObject.h"
+#include "ForceFieldAssetParams.h"
+#include "ReadCheck.h"
+#include "WriteCheck.h"
+#include "ApexAuthorableObject.h"
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+class ForceFieldActorDesc : public ApexDesc
+{
+public:
+	physx::PxFilterData samplerFilterData;
+	physx::PxFilterData boundaryFilterData;
+
+	PxMat44 initialPose;
+	
+	//deprecated, has no effect
+	float	 scale;
+	PxActor* nxActor;
+	const char* actorName;
+
+	/**
+	\brief constructor sets to default.
+	*/
+	PX_INLINE ForceFieldActorDesc() : ApexDesc()
+	{
+		init();
+	}
+
+	/**
+	\brief sets members to default values.
+	*/
+	PX_INLINE void setToDefault()
+	{
+		ApexDesc::setToDefault();
+		init();
+	}
+
+	/**
+	\brief checks if this is a valid descriptor.
+	*/
+	PX_INLINE bool isValid() const
+	{
+		if (!ApexDesc::isValid())
+		{
+			return false;
+		}
+
+		return true;
+	}
+
+private:
+	PX_INLINE void init()
+	{
+		initialPose = PxMat44(PxIdentity);
+		scale = 1.0f;
+		nxActor = NULL;
+		actorName = NULL;
+	}
+};
+
+/**
+\brief Descriptor for a ForceField Asset
+*/
+class ForceFieldPreviewDesc
+{
+public:
+	ForceFieldPreviewDesc() :
+		mPose(PxMat44()),
+		mIconScale(1.0f),
+		mPreviewDetail(APEX_FORCEFIELD::FORCEFIELD_DRAW_ICON)
+	{
+		mPose = PxMat44(PxIdentity);
+	};
+
+	/**
+	\brief The pose that translates from explosion preview coordinates to world coordinates.
+	*/
+	PxMat44							mPose;
+	/**
+	\brief The scale of the icon.
+	*/
+	float							mIconScale;
+	/**
+	\brief The detail options of the preview drawing
+	*/
+	uint32_t							mPreviewDetail;
+};
+
+
+class ForceFieldActorImpl;
+
+class ForceFieldAssetImpl : public ForceFieldAsset, public ApexResourceInterface, public ApexResource, public ApexRWLockable
+{
+	friend class ForceFieldAssetDummyAuthoring;
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	ForceFieldAssetImpl(ModuleForceFieldImpl*, ResourceList&, const char* name);
+	ForceFieldAssetImpl(ModuleForceFieldImpl*, ResourceList&, NvParameterized::Interface*, const char*);
+
+	~ForceFieldAssetImpl();
+
+	/* Asset */
+	const char* 					getName() const
+	{
+		return mName.c_str();
+	}
+	AuthObjTypeID					getObjTypeID() const
+	{
+		READ_ZONE();
+		return mAssetTypeID;
+	}
+	const char* 					getObjTypeName() const
+	{
+		READ_ZONE();
+		return getClassName();
+	}
+	uint32_t					forceLoadAssets();
+
+	/* ApexInterface */
+	virtual void					release()
+	{
+		mModule->mSdk->releaseAsset(*this);
+	}
+
+	/* ApexResourceInterface, ApexResource */
+	uint32_t					getListIndex() const
+	{
+		return m_listIndex;
+	}
+	void							setListIndex(class ResourceList& list, uint32_t index)
+	{
+		m_list = &list;
+		m_listIndex = index;
+	}
+
+	/* ForceFieldAsset specific methods */
+	void							releaseForceFieldActor(ForceFieldActor&);
+	const ForceFieldAssetParams&	getForceFieldParameters() const
+	{
+		return *mParams;
+	}
+	float					getDefaultScale() const
+	{
+		READ_ZONE();
+		return mParams->defScale;
+	}
+	void							destroy();
+	ForceFieldPreview*			createForceFieldPreview(const ForceFieldPreviewDesc& desc, AssetPreviewScene* previewScene);
+	ForceFieldPreview*			createForceFieldPreviewImpl(const ForceFieldPreviewDesc& desc, ForceFieldAssetImpl* forceFieldAsset, AssetPreviewScene* previewScene);
+	void							releaseForceFieldPreview(ForceFieldPreview& preview);
+
+	const NvParameterized::Interface* getAssetNvParameterized() const
+	{
+		return mParams;
+	}
+	/**
+	 * \brief Releases the ApexAsset but returns the NvParameterized::Interface and *ownership* to the caller.
+	 */
+	virtual NvParameterized::Interface* releaseAndReturnNvParameterizedInterface(void)
+	{
+		NvParameterized::Interface* ret = mParams;
+		mParams = NULL;
+		release();
+		return ret;
+	}
+	NvParameterized::Interface* getDefaultActorDesc();
+	NvParameterized::Interface* getDefaultAssetPreviewDesc();
+	virtual Actor* createApexActor(const NvParameterized::Interface& /*parms*/, Scene& /*apexScene*/);
+	virtual AssetPreview* createApexAssetPreview(const NvParameterized::Interface& params, AssetPreviewScene* previewScene);
+
+	virtual bool isValidForActorCreation(const ::NvParameterized::Interface& /*parms*/, Scene& /*apexScene*/) const
+	{
+		READ_ZONE();
+		return true; // TODO implement this method
+	}
+
+	virtual bool isDirty() const
+	{
+		READ_ZONE();
+		return false;
+	}
+
+protected:
+	static const char* 				getClassName()
+	{
+		return FORCEFIELD_AUTHORING_TYPE_NAME;
+	}
+	static AuthObjTypeID			mAssetTypeID;
+
+	ModuleForceFieldImpl*				mModule;
+
+	ResourceList					mForceFieldActors;
+	ApexSimpleString				mName;
+	ForceFieldAssetParams*			mParams;
+	ForceFieldActorParams*			mDefaultActorParams;
+	ForceFieldAssetPreviewParams*	mDefaultPreviewParams;
+
+	GenericForceFieldKernelParams*	mGenericParams;
+	RadialForceFieldKernelParams*	mRadialParams;
+	ForceFieldFalloffParams*		mFalloffParams;
+	ForceFieldNoiseParams*			mNoiseParams;
+
+	void							initializeAssetNameTable();
+
+	friend class ModuleForceFieldImpl;
+	friend class ForceFieldActorImpl;
+	template <class T_Module, class T_Asset, class T_AssetAuthoring> friend class nvidia::apex::ApexAuthorableObject;
+};
+
+#ifndef WITHOUT_APEX_AUTHORING
+class ForceFieldAssetAuthoringImpl : public ForceFieldAssetImpl, public ApexAssetAuthoring, public ForceFieldAssetAuthoring
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	/* ForceFieldAssetAuthoring */
+	ForceFieldAssetAuthoringImpl(ModuleForceFieldImpl* m, ResourceList& l) :
+		ForceFieldAssetImpl(m, l, "ForceFieldAssetAuthoringImpl") {}
+
+	ForceFieldAssetAuthoringImpl(ModuleForceFieldImpl* m, ResourceList& l, const char* name) :
+		ForceFieldAssetImpl(m, l, name) {}
+
+	ForceFieldAssetAuthoringImpl(ModuleForceFieldImpl* m, ResourceList& l, NvParameterized::Interface* params, const char* name) :
+		ForceFieldAssetImpl(m, l, params, name) {}
+
+	~ForceFieldAssetAuthoringImpl() {}
+
+	void							destroy()
+	{
+		delete this;
+	}
+
+	/* AssetAuthoring */
+	const char* 					getName(void) const
+	{
+		READ_ZONE();
+		return ForceFieldAssetImpl::getName();
+	}
+	const char* 					getObjTypeName() const
+	{
+		return ForceFieldAssetImpl::getClassName();
+	}
+	virtual bool					prepareForPlatform(nvidia::apex::PlatformTag)
+	{
+		APEX_INVALID_OPERATION("Not Implemented.");
+		return false;
+	}
+
+	void setToolString(const char* toolName, const char* toolVersion, uint32_t toolChangelist)
+	{
+		ApexAssetAuthoring::setToolString(toolName, toolVersion, toolChangelist);
+	}
+
+	/* ApexInterface */
+	virtual void					release()
+	{
+		mModule->mSdk->releaseAssetAuthoring(*this);
+	}
+
+	NvParameterized::Interface* getNvParameterized() const
+	{
+		return (NvParameterized::Interface*)getAssetNvParameterized();
+	}
+	/**
+	 * \brief Releases the ApexAsset but returns the NvParameterized::Interface and *ownership* to the caller.
+	 */
+	virtual NvParameterized::Interface* releaseAndReturnNvParameterizedInterface(void)
+	{
+		WRITE_ZONE();
+		NvParameterized::Interface* ret = mParams;
+		mParams = NULL;
+		release();
+		return ret;
+	}
+};
+#endif
+
+}
+} // end namespace nvidia
+
+#endif // FORCEFIELD_ASSET_IMPL_H
diff --git a/APEX_1.4/module/forcefield/include/ForceFieldAssetPreviewImpl.h b/APEX_1.4/module/forcefield/include/ForceFieldAssetPreviewImpl.h
new file mode 100644
index 00000000..6a4c11d3
--- /dev/null
+++ b/APEX_1.4/module/forcefield/include/ForceFieldAssetPreviewImpl.h
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#ifndef __FORCEFIELD_ASSET_PREVIEW_IMPL_H__
+#define __FORCEFIELD_ASSET_PREVIEW_IMPL_H__
+
+#include "ApexPreview.h"
+
+#include "ApexSDKIntl.h"
+#include "ForceFieldPreview.h"
+#include "RenderDebugInterface.h"
+#include "ForceFieldAssetImpl.h"
+
+#include "ApexRWLockable.h"
+#include "ReadCheck.h"
+#include "WriteCheck.h"
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+/*
+	APEX asset preview explosion asset.
+	Preview.
+*/
+class ForceFieldAssetPreviewImpl : public ForceFieldPreview, public ApexResource, public ApexPreview, public ApexRWLockable
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	ForceFieldAssetPreviewImpl(const ForceFieldPreviewDesc& PreviewDesc, ApexSDK* myApexSDK, ForceFieldAssetImpl* myForceFieldAsset, AssetPreviewScene* previewScene);
+	void					drawForceFieldPreview(void);
+	void					drawForceFieldPreviewUnscaled(void);
+	void					drawForceFieldPreviewScaled(void);
+	void					drawForceFieldPreviewIcon(void);
+	void					drawForceFieldBoundaries(void);
+	void					drawForceFieldWithCylinder();
+	void					destroy();
+
+	void					setPose(const PxMat44& pose);	// Sets the preview instance's pose.  This may include scaling.
+	const PxMat44	getPose() const;
+
+	// from RenderDataProvider
+	void					lockRenderResources(void);
+	void					unlockRenderResources(void);
+	void					updateRenderResources(bool rewriteBuffers = false, void* userRenderData = 0);
+
+	// from Renderable.h
+	void					dispatchRenderResources(UserRenderer& renderer);
+	PxBounds3		getBounds(void) const;
+
+	// from ApexResource.h
+	void					release(void);
+
+	void					setDetailLevel(uint32_t detail);
+
+	typedef struct
+	{
+		float x, y;
+	} point2;
+
+private:
+
+	~ForceFieldAssetPreviewImpl();
+	PxMat44					mPose;						// the pose for the preview rendering
+	ApexSDK*						mApexSDK;					// pointer to the APEX SDK
+	ForceFieldAssetImpl*				mAsset;						// our parent ForceField Asset
+	RenderDebugInterface*				mApexRenderDebug;			// Pointer to the RenderLines class to draw the
+	// preview stuff
+	uint32_t					mDrawGroupIconScaled;		// the ApexDebugRenderer draw group for the Icon
+	uint32_t					mDrawGroupCylinder;
+	uint32_t					mPreviewDetail;				// the detail options of the preview drawing
+	float					mIconScale;					// the scale for the icon
+	AssetPreviewScene*		mPreviewScene;
+
+	bool							mDrawWithCylinder;
+
+	void							drawIcon(void);
+	void							drawMultilinePoint2(const point2* pts, uint32_t numPoints, uint32_t color);
+	void							setIconScale(float scale);
+
+	void							setPose(PxMat44 pose);
+
+	void							toggleDrawPreview();
+	void							setDrawGroupsPoseScaled();
+};
+
+}
+} // end namespace nvidia
+
+#endif // __FORCEFIELD_ASSET_PREVIEW_IMPL_H__
diff --git a/APEX_1.4/module/forcefield/include/ForceFieldFSCommon.h b/APEX_1.4/module/forcefield/include/ForceFieldFSCommon.h
new file mode 100644
index 00000000..f2811f6d
--- /dev/null
+++ b/APEX_1.4/module/forcefield/include/ForceFieldFSCommon.h
@@ -0,0 +1,554 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#ifndef __FORCEFIELD_FS_COMMON_SRC_H__
+#define __FORCEFIELD_FS_COMMON_SRC_H__
+
+#include "../../fieldsampler/include/FieldSamplerCommon.h"
+#include "SimplexNoise.h"
+#include "TableLookup.h"
+#include "PxMat33.h"
+
+namespace nvidia
+{
+namespace apex
+{
+
+template <> struct InplaceTypeTraits<TableLookup>
+{
+	template <int _inplace_offset_, typename R, typename RA>
+	APEX_CUDA_CALLABLE PX_INLINE static void reflectType(R& r, RA ra, TableLookup& t)
+	{
+		InplaceTypeHelper::reflectType<APEX_OFFSETOF(TableLookup, xVals)      + _inplace_offset_>(r, ra, t.xVals,      InplaceTypeMemberDefaultTraits());
+		InplaceTypeHelper::reflectType<APEX_OFFSETOF(TableLookup, yVals)      + _inplace_offset_>(r, ra, t.yVals,      InplaceTypeMemberDefaultTraits());
+		InplaceTypeHelper::reflectType<APEX_OFFSETOF(TableLookup, x1)         + _inplace_offset_>(r, ra, t.x1,         InplaceTypeMemberDefaultTraits());
+		InplaceTypeHelper::reflectType<APEX_OFFSETOF(TableLookup, x2)         + _inplace_offset_>(r, ra, t.x2,         InplaceTypeMemberDefaultTraits());
+		InplaceTypeHelper::reflectType<APEX_OFFSETOF(TableLookup, multiplier) + _inplace_offset_>(r, ra, t.multiplier, InplaceTypeMemberDefaultTraits());
+	}
+};
+
+}
+namespace forcefield
+{
+
+struct ForceFieldShapeType
+{
+	enum Enum
+	{
+		SPHERE = 0,
+		CAPSULE,
+		CYLINDER,
+		CONE,
+		BOX,
+		NONE,
+	};
+};
+
+struct ForceFieldFalloffType
+{
+	enum Enum
+	{
+		LINEAR = 0,
+		STEEP,
+		SCURVE,
+		CUSTOM,
+		NONE,
+	};
+};
+
+struct ForceFieldCoordinateSystemType
+{
+	enum Enum
+	{
+		CARTESIAN = 0,
+		SPHERICAL,
+		CYLINDRICAL,
+		TOROIDAL,
+	};
+};
+
+struct ForceFieldKernelType
+{
+	enum Enum
+	{
+		RADIAL = 0,
+		GENERIC
+	};
+};
+
+//struct ForceFieldShapeDesc
+#define INPLACE_TYPE_STRUCT_NAME ForceFieldShapeDesc
+#define INPLACE_TYPE_STRUCT_FIELDS \
+	INPLACE_TYPE_FIELD(InplaceEnum<ForceFieldShapeType::Enum>,	type) \
+	INPLACE_TYPE_FIELD(PxMat44,							forceFieldToShape) \
+	INPLACE_TYPE_FIELD(PxVec3,							dimensions)
+#include INPLACE_TYPE_BUILD()
+
+
+//struct NoiseParams
+#define INPLACE_TYPE_STRUCT_NAME NoiseParams
+#define INPLACE_TYPE_STRUCT_FIELDS \
+	INPLACE_TYPE_FIELD(float,	strength) \
+	INPLACE_TYPE_FIELD(float,	spaceScale) \
+	INPLACE_TYPE_FIELD(float,	timeScale) \
+	INPLACE_TYPE_FIELD(uint32_t,	octaves)
+#include INPLACE_TYPE_BUILD()
+
+//struct ForceFieldCoordinateSystem
+#define INPLACE_TYPE_STRUCT_NAME ForceFieldCoordinateSystem
+#define INPLACE_TYPE_STRUCT_FIELDS \
+	INPLACE_TYPE_FIELD(InplaceEnum<ForceFieldCoordinateSystemType::Enum>,	type) \
+	INPLACE_TYPE_FIELD(float,										torusRadius)
+#include INPLACE_TYPE_BUILD()
+
+//struct ForceFieldFSKernelParams
+#define INPLACE_TYPE_STRUCT_NAME ForceFieldFSKernelParams
+#define INPLACE_TYPE_STRUCT_FIELDS \
+	INPLACE_TYPE_FIELD(PxMat44,		pose) \
+	INPLACE_TYPE_FIELD(float,		strength) \
+	INPLACE_TYPE_FIELD(ForceFieldShapeDesc,	includeShape)
+#include INPLACE_TYPE_BUILD()
+
+//struct GenericForceFieldFSKernelParams
+#define INPLACE_TYPE_STRUCT_NAME GenericForceFieldFSKernelParams
+#define INPLACE_TYPE_STRUCT_BASE ForceFieldFSKernelParams
+#define INPLACE_TYPE_STRUCT_FIELDS \
+	INPLACE_TYPE_FIELD(ForceFieldCoordinateSystem,		cs) \
+	INPLACE_TYPE_FIELD(PxVec3,					constant) \
+	INPLACE_TYPE_FIELD(PxMat33,					positionMultiplier) \
+	INPLACE_TYPE_FIELD(PxVec3,					positionTarget) \
+	INPLACE_TYPE_FIELD(PxMat33,					velocityMultiplier) \
+	INPLACE_TYPE_FIELD(PxVec3,					velocityTarget) \
+	INPLACE_TYPE_FIELD(PxVec3,					noise) \
+	INPLACE_TYPE_FIELD(PxVec3,					falloffLinear) \
+	INPLACE_TYPE_FIELD(PxVec3,					falloffQuadratic)
+#include INPLACE_TYPE_BUILD()
+
+//struct RadialForceFieldFSKernelParams
+#define INPLACE_TYPE_STRUCT_NAME RadialForceFieldFSKernelParams
+#define INPLACE_TYPE_STRUCT_BASE ForceFieldFSKernelParams
+#define INPLACE_TYPE_STRUCT_FIELDS \
+	INPLACE_TYPE_FIELD(float,		radius) \
+	INPLACE_TYPE_FIELD(TableLookup,			falloffTable) \
+	INPLACE_TYPE_FIELD(NoiseParams,			noiseParams)
+#include INPLACE_TYPE_BUILD()
+
+APEX_CUDA_CALLABLE PX_INLINE bool isPosInShape(const ForceFieldShapeDesc& shapeParams, const PxVec3& pos)
+{
+	// Sphere: x = radius
+	// Capsule: x = radius, y = height
+	// Cylinder: x = radius, y = height
+	// Cone: x = top radius, y = height, z = bottom radius
+	// Box: x,y,z = half-dimensions
+
+	// transform position from force field coordinates to local shape coordinates
+	PxVec3 shapePos = shapeParams.forceFieldToShape.transform(pos);
+
+	switch (shapeParams.type)
+	{
+	case ForceFieldShapeType::SPHERE:
+		{
+			return (shapePos.magnitude() <= shapeParams.dimensions.x);
+		}
+	case ForceFieldShapeType::CAPSULE:
+		{
+			float halfHeight = shapeParams.dimensions.y / 2.0f;
+
+			// check if y-position is within height of cylinder
+			if (shapePos.y >= -halfHeight && shapePos.y <= halfHeight)
+			{
+				// check if x and z positions is inside radius height of cylinder
+				if (PxSqrt(shapePos.x * shapePos.x + shapePos.z * shapePos.z) <= shapeParams.dimensions.x)
+				{
+					return true;
+				}
+			}
+
+			// check if position falls inside top sphere in capsule
+			PxVec3 spherePos = shapePos - PxVec3(0, halfHeight, 0);
+			if (spherePos.magnitude() <= shapeParams.dimensions.x)
+			{
+				return true;
+			}
+
+			// check if position falls inside bottom sphere in capsule
+			spherePos = shapePos + PxVec3(0, halfHeight, 0);
+			if (spherePos.magnitude() <= shapeParams.dimensions.x)
+			{
+				return true;
+			}
+
+			return false;
+		}
+	case ForceFieldShapeType::CYLINDER:
+		{
+			float halfHeight = shapeParams.dimensions.y / 2.0f;
+
+			// check if y-position is within height of cylinder
+			if (shapePos.y >= -halfHeight && shapePos.y <= halfHeight)
+			{
+				// check if x and z positions is inside radius height of cylinder
+				if (PxSqrt(shapePos.x * shapePos.x + shapePos.z * shapePos.z) <= shapeParams.dimensions.x)
+				{
+					return true;
+				}
+			}
+			return false;
+		}
+	case ForceFieldShapeType::CONE:
+		{
+			float halfHeight = shapeParams.dimensions.y / 2.0f;
+
+			// check if y-position is within height of cone
+			if (shapePos.y >= -halfHeight && shapePos.y <= halfHeight)
+			{
+				// cone can be normal or inverted
+				float smallerBase;
+				float heightFromSmallerBase;
+				float radiusDiff;
+				if (shapeParams.dimensions.x > shapeParams.dimensions.z)
+				{
+					smallerBase = shapeParams.dimensions.z;
+					heightFromSmallerBase = shapePos.y + halfHeight;
+					radiusDiff = shapeParams.dimensions.x - shapeParams.dimensions.z;
+				}
+				else
+				{
+					smallerBase = shapeParams.dimensions.x;
+					heightFromSmallerBase = halfHeight - shapePos.y;
+					radiusDiff = shapeParams.dimensions.z - shapeParams.dimensions.x;
+				}
+
+				// compute radius at y-position along height of cone
+				float radiusAlongCone = smallerBase + (heightFromSmallerBase / shapeParams.dimensions.y) * radiusDiff;
+
+				// check if x and z positions is inside radius at a specific height of cone
+				if (PxSqrt(shapePos.x * shapePos.x + shapePos.z * shapePos.z) <= radiusAlongCone)
+				{
+					return true;
+				}
+			}
+			return false;
+		}
+	case ForceFieldShapeType::BOX:
+		{
+			return (PxAbs(shapePos.x) <= shapeParams.dimensions.x && 
+					PxAbs(shapePos.y) <= shapeParams.dimensions.y &&
+					PxAbs(shapePos.z) <= shapeParams.dimensions.z);
+		}
+	default:
+		{
+			return false;
+		}
+	}
+}
+
+APEX_CUDA_CALLABLE PX_INLINE PxVec3 getNoise(const NoiseParams& params, const PxVec3& pos, const uint32_t& totalElapsedMS)
+{
+	PxVec3 point = params.spaceScale * pos;
+	float time = (params.timeScale * 1e-3f) * totalElapsedMS;
+
+	PxVec4 dFx;
+	dFx.setZero();
+	PxVec4 dFy;
+	dFy.setZero();
+	PxVec4 dFz;
+	dFz.setZero();
+	int seed = 0;
+	float amp = 1.0f;
+	for (uint32_t i = 0; i < params.octaves; ++i)
+	{
+		dFx += amp * SimplexNoise::eval4D(point.x, point.y, point.z, time, ++seed);
+		dFy += amp * SimplexNoise::eval4D(point.x, point.y, point.z, time, ++seed);
+		dFz += amp * SimplexNoise::eval4D(point.x, point.y, point.z, time, ++seed);
+
+		point *= 2;
+		time *= 2;
+		amp *= 0.5f;
+	}
+
+	//get rotor
+	PxVec3 rot;
+	rot.x = dFz.y - dFy.z;
+	rot.y = dFx.z - dFz.x;
+	rot.z = dFy.x - dFx.y;
+
+	return params.strength * rot;
+}
+
+APEX_CUDA_CALLABLE PX_INLINE PxVec3 executeForceFieldMainFS(const RadialForceFieldFSKernelParams& params, const PxVec3& pos, const uint32_t& totalElapsedMS)
+{
+	// bring pos to force field coordinate system
+	PxVec3 localPos = params.pose.inverseRT().transform(pos);
+
+	if (isPosInShape(params.includeShape, localPos))
+	{
+		PxVec3 result = localPos.getNormalized();
+		result = result * params.strength;
+
+		// apply falloff
+		result = result * params.falloffTable.lookupTableValue(localPos.magnitude() / params.radius);
+
+		// apply noise
+		result = result + getNoise(params.noiseParams, localPos, totalElapsedMS);
+
+		// rotate result back to world coordinate system
+		return params.pose.rotate(result);
+	}
+
+	return PxVec3(0, 0, 0);
+}
+
+// function to compute the Scalar falloff for the cylinderical, toroidal, cartesian and generic
+// force fields so that the falloff does not make the direction of the force vector change.
+APEX_CUDA_CALLABLE PX_INLINE float falloff(PxVec3 val, PxVec3 linearff, PxVec3 quadraticff)
+{
+	float magnitude = val.magnitude();
+	float v = (linearff.x * magnitude + quadraticff.x * magnitude * magnitude) +
+			  (linearff.y * magnitude + quadraticff.y * magnitude * magnitude) +
+			  (linearff.z * magnitude + quadraticff.z * magnitude * magnitude);
+	v += 1.0f;
+	//PX_ASSERT(v>0);
+	return 1.0f/v;
+}
+
+APEX_CUDA_CALLABLE PX_INLINE PxVec3 genericEvalLinearKernel(const PxVec3& localPos, const PxVec3& localVel, const GenericForceFieldFSKernelParams& params)
+{
+	const bool useFalloff = params.falloffLinear.magnitudeSquared() +
+							params.falloffQuadratic.magnitudeSquared() != 0;
+
+	const bool useVelMul = !(params.velocityMultiplier.column0.isZero() && 
+							 params.velocityMultiplier.column1.isZero() && 
+							 params.velocityMultiplier.column2.isZero()); 
+
+	const bool usePosMul = !(params.positionMultiplier.column0.isZero() &&
+							 params.positionMultiplier.column1.isZero() &&
+							 params.positionMultiplier.column2.isZero());
+						
+
+	PxVec3 ffPosErr;
+	PxMat33 tangentFrame;
+	PxVec3 ffForce = params.constant;
+	switch(params.cs.type)
+	{
+	case ForceFieldCoordinateSystemType::CARTESIAN:
+		{
+			ffPosErr = params.positionTarget - (localPos);
+		} 
+		break;
+	case ForceFieldCoordinateSystemType::SPHERICAL:
+		{
+			const float& r = localPos.x;
+			ffPosErr = PxVec3(params.positionTarget.x - r, 0, 0);
+		} 
+		break;
+	case ForceFieldCoordinateSystemType::CYLINDRICAL:
+		{
+			const float& r = localPos.x;
+			ffPosErr = PxVec3(params.positionTarget.x - r, params.positionTarget.y - localPos.y, 0);
+		} 
+		break;
+	case ForceFieldCoordinateSystemType::TOROIDAL:
+		{
+			float r = 0.0f;
+			PxVec3 t0;
+			PxVec3 circleDir(localPos.x, 0.0f, localPos.z);
+			float l2 = circleDir.magnitudeSquared();
+			if(l2<1e-4f*1e-4f)
+			{
+				circleDir = PxVec3(0);
+			}
+			else
+			{
+				circleDir /= PxSqrt(l2);	// Normalize circleDir
+				PxVec3 circlePoint = circleDir * params.cs.torusRadius;
+				t0 = localPos - circlePoint;
+				l2 = t0.magnitudeSquared();
+				if(l2<1e-4f*1e-4f)
+				{
+					circleDir = PxVec3(0);
+					t0 = PxVec3(0);
+				}
+				else
+				{
+					r = PxSqrt(l2);
+					t0 /= r;	// Normalize t0
+				}
+			}
+			PxVec3 t1(-circleDir.z, 0.0f, circleDir.x);		// PxVec3 t1 = circleDir.cross(PxVec3(0,1,0));
+			tangentFrame.column0 = t0;
+			tangentFrame.column1 = t1;
+			tangentFrame.column2 = t0.cross(t1);
+			ffPosErr = PxVec3(params.positionTarget.x - r, 0, 0);
+		}
+		break;
+	}
+			
+	PxVec3 ffVel = (params.cs.type == ForceFieldCoordinateSystemType::TOROIDAL) ? tangentFrame.getInverse() * localVel : localVel; 
+
+	if(useVelMul)
+	{
+		ffForce += params.velocityMultiplier * (params.velocityTarget - ffVel);
+	}
+
+	if(usePosMul)
+	{
+		ffForce += params.positionMultiplier * ffPosErr;
+	}
+
+	//TODO, enable noise, with existing noise functionality
+	//applyNoise(ffForce, params.noise, NpPhysicsSDK::instance->getNpPhysicsTls()->mNpLinearKernelRnd);
+	//ffForce *= PxVec3(1) + params.noise * [-1, 1]^3
+
+	if(useFalloff)
+	{
+		ffForce *= falloff(ffPosErr, params.falloffLinear, params.falloffQuadratic);
+	}
+
+	PxVec3 force = (params.cs.type == ForceFieldCoordinateSystemType::TOROIDAL) ? tangentFrame * ffForce : ffForce;
+	return force;
+}
+
+APEX_CUDA_CALLABLE PX_INLINE void genericEvalCartesian(PxVec3& force, const PxVec3& localPos, const PxVec3& localVel, const GenericForceFieldFSKernelParams& params)
+{
+	// compute tangent frame
+	// -- none here
+
+	// evaluate kernel
+	force = genericEvalLinearKernel(localPos, localVel, params);
+}
+
+APEX_CUDA_CALLABLE PX_INLINE void genericEvalSpherical(PxVec3& force, const PxVec3& localPos, const PxVec3& localVel, const GenericForceFieldFSKernelParams& params)
+{
+	// compute tangent frame
+	PxMat33 tangentFrame(PxZero);
+	float l2 = localPos.magnitudeSquared();
+	PxVec3 tangentPos;
+	if(l2>1e-4f*1e-4f)
+	{
+		float r = PxSqrt(l2);
+		PxVec3 t0 = localPos/r;
+		tangentFrame.column0 = t0;
+		tangentPos = PxVec3(r, 0, 0);
+	}
+	else
+	{
+		tangentPos = PxVec3(0);
+	}
+
+	// compute tangent frame velocity
+	const PxVec3 tangentVel = tangentFrame.getInverse() * localVel;
+
+	// evaluate kernel
+	force = genericEvalLinearKernel(tangentPos, tangentVel, params);
+
+	// transform back to local space
+	force = tangentFrame * force;
+}
+
+APEX_CUDA_CALLABLE PX_INLINE void genericEvalCylindrical(PxVec3& force, const PxVec3& localPos, const PxVec3& localVel, const GenericForceFieldFSKernelParams& params)
+{
+	// compute tangent frame
+	PxMat33 tangentFrame;
+	PxVec3 t0(localPos.x, 0, localPos.z); // Project to Cylindrical
+	const float len = t0.magnitude();
+	PxVec3 tangentPos;
+	if(len > 1e-4f)
+	{
+		t0 /= len;
+		tangentPos = PxVec3(len, localPos.y, 0);
+	}
+	else
+	{
+		t0 = PxVec3(0);
+		tangentPos = PxVec3(0, localPos.y, 0);
+	}
+	tangentFrame.column0 = t0;
+	tangentFrame.column1 = PxVec3(0.0f, 1.0f, 0.0f);	// t1
+	tangentFrame.column2 = PxVec3(-t0.z, 0.0f, t0.x);	// t0.cross(t1)
+
+	// compute tangent frame velocity
+	const PxVec3 tangentVel = tangentFrame.getInverse() * localVel;
+
+	// evaluate kernel
+	force = genericEvalLinearKernel(tangentPos, tangentVel, params);
+
+	// transform back to local space
+	force = tangentFrame * force;
+}
+
+APEX_CUDA_CALLABLE PX_INLINE void genericEvalToroidal(PxVec3& force, const PxVec3& localPos, const PxVec3& localVel, const GenericForceFieldFSKernelParams& params)
+{
+	// evaluate kernel
+	force = genericEvalLinearKernel(localPos, localVel, params);
+}
+
+/**
+This is more or less a 1:1 copy of PhysX 2.8.4/UE3 generic force fields. 
+Since 2.8.4 supported more flexible callbacks, we should probably optimize 
+this quite a bit. 
+*/
+APEX_CUDA_CALLABLE PX_INLINE PxVec3 executeForceFieldMainFS(const GenericForceFieldFSKernelParams& params, const PxVec3& pos, const PxVec3& vel, const uint32_t&)
+{
+	// bring pos to force field coordinate system
+	PxVec3 localPos = params.pose.inverseRT().transform(pos);
+
+	if (isPosInShape(params.includeShape, localPos))
+	{
+		PxVec3 localVel = params.pose.inverseRT().rotate(vel); 
+
+		PxVec3 result(0);
+		switch (params.cs.type)
+		{
+		case ForceFieldCoordinateSystemType::CARTESIAN:
+			genericEvalCartesian(result, localPos, localVel, params);
+			break;
+		case ForceFieldCoordinateSystemType::SPHERICAL:
+			genericEvalSpherical(result, localPos, localVel, params);
+			break;
+		case ForceFieldCoordinateSystemType::CYLINDRICAL:
+			genericEvalCylindrical(result, localPos, localVel, params);
+			break;
+		case ForceFieldCoordinateSystemType::TOROIDAL:
+			genericEvalToroidal(result, localPos, localVel, params);
+			break;
+		default:
+			break;
+		}
+
+		// apply strength
+		result = result * params.strength;
+
+		// rotate result back to world coordinate system
+		return params.pose.rotate(result);
+	}
+
+	return PxVec3(0, 0, 0);
+}
+
+APEX_CUDA_CALLABLE PX_INLINE PxVec3 executeForceFieldFS(const RadialForceFieldFSKernelParams& params, const PxVec3& pos, const uint32_t& totalElapsedMS)
+{
+	PxVec3 resultField(0, 0, 0);
+	resultField += executeForceFieldMainFS(params, pos, totalElapsedMS);
+	return resultField;
+}
+
+APEX_CUDA_CALLABLE PX_INLINE PxVec3 executeForceFieldFS(const GenericForceFieldFSKernelParams& params, const PxVec3& pos, const PxVec3& vel, const uint32_t& totalElapsedMS)
+{
+	PxVec3 resultField(0, 0, 0);
+	resultField += executeForceFieldMainFS(params, pos, vel, totalElapsedMS);
+	return resultField;
+}
+
+}
+} // end namespace nvidia
+
+#endif
diff --git a/APEX_1.4/module/forcefield/include/ForceFieldScene.h b/APEX_1.4/module/forcefield/include/ForceFieldScene.h
new file mode 100644
index 00000000..1c751fed
--- /dev/null
+++ b/APEX_1.4/module/forcefield/include/ForceFieldScene.h
@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#ifndef __FORCEFIELD_SCENE_H__
+#define __FORCEFIELD_SCENE_H__
+
+#include "Apex.h"
+
+#include "ModuleForceFieldImpl.h"
+
+#include "ApexResource.h"
+#include "ApexContext.h"
+#include "ApexSDKHelpers.h"
+
+#include "RenderDebugInterface.h"
+#include "ApexSDKIntl.h"
+#include "ModuleIntl.h"
+
+#include "DebugRenderParams.h"
+#include "ForceFieldDebugRenderParams.h"
+
+#include "PxTask.h"
+
+#include "FieldSamplerSceneIntl.h"
+
+#if APEX_CUDA_SUPPORT
+#include "ApexCudaWrapper.h"
+#include "ApexCuda.h"
+#include "CudaModuleScene.h"
+
+#include "../cuda/include/common.h"
+
+#define SCENE_CUDA_OBJ(scene, name) static_cast<ForceFieldSceneGPU*>(scene)->APEX_CUDA_OBJ_NAME(name)
+#define CUDA_OBJ(name) SCENE_CUDA_OBJ(mForceFieldScene, name)
+#endif
+
+namespace nvidia
+{
+namespace apex
+{
+class SceneIntl;
+class DebugRenderParams;
+class FieldSamplerManagerIntl;
+}
+namespace forcefield
+{
+class ModuleForceFieldImpl;
+class ForceFieldActorImpl;
+class ForceFieldActorDesc;
+
+
+class ForceFieldScene : public FieldSamplerSceneIntl, public ApexContext, public ApexResourceInterface, public ApexResource
+{
+public:
+	ForceFieldScene(ModuleForceFieldImpl& module, SceneIntl& scene, RenderDebugInterface* renderDebug, ResourceList& list);
+	~ForceFieldScene();
+
+	/* ModuleSceneIntl */
+	void						updateActors(float deltaTime);
+	void						submitTasks(float elapsedTime, float substepSize, uint32_t numSubSteps);
+	void						setTaskDependencies();
+
+	virtual void				visualize(void);
+	virtual void				visualizeForceFieldForceFields(void);
+	virtual void				visualizeForceFieldForces(void);
+	virtual void				fetchResults(void);
+
+	virtual void				setModulePhysXScene(PxScene* s);
+	virtual PxScene*			getModulePhysXScene() const
+	{
+		return mPhysXScene;
+	}
+
+	virtual Module*			getModule()
+	{
+		return mModule;
+	}
+
+	bool							lockRenderResources()
+	{
+		renderLockAllActors();	// Lock options not implemented yet
+		return true;
+	}
+
+	bool							unlockRenderResources()
+	{
+		renderUnLockAllActors();	// Lock options not implemented yet
+		return true;
+	}
+
+	/* ApexResourceInterface */
+	uint32_t						getListIndex(void) const
+	{
+		return m_listIndex;
+	}
+	void						setListIndex(ResourceList& list, uint32_t index)
+	{
+		m_listIndex = index;
+		m_list = &list;
+	}
+	virtual void				release(void)
+	{
+		mModule->releaseModuleSceneIntl(*this);
+	}
+
+	virtual ForceFieldActorImpl*	createForceFieldActor(const ForceFieldActorDesc& desc, ForceFieldAssetImpl& asset, ResourceList& list) = 0;
+
+	SceneIntl& getApexScene() const
+	{
+		return *mApexScene;
+	}
+
+	FieldSamplerManagerIntl*	getInternalFieldSamplerManager();
+
+	/* FieldSamplerSceneIntl */
+	virtual void getFieldSamplerSceneDesc(FieldSamplerSceneDescIntl& ) const
+	{
+	}
+
+protected:
+	void						destroy();
+
+	ModuleForceFieldImpl* 			mModule;
+	SceneIntl*                mApexScene;
+	PxScene*                    mPhysXScene;
+
+	RenderDebugInterface* 			mRenderDebug;
+
+	DebugRenderParams*				mDebugRenderParams;
+	ForceFieldDebugRenderParams*	mForceFieldDebugRenderParams;
+
+	FieldSamplerManagerIntl*		mFieldSamplerManager;
+
+private:
+	class TaskUpdate : public PxTask
+	{
+	public:
+		TaskUpdate(ForceFieldScene& owner) : mOwner(owner) {}
+		const char* getName() const
+		{
+			return "ForceFieldScene::Update";
+		}
+		void run();
+	protected:
+		ForceFieldScene& mOwner;
+	private:
+		TaskUpdate& operator=(const  TaskUpdate&);
+	};
+
+	TaskUpdate					mUpdateTask;
+
+	friend class ModuleForceFieldImpl;
+	friend class ForceFieldActorImpl;
+	friend class TaskUpdate;
+};
+
+class ForceFieldSceneCPU : public ForceFieldScene
+{
+public:
+	ForceFieldSceneCPU(ModuleForceFieldImpl& module, SceneIntl& scene, RenderDebugInterface* renderDebug, ResourceList& list);
+	~ForceFieldSceneCPU();
+
+	ForceFieldActorImpl*	createForceFieldActor(const ForceFieldActorDesc& desc, ForceFieldAssetImpl& asset, ResourceList& list);
+
+	/* FieldSamplerSceneIntl */
+
+protected:
+};
+
+#if APEX_CUDA_SUPPORT
+class ForceFieldSceneGPU : public ForceFieldScene, public CudaModuleScene
+{
+public:
+	ForceFieldSceneGPU(ModuleForceFieldImpl& module, SceneIntl& scene, RenderDebugInterface* renderDebug, ResourceList& list);
+	~ForceFieldSceneGPU();
+
+	ForceFieldActorImpl*	createForceFieldActor(const ForceFieldActorDesc& desc, ForceFieldAssetImpl& asset, ResourceList& list);
+
+//CUDA module objects
+#include "../cuda/include/ForceField.h"
+
+	/* FieldSamplerSceneIntl */
+	virtual ApexCudaConstStorage*	getFieldSamplerCudaConstStorage();
+	virtual bool					launchFieldSamplerCudaKernel(const nvidia::fieldsampler::FieldSamplerKernelLaunchDataIntl&);
+
+protected:
+	/* keep a convenience pointer to the cuda context manager */
+	PxCudaContextManager* mCtxMgr;
+};
+#endif
+
+}
+} // end namespace nvidia
+
+#endif
diff --git a/APEX_1.4/module/forcefield/include/ModuleEventDefs.h b/APEX_1.4/module/forcefield/include/ModuleEventDefs.h
new file mode 100644
index 00000000..fad8349b
--- /dev/null
+++ b/APEX_1.4/module/forcefield/include/ModuleEventDefs.h
@@ -0,0 +1,29 @@
+/*
+ * 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.
+ */
+
+
+// This file is used to define a list of AgPerfMon events.
+//
+// This file is included exclusively by AgPerfMonEventSrcAPI.h
+// and by AgPerfMonEventSrcAPI.cpp, for the purpose of building
+// an enumeration (enum xx) and an array of strings ()
+// that contain the list of events.
+//
+// This file should only contain event definitions, using the
+// DEFINE_EVENT macro.  E.g.:
+//
+//     DEFINE_EVENT(sample_name_1)
+//     DEFINE_EVENT(sample_name_2)
+//     DEFINE_EVENT(sample_name_3)
+
+DEFINE_EVENT(ForceFieldModuleInit)
+DEFINE_EVENT(ForceFieldSceneFetchResults)
+DEFINE_EVENT(ForceFieldDrawIcon)
+DEFINE_EVENT(ForceFieldDrawForceFieldPreview)
diff --git a/APEX_1.4/module/forcefield/include/ModuleForceFieldImpl.h b/APEX_1.4/module/forcefield/include/ModuleForceFieldImpl.h
new file mode 100644
index 00000000..f7b99b86
--- /dev/null
+++ b/APEX_1.4/module/forcefield/include/ModuleForceFieldImpl.h
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#ifndef __MODULE_FORCEFIELD_IMPL_H__
+#define __MODULE_FORCEFIELD_IMPL_H__
+
+#include "Apex.h"
+#include "ModuleForceField.h"
+#include "ApexSDKIntl.h"
+#include "ModuleIntl.h"
+#include "ModuleBase.h"
+
+#include "ApexSDKHelpers.h"
+#include "ApexRWLockable.h"
+#include "ReadCheck.h"
+#include "WriteCheck.h"
+#include "ModuleForceFieldRegistration.h"
+
+namespace nvidia
+{
+namespace apex
+{
+class SceneIntl;
+class ModuleFieldSamplerIntl;
+}
+namespace forcefield
+{
+
+class ForceFieldAssetImpl;
+class ForceFieldAssetAuthoringImpl;
+class ForceFieldScene;
+
+class ModuleForceFieldDesc : public ApexDesc
+{
+public:
+
+	/**
+	\brief Constructor sets to default.
+	*/
+	PX_INLINE ModuleForceFieldDesc()
+	{
+		setToDefault();
+	}
+	/**
+	\brief (re)sets the structure to the default.
+	*/
+	PX_INLINE void	setToDefault()
+	{
+		ApexDesc::setToDefault();
+		moduleValue = 0;
+	}
+
+	/**
+	Returns true if an object can be created using this descriptor.
+	*/
+	PX_INLINE bool	isValid() const
+	{
+		return ApexDesc::isValid();
+	}
+
+	/**
+	ModuleBase configurable parameter.
+	*/
+	uint32_t moduleValue;
+};
+
+
+class ModuleForceFieldImpl : public ModuleForceField, public ModuleIntl, public ModuleBase, public ApexRWLockable
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	ModuleForceFieldImpl(ApexSDKIntl* sdk);
+	~ModuleForceFieldImpl();
+
+	void						init(const ModuleForceFieldDesc& explosionDesc);
+
+	// base class methods
+	void						init(NvParameterized::Interface&) {}
+	NvParameterized::Interface* getDefaultModuleDesc();
+	void release()
+	{
+		ModuleBase::release();
+	}
+	void destroy();
+	const char*					getName() const
+	{
+		return ModuleBase::getName();
+	}
+	
+	ModuleSceneIntl* 				createInternalModuleScene(SceneIntl&, RenderDebugInterface*);
+	void						releaseModuleSceneIntl(ModuleSceneIntl&);
+	uint32_t				forceLoadAssets();
+	AuthObjTypeID				getModuleID() const;
+	RenderableIterator* 	createRenderableIterator(const Scene&);
+
+	AuthObjTypeID             getForceFieldAssetTypeID() const;
+
+	uint32_t				getModuleValue() const
+	{
+		READ_ZONE();
+		return mModuleValue;
+	}
+
+	ModuleFieldSamplerIntl*		getInternalModuleFieldSampler();
+
+protected:
+	ForceFieldScene* 			getForceFieldScene(const Scene& apexScene);
+
+	ResourceList				mAuthorableObjects;
+
+	ResourceList				mForceFieldScenes;
+
+	uint32_t				mModuleValue;
+
+	ModuleFieldSamplerIntl*		mFieldSamplerModule;
+
+	friend class ForceFieldAssetImpl;
+
+private:
+
+	ForceFieldModuleParams*				mModuleParams;
+};
+
+}
+} // end namespace nvidia
+
+#endif // __MODULE_FORCEFIELD_IMPL_H__
diff --git a/APEX_1.4/module/forcefield/include/ModulePerfScope.h b/APEX_1.4/module/forcefield/include/ModulePerfScope.h
new file mode 100644
index 00000000..56e6adeb
--- /dev/null
+++ b/APEX_1.4/module/forcefield/include/ModulePerfScope.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#ifndef __MODULE_PERF_SCOPE_H___
+#define __MODULE_PERF_SCOPE_H___
+
+#define MODULE_NAMESPACE forcefield
+#include "ModuleProfileCommon.h"
+
+#endif
\ No newline at end of file
diff --git a/APEX_1.4/module/forcefield/include/autogen/ForceFieldActorParams.h b/APEX_1.4/module/forcefield/include/autogen/ForceFieldActorParams.h
new file mode 100644
index 00000000..12b6111a
--- /dev/null
+++ b/APEX_1.4/module/forcefield/include/autogen/ForceFieldActorParams.h
@@ -0,0 +1,233 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ForceFieldActorParams_h
+#define HEADER_ForceFieldActorParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ForceFieldActorParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxTransform initialPose;
+	float scale;
+	NvParameterized::DummyStringStruct fieldBoundaryFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+
+};
+
+static const uint32_t checksum[] = { 0xcc531b53, 0xf5e67337, 0x01ed51a1, 0x940acec1, };
+
+} // namespace ForceFieldActorParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ForceFieldActorParams : public NvParameterized::NvParameters, public ForceFieldActorParamsNS::ParametersStruct
+{
+public:
+	ForceFieldActorParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ForceFieldActorParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ForceFieldActorParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)1;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ForceFieldActorParamsNS::checksum);
+		return ForceFieldActorParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ForceFieldActorParamsNS::ParametersStruct& parameters(void) const
+	{
+		ForceFieldActorParams* tmpThis = const_cast<ForceFieldActorParams*>(this);
+		return *(static_cast<ForceFieldActorParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ForceFieldActorParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ForceFieldActorParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ForceFieldActorParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ForceFieldActorParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ForceFieldActorParams), ForceFieldActorParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ForceFieldActorParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldActorParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ForceFieldActorParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ForceFieldActorParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ForceFieldActorParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ForceFieldActorParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldActorParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ForceFieldActorParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ForceFieldActorParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ForceFieldActorParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ForceFieldActorParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ForceFieldActorParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ForceFieldActorParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace forcefield
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/forcefield/include/autogen/ForceFieldAssetParams.h b/APEX_1.4/module/forcefield/include/autogen/ForceFieldAssetParams.h
new file mode 100644
index 00000000..658efd24
--- /dev/null
+++ b/APEX_1.4/module/forcefield/include/autogen/ForceFieldAssetParams.h
@@ -0,0 +1,243 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ForceFieldAssetParams_h
+#define HEADER_ForceFieldAssetParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ForceFieldAssetParamsNS
+{
+
+struct IncludeShapeParameters_Type;
+
+struct IncludeShapeParameters_Type
+{
+	const char* shape;
+	physx::PxMat44 forceFieldToShape;
+	physx::PxVec3 dimensions;
+};
+
+struct ParametersStruct
+{
+
+	NvParameterized::Interface* forceFieldKernelType;
+	float defScale;
+	float strength;
+	float lifetime;
+	IncludeShapeParameters_Type includeShapeParameters;
+	NvParameterized::DummyStringStruct fieldBoundaryFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+
+};
+
+static const uint32_t checksum[] = { 0xe5a9b1aa, 0x3070d787, 0x1e3b66da, 0x094e7338, };
+
+} // namespace ForceFieldAssetParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ForceFieldAssetParams : public NvParameterized::NvParameters, public ForceFieldAssetParamsNS::ParametersStruct
+{
+public:
+	ForceFieldAssetParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ForceFieldAssetParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ForceFieldAssetParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)1;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ForceFieldAssetParamsNS::checksum);
+		return ForceFieldAssetParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ForceFieldAssetParamsNS::ParametersStruct& parameters(void) const
+	{
+		ForceFieldAssetParams* tmpThis = const_cast<ForceFieldAssetParams*>(this);
+		return *(static_cast<ForceFieldAssetParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ForceFieldAssetParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ForceFieldAssetParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ForceFieldAssetParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ForceFieldAssetParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ForceFieldAssetParams), ForceFieldAssetParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ForceFieldAssetParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldAssetParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ForceFieldAssetParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ForceFieldAssetParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ForceFieldAssetParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ForceFieldAssetParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldAssetParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ForceFieldAssetParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ForceFieldAssetParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ForceFieldAssetParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ForceFieldAssetParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ForceFieldAssetParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ForceFieldAssetParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace forcefield
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/forcefield/include/autogen/ForceFieldAssetPreviewParams.h b/APEX_1.4/module/forcefield/include/autogen/ForceFieldAssetPreviewParams.h
new file mode 100644
index 00000000..17143b43
--- /dev/null
+++ b/APEX_1.4/module/forcefield/include/autogen/ForceFieldAssetPreviewParams.h
@@ -0,0 +1,234 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ForceFieldAssetPreviewParams_h
+#define HEADER_ForceFieldAssetPreviewParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ForceFieldAssetPreviewParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxMat44 pose;
+	float iconScale;
+	bool drawIcon;
+	bool drawBoundaries;
+	bool drawBold;
+
+};
+
+static const uint32_t checksum[] = { 0x7e31b030, 0x359317ac, 0x60fcab26, 0xe033ecb7, };
+
+} // namespace ForceFieldAssetPreviewParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ForceFieldAssetPreviewParams : public NvParameterized::NvParameters, public ForceFieldAssetPreviewParamsNS::ParametersStruct
+{
+public:
+	ForceFieldAssetPreviewParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ForceFieldAssetPreviewParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ForceFieldAssetPreviewParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ForceFieldAssetPreviewParamsNS::checksum);
+		return ForceFieldAssetPreviewParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ForceFieldAssetPreviewParamsNS::ParametersStruct& parameters(void) const
+	{
+		ForceFieldAssetPreviewParams* tmpThis = const_cast<ForceFieldAssetPreviewParams*>(this);
+		return *(static_cast<ForceFieldAssetPreviewParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ForceFieldAssetPreviewParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ForceFieldAssetPreviewParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ForceFieldAssetPreviewParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ForceFieldAssetPreviewParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ForceFieldAssetPreviewParams), ForceFieldAssetPreviewParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ForceFieldAssetPreviewParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldAssetPreviewParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ForceFieldAssetPreviewParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ForceFieldAssetPreviewParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ForceFieldAssetPreviewParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ForceFieldAssetPreviewParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldAssetPreviewParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ForceFieldAssetPreviewParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ForceFieldAssetPreviewParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ForceFieldAssetPreviewParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ForceFieldAssetPreviewParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ForceFieldAssetPreviewParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ForceFieldAssetPreviewParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace forcefield
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/forcefield/include/autogen/ForceFieldDebugRenderParams.h b/APEX_1.4/module/forcefield/include/autogen/ForceFieldDebugRenderParams.h
new file mode 100644
index 00000000..7372cb44
--- /dev/null
+++ b/APEX_1.4/module/forcefield/include/autogen/ForceFieldDebugRenderParams.h
@@ -0,0 +1,230 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ForceFieldDebugRenderParams_h
+#define HEADER_ForceFieldDebugRenderParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ForceFieldDebugRenderParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	bool VISUALIZE_FORCEFIELD_ACTOR;
+
+};
+
+static const uint32_t checksum[] = { 0xe1b8703d, 0x1fdfe32b, 0xdfd01cd1, 0x8ba595b4, };
+
+} // namespace ForceFieldDebugRenderParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ForceFieldDebugRenderParams : public NvParameterized::NvParameters, public ForceFieldDebugRenderParamsNS::ParametersStruct
+{
+public:
+	ForceFieldDebugRenderParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ForceFieldDebugRenderParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ForceFieldDebugRenderParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ForceFieldDebugRenderParamsNS::checksum);
+		return ForceFieldDebugRenderParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ForceFieldDebugRenderParamsNS::ParametersStruct& parameters(void) const
+	{
+		ForceFieldDebugRenderParams* tmpThis = const_cast<ForceFieldDebugRenderParams*>(this);
+		return *(static_cast<ForceFieldDebugRenderParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ForceFieldDebugRenderParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ForceFieldDebugRenderParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ForceFieldDebugRenderParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ForceFieldDebugRenderParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ForceFieldDebugRenderParams), ForceFieldDebugRenderParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ForceFieldDebugRenderParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldDebugRenderParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ForceFieldDebugRenderParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ForceFieldDebugRenderParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ForceFieldDebugRenderParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ForceFieldDebugRenderParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldDebugRenderParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ForceFieldDebugRenderParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ForceFieldDebugRenderParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ForceFieldDebugRenderParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ForceFieldDebugRenderParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ForceFieldDebugRenderParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ForceFieldDebugRenderParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace forcefield
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/forcefield/include/autogen/ForceFieldFalloffParams.h b/APEX_1.4/module/forcefield/include/autogen/ForceFieldFalloffParams.h
new file mode 100644
index 00000000..be2c3f24
--- /dev/null
+++ b/APEX_1.4/module/forcefield/include/autogen/ForceFieldFalloffParams.h
@@ -0,0 +1,233 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ForceFieldFalloffParams_h
+#define HEADER_ForceFieldFalloffParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ForceFieldFalloffParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	const char* type;
+	float multiplier;
+	float start;
+	float end;
+
+};
+
+static const uint32_t checksum[] = { 0x6c2d91a1, 0xd148985c, 0xcfbee3bb, 0xefb2f190, };
+
+} // namespace ForceFieldFalloffParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ForceFieldFalloffParams : public NvParameterized::NvParameters, public ForceFieldFalloffParamsNS::ParametersStruct
+{
+public:
+	ForceFieldFalloffParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ForceFieldFalloffParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ForceFieldFalloffParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ForceFieldFalloffParamsNS::checksum);
+		return ForceFieldFalloffParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ForceFieldFalloffParamsNS::ParametersStruct& parameters(void) const
+	{
+		ForceFieldFalloffParams* tmpThis = const_cast<ForceFieldFalloffParams*>(this);
+		return *(static_cast<ForceFieldFalloffParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ForceFieldFalloffParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ForceFieldFalloffParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ForceFieldFalloffParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ForceFieldFalloffParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ForceFieldFalloffParams), ForceFieldFalloffParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ForceFieldFalloffParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldFalloffParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ForceFieldFalloffParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ForceFieldFalloffParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ForceFieldFalloffParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ForceFieldFalloffParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldFalloffParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ForceFieldFalloffParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ForceFieldFalloffParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ForceFieldFalloffParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ForceFieldFalloffParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ForceFieldFalloffParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ForceFieldFalloffParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace forcefield
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/forcefield/include/autogen/ForceFieldModuleParams.h b/APEX_1.4/module/forcefield/include/autogen/ForceFieldModuleParams.h
new file mode 100644
index 00000000..eb7f8c9e
--- /dev/null
+++ b/APEX_1.4/module/forcefield/include/autogen/ForceFieldModuleParams.h
@@ -0,0 +1,230 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ForceFieldModuleParams_h
+#define HEADER_ForceFieldModuleParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ForceFieldModuleParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	uint32_t unused;
+
+};
+
+static const uint32_t checksum[] = { 0x3c8f0dec, 0x042ae5c4, 0xd5557fc3, 0x0c637e85, };
+
+} // namespace ForceFieldModuleParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ForceFieldModuleParams : public NvParameterized::NvParameters, public ForceFieldModuleParamsNS::ParametersStruct
+{
+public:
+	ForceFieldModuleParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ForceFieldModuleParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ForceFieldModuleParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ForceFieldModuleParamsNS::checksum);
+		return ForceFieldModuleParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ForceFieldModuleParamsNS::ParametersStruct& parameters(void) const
+	{
+		ForceFieldModuleParams* tmpThis = const_cast<ForceFieldModuleParams*>(this);
+		return *(static_cast<ForceFieldModuleParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ForceFieldModuleParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ForceFieldModuleParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ForceFieldModuleParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ForceFieldModuleParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ForceFieldModuleParams), ForceFieldModuleParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ForceFieldModuleParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldModuleParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ForceFieldModuleParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ForceFieldModuleParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ForceFieldModuleParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ForceFieldModuleParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldModuleParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ForceFieldModuleParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ForceFieldModuleParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ForceFieldModuleParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ForceFieldModuleParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ForceFieldModuleParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ForceFieldModuleParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace forcefield
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/forcefield/include/autogen/ForceFieldNoiseParams.h b/APEX_1.4/module/forcefield/include/autogen/ForceFieldNoiseParams.h
new file mode 100644
index 00000000..1d843a84
--- /dev/null
+++ b/APEX_1.4/module/forcefield/include/autogen/ForceFieldNoiseParams.h
@@ -0,0 +1,233 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_ForceFieldNoiseParams_h
+#define HEADER_ForceFieldNoiseParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ForceFieldNoiseParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float strength;
+	float spaceScale;
+	float timeScale;
+	uint32_t octaves;
+
+};
+
+static const uint32_t checksum[] = { 0x0bfb1c14, 0xbcb9bf7a, 0xb02be14c, 0x582b638f, };
+
+} // namespace ForceFieldNoiseParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ForceFieldNoiseParams : public NvParameterized::NvParameters, public ForceFieldNoiseParamsNS::ParametersStruct
+{
+public:
+	ForceFieldNoiseParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ForceFieldNoiseParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ForceFieldNoiseParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(ForceFieldNoiseParamsNS::checksum);
+		return ForceFieldNoiseParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ForceFieldNoiseParamsNS::ParametersStruct& parameters(void) const
+	{
+		ForceFieldNoiseParams* tmpThis = const_cast<ForceFieldNoiseParams*>(this);
+		return *(static_cast<ForceFieldNoiseParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ForceFieldNoiseParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ForceFieldNoiseParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class ForceFieldNoiseParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ForceFieldNoiseParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ForceFieldNoiseParams), ForceFieldNoiseParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ForceFieldNoiseParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldNoiseParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ForceFieldNoiseParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ForceFieldNoiseParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ForceFieldNoiseParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ForceFieldNoiseParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldNoiseParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ForceFieldNoiseParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (ForceFieldNoiseParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ForceFieldNoiseParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ForceFieldNoiseParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ForceFieldNoiseParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ForceFieldNoiseParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace forcefield
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/forcefield/include/autogen/GenericForceFieldKernelParams.h b/APEX_1.4/module/forcefield/include/autogen/GenericForceFieldKernelParams.h
new file mode 100644
index 00000000..a542471a
--- /dev/null
+++ b/APEX_1.4/module/forcefield/include/autogen/GenericForceFieldKernelParams.h
@@ -0,0 +1,244 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_GenericForceFieldKernelParams_h
+#define HEADER_GenericForceFieldKernelParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace GenericForceFieldKernelParamsNS
+{
+
+struct CoordinateSystemParameters_Type;
+
+struct CoordinateSystemParameters_Type
+{
+	const char* type;
+	float torusRadius;
+};
+
+struct ParametersStruct
+{
+
+	CoordinateSystemParameters_Type coordinateSystemParameters;
+	physx::PxVec3 constant;
+	physx::PxMat33 positionMultiplier;
+	physx::PxVec3 positionTarget;
+	physx::PxMat33 velocityMultiplier;
+	physx::PxVec3 velocityTarget;
+	physx::PxVec3 noise;
+	physx::PxVec3 falloffLinear;
+	physx::PxVec3 falloffQuadratic;
+
+};
+
+static const uint32_t checksum[] = { 0xff6bc966, 0x041661be, 0x3110753d, 0x08c8332e, };
+
+} // namespace GenericForceFieldKernelParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class GenericForceFieldKernelParams : public NvParameterized::NvParameters, public GenericForceFieldKernelParamsNS::ParametersStruct
+{
+public:
+	GenericForceFieldKernelParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~GenericForceFieldKernelParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("GenericForceFieldKernelParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)1;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(GenericForceFieldKernelParamsNS::checksum);
+		return GenericForceFieldKernelParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const GenericForceFieldKernelParamsNS::ParametersStruct& parameters(void) const
+	{
+		GenericForceFieldKernelParams* tmpThis = const_cast<GenericForceFieldKernelParams*>(this);
+		return *(static_cast<GenericForceFieldKernelParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	GenericForceFieldKernelParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<GenericForceFieldKernelParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class GenericForceFieldKernelParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		GenericForceFieldKernelParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(GenericForceFieldKernelParams), GenericForceFieldKernelParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, GenericForceFieldKernelParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GenericForceFieldKernelParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(GenericForceFieldKernelParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, GenericForceFieldKernelParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, GenericForceFieldKernelParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, GenericForceFieldKernelParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GenericForceFieldKernelParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of GenericForceFieldKernelParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (GenericForceFieldKernelParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (GenericForceFieldKernelParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (GenericForceFieldKernelParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (GenericForceFieldKernelParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (GenericForceFieldKernelParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace forcefield
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/forcefield/include/autogen/ModuleForceFieldRegistration.h b/APEX_1.4/module/forcefield/include/autogen/ModuleForceFieldRegistration.h
new file mode 100644
index 00000000..6954a256
--- /dev/null
+++ b/APEX_1.4/module/forcefield/include/autogen/ModuleForceFieldRegistration.h
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+#ifndef MODULE_MODULEFORCEFIELDREGISTRATIONH_H
+#define MODULE_MODULEFORCEFIELDREGISTRATIONH_H
+
+#include "PsAllocator.h"
+#include "NvRegistrationsForTraitsBase.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "PxAssert.h"
+#include <stdint.h>
+
+// INCLUDE GENERATED FACTORIES
+#include "ForceFieldActorParams.h"
+#include "ForceFieldAssetParams.h"
+#include "ForceFieldAssetPreviewParams.h"
+#include "ForceFieldDebugRenderParams.h"
+#include "ForceFieldFalloffParams.h"
+#include "ForceFieldNoiseParams.h"
+#include "GenericForceFieldKernelParams.h"
+#include "RadialForceFieldKernelParams.h"
+#include "ForceFieldModuleParams.h"
+
+
+// INCLUDE GENERATED CONVERSION
+
+
+namespace nvidia {
+namespace forcefield {
+
+
+class ModuleForceFieldRegistration : public NvParameterized::RegistrationsForTraitsBase
+{
+public:
+	static void invokeRegistration(NvParameterized::Traits* parameterizedTraits)
+	{
+		if (parameterizedTraits)
+		{
+			ModuleForceFieldRegistration().registerAll(*parameterizedTraits);
+		}
+	}
+
+	static void invokeUnregistration(NvParameterized::Traits* parameterizedTraits)
+	{
+		if (parameterizedTraits)
+		{
+			ModuleForceFieldRegistration().unregisterAll(*parameterizedTraits);
+		}
+	}
+
+	void registerAvailableFactories(NvParameterized::Traits& parameterizedTraits)
+	{
+		::NvParameterized::Factory* factoriesToRegister[] = {
+// REGISTER GENERATED FACTORIES
+			new nvidia::forcefield::ForceFieldActorParamsFactory(),
+			new nvidia::forcefield::ForceFieldAssetParamsFactory(),
+			new nvidia::forcefield::ForceFieldAssetPreviewParamsFactory(),
+			new nvidia::forcefield::ForceFieldDebugRenderParamsFactory(),
+			new nvidia::forcefield::ForceFieldFalloffParamsFactory(),
+			new nvidia::forcefield::ForceFieldNoiseParamsFactory(),
+			new nvidia::forcefield::GenericForceFieldKernelParamsFactory(),
+			new nvidia::forcefield::RadialForceFieldKernelParamsFactory(),
+			new nvidia::forcefield::ForceFieldModuleParamsFactory(),
+
+		};
+
+		for (size_t i = 0; i < sizeof(factoriesToRegister)/sizeof(factoriesToRegister[0]); ++i)
+		{
+			parameterizedTraits.registerFactory(*factoriesToRegister[i]);
+		}
+	}
+
+	virtual void registerAvailableConverters(NvParameterized::Traits& parameterizedTraits)
+	{
+// REGISTER GENERATED CONVERSION
+PX_UNUSED(parameterizedTraits);
+
+	}
+
+	void unregisterAvailableFactories(NvParameterized::Traits& parameterizedTraits)
+	{
+		struct FactoryDesc
+		{
+			const char* name;
+			uint32_t version;
+		};
+
+		::NvParameterized::Factory* factoriesToUnregister[] = {
+// UNREGISTER GENERATED FACTORIES
+			new nvidia::forcefield::ForceFieldActorParamsFactory(),
+			new nvidia::forcefield::ForceFieldAssetParamsFactory(),
+			new nvidia::forcefield::ForceFieldAssetPreviewParamsFactory(),
+			new nvidia::forcefield::ForceFieldDebugRenderParamsFactory(),
+			new nvidia::forcefield::ForceFieldFalloffParamsFactory(),
+			new nvidia::forcefield::ForceFieldNoiseParamsFactory(),
+			new nvidia::forcefield::GenericForceFieldKernelParamsFactory(),
+			new nvidia::forcefield::RadialForceFieldKernelParamsFactory(),
+			new nvidia::forcefield::ForceFieldModuleParamsFactory(),
+
+		};
+
+		for (size_t i = 0; i < sizeof(factoriesToUnregister)/sizeof(factoriesToUnregister[0]); ++i)
+		{
+			::NvParameterized::Factory* removedFactory = parameterizedTraits.removeFactory(factoriesToUnregister[i]->getClassName(), factoriesToUnregister[i]->getVersion());
+			if (!removedFactory) 
+			{
+				PX_ASSERT_WITH_MESSAGE(0, "Factory can not be removed!");
+			}
+			else
+			{
+				removedFactory->freeParameterDefinitionTable(&parameterizedTraits);
+				delete removedFactory;
+				delete factoriesToUnregister[i];
+			}
+		}
+	}
+
+	virtual void unregisterAvailableConverters(NvParameterized::Traits& parameterizedTraits)
+	{
+// UNREGISTER GENERATED CONVERSION
+PX_UNUSED(parameterizedTraits);
+
+	}
+
+};
+
+
+}
+} //nvidia::forcefield
+
+#endif
diff --git a/APEX_1.4/module/forcefield/include/autogen/RadialForceFieldKernelParams.h b/APEX_1.4/module/forcefield/include/autogen/RadialForceFieldKernelParams.h
new file mode 100644
index 00000000..3eff9c46
--- /dev/null
+++ b/APEX_1.4/module/forcefield/include/autogen/RadialForceFieldKernelParams.h
@@ -0,0 +1,232 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_RadialForceFieldKernelParams_h
+#define HEADER_RadialForceFieldKernelParams_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace RadialForceFieldKernelParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::Interface* falloffParameters;
+	NvParameterized::Interface* noiseParameters;
+	float radius;
+
+};
+
+static const uint32_t checksum[] = { 0xa0410ec7, 0x17712202, 0x427b07d4, 0xa8ce4d70, };
+
+} // namespace RadialForceFieldKernelParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class RadialForceFieldKernelParams : public NvParameterized::NvParameters, public RadialForceFieldKernelParamsNS::ParametersStruct
+{
+public:
+	RadialForceFieldKernelParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~RadialForceFieldKernelParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("RadialForceFieldKernelParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(RadialForceFieldKernelParamsNS::checksum);
+		return RadialForceFieldKernelParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const RadialForceFieldKernelParamsNS::ParametersStruct& parameters(void) const
+	{
+		RadialForceFieldKernelParams* tmpThis = const_cast<RadialForceFieldKernelParams*>(this);
+		return *(static_cast<RadialForceFieldKernelParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	RadialForceFieldKernelParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<RadialForceFieldKernelParamsNS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class RadialForceFieldKernelParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		RadialForceFieldKernelParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(RadialForceFieldKernelParams), RadialForceFieldKernelParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, RadialForceFieldKernelParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RadialForceFieldKernelParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(RadialForceFieldKernelParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, RadialForceFieldKernelParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, RadialForceFieldKernelParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, RadialForceFieldKernelParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RadialForceFieldKernelParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of RadialForceFieldKernelParams here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (RadialForceFieldKernelParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (RadialForceFieldKernelParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (RadialForceFieldKernelParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (RadialForceFieldKernelParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (RadialForceFieldKernelParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace forcefield
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
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