Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

45 files changed, 7872 insertions, 0 deletions

diff --git a/APEX_1.4/module/basicfs/include/AttractorFSActorImpl.h b/APEX_1.4/module/basicfs/include/AttractorFSActorImpl.h
new file mode 100644
index 00000000..33e857cc
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/AttractorFSActorImpl.h
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#ifndef __ATTRACTOR_FS_ACTOR_IMPL_H__
+#define __ATTRACTOR_FS_ACTOR_IMPL_H__
+
+#include "BasicFSActor.h"
+#include "AttractorFSActor.h"
+#include "ApexRWLockable.h"
+#include "AttractorFSCommon.h"
+
+
+namespace nvidia
+{
+namespace apex
+{
+class RenderMeshActor;
+}
+namespace basicfs
+{
+
+class AttractorFSAsset;
+class BasicFSScene;
+class AttractorFSActorParams;
+
+class AttractorFSActorImpl : public BasicFSActor, public AttractorFSActor, public ApexRWLockable
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	/* AttractorFSActor methods */
+	AttractorFSActorImpl(const AttractorFSActorParams&, AttractorFSAsset&, ResourceList&, BasicFSScene&);
+	~AttractorFSActorImpl();
+
+	BasicFSAsset* 		getAttractorFSAsset() const;
+
+	PxVec3			getCurrentPosition() const
+	{
+		return mPose.p;
+	}
+	void					setCurrentPosition(const PxVec3& pos)
+	{
+		mPose.p = pos;
+		mFieldSamplerChanged = true;
+	}
+	void					setFieldRadius(float radius)
+	{
+		mRadius = radius;
+		mFieldSamplerChanged = true;
+	}
+	void					setConstFieldStrength(float strength);
+
+	void					setVariableFieldStrength(float strength);
+
+	void					setEnabled(bool isEnabled)
+	{
+		mFieldSamplerEnabled = isEnabled;
+	}
+
+	/* Renderable, RenderDataProvider */
+	void					updateRenderResources(bool rewriteBuffers, void* userRenderData);
+	void					dispatchRenderResources(UserRenderer& renderer);
+
+	PxBounds3				getBounds() const
+	{
+		return ApexRenderable::getBounds();
+	}
+
+	void					lockRenderResources()
+	{
+		ApexRenderable::renderDataLock();
+	}
+	void					unlockRenderResources()
+	{
+		ApexRenderable::renderDataUnLock();
+	}
+
+	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)
+	{
+		ApexActor::setEnableDebugVisualization(state);
+	}
+
+	Renderable*		getRenderable()
+	{
+		return this;
+	}
+	Actor*			getActor()
+	{
+		return this;
+	}
+
+	/* Resource, ApexResource */
+	void					release();
+
+	/* Actor, ApexActor */
+	void					destroy();
+	Asset*			getOwner() const;
+
+	virtual void			simulate(float dt);
+
+	virtual void			visualize();
+
+	/* FieldSamplerIntl */
+	virtual bool			updateFieldSampler(FieldShapeDescIntl& shapeDesc, bool& isEnabled);
+
+	///Sets the uniform overall object scale
+	virtual void				setCurrentScale(float scale) 
+	{
+		mScale = scale;
+		mFieldSamplerChanged = true;
+	}
+
+	//Retrieves the uniform overall object scale
+	virtual float				getCurrentScale(void) const
+	{
+		return mScale;
+	}
+
+protected:
+	AttractorFSAsset*		mAsset;
+
+	float			mRadius;
+
+	float			mConstFieldStrength;
+	float			mVariableFieldStrength;
+
+	AttractorFSParams		mExecuteParams; 
+
+	nvidia::Array<PxVec3> mDebugPoints;
+
+	friend class BasicFSScene;
+};
+
+class AttractorFSActorCPU : public AttractorFSActorImpl
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	AttractorFSActorCPU(const AttractorFSActorParams&, AttractorFSAsset&, ResourceList&, BasicFSScene&);
+	~AttractorFSActorCPU();
+
+	/* FieldSamplerIntl */
+	virtual void executeFieldSampler(const ExecuteData& data);
+
+private:
+};
+
+#if APEX_CUDA_SUPPORT
+
+class AttractorFSActorGPU : public AttractorFSActorCPU
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	AttractorFSActorGPU(const AttractorFSActorParams&, AttractorFSAsset&, ResourceList&, BasicFSScene&);
+	~AttractorFSActorGPU();
+
+	/* FieldSamplerIntl */
+	virtual bool updateFieldSampler(FieldShapeDescIntl& shapeDesc, bool& isEnabled);
+
+	virtual void getFieldSamplerCudaExecuteInfo(CudaExecuteInfo& info) const
+	{
+		info.executeType = 2;
+		info.executeParamsHandle = mParamsHandle;
+	}
+
+private:
+	ApexCudaConstMemGroup				mConstMemGroup;
+	InplaceHandle<AttractorFSParams>	mParamsHandle;
+
+};
+
+#endif
+
+}
+} // end namespace nvidia
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/AttractorFSAsset.h b/APEX_1.4/module/basicfs/include/AttractorFSAsset.h
new file mode 100644
index 00000000..00a1ad8c
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/AttractorFSAsset.h
@@ -0,0 +1,186 @@
+/*
+ * 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 __ATTRACTOR_FS_ASSET_H__
+#define __ATTRACTOR_FS_ASSET_H__
+
+#include "BasicFSAssetImpl.h"
+#include "AttractorFSAssetPreview.h"
+#include "AttractorFSAssetParams.h"
+#include "AttractorFSActorParams.h"
+#include "ApexAuthorableObject.h"
+
+namespace nvidia
+{
+namespace apex
+{
+class RenderMeshAsset;
+}
+namespace basicfs
+{
+
+class AttractorFSActorImpl;
+
+class AttractorFSAsset : public BasicFSAssetImpl
+{
+	friend class BasicFSAssetDummyAuthoring;
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	AttractorFSAsset(ModuleBasicFSImpl*, ResourceList&, const char*);
+	AttractorFSAsset(ModuleBasicFSImpl*, ResourceList&, NvParameterized::Interface*, const char*);
+	~AttractorFSAsset();
+
+	/* Asset */
+	AuthObjTypeID			getObjTypeID() const
+	{
+		return mAssetTypeID;
+	}
+	const char* 			getObjTypeName() const
+	{
+		return getClassName();
+	}
+
+	/* ApexInterface */
+	virtual void			release()
+	{
+		mModule->mSdk->releaseAsset(*this);
+	}
+
+	// TODO: implement forceLoadAssets
+	uint32_t					forceLoadAssets()
+	{
+		return 0;
+	}
+
+	NvParameterized::Interface* getAssetNvParameterized() const
+	{
+		return mParams;
+	}
+
+	NvParameterized::Interface* releaseAndReturnNvParameterizedInterface(void)
+	{
+		NvParameterized::Interface* ret = mParams;
+		mParams = NULL;
+		release();
+		return ret;
+	}
+
+	/* BasicFSAsset specific methods */
+	void                    destroy();
+
+	/**
+	* \brief Apply any changes that may been made to the NvParameterized::Interface on this asset.
+	*/
+	virtual void applyEditingChanges(void)
+	{
+		APEX_INVALID_OPERATION("Not yet implemented!");
+	}
+
+	NvParameterized::Interface* getDefaultActorDesc();
+	virtual Actor* createApexActor(const NvParameterized::Interface& /*parms*/, Scene& /*apexScene*/);
+
+	AttractorFSPreview*	createAttractorFSPreview(const AttractorFSPreviewDesc& desc, AssetPreviewScene* previewScene);
+	AttractorFSPreview*	createAttractorFSPreviewImpl(const AttractorFSPreviewDesc& desc, AttractorFSAsset* TurboAsset, AssetPreviewScene* previewScene);
+	void					releaseAttractorFSPreview(AttractorFSPreview& preview);
+
+	NvParameterized::Interface* getDefaultAssetPreviewDesc();
+
+	virtual AssetPreview* createApexAssetPreview(const NvParameterized::Interface& /*params*/, AssetPreviewScene* previewScene);
+
+	virtual bool isValidForActorCreation(const ::NvParameterized::Interface& /*parms*/, Scene& /*apexScene*/) const
+	{
+		return true; // todo implement this method
+	}
+
+	/* Typical asset members */
+	static const char* 			getClassName() // return to protected
+	{
+		return ATTRACTOR_FS_AUTHORING_TYPE_NAME;
+	}
+
+protected:
+
+	static AuthObjTypeID		mAssetTypeID;
+
+	AttractorFSAssetParams*		mParams;
+	AttractorFSActorParams*		mDefaultActorParams;
+	AttractorFSPreviewParams*	mDefaultPreviewParams;
+
+	friend class ModuleBasicFSImpl;
+	friend class AttractorFSActorImpl;
+	template <class T_Module, class T_Asset, class T_AssetAuthoring> friend class nvidia::apex::ApexAuthorableObject;
+
+};
+
+class AttractorFSAssetAuthoring : public AttractorFSAsset, public ApexAssetAuthoring, public BasicFSAssetAuthoring
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	/* BasicFSAssetAuthoring */
+	AttractorFSAssetAuthoring(ModuleBasicFSImpl* m, ResourceList& l) :
+		AttractorFSAsset(m, l, "AttractorFSAssetAuthoring") {}
+
+	AttractorFSAssetAuthoring(ModuleBasicFSImpl* m, ResourceList& l, const char* name) :
+		AttractorFSAsset(m, l, name) {}
+
+	AttractorFSAssetAuthoring(ModuleBasicFSImpl* m, ResourceList& l, NvParameterized::Interface* params, const char* name) :
+		AttractorFSAsset(m, l, params, name) {}
+
+	~AttractorFSAssetAuthoring() {}
+	void                    destroy()
+	{
+		delete this;
+	}
+
+	/* AssetAuthoring */
+	const char* 			getName(void) const
+	{
+		return AttractorFSAsset::getName();
+	}
+	const char* 			getObjTypeName() const
+	{
+		return AttractorFSAsset::getClassName();
+	}
+	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 AttractorFSAsset::getAssetNvParameterized();
+	}
+
+	NvParameterized::Interface* releaseAndReturnNvParameterizedInterface(void)
+	{
+		return AttractorFSAsset::releaseAndReturnNvParameterizedInterface();
+	}
+
+};
+
+}
+} // end namespace nvidia::apex
+
+#endif
\ No newline at end of file
diff --git a/APEX_1.4/module/basicfs/include/AttractorFSAssetPreview.h b/APEX_1.4/module/basicfs/include/AttractorFSAssetPreview.h
new file mode 100644
index 00000000..bd1f08ca
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/AttractorFSAssetPreview.h
@@ -0,0 +1,115 @@
+/*
+ * 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 __ATTRACTOR_FSPREVIEW_H__
+#define __ATTRACTOR_FSPREVIEW_H__
+
+#include "ApexPreview.h"
+#include "ApexRWLockable.h"
+#include "ApexSDKIntl.h"
+#include "AttractorFSPreview.h"
+#include "RenderDebugInterface.h"
+
+namespace nvidia
+{
+namespace basicfs
+{
+
+class AttractorFSAsset;
+
+/**
+\brief Descriptor for a AttractorFS Preview Asset
+*/
+class AttractorFSPreviewDesc
+{
+public:
+	AttractorFSPreviewDesc() :
+		mPose(PxMat44()),
+		mPreviewDetail()
+	{
+		mPose = PxMat44(PxIdentity);
+	};
+
+	/**
+	\brief The pose that translates from preview coordinates to world coordinates.
+	*/
+	PxMat44			mPose;
+	/**
+	\brief Radius of the attractor.
+	*/
+	float			mRadius;
+	/**
+	\brief The detail options of the preview drawing
+	*/
+	uint32_t			mPreviewDetail;
+};
+
+/*
+	APEX asset preview asset.
+	Preview.
+*/
+class AttractorFSAssetPreview : public AttractorFSPreview, public ApexResource, public ApexPreview, public ApexRWLockable
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	AttractorFSAssetPreview(const AttractorFSPreviewDesc& PreviewDesc, ApexSDK* myApexSDK, AttractorFSAsset* myAsset, AssetPreviewScene* previewScene);
+	void					drawAttractorFSPreview(void);
+	void					destroy();
+
+	float					getAttractorRadius(NvParameterized::Interface* assetParams);
+
+	void					setPose(const PxMat44& pose);	// Sets the preview instance's pose.  This may include scaling.
+	const PxMat44	getPose() const;
+
+	void					setRadius(float radius);
+	const float				getRadius() const;
+
+	void					setDetailLevel(uint32_t detail);
+
+	// 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);
+
+private:
+	~AttractorFSAssetPreview();
+
+	PxMat44					mPose;						// the pose for the preview rendering
+	ApexSDK*						mApexSDK;					// pointer to the APEX SDK
+	AttractorFSAsset*				mAsset;						// our parent AttractorFS Asset
+	RenderDebugInterface*				mApexRenderDebug;			// Pointer to the RenderLines class to draw the
+	AssetPreviewScene*		mPreviewScene;
+																// preview stuff
+	float					mRadius;					// the radius of the attractor
+	uint32_t					mPreviewDetail;				// the detail options of the preview drawing
+
+	int32_t					mDrawGroupBox;
+
+	void drawPreviewShape();
+	void drawPreviewAssetInfo();
+	void toggleDrawPreview();
+	void setDrawGroupsPose();
+
+	void drawInfoLine(uint32_t lineNum, const char* str);
+};
+
+}
+} // namespace nvidia
+
+#endif // __TURBULENCE_ASSET_PREVIEW_H__
diff --git a/APEX_1.4/module/basicfs/include/AttractorFSCommon.h b/APEX_1.4/module/basicfs/include/AttractorFSCommon.h
new file mode 100644
index 00000000..8f673f5f
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/AttractorFSCommon.h
@@ -0,0 +1,65 @@
+/*
+ * 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 __ATTRACTOR_FS_COMMON_SRC_H__
+#define __ATTRACTOR_FS_COMMON_SRC_H__
+
+#include "../../fieldsampler/include/FieldSamplerCommon.h"
+
+namespace nvidia
+{
+namespace basicfs
+{
+
+//struct AttractorFSParams
+#define INPLACE_TYPE_STRUCT_NAME AttractorFSParams
+#define INPLACE_TYPE_STRUCT_FIELDS \
+	INPLACE_TYPE_FIELD(PxVec3,	origin) \
+	INPLACE_TYPE_FIELD(float,	radius) \
+	INPLACE_TYPE_FIELD(float,	constFieldStrength) \
+	INPLACE_TYPE_FIELD(float,	variableFieldStrength)
+#include INPLACE_TYPE_BUILD()
+
+
+PX_CUDA_CALLABLE PX_INLINE PxVec3 commonAttractorFSKernel(const AttractorFSParams& params, const PxVec3& pos)
+{
+	PxVec3 dir = params.origin - pos;
+	PX_ASSERT(params.radius);
+	float dist = dir.magnitude() / params.radius;
+
+	float result = params.constFieldStrength;
+	if (dist >= 0.4)
+	{
+		result += params.variableFieldStrength / dist;
+	}
+
+	return result * dir.getNormalized();
+}
+
+PX_CUDA_CALLABLE PX_INLINE PxVec3 executeAttractorFS(const AttractorFSParams& params, const PxVec3& pos/*, uint32_t totalElapsedMS*/)
+{
+	PxVec3 dir = params.origin - pos;
+	PX_ASSERT(params.radius);
+	float dist = dir.magnitude() / params.radius;
+
+	float result = params.constFieldStrength;
+	if (dist >= 0.4)
+	{
+		result += params.variableFieldStrength / dist;
+	}
+
+	return result * dir.getNormalized();
+}
+
+}
+} // namespace nvidia
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/BasicFSActor.h b/APEX_1.4/module/basicfs/include/BasicFSActor.h
new file mode 100644
index 00000000..92898907
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/BasicFSActor.h
@@ -0,0 +1,88 @@
+/*
+ * 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 __BASIC_FS_ACTOR_H__
+#define __BASIC_FS_ACTOR_H__
+
+#include "Apex.h"
+
+#include "ApexActor.h"
+#include "FieldSamplerIntl.h"
+#include "BasicFSAssetImpl.h"
+
+#include "PxTask.h"
+
+#if APEX_CUDA_SUPPORT
+#include "ApexCudaWrapper.h"
+#endif
+
+
+namespace nvidia
+{
+namespace apex
+{
+class RenderMeshActor;
+}
+namespace basicfs
+{
+
+class BasicFSScene;
+
+class BasicFSActor : public ApexActor, public ApexResourceInterface, public ApexResource, public FieldSamplerIntl
+{
+public:
+	BasicFSActor(BasicFSScene&);
+	virtual ~BasicFSActor();
+
+	/* ApexResourceInterface, ApexResource */
+	uint32_t					getListIndex() const
+	{
+		return m_listIndex;
+	}
+	void					setListIndex(class ResourceList& list, uint32_t index)
+	{
+		m_list = &list;
+		m_listIndex = index;
+	}
+
+	virtual void			visualize()
+	{
+	}
+
+	virtual void			simulate(float dt)
+	{
+		PX_UNUSED(dt);
+	}
+
+	void					setPhysXScene(PxScene*);
+	PxScene*				getPhysXScene() const;
+
+	/* FieldSamplerIntl */
+	virtual bool			updateFieldSampler(FieldShapeDescIntl& shapeDesc, bool& isEnabled) = 0;
+
+protected:
+	BasicFSScene*			mScene;
+
+	PxTransform		mPose;
+	float			mScale;
+
+	bool					mFieldSamplerChanged;
+	bool					mFieldSamplerEnabled;
+
+	float			mFieldWeight;
+
+	friend class BasicFSScene;
+};
+
+}
+} // end namespace nvidia
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/BasicFSAssetImpl.h b/APEX_1.4/module/basicfs/include/BasicFSAssetImpl.h
new file mode 100644
index 00000000..59de33b7
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/BasicFSAssetImpl.h
@@ -0,0 +1,151 @@
+/*
+ * 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 BASIC_FS_ASSET_IMPL_H
+#define BASIC_FS_ASSET_IMPL_H
+
+#include "Apex.h"
+
+#include "BasicFSAsset.h"
+#include "ApexSDKHelpers.h"
+#include "ModuleBasicFSImpl.h"
+#include "ApexAssetAuthoring.h"
+#include "ApexString.h"
+#include "ApexAssetTracker.h"
+#include "ApexAuthorableObject.h"
+#include "ApexRWLockable.h"
+#include "FieldBoundaryIntl.h"
+
+namespace nvidia
+{
+namespace apex
+{
+class RenderMeshAsset;
+}
+namespace basicfs
+{
+
+class BasicFSActor;
+
+///p,q -> p cross q = n (n - must be normalized!)
+PX_INLINE void BuildPlaneBasis(const PxVec3& n, PxVec3& p, PxVec3& q)
+{
+	float nzSqr = n.z * n.z;
+	if (nzSqr > 0.5f)
+	{
+		// choose p in y-z plane
+		const float k = PxSqrt(n.y * n.y + nzSqr);
+		// k can not be zero here
+		const float rk = (1 / k);
+		p.x = 0;
+		p.y = -n.z * rk;
+		p.z = n.y * rk;
+		// set q = n cross p
+		q.x = k;
+		q.y = -n.x * p.z;
+		q.z = n.x * p.y;
+	}
+	else
+	{
+		// choose p in x-y plane
+		const float k = PxSqrt(n.x * n.x + n.y * n.y);
+		// k can be zero in case n is zero
+		const float rk = (k > 0) ? (1 / k) : 0;
+		p.x = -n.y * rk;
+		p.y = n.x * rk;
+		p.z = 0;
+		// set q = n cross p
+		q.x = -n.z * p.y;
+		q.y = n.z * p.x;
+		q.z = k;
+	}
+}
+
+class BasicFSAssetImpl : public BasicFSAsset, public ApexResourceInterface, public ApexResource, public ApexRWLockable
+{
+	friend class BasicFSAssetDummyAuthoring;
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	BasicFSAssetImpl(ModuleBasicFSImpl*, const char*);
+	virtual ~BasicFSAssetImpl();
+
+	/* Asset */
+	const char* 			getName() const
+	{
+		return mName.c_str();
+	}
+
+	// TODO: implement forceLoadAssets
+	uint32_t					forceLoadAssets()
+	{
+		return 0;
+	}
+
+	/* ApexResourceInterface, ApexResource */
+	uint32_t					getListIndex() const
+	{
+		return m_listIndex;
+	}
+	void					setListIndex(class ResourceList& list, uint32_t index)
+	{
+		m_list = &list;
+		m_listIndex = index;
+	}
+
+	/**
+	* \brief Apply any changes that may been made to the NvParameterized::Interface on this asset.
+	*/
+	virtual void applyEditingChanges(void)
+	{
+		APEX_INVALID_OPERATION("Not yet implemented!");
+	}
+
+	NvParameterized::Interface* getDefaultActorDesc() = 0;
+	virtual Actor* createApexActor(const NvParameterized::Interface& /*parms*/, Scene& /*apexScene*/) = 0;
+
+	NvParameterized::Interface* getDefaultAssetPreviewDesc()
+	{
+		APEX_INVALID_OPERATION("Not yet implemented!");
+		return NULL;
+	}
+
+	virtual AssetPreview* createApexAssetPreview(const NvParameterized::Interface& /*params*/, AssetPreviewScene* /*previewScene*/)
+	{
+		APEX_INVALID_OPERATION("Not yet implemented!");
+		return NULL;
+	}
+
+	virtual bool isValidForActorCreation(const ::NvParameterized::Interface& /*parms*/, Scene& /*apexScene*/) const
+	{
+		return true; // todo implement this method
+	}
+
+	virtual bool isDirty() const
+	{
+		return false;
+	}
+
+
+protected:
+
+	ModuleBasicFSImpl* 				mModule;
+	ResourceList				mFSActors;
+	ApexSimpleString			mName;
+
+	friend class ModuleBasicFSImpl;
+	friend class BasicFSActor;
+};
+
+}
+} // end namespace nvidia::apex
+
+#endif // BASIC_FS_ASSET_IMPL_H
diff --git a/APEX_1.4/module/basicfs/include/BasicFSScene.h b/APEX_1.4/module/basicfs/include/BasicFSScene.h
new file mode 100644
index 00000000..1cafb133
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/BasicFSScene.h
@@ -0,0 +1,214 @@
+/*
+ * 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 __BASIC_FS_SCENE_H__
+#define __BASIC_FS_SCENE_H__
+
+#include "Apex.h"
+
+#include "ModuleBasicFSImpl.h"
+#include "ApexSDKIntl.h"
+#include "ModuleIntl.h"
+#include "ApexResource.h"
+#include "ApexContext.h"
+#include "ApexSDKHelpers.h"
+
+#include "DebugRenderParams.h"
+#include "BasicFSDebugRenderParams.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<BasicFSSceneGPU*>(scene)->APEX_CUDA_OBJ_NAME(name)
+#define CUDA_OBJ(name) SCENE_CUDA_OBJ(mScene, name)
+#endif
+
+
+namespace nvidia
+{
+namespace apex
+{
+class SceneIntl;
+class FieldSamplerManagerIntl;
+}
+namespace basicfs
+{
+
+class ModuleBasicFSImpl;
+
+class BasicFSAssetImpl;
+class BasicFSActor;
+
+class JetFSAsset;
+class JetFSActorImpl;
+
+class AttractorFSAsset;
+class AttractorFSActorImpl;
+
+class VortexFSAsset;
+class VortexFSActorImpl;
+
+class NoiseFSAsset;
+class NoiseFSActorImpl;
+
+class WindFSAsset;
+class WindFSActorImpl;
+
+
+class BasicFSScene : public FieldSamplerSceneIntl, public ApexContext, public ApexResourceInterface, public ApexResource
+{
+public:
+	BasicFSScene(ModuleBasicFSImpl& module, SceneIntl& scene, RenderDebugInterface* debugRender, ResourceList& list);
+	~BasicFSScene();
+
+	/* ModuleSceneIntl */
+	void						visualize();
+	void						setModulePhysXScene(PxScene* s);
+	PxScene*					getModulePhysXScene() const
+	{
+		return mPhysXScene;
+	}
+
+	void						submitTasks(float elapsedTime, float substepSize, uint32_t numSubSteps);
+	void						fetchResults();
+
+	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() const
+	{
+		return m_listIndex;
+	}
+	void						setListIndex(ResourceList& list, uint32_t index)
+	{
+		m_listIndex = index;
+		m_list = &list;
+	}
+	void						release()
+	{
+		mModule->releaseModuleSceneIntl(*this);
+	}
+
+	virtual JetFSActorImpl*			createJetFSActor(const JetFSActorParams&, JetFSAsset&, ResourceList&) = 0;
+	virtual AttractorFSActorImpl*	createAttractorFSActor(const AttractorFSActorParams&, AttractorFSAsset&, ResourceList&) = 0;
+	virtual VortexFSActorImpl*		createVortexFSActor(const VortexFSActorParams&, VortexFSAsset&, ResourceList&) = 0;
+	virtual NoiseFSActorImpl*		createNoiseFSActor(const NoiseFSActorParams&, NoiseFSAsset&, ResourceList&) = 0;
+	virtual WindFSActorImpl*		createWindFSActor(const WindFSActorParams&, WindFSAsset&, ResourceList&) = 0;
+
+	SceneIntl&				getApexScene() const
+	{
+		return *mApexScene;
+	}
+
+	FieldSamplerManagerIntl* 		getInternalFieldSamplerManager();
+
+	/* FieldSamplerSceneIntl */
+	virtual void				getFieldSamplerSceneDesc(FieldSamplerSceneDescIntl& desc) const
+	{
+		PX_UNUSED(desc);
+	}
+
+protected:
+	void						destroy();
+
+	ModuleBasicFSImpl*				mModule;
+	SceneIntl*				mApexScene;
+	PxScene*					mPhysXScene;
+	RenderDebugInterface*			mDebugRender;
+
+	DebugRenderParams*			mDebugRenderParams;
+	BasicFSDebugRenderParams*	mBasicFSDebugRenderParams;
+
+	FieldSamplerManagerIntl* 		mFieldSamplerManager;
+
+	friend class ModuleBasicFSImpl;
+	friend class JetFSActorImpl;
+	friend class AttractorFSActorImpl;
+	friend class VortexFSActorImpl;
+	friend class NoiseFSActorImpl;
+	friend class WindFSActorImpl;
+};
+
+class BasicFSSceneCPU : public BasicFSScene
+{
+public:
+	BasicFSSceneCPU(ModuleBasicFSImpl& module, SceneIntl& scene, RenderDebugInterface* debugRender, ResourceList& list);
+	~BasicFSSceneCPU();
+
+	JetFSActorImpl*					createJetFSActor(const JetFSActorParams&, JetFSAsset&, ResourceList&);
+	AttractorFSActorImpl*			createAttractorFSActor(const AttractorFSActorParams&, AttractorFSAsset&, ResourceList&);
+	VortexFSActorImpl*				createVortexFSActor(const VortexFSActorParams&, VortexFSAsset&, ResourceList&);
+	NoiseFSActorImpl*				createNoiseFSActor(const NoiseFSActorParams&, NoiseFSAsset&, ResourceList&);
+	WindFSActorImpl*				createWindFSActor(const WindFSActorParams&, WindFSAsset&, ResourceList&);
+
+	/* FieldSamplerSceneIntl */
+
+protected:
+};
+
+#if APEX_CUDA_SUPPORT
+class BasicFSSceneGPU : public BasicFSScene, public CudaModuleScene
+{
+public:
+	BasicFSSceneGPU(ModuleBasicFSImpl& module, SceneIntl& scene, RenderDebugInterface* debugRender, ResourceList& list);
+	~BasicFSSceneGPU();
+
+	JetFSActorImpl*					createJetFSActor(const JetFSActorParams&, JetFSAsset&, ResourceList&);
+	AttractorFSActorImpl*			createAttractorFSActor(const AttractorFSActorParams&, AttractorFSAsset&, ResourceList&);
+	VortexFSActorImpl*				createVortexFSActor(const VortexFSActorParams&, VortexFSAsset&, ResourceList&);
+	NoiseFSActorImpl*				createNoiseFSActor(const NoiseFSActorParams&, NoiseFSAsset&, ResourceList&);
+	WindFSActorImpl*				createWindFSActor(const WindFSActorParams&, WindFSAsset&, ResourceList&);
+
+	void*						getHeadCudaObj()
+	{
+		return CudaModuleScene::getHeadCudaObj();
+	}
+
+//CUDA module objects
+#include "../cuda/include/basicfs.h"
+
+	/* FieldSamplerSceneIntl */
+	virtual ApexCudaConstStorage*	getFieldSamplerCudaConstStorage();
+	virtual bool					launchFieldSamplerCudaKernel(const fieldsampler::FieldSamplerKernelLaunchDataIntl&);
+
+protected:
+	/* keep a convenience pointer to the cuda context manager */
+	PxCudaContextManager* mCtxMgr;
+};
+#endif
+
+}
+} // end namespace nvidia::apex
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/JetFSActorImpl.h b/APEX_1.4/module/basicfs/include/JetFSActorImpl.h
new file mode 100644
index 00000000..c08d5f3e
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/JetFSActorImpl.h
@@ -0,0 +1,204 @@
+/*
+ * 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 __JET_FS_ACTOR_IMPL_H__
+#define __JET_FS_ACTOR_IMPL_H__
+
+#include "BasicFSActor.h"
+#include "JetFSActor.h"
+#include "ApexRWLockable.h"
+#include "JetFSCommon.h"
+
+#include "variable_oscillator.h"
+
+
+namespace nvidia
+{
+namespace apex
+{
+class RenderMeshActor;
+}
+namespace basicfs
+{
+
+class JetFSAsset;
+class BasicFSScene;
+class JetFSActorParams;
+
+class JetFSActorImpl : public BasicFSActor, public JetFSActor, public ApexRWLockable
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	/* JetFSActor methods */
+	JetFSActorImpl(const JetFSActorParams&, JetFSAsset&, ResourceList&, BasicFSScene&);
+	~JetFSActorImpl();
+
+	BasicFSAsset* 		getJetFSAsset() const;
+
+	PxMat44			getCurrentPose() const
+	{
+		return PxMat44(mPose);
+	}
+
+	void					setCurrentPose(const PxTransform& pose)
+	{
+		mPose = pose;
+		mFieldSamplerChanged = true;
+	}
+
+	PxVec3			getCurrentPosition() const
+	{		
+		return mPose.p;
+	}
+	void					setCurrentPosition(const PxVec3& pos)
+	{
+		mPose.p = pos;
+		mFieldSamplerChanged = true;
+	}
+
+	float			getCurrentScale() const
+	{
+		return mScale;
+	}
+
+	void					setCurrentScale(const float& scale)
+	{
+		mScale = scale;
+		mFieldSamplerChanged = true;
+	}
+
+	void					setFieldStrength(float strength);
+	void					setFieldDirection(const PxVec3& direction);
+
+	void					setEnabled(bool isEnabled)
+	{
+		mFieldSamplerEnabled = isEnabled;
+	}
+
+	/* Renderable, RenderDataProvider */
+	void					updateRenderResources(bool rewriteBuffers, void* userRenderData);
+	void					dispatchRenderResources(UserRenderer& renderer);
+
+	PxBounds3				getBounds() const
+	{
+		return ApexRenderable::getBounds();
+	}
+
+	void					lockRenderResources()
+	{
+		ApexRenderable::renderDataLock();
+	}
+	void					unlockRenderResources()
+	{
+		ApexRenderable::renderDataUnLock();
+	}
+
+	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)
+	{
+		ApexActor::setEnableDebugVisualization(state);
+	}
+
+	Renderable*		getRenderable()
+	{
+		return this;
+	}
+	Actor*			getActor()
+	{
+		return this;
+	}
+
+	/* Resource, ApexResource */
+	void					release();
+
+	/* Actor, ApexActor */
+	void					destroy();
+	Asset*			getOwner() const;
+
+	virtual void			simulate(float dt);
+
+	virtual void			visualize();
+
+	/* FieldSamplerIntl */
+	virtual bool			updateFieldSampler(FieldShapeDescIntl& shapeDesc, bool& isEnabled);
+
+protected:
+	JetFSAsset*				mAsset;
+
+	PxVec3			mFieldDirection;
+	variableOscillator*		mFieldDirectionVO1;
+	variableOscillator*		mFieldDirectionVO2;
+
+	float			mFieldStrength;
+	variableOscillator*		mFieldStrengthVO;
+
+	float			mStrengthVar;
+	PxVec3			mLocalDirVar;
+	PxTransform	mDirToWorld;
+
+	JetFSParams				mExecuteParams; 
+
+	nvidia::Array<PxVec3> mDebugPoints;
+
+	friend class BasicFSScene;
+};
+
+class JetFSActorCPU : public JetFSActorImpl
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	JetFSActorCPU(const JetFSActorParams&, JetFSAsset&, ResourceList&, BasicFSScene&);
+	~JetFSActorCPU();
+
+	/* FieldSamplerIntl */
+	virtual void executeFieldSampler(const ExecuteData& data);
+
+private:
+};
+
+#if APEX_CUDA_SUPPORT
+
+class JetFSActorGPU : public JetFSActorCPU
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	JetFSActorGPU(const JetFSActorParams&, JetFSAsset&, ResourceList&, BasicFSScene&);
+	~JetFSActorGPU();
+
+	/* FieldSamplerIntl */
+	virtual bool updateFieldSampler(FieldShapeDescIntl& shapeDesc, bool& isEnabled);
+
+	virtual void getFieldSamplerCudaExecuteInfo(CudaExecuteInfo& info) const
+	{
+		info.executeType = 1;
+		info.executeParamsHandle = mParamsHandle;
+	}
+
+private:
+	ApexCudaConstMemGroup           mConstMemGroup;
+	InplaceHandle<JetFSParams>		mParamsHandle;
+
+};
+
+#endif
+
+}
+} // end namespace nvidia
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/JetFSAsset.h b/APEX_1.4/module/basicfs/include/JetFSAsset.h
new file mode 100644
index 00000000..fa877bae
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/JetFSAsset.h
@@ -0,0 +1,190 @@
+/*
+ * 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 __JET_FS_ASSET_H__
+#define __JET_FS_ASSET_H__
+
+#include "BasicFSAssetImpl.h"
+#include "JetFSAssetPreview.h"
+#include "JetFSAssetParams.h"
+#include "JetFSActorParams.h"
+#include "ApexAuthorableObject.h"
+
+namespace nvidia
+{
+namespace apex
+{
+class RenderMeshAsset;
+}
+namespace basicfs
+{
+
+class JetFSActorImpl;
+
+class JetFSAsset : public BasicFSAssetImpl
+{
+	friend class BasicFSAssetDummyAuthoring;
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	JetFSAsset(ModuleBasicFSImpl*, ResourceList&, const char*);
+	JetFSAsset(ModuleBasicFSImpl*, ResourceList&, NvParameterized::Interface*, const char*);
+	~JetFSAsset();
+
+	/* Asset */
+//	const char* 			getName() const
+//	{
+//		return mName.c_str();
+//	}
+	AuthObjTypeID			getObjTypeID() const
+	{
+		return mAssetTypeID;
+	}
+	const char* 			getObjTypeName() const
+	{
+		return getClassName();
+	}
+
+	/* ApexInterface */
+	virtual void			release()
+	{
+		mModule->mSdk->releaseAsset(*this);
+	}
+
+	// TODO: implement forceLoadAssets
+	uint32_t					forceLoadAssets()
+	{
+		return 0;
+	}
+
+	NvParameterized::Interface* getAssetNvParameterized() const
+	{
+		return mParams;
+	}
+
+	NvParameterized::Interface* releaseAndReturnNvParameterizedInterface(void)
+	{
+		NvParameterized::Interface* ret = mParams;
+		mParams = NULL;
+		release();
+		return ret;
+	}
+
+	/* BasicFSAsset specific methods */
+	void                    destroy();
+
+	/**
+	* \brief Apply any changes that may been made to the NvParameterized::Interface on this asset.
+	*/
+	virtual void applyEditingChanges(void)
+	{
+		APEX_INVALID_OPERATION("Not yet implemented!");
+	}
+
+	JetFSPreview*	createJetFSPreview(const JetFSPreviewDesc& desc, AssetPreviewScene* previewScene);
+	JetFSPreview*	createJetFSPreviewImpl(const JetFSPreviewDesc& desc, JetFSAsset* TurboAsset, AssetPreviewScene* previewScene);
+	void			releaseJetFSPreview(JetFSPreview& preview);
+
+	NvParameterized::Interface* getDefaultActorDesc();
+	virtual Actor* createApexActor(const NvParameterized::Interface& /*parms*/, Scene& /*apexScene*/);
+
+	NvParameterized::Interface* getDefaultAssetPreviewDesc();
+	virtual AssetPreview* createApexAssetPreview(const NvParameterized::Interface& /*params*/, AssetPreviewScene* previewScene);
+
+	virtual bool isValidForActorCreation(const ::NvParameterized::Interface& /*parms*/, Scene& /*apexScene*/) const
+	{
+		return true; // todo implement this method
+	}
+
+	/* Typical asset members */
+	static const char* 			getClassName() // return to protected
+	{
+		return JET_FS_AUTHORING_TYPE_NAME;
+	}
+
+protected:
+
+	static AuthObjTypeID		mAssetTypeID;
+
+	JetFSAssetParams*			mParams;
+	JetFSActorParams*			mDefaultActorParams;
+	JetFSPreviewParams*			mDefaultPreviewParams;
+
+	friend class ModuleBasicFSImpl;
+	friend class JetFSActorImpl;
+	friend class JetFSAssetPreview;
+	template <class T_Module, class T_Asset, class T_AssetAuthoring> friend class nvidia::apex::ApexAuthorableObject;
+
+};
+
+class JetFSAssetAuthoring : public JetFSAsset, public ApexAssetAuthoring, public BasicFSAssetAuthoring
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	/* BasicFSAssetAuthoring */
+	JetFSAssetAuthoring(ModuleBasicFSImpl* m, ResourceList& l) :
+		JetFSAsset(m, l, "JetFSAssetAuthoring") {}
+
+	JetFSAssetAuthoring(ModuleBasicFSImpl* m, ResourceList& l, const char* name) :
+		JetFSAsset(m, l, name) {}
+
+	JetFSAssetAuthoring(ModuleBasicFSImpl* m, ResourceList& l, NvParameterized::Interface* params, const char* name) :
+		JetFSAsset(m, l, params, name) {}
+
+	~JetFSAssetAuthoring() {}
+	void                    destroy()
+	{
+		delete this;
+	}
+
+	/* AssetAuthoring */
+	const char* 			getName(void) const
+	{
+		return JetFSAsset::getName();
+	}
+	const char* 			getObjTypeName() const
+	{
+		return JetFSAsset::getClassName();
+	}
+	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 JetFSAsset::getAssetNvParameterized();
+	}
+
+	NvParameterized::Interface* releaseAndReturnNvParameterizedInterface(void)
+	{
+		return JetFSAsset::releaseAndReturnNvParameterizedInterface();
+	}
+
+};
+
+}
+} // end namespace nvidia::apex
+
+#endif
\ No newline at end of file
diff --git a/APEX_1.4/module/basicfs/include/JetFSAssetPreview.h b/APEX_1.4/module/basicfs/include/JetFSAssetPreview.h
new file mode 100644
index 00000000..3ad34004
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/JetFSAssetPreview.h
@@ -0,0 +1,108 @@
+/*
+ * 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 __JET_ASSET_PREVIEW_H__
+#define __JET_ASSET_PREVIEW_H__
+
+#include "ApexPreview.h"
+#include "ApexRWLockable.h"
+#include "ApexSDKIntl.h"
+#include "JetFSPreview.h"
+#include "RenderDebugInterface.h"
+
+namespace nvidia
+{
+namespace basicfs
+{
+
+class JetFSAsset;
+
+/**
+\brief Descriptor for a JetFS Preview Asset
+*/
+class JetFSPreviewDesc
+{
+public:
+	JetFSPreviewDesc() :
+		mPose(PxMat44()),
+		mPreviewDetail(APEX_JET::JET_DRAW_FULL_DETAIL)
+	{
+		mPose = PxMat44(PxIdentity);
+	};
+
+	/**
+	\brief The pose that translates from preview coordinates to world coordinates.
+	*/
+	PxMat44			mPose;
+	/**
+	\brief The detail options of the preview drawing
+	*/
+	uint32_t			mPreviewDetail;
+};
+
+/*
+	APEX asset preview asset.
+	Preview.
+*/
+class JetFSAssetPreview : public JetFSPreview, public ApexResource, public ApexPreview, public ApexRWLockable
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	JetFSAssetPreview(const JetFSPreviewDesc& PreviewDesc, ApexSDK* myApexSDK, JetFSAsset* myAsset, AssetPreviewScene* previewScene);
+	void					drawJetFSPreview(void);
+	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);
+
+private:
+
+	~JetFSAssetPreview();
+	PxMat44					mPose;						// the pose for the preview rendering
+	ApexSDK*						mApexSDK;					// pointer to the APEX SDK
+	JetFSAsset*						mAsset;						// our parent JetFS Asset
+	RenderDebugInterface*				mApexRenderDebug;			// Pointer to the RenderLines class to draw the
+	PxMat33					mDirToWorld;
+	AssetPreviewScene*		mPreviewScene;
+
+	// preview stuff
+	uint32_t					mPreviewDetail;				// the detail options of the preview drawing
+
+	int32_t					mDrawGroupShape;
+	int32_t					mDrawGroupTorus;
+
+//	void							setHalfLengthDimensions(PxVec3 halfLenDim);
+	void							setDetailLevel(uint32_t detail);
+
+	void							drawPreviewAssetInfo();
+	void							drawShape(/*uint32_t color*/);
+	void							toggleDrawPreview();
+	void							setDrawGroupsPose();
+	void							drawInfoLine(uint32_t lineNum, const char* str);
+};
+
+}
+} // namespace nvidia
+
+#endif // __TURBULENCE_ASSET_PREVIEW_H__
diff --git a/APEX_1.4/module/basicfs/include/JetFSCommon.h b/APEX_1.4/module/basicfs/include/JetFSCommon.h
new file mode 100644
index 00000000..55693843
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/JetFSCommon.h
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#ifndef __JET_FS_COMMON_SRC_H__
+#define __JET_FS_COMMON_SRC_H__
+
+#include "../../fieldsampler/include/FieldSamplerCommon.h"
+#include "SimplexNoise.h"
+
+namespace nvidia
+{
+namespace basicfs
+{
+
+//struct JetFSParams
+#define INPLACE_TYPE_STRUCT_NAME JetFSParams
+#define INPLACE_TYPE_STRUCT_FIELDS \
+	INPLACE_TYPE_FIELD(float,					strength) \
+	INPLACE_TYPE_FIELD(float,					instStrength) \
+	INPLACE_TYPE_FIELD(PxTransform,			worldToDir) \
+	INPLACE_TYPE_FIELD(PxTransform,			worldToInstDir) \
+	INPLACE_TYPE_FIELD(fieldsampler::FieldShapeParams,	gridIncludeShape) \
+	INPLACE_TYPE_FIELD(float,					nearRadius) \
+	INPLACE_TYPE_FIELD(float,					pivotRadius) \
+	INPLACE_TYPE_FIELD(float,					farRadius) \
+	INPLACE_TYPE_FIELD(float,					directionalStretch) \
+	INPLACE_TYPE_FIELD(float,					averageStartDistance) \
+	INPLACE_TYPE_FIELD(float,					averageEndDistance) \
+	INPLACE_TYPE_FIELD(float,					pivotRatio) \
+	INPLACE_TYPE_FIELD(float,					noiseStrength) \
+	INPLACE_TYPE_FIELD(float,					noiseSpaceScale) \
+	INPLACE_TYPE_FIELD(float,					noiseTimeScale) \
+	INPLACE_TYPE_FIELD(uint32_t,					noiseOctaves)
+#include INPLACE_TYPE_BUILD()
+
+
+PX_CUDA_CALLABLE PX_INLINE float smoothstep(float x, float edge0, float edge1)
+{
+	//x should be >= 0
+	x = (PxClamp(x, edge0, edge1) - edge0) / (edge1 - edge0);
+	// Evaluate polynomial
+	return x * x * (3 - 2 * x);
+}
+
+PX_CUDA_CALLABLE PX_INLINE float smoothstep1(float x, float edge)
+{
+	//x should be >= 0
+	x = PxMin(x, edge) / edge;
+	// Evaluate polynomial
+	return x * x * (3 - 2 * x);
+}
+
+PX_CUDA_CALLABLE PX_INLINE PxVec3 executeJetFS_GRID(const JetFSParams& params)
+{
+	return params.worldToDir.q.rotate(PxVec3(0, params.strength, 0));
+}
+
+PX_CUDA_CALLABLE PX_INLINE PxVec3 evalToroidalField(const JetFSParams& params, const PxVec3& pos, const PxTransform& worldToDir, float strength0)
+{
+	PxVec3 point = worldToDir.transform(pos);
+
+	float r = PxSqrt(point.x * point.x + point.z * point.z);
+	float h = point.y / params.directionalStretch;
+
+	float t;
+	{
+		const float r1 = r - params.pivotRadius;
+		const float a = params.pivotRatio;
+		const float b = (params.pivotRatio - 1) * r1;
+		const float c = r1 * r1 + h * h;
+
+		t = (PxSqrt(b * b + 4 * a * c) - b) / (2 * a);
+	}
+
+	const float r0 = params.pivotRadius + t * ((params.pivotRatio - 1) / 2);
+
+	const float d = r0 - r;
+	const float cosAngle = d / PxSqrt(d * d + h * h);
+	const float angleLerp = (cosAngle + 1) * 0.5f;
+
+	float rr = (r > 1e-10f) ? (1 / r) : 0;
+
+	float xRatio = point.x * rr;
+	float zRatio = point.z * rr;
+
+	PxVec3 dir;
+	dir.x = xRatio * h;
+	dir.y = d * params.directionalStretch;
+	dir.z = zRatio * h;
+
+	dir.normalize();
+
+	float strength = 0.0f;
+	if (t <= params.pivotRadius)
+	{
+		strength = strength0 * smoothstep1(t, params.pivotRadius - params.nearRadius);
+
+		strength *= (params.pivotRadius - t) * rr;
+	}
+	strength /= (angleLerp + params.pivotRatio * (1 - angleLerp));
+
+	return strength * worldToDir.q.rotate(dir);
+}
+
+PX_CUDA_CALLABLE PX_INLINE PxVec3 executeJetFS(const JetFSParams& params, const PxVec3& pos, uint32_t totalElapsedMS)
+{
+	PxVec3 avgField = evalToroidalField(params, pos, params.worldToDir, params.strength);
+	PxVec3 instField = evalToroidalField(params, pos, params.worldToInstDir, params.instStrength);
+
+	float distance = (pos - params.worldToDir.p).magnitude();
+	float lerpFactor = smoothstep(distance, params.averageStartDistance, params.averageEndDistance);
+	PxVec3 result = lerpFactor * avgField + (1 - lerpFactor) * instField;
+
+	if (params.noiseStrength > 0)
+	{
+		//add some noise
+		PxVec3 point = params.noiseSpaceScale * (params.worldToDir.transform(pos));
+		float time = (params.noiseTimeScale * 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.noiseOctaves; ++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;
+
+		result += params.noiseStrength * params.worldToDir.q.rotate(rot);
+	}
+	return result;
+}
+
+}
+} // namespace nvidia
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/ModuleBasicFSImpl.h b/APEX_1.4/module/basicfs/include/ModuleBasicFSImpl.h
new file mode 100644
index 00000000..da1470bb
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/ModuleBasicFSImpl.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 __MODULE_BASIC_FS_IMPL_H__
+#define __MODULE_BASIC_FS_IMPL_H__
+
+#include "Apex.h"
+#include "ModuleBasicFS.h"
+#include "ApexSDKIntl.h"
+#include "ModuleIntl.h"
+#include "ModuleBase.h"
+
+#include "ApexSDKHelpers.h"
+#include "ApexRWLockable.h"
+#include "ModuleBasicFSRegistration.h"
+
+
+namespace nvidia
+{
+namespace apex
+{
+class SceneIntl;
+class ModuleFieldSamplerIntl;
+}	
+namespace basicfs
+{
+
+class BasicFSAssetImpl;
+class JetFSAssetAuthoring;
+class AttractorFSAssetAuthoring;
+class VortexFSAssetAuthoring;
+class BasicFSScene;
+
+class ModuleBasicFSImpl : public ModuleBasicFS, public ModuleIntl, public ModuleBase, public ApexRWLockable
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	ModuleBasicFSImpl(ApexSDKIntl* sdk);
+	~ModuleBasicFSImpl();
+
+	// 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&);
+	AuthObjTypeID				getModuleID() const;
+	RenderableIterator* 	createRenderableIterator(const Scene&);
+
+	AuthObjTypeID             getJetFSAssetTypeID() const;
+	AuthObjTypeID             getAttractorFSAssetTypeID() const;
+	AuthObjTypeID             getVortexFSAssetTypeID() const;
+	AuthObjTypeID             getNoiseFSAssetTypeID() const;
+	AuthObjTypeID             getWindFSAssetTypeID() const;
+
+	ApexActor* 					getApexActor(Actor*, AuthObjTypeID) const;
+
+	ModuleFieldSamplerIntl* 		getInternalModuleFieldSampler();
+
+	BasicFSScene* 				getBasicFSScene(const Scene& apexScene); // return to protected
+protected:
+	ResourceList				mAuthorableObjects;
+
+	ResourceList				mBasicFSScenes;
+
+	friend class BasicFSAssetImpl;
+	friend class JetFSAsset;
+	friend class AttractorFSAsset;
+	friend class VortexFSAsset;
+	friend class BasicFSScene;
+
+private:
+
+	BasicFSModuleParameters* 			mModuleParams;
+
+	ModuleFieldSamplerIntl* 				mFieldSamplerModule;
+};
+
+}
+} // end namespace nvidia::apex
+
+#endif // __MODULE_BASIC_FS_IMPL_H__
diff --git a/APEX_1.4/module/basicfs/include/ModuleEventDefs.h b/APEX_1.4/module/basicfs/include/ModuleEventDefs.h
new file mode 100644
index 00000000..eac5dd20
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/ModuleEventDefs.h
@@ -0,0 +1,26 @@
+/*
+ * 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 ModulePerfScope.h
+// and by ModuleFoo.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(BasicFSSceneFetchResults)
diff --git a/APEX_1.4/module/basicfs/include/ModuleGpuEventDefs.h b/APEX_1.4/module/basicfs/include/ModuleGpuEventDefs.h
new file mode 100644
index 00000000..919e612a
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/ModuleGpuEventDefs.h
@@ -0,0 +1,26 @@
+/*
+ * 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 ModulePerfScope.h
+// and by ModuleFoo.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_GPU_EVENT(kernel_name_1)
+//     DEFINE_GPU_EVENT(kernel_name_2)
+//     DEFINE_GPU_EVENT(copy_name_1)
+
+DEFINE_GPU_EVENT(BasicFSKernel)
diff --git a/APEX_1.4/module/basicfs/include/ModulePerfScope.h b/APEX_1.4/module/basicfs/include/ModulePerfScope.h
new file mode 100644
index 00000000..efbe5a7e
--- /dev/null
+++ b/APEX_1.4/module/basicfs/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 basicfs
+#include "ModuleProfileCommon.h"
+
+#endif
\ No newline at end of file
diff --git a/APEX_1.4/module/basicfs/include/NoiseFSActorImpl.h b/APEX_1.4/module/basicfs/include/NoiseFSActorImpl.h
new file mode 100644
index 00000000..be0a3a2f
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/NoiseFSActorImpl.h
@@ -0,0 +1,197 @@
+/*
+ * 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 __NOISE_FS_ACTOR_IMPL_H__
+#define __NOISE_FS_ACTOR_IMPL_H__
+
+#include "BasicFSActor.h"
+#include "NoiseFSActor.h"
+#include "ApexRWLockable.h"
+#include "NoiseFSCommon.h"
+
+#include "ReadCheck.h"
+#include "WriteCheck.h"
+
+namespace nvidia
+{
+namespace apex
+{
+class RenderMeshActor;	
+}	
+namespace basicfs
+{
+
+class NoiseFSAsset;
+class BasicFSScene;
+class NoiseFSActorParams;
+
+class NoiseFSActorImpl : public BasicFSActor, public NoiseFSActor, public ApexRWLockable
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	/* NoiseFSActor methods */
+	NoiseFSActorImpl(const NoiseFSActorParams&, NoiseFSAsset&, ResourceList&, BasicFSScene&);
+	~NoiseFSActorImpl();
+
+	BasicFSAsset* 		getNoiseFSAsset() const;
+
+	PxMat44			getCurrentPose() const
+	{
+		READ_ZONE();
+		return PxMat44(mPose);
+	}
+
+	void					setCurrentPose(const PxTransform& pose)
+	{
+		WRITE_ZONE();
+		mPose = pose;
+		mFieldSamplerChanged = true;
+	}
+
+	PxVec3			getCurrentPosition() const
+	{		
+		READ_ZONE();
+		return mPose.p;
+	}
+	void					setCurrentPosition(const PxVec3& pos)
+	{
+		WRITE_ZONE();
+		mPose.p = pos;
+		mFieldSamplerChanged = true;
+	}
+
+	float			getCurrentScale() const
+	{
+		READ_ZONE();
+		return mScale;
+	}
+
+	void					setCurrentScale(const float& scale)
+	{
+		WRITE_ZONE();
+		mScale = scale;
+		mFieldSamplerChanged = true;
+	}
+
+	void					setNoiseStrength(float strength);
+
+	void					setEnabled(bool isEnabled)
+	{
+		WRITE_ZONE();
+		mFieldSamplerEnabled = isEnabled;
+	}
+
+	/* Renderable, RenderDataProvider */
+	void					updateRenderResources(bool rewriteBuffers, void* userRenderData);
+	void					dispatchRenderResources(UserRenderer& renderer);
+
+	PxBounds3				getBounds() const
+	{
+		return ApexRenderable::getBounds();
+	}
+
+	void					lockRenderResources()
+	{
+		ApexRenderable::renderDataLock();
+	}
+	void					unlockRenderResources()
+	{
+		ApexRenderable::renderDataUnLock();
+	}
+
+	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)
+	{
+		ApexActor::setEnableDebugVisualization(state);
+	}
+
+	Renderable*		getRenderable()
+	{
+		return this;
+	}
+	Actor*			getActor()
+	{
+		return this;
+	}
+
+	/* Resource, ApexResource */
+	void					release();
+
+	/* Actor, ApexActor */
+	void					destroy();
+	Asset*			getOwner() const;
+
+	virtual void			simulate(float dt);
+
+	virtual void			visualize();
+
+	/* FieldSamplerIntl */
+	virtual bool			updateFieldSampler(FieldShapeDescIntl& shapeDesc, bool& isEnabled);
+
+protected:
+	NoiseFSAsset*				mAsset;
+
+	NoiseFSParams				mExecuteParams; 
+
+	friend class BasicFSScene;
+};
+
+class NoiseFSActorCPU : public NoiseFSActorImpl
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	NoiseFSActorCPU(const NoiseFSActorParams&, NoiseFSAsset&, ResourceList&, BasicFSScene&);
+	~NoiseFSActorCPU();
+
+	/* FieldSamplerIntl */
+	virtual void executeFieldSampler(const ExecuteData& data);
+
+private:
+};
+
+#if APEX_CUDA_SUPPORT
+
+class NoiseFSActorGPU : public NoiseFSActorCPU
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	NoiseFSActorGPU(const NoiseFSActorParams&, NoiseFSAsset&, ResourceList&, BasicFSScene&);
+	~NoiseFSActorGPU();
+
+	/* FieldSamplerIntl */
+	virtual bool updateFieldSampler(FieldShapeDescIntl& shapeDesc, bool& isEnabled);
+
+	virtual void getFieldSamplerCudaExecuteInfo(CudaExecuteInfo& info) const
+	{
+		info.executeType = 3;
+		info.executeParamsHandle = mParamsHandle;
+	}
+
+private:
+	ApexCudaConstMemGroup			mConstMemGroup;
+	InplaceHandle<NoiseFSParams>	mParamsHandle;
+
+};
+
+#endif
+
+}
+} // end namespace nvidia
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/NoiseFSAsset.h b/APEX_1.4/module/basicfs/include/NoiseFSAsset.h
new file mode 100644
index 00000000..7e776c0e
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/NoiseFSAsset.h
@@ -0,0 +1,190 @@
+/*
+ * 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 __NOISE_FS_ASSET_H__
+#define __NOISE_FS_ASSET_H__
+
+#include "BasicFSAssetImpl.h"
+#include "NoiseFSAssetPreview.h"
+#include "NoiseFSAssetParams.h"
+#include "NoiseFSActorParams.h"
+#include "ApexAuthorableObject.h"
+
+namespace nvidia
+{
+namespace apex
+{
+class RenderMeshAsset;
+}
+namespace basicfs
+{
+
+class NoiseFSActorImpl;
+
+class NoiseFSAsset : public BasicFSAssetImpl
+{
+	friend class BasicFSAssetDummyAuthoring;
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	NoiseFSAsset(ModuleBasicFSImpl*, ResourceList&, const char*);
+	NoiseFSAsset(ModuleBasicFSImpl*, ResourceList&, NvParameterized::Interface*, const char*);
+	~NoiseFSAsset();
+
+	/* Asset */
+//	const char* 			getName() const
+//	{
+//		return mName.c_str();
+//	}
+	AuthObjTypeID			getObjTypeID() const
+	{
+		return mAssetTypeID;
+	}
+	const char* 			getObjTypeName() const
+	{
+		return getClassName();
+	}
+
+	/* ApexInterface */
+	virtual void			release()
+	{
+		mModule->mSdk->releaseAsset(*this);
+	}
+
+	// TODO: implement forceLoadAssets
+	uint32_t					forceLoadAssets()
+	{
+		return 0;
+	}
+
+	NvParameterized::Interface* getAssetNvParameterized() const
+	{
+		return mParams;
+	}
+
+	NvParameterized::Interface* releaseAndReturnNvParameterizedInterface(void)
+	{
+		NvParameterized::Interface* ret = mParams;
+		mParams = NULL;
+		release();
+		return ret;
+	}
+
+	/* BasicFSAsset specific methods */
+	void                    destroy();
+
+	/**
+	* \brief Apply any changes that may been made to the NvParameterized::Interface on this asset.
+	*/
+	virtual void applyEditingChanges(void)
+	{
+		APEX_INVALID_OPERATION("Not yet implemented!");
+	}
+
+	NoiseFSPreview*	createNoiseFSPreview(const NoiseFSPreviewDesc& desc, AssetPreviewScene* previewScene);
+	NoiseFSPreview*	createNoiseFSPreviewImpl(const NoiseFSPreviewDesc& desc, NoiseFSAsset* TurboAsset, AssetPreviewScene* previewScene);
+	void				releaseNoiseFSPreview(NoiseFSPreview& preview);
+
+	NvParameterized::Interface* getDefaultActorDesc();
+	virtual Actor* createApexActor(const NvParameterized::Interface& /*parms*/, Scene& /*apexScene*/);
+
+	NvParameterized::Interface* getDefaultAssetPreviewDesc();
+	virtual AssetPreview* createApexAssetPreview(const NvParameterized::Interface& /*params*/, AssetPreviewScene* previewScene);
+
+	virtual bool isValidForActorCreation(const ::NvParameterized::Interface& /*parms*/, Scene& /*apexScene*/) const
+	{
+		return true; // todo implement this method
+	}
+
+	/* Typical asset members */
+	static const char* 			getClassName() // return to protected
+	{
+		return NOISE_FS_AUTHORING_TYPE_NAME;
+	}
+
+protected:
+
+	static AuthObjTypeID		mAssetTypeID;
+
+	NoiseFSAssetParams*			mParams;
+	NoiseFSActorParams*			mDefaultActorParams;
+	NoiseFSPreviewParams*		mDefaultPreviewParams;
+
+	friend class ModuleBasicFSImpl;
+	friend class NoiseFSActorImpl;
+	friend class NoiseFSAssetPreview;
+	template <class T_Module, class T_Asset, class T_AssetAuthoring> friend class nvidia::apex::ApexAuthorableObject;
+
+};
+
+class NoiseFSAssetAuthoring : public NoiseFSAsset, public ApexAssetAuthoring, public BasicFSAssetAuthoring
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	/* BasicFSAssetAuthoring */
+	NoiseFSAssetAuthoring(ModuleBasicFSImpl* m, ResourceList& l) :
+		NoiseFSAsset(m, l, "NoiseFSAssetAuthoring") {}
+
+	NoiseFSAssetAuthoring(ModuleBasicFSImpl* m, ResourceList& l, const char* name) :
+		NoiseFSAsset(m, l, name) {}
+
+	NoiseFSAssetAuthoring(ModuleBasicFSImpl* m, ResourceList& l, NvParameterized::Interface* params, const char* name) :
+		NoiseFSAsset(m, l, params, name) {}
+
+	~NoiseFSAssetAuthoring() {}
+	void                    destroy()
+	{
+		delete this;
+	}
+
+	/* AssetAuthoring */
+	const char* 			getName(void) const
+	{
+		return NoiseFSAsset::getName();
+	}
+	const char* 			getObjTypeName() const
+	{
+		return NoiseFSAsset::getClassName();
+	}
+	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 NoiseFSAsset::getAssetNvParameterized();
+	}
+
+	NvParameterized::Interface* releaseAndReturnNvParameterizedInterface(void)
+	{
+		return NoiseFSAsset::releaseAndReturnNvParameterizedInterface();
+	}
+
+};
+
+}
+} // end namespace nvidia::apex
+
+#endif
\ No newline at end of file
diff --git a/APEX_1.4/module/basicfs/include/NoiseFSAssetPreview.h b/APEX_1.4/module/basicfs/include/NoiseFSAssetPreview.h
new file mode 100644
index 00000000..5bac9d02
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/NoiseFSAssetPreview.h
@@ -0,0 +1,106 @@
+/*
+ * 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 __NOISE_ASSET_PREVIEW_H__
+#define __NOISE_ASSET_PREVIEW_H__
+
+#include "ApexPreview.h"
+#include "ApexRWLockable.h"
+#include "ApexSDKIntl.h"
+#include "NoiseFSPreview.h"
+#include "RenderDebugInterface.h"
+
+namespace nvidia
+{
+namespace basicfs
+{
+
+class NoiseFSAsset;
+
+/**
+\brief Descriptor for a NoiseFS Preview Asset
+*/
+class NoiseFSPreviewDesc
+{
+public:
+	NoiseFSPreviewDesc() :
+		mPose(PxMat44()),
+		mPreviewDetail(APEX_NOISE::NOISE_DRAW_FULL_DETAIL)
+	{
+		mPose = PxMat44(PxIdentity);
+	};
+
+	/**
+	\brief The pose that translates from preview coordinates to world coordinates.
+	*/
+	PxMat44			mPose;
+	/**
+	\brief The detail options of the preview drawing
+	*/
+	uint32_t			mPreviewDetail;
+};
+
+/*
+	APEX asset preview asset.
+	Preview.
+*/
+class NoiseFSAssetPreview : public NoiseFSPreview, public ApexResource, public ApexPreview, public ApexRWLockable
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	NoiseFSAssetPreview(const NoiseFSPreviewDesc& PreviewDesc, ApexSDK* myApexSDK, NoiseFSAsset* myAsset, AssetPreviewScene* previewScene);
+	void					drawNoiseFSPreview(void);
+	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);
+
+private:
+
+	~NoiseFSAssetPreview();
+	PxMat44					mPose;						// the pose for the preview rendering
+	ApexSDK*						mApexSDK;					// pointer to the APEX SDK
+	NoiseFSAsset*					mAsset;						// our parent NoiseFS Asset
+	RenderDebugInterface*				mApexRenderDebug;			// Pointer to the RenderLines class to draw the
+	AssetPreviewScene*		mPreviewScene;
+
+	// preview stuff
+	uint32_t					mPreviewDetail;				// the detail options of the preview drawing
+
+	int32_t					mDrawGroupShape;
+
+//	void							setHalfLengthDimensions(PxVec3 halfLenDim);
+	void							setDetailLevel(uint32_t detail);
+
+	void							drawPreviewAssetInfo();
+	void							drawShape(/*uint32_t color*/);
+	void							toggleDrawPreview();
+	void							setDrawGroupsPose();
+	void							drawInfoLine(uint32_t lineNum, const char* str);
+};
+
+}
+} // namespace nvidia
+
+#endif // __NOISE_ASSET_PREVIEW_H__
diff --git a/APEX_1.4/module/basicfs/include/NoiseFSCommon.h b/APEX_1.4/module/basicfs/include/NoiseFSCommon.h
new file mode 100644
index 00000000..2441b845
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/NoiseFSCommon.h
@@ -0,0 +1,128 @@
+/*
+ * 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 __NOISE_FS_COMMON_H__
+#define __NOISE_FS_COMMON_H__
+
+#include "../../fieldsampler/include/FieldSamplerCommon.h"
+#include "SimplexNoise.h"
+
+namespace nvidia
+{
+namespace basicfs
+{
+
+struct NoiseType
+{
+	enum Enum
+	{
+		SIMPLEX,
+		CURL
+	};
+};
+
+//struct NoiseFSParams
+#define INPLACE_TYPE_STRUCT_NAME NoiseFSParams
+#define INPLACE_TYPE_STRUCT_FIELDS \
+	INPLACE_TYPE_FIELD(float,			noiseStrength) \
+	INPLACE_TYPE_FIELD(PxVec3,			noiseSpaceFreq) \
+	INPLACE_TYPE_FIELD(float,			noiseTimeFreq) \
+	INPLACE_TYPE_FIELD(uint32_t,			noiseOctaves) \
+	INPLACE_TYPE_FIELD(float,			noiseStrengthOctaveMultiplier) \
+	INPLACE_TYPE_FIELD(PxVec3,			noiseSpaceFreqOctaveMultiplier) \
+	INPLACE_TYPE_FIELD(float,			noiseTimeFreqOctaveMultiplier) \
+	INPLACE_TYPE_FIELD(uint32_t,			noiseType) \
+	INPLACE_TYPE_FIELD(uint32_t,			noiseSeed) \
+	INPLACE_TYPE_FIELD(PxTransform,	worldToShape) \
+	INPLACE_TYPE_FIELD(InplaceBool,				useLocalSpace)
+#include INPLACE_TYPE_BUILD()
+
+
+APEX_CUDA_CALLABLE PX_INLINE PxVec3 evalNoise(const NoiseFSParams& params, const PxVec3& pos, uint32_t totalElapsedMS)
+{
+	PxVec3 point;
+	if (params.useLocalSpace)
+	{
+		const PxVec3 posInShape = params.worldToShape.transform(pos);
+		point = PxVec3(params.noiseSpaceFreq.x * posInShape.x, params.noiseSpaceFreq.y * posInShape.y, params.noiseSpaceFreq.z * posInShape.z);
+	}
+	else
+	{
+		point = PxVec3(params.noiseSpaceFreq.x * pos.x, params.noiseSpaceFreq.y * pos.y, params.noiseSpaceFreq.z * pos.z);
+	}
+	float time = params.noiseTimeFreq * (totalElapsedMS * 1e-3f);
+
+	PxVec3 result;
+	if (params.noiseType == NoiseType::CURL)
+	{
+		PxVec4 dFx;
+		dFx.setZero();
+		PxVec4 dFy;
+		dFy.setZero();
+		PxVec4 dFz;
+		dFz.setZero();
+		float amp = 1.0f;
+		int seed = (int)params.noiseSeed;
+		for (uint32_t i = 0; i < params.noiseOctaves; ++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);
+
+			amp *= params.noiseStrengthOctaveMultiplier;
+			point.x *= params.noiseSpaceFreqOctaveMultiplier.x;
+			point.y *= params.noiseSpaceFreqOctaveMultiplier.y;
+			point.z *= params.noiseSpaceFreqOctaveMultiplier.z;
+			time *= params.noiseTimeFreqOctaveMultiplier;
+		}
+		//build curl noise as a result
+		result.x = dFz.y - dFy.z;
+		result.y = dFx.z - dFz.x;
+		result.z = dFy.x - dFx.y;
+	}
+	else
+	{
+		PxVec4 noise;
+		noise.setZero();
+		float amp = 1.0f;
+		int seed = (int)params.noiseSeed;
+		for (uint32_t i = 0; i < params.noiseOctaves; ++i)
+		{
+			noise += amp * SimplexNoise::eval4D(point.x, point.y, point.z, time, ++seed);
+
+			amp *= params.noiseStrengthOctaveMultiplier;
+			point.x *= params.noiseSpaceFreqOctaveMultiplier.x;
+			point.y *= params.noiseSpaceFreqOctaveMultiplier.y;
+			point.z *= params.noiseSpaceFreqOctaveMultiplier.z;
+			time *= params.noiseTimeFreqOctaveMultiplier;
+		}
+		//get noise gradient as a result
+		result = noise.getXYZ();
+	}
+	result *= params.noiseStrength;
+	return result;
+}
+
+APEX_CUDA_CALLABLE PX_INLINE PxVec3 executeNoiseFS_GRID(const NoiseFSParams& params, const PxVec3& pos, uint32_t totalElapsedMS)
+{
+	return evalNoise(params, pos, totalElapsedMS);
+}
+
+
+APEX_CUDA_CALLABLE PX_INLINE PxVec3 executeNoiseFS(const NoiseFSParams& params, const PxVec3& pos, uint32_t totalElapsedMS)
+{
+	return evalNoise(params, pos, totalElapsedMS);
+}
+
+}
+} // namespace nvidia
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/VortexFSActorImpl.h b/APEX_1.4/module/basicfs/include/VortexFSActorImpl.h
new file mode 100644
index 00000000..2cdcf9fb
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/VortexFSActorImpl.h
@@ -0,0 +1,257 @@
+/*
+ * 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 __VORTEX_FS_ACTOR_IMPL_H__
+#define __VORTEX_FS_ACTOR_IMPL_H__
+
+#include "BasicFSActor.h"
+#include "VortexFSActor.h"
+
+#include "VortexFSCommon.h"
+
+#include "ReadCheck.h"
+#include "WriteCheck.h"
+
+namespace nvidia
+{
+namespace apex
+{
+class RenderMeshActor;	
+}	
+namespace basicfs
+{
+
+class VortexFSAsset;
+class BasicFSScene;
+class VortexFSActorParams;
+
+class VortexFSActorImpl : public BasicFSActor, public VortexFSActor, public ApexRWLockable
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	/* VortexFSActor methods */
+	VortexFSActorImpl(const VortexFSActorParams&, VortexFSAsset&, ResourceList&, BasicFSScene&);
+	~VortexFSActorImpl();
+
+	BasicFSAsset* 		getVortexFSAsset() const;
+
+	PxMat44			getCurrentPose() const
+	{
+		READ_ZONE();
+		return PxMat44(mPose);
+	}
+
+	void					setCurrentPose(const PxTransform& pose)
+	{
+		WRITE_ZONE();
+		mPose = pose;
+		mFieldSamplerChanged = true;
+	}
+
+	PxVec3			getCurrentPosition() const
+	{
+		READ_ZONE();
+		return mPose.p;
+	}
+	void					setCurrentPosition(const PxVec3& pos)
+	{
+		WRITE_ZONE();
+		mPose.p = pos;
+		mFieldSamplerChanged = true;
+	}
+	void					setAxis(const PxVec3& axis)
+	{
+		WRITE_ZONE();
+		mAxis = axis;
+		mFieldSamplerChanged = true;
+	}
+	void					setHeight(float height)
+	{
+		WRITE_ZONE();
+		mHeight = height;
+		mFieldSamplerChanged = true;
+		mDebugShapeChanged = true;
+	}
+	void					setBottomRadius(float radius)
+	{
+		mBottomRadius = radius;
+		mFieldSamplerChanged = true;
+		mDebugShapeChanged = true;
+	}
+	void					setTopRadius(float radius)
+	{
+		WRITE_ZONE();
+		mTopRadius = radius;
+		mFieldSamplerChanged = true;
+		mDebugShapeChanged = true;
+	}
+
+	void					setBottomSphericalForce(bool isEnabled)
+	{
+		WRITE_ZONE();
+		mBottomSphericalForce = isEnabled;
+		mFieldSamplerChanged = true;
+	}
+	void					setTopSphericalForce(bool isEnabled)
+	{
+		WRITE_ZONE();
+		mTopSphericalForce = isEnabled;
+		mFieldSamplerChanged = true;
+	}
+
+	void					setRotationalStrength(float strength);
+	void					setRadialStrength(float strength);
+	void					setLiftStrength(float strength);
+
+	void					setEnabled(bool isEnabled)
+	{
+		WRITE_ZONE();
+		mFieldSamplerEnabled = isEnabled;
+	}
+
+	/* Renderable, RenderDataProvider */
+	void					updateRenderResources(bool rewriteBuffers, void* userRenderData);
+	void					dispatchRenderResources(UserRenderer& renderer);
+
+	PxBounds3				getBounds() const
+	{
+		return ApexRenderable::getBounds();
+	}
+
+	void					lockRenderResources()
+	{
+		ApexRenderable::renderDataLock();
+	}
+	void					unlockRenderResources()
+	{
+		ApexRenderable::renderDataUnLock();
+	}
+
+	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)
+	{
+		ApexActor::setEnableDebugVisualization(state);
+	}
+
+	Renderable*		getRenderable()
+	{
+		return this;
+	}
+	Actor*			getActor()
+	{
+		return this;
+	}
+
+	/* Resource, ApexResource */
+	void					release();
+
+	/* Actor, ApexActor */
+	void					destroy();
+	Asset*			getOwner() const;
+
+	virtual void			simulate(float dt);
+
+	virtual void			visualize();
+
+	/* FieldSamplerIntl */
+	virtual bool			updateFieldSampler(FieldShapeDescIntl& shapeDesc, bool& isEnabled);
+
+	///Sets the uniform overall object scale
+	virtual void				setCurrentScale(float scale)
+	{
+		WRITE_ZONE();
+		mScale = scale;
+		mFieldSamplerChanged = true;
+	}
+
+	//Retrieves the uniform overall object scale
+	virtual float				getCurrentScale(void) const
+	{
+		READ_ZONE();
+		return mScale;
+	}
+
+protected:
+	VortexFSAsset*			mAsset;
+	
+	bool					mBottomSphericalForce;
+	bool					mTopSphericalForce;
+
+	PxVec3			mAxis;
+	float			mHeight;
+	float			mBottomRadius;
+	float			mTopRadius;
+
+	float			mRotationalStrength;
+	float			mRadialStrength;
+	float			mLiftStrength;
+
+	VortexFSParams			mExecuteParams; 
+
+	PxTransform	mDirToWorld;
+
+	bool						mDebugShapeChanged;
+	nvidia::Array<PxVec3> mDebugPoints;
+
+	friend class BasicFSScene;
+};
+
+class VortexFSActorCPU : public VortexFSActorImpl
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	VortexFSActorCPU(const VortexFSActorParams&, VortexFSAsset&, ResourceList&, BasicFSScene&);
+	~VortexFSActorCPU();
+
+	/* FieldSamplerIntl */
+	virtual void executeFieldSampler(const ExecuteData& data);
+
+private:
+};
+
+#if APEX_CUDA_SUPPORT
+
+class VortexFSActorGPU : public VortexFSActorCPU
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	VortexFSActorGPU(const VortexFSActorParams&, VortexFSAsset&, ResourceList&, BasicFSScene&);
+	~VortexFSActorGPU();
+
+	/* FieldSamplerIntl */
+	virtual bool updateFieldSampler(FieldShapeDescIntl& shapeDesc, bool& isEnabled);
+
+	virtual void getFieldSamplerCudaExecuteInfo(CudaExecuteInfo& info) const
+	{
+		info.executeType = 4;
+		info.executeParamsHandle = mParamsHandle;
+	}
+
+private:
+	ApexCudaConstMemGroup			mConstMemGroup;
+	InplaceHandle<VortexFSParams>	mParamsHandle;
+
+};
+
+#endif
+
+}
+} // end namespace nvidia
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/VortexFSAsset.h b/APEX_1.4/module/basicfs/include/VortexFSAsset.h
new file mode 100644
index 00000000..75f00f30
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/VortexFSAsset.h
@@ -0,0 +1,188 @@
+/*
+ * 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 __VORTEX_FS_ASSET_H__
+#define __VORTEX_FS_ASSET_H__
+
+#include "BasicFSAssetImpl.h"
+#include "VortexFSAssetPreview.h"
+#include "VortexFSAssetParams.h"
+#include "VortexFSActorParams.h"
+#include "ApexAuthorableObject.h"
+
+#define VORTEX_FS_AUTHORING_TYPE_NAME "VortexFSAsset"
+
+namespace nvidia
+{
+namespace apex
+{
+class RenderMeshAsset;	
+}	
+namespace basicfs
+{
+
+class VortexFSActorImpl;
+
+class VortexFSAsset : public BasicFSAssetImpl
+{
+	friend class BasicFSAssetDummyAuthoring;
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	VortexFSAsset(ModuleBasicFSImpl*, ResourceList&, const char*);
+	VortexFSAsset(ModuleBasicFSImpl*, ResourceList&, NvParameterized::Interface*, const char*);
+	~VortexFSAsset();
+
+	/* Asset */
+	AuthObjTypeID			getObjTypeID() const
+	{
+		return mAssetTypeID;
+	}
+	const char* 			getObjTypeName() const
+	{
+		return getClassName();
+	}
+
+	/* ApexInterface */
+	virtual void			release()
+	{
+		mModule->mSdk->releaseAsset(*this);
+	}
+
+	// TODO: implement forceLoadAssets
+	uint32_t					forceLoadAssets()
+	{
+		return 0;
+	}
+
+	NvParameterized::Interface* getAssetNvParameterized() const
+	{
+		return mParams;
+	}
+
+	NvParameterized::Interface* releaseAndReturnNvParameterizedInterface(void)
+	{
+		NvParameterized::Interface* ret = mParams;
+		mParams = NULL;
+		release();
+		return ret;
+	}
+
+	/* BasicFSAsset specific methods */
+	void                    destroy();
+
+	/**
+	* \brief Apply any changes that may been made to the NvParameterized::Interface on this asset.
+	*/
+	virtual void applyEditingChanges(void)
+	{
+		APEX_INVALID_OPERATION("Not yet implemented!");
+	}
+
+	NvParameterized::Interface* getDefaultActorDesc();
+	virtual Actor* createApexActor(const NvParameterized::Interface& /*parms*/, Scene& /*apexScene*/);
+
+	VortexFSPreview*	createVortexFSPreview(const VortexFSPreviewDesc& desc, AssetPreviewScene* previewScene);
+	VortexFSPreview*	createVortexFSPreviewImpl(const VortexFSPreviewDesc& desc, VortexFSAsset* TurboAsset, AssetPreviewScene* previewScene);
+	void				releaseVortexFSPreview(VortexFSPreview& preview);
+
+	NvParameterized::Interface* getDefaultAssetPreviewDesc();
+
+	virtual AssetPreview* createApexAssetPreview(const NvParameterized::Interface& /*params*/, AssetPreviewScene* previewScene);
+
+	virtual bool isValidForActorCreation(const ::NvParameterized::Interface& /*parms*/, Scene& /*apexScene*/) const
+	{
+		return true; // todo implement this method
+	}
+
+	/* Typical asset members */
+	static const char* 			getClassName() // return to protected
+	{
+		return VORTEX_FS_AUTHORING_TYPE_NAME;
+	}
+
+protected:
+
+	static AuthObjTypeID		mAssetTypeID;
+
+	VortexFSAssetParams*		mParams;
+	VortexFSActorParams*		mDefaultActorParams;
+	VortexFSPreviewParams*		mDefaultPreviewParams;
+
+	friend class ModuleBasicFSImpl;
+	friend class VortexFSActorImpl;
+	template <class T_Module, class T_Asset, class T_AssetAuthoring> friend class nvidia::apex::ApexAuthorableObject;
+
+};
+
+class VortexFSAssetAuthoring : public VortexFSAsset, public ApexAssetAuthoring, public BasicFSAssetAuthoring
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	/* BasicFSAssetAuthoring */
+	VortexFSAssetAuthoring(ModuleBasicFSImpl* m, ResourceList& l) :
+		VortexFSAsset(m, l, "VortexFSAssetAuthoring") {}
+
+	VortexFSAssetAuthoring(ModuleBasicFSImpl* m, ResourceList& l, const char* name) :
+		VortexFSAsset(m, l, name) {}
+
+	VortexFSAssetAuthoring(ModuleBasicFSImpl* m, ResourceList& l, NvParameterized::Interface* params, const char* name) :
+		VortexFSAsset(m, l, params, name) {}
+
+	~VortexFSAssetAuthoring() {}
+	void                    destroy()
+	{
+		delete this;
+	}
+
+	/* AssetAuthoring */
+	const char* 			getName(void) const
+	{
+		return VortexFSAsset::getName();
+	}
+	const char* 			getObjTypeName() const
+	{
+		return VortexFSAsset::getClassName();
+	}
+	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 VortexFSAsset::getAssetNvParameterized();
+	}
+
+	NvParameterized::Interface* releaseAndReturnNvParameterizedInterface(void)
+	{
+		return VortexFSAsset::releaseAndReturnNvParameterizedInterface();
+	}
+
+};
+
+}
+} // end namespace nvidia::apex
+
+#endif
\ No newline at end of file
diff --git a/APEX_1.4/module/basicfs/include/VortexFSAssetPreview.h b/APEX_1.4/module/basicfs/include/VortexFSAssetPreview.h
new file mode 100644
index 00000000..ce19093d
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/VortexFSAssetPreview.h
@@ -0,0 +1,115 @@
+/*
+ * 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 __VORTEX_FSPREVIEW_H__
+#define __VORTEX_FSPREVIEW_H__
+
+#include "ApexPreview.h"
+#include "ApexRWLockable.h"
+#include "ApexSDKIntl.h"
+#include "VortexFSPreview.h"
+#include "RenderDebugInterface.h"
+
+namespace nvidia
+{
+namespace basicfs
+{
+
+class VortexFSAsset;
+
+/**
+\brief Descriptor for a VortexFS Preview Asset
+*/
+class VortexFSPreviewDesc
+{
+public:
+	VortexFSPreviewDesc() :
+		mPose(PxMat44()),
+		mPreviewDetail()
+	{
+		mPose = PxMat44(PxIdentity);
+	};
+
+	/**
+	\brief The pose that translates from preview coordinates to world coordinates.
+	*/
+	PxMat44			mPose;
+	/**
+	\brief Radius of the attractor.
+	*/
+	float			mRadius;
+	/**
+	\brief The detail options of the preview drawing
+	*/
+	uint32_t			mPreviewDetail;
+};
+
+/*
+	APEX asset preview asset.
+	Preview.
+*/
+class VortexFSAssetPreview : public VortexFSPreview, public ApexResource, public ApexPreview, public ApexRWLockable
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	VortexFSAssetPreview(const VortexFSPreviewDesc& PreviewDesc, ApexSDK* myApexSDK, VortexFSAsset* myAsset, AssetPreviewScene* previewScene);
+	void					drawVortexFSPreview(void);
+	void					destroy();
+
+	float					getVortexRadius(NvParameterized::Interface* assetParams);
+
+	void					setPose(const PxMat44& pose);	// Sets the preview instance's pose.  This may include scaling.
+	const PxMat44	getPose() const;
+
+	void					setRadius(float radius);
+	const float				getRadius() const;
+
+	void					setDetailLevel(uint32_t detail);
+
+	// 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);
+
+private:
+	~VortexFSAssetPreview();
+
+	PxMat44					mPose;						// the pose for the preview rendering
+	ApexSDK*						mApexSDK;					// pointer to the APEX SDK
+	VortexFSAsset*				mAsset;						// our parent VortexFS Asset
+	RenderDebugInterface*				mApexRenderDebug;			// Pointer to the RenderLines class to draw the
+	AssetPreviewScene*		mPreviewScene;
+																// preview stuff
+	float					mRadius;					// the radius of the attractor
+	uint32_t					mPreviewDetail;				// the detail options of the preview drawing
+
+	int32_t					mDrawGroupBox;
+
+	void drawPreviewShape();
+	void drawPreviewAssetInfo();
+	void toggleDrawPreview();
+	void setDrawGroupsPose();
+
+	void drawInfoLine(uint32_t lineNum, const char* str);
+};
+
+}
+} // namespace nvidia
+
+#endif // __TURBULENCE_ASSET_PREVIEW_H__
diff --git a/APEX_1.4/module/basicfs/include/VortexFSCommon.h b/APEX_1.4/module/basicfs/include/VortexFSCommon.h
new file mode 100644
index 00000000..1221e808
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/VortexFSCommon.h
@@ -0,0 +1,99 @@
+/*
+ * 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 __VORTEX_FS_COMMON_SRC_H__
+#define __VORTEX_FS_COMMON_SRC_H__
+
+#include "../../fieldsampler/include/FieldSamplerCommon.h"
+
+namespace nvidia
+{
+namespace basicfs
+{
+
+//struct VortexFSParams
+#define INPLACE_TYPE_STRUCT_NAME VortexFSParams
+#define INPLACE_TYPE_STRUCT_FIELDS \
+	INPLACE_TYPE_FIELD(PxTransform,			worldToDir) \
+	INPLACE_TYPE_FIELD(InplaceBool,						bottomSphericalForce) \
+	INPLACE_TYPE_FIELD(InplaceBool,						topSphericalForce) \
+	INPLACE_TYPE_FIELD(float,					height) \
+	INPLACE_TYPE_FIELD(float,					bottomRadius) \
+	INPLACE_TYPE_FIELD(float,					topRadius) \
+	INPLACE_TYPE_FIELD(float,					rotationalStrength) \
+	INPLACE_TYPE_FIELD(float,					radialStrength) \
+	INPLACE_TYPE_FIELD(float,					liftStrength)
+#include INPLACE_TYPE_BUILD()
+
+
+PX_CUDA_CALLABLE PX_INLINE float sqr(float x)
+{
+	return x * x;
+}
+
+/*
+PX_CUDA_CALLABLE PX_INLINE PxVec3 executeVortexFS_GRID(const VortexFSParams& params)
+{
+	return params.worldToDir.M.multiplyByTranspose(PxVec3(0, params.strength, 0));
+}*/
+
+APEX_CUDA_CALLABLE PX_INLINE PxVec3 executeVortexFS(const VortexFSParams& params, const PxVec3& pos/*, uint32_t totalElapsedMS*/)
+{
+	PX_ASSERT(params.bottomRadius);
+	PX_ASSERT(params.topRadius);
+	
+	PxVec3 result(PxZero);
+	PxVec3 point = params.worldToDir.transform(pos);
+	float R = PxSqrt(point.x * point.x + point.z * point.z);
+	float invR = 1.f / R;
+	float invRS = invR;
+	float curR = 0;
+	float h = params.height, r1 = params.bottomRadius, r2 = params.topRadius, y = point.y;
+
+	if (y < h/2 && y > -h/2)
+	{
+		curR = r1 + (r2-r1) * (y / h + 0.5f);
+	}
+	else if (y <= -h/2 && y >= -h/2-r1)
+	{
+		curR = PxSqrt(r1*r1 - sqr(y+h/2));
+		if (params.bottomSphericalForce)
+		{
+			float y = point.y + h/2;
+			invRS = 1.f / PxSqrt(point.x * point.x + y * y + point.z * point.z);
+			result.y = params.radialStrength * y;
+		}
+	}
+	else if (y >= h/2 && y <= h/2+r2)
+	{
+		curR = PxSqrt(r2*r2 - sqr(y-h/2));
+		if (params.topSphericalForce)
+		{
+			float y = point.y - h/2;
+			invRS = 1.f / PxSqrt(point.x * point.x + y * y + point.z * point.z);
+			result.y = params.radialStrength * y;
+		}
+	}
+
+	if (curR > 0.f && R <= curR)
+	{
+		result.x += params.radialStrength * point.x * invRS - params.rotationalStrength * R / curR * point.z * invR;
+		result.y += params.liftStrength;
+		result.z += params.radialStrength * point.z * invRS + params.rotationalStrength * R / curR * point.x * invR;
+	}
+
+	return params.worldToDir.q.rotate(result);
+}
+
+}
+} // namespace nvidia
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/WindFSActorImpl.h b/APEX_1.4/module/basicfs/include/WindFSActorImpl.h
new file mode 100644
index 00000000..cf859674
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/WindFSActorImpl.h
@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#ifndef __WIND_FS_ACTOR_IMPL_H__
+#define __WIND_FS_ACTOR_IMPL_H__
+
+#include "BasicFSActor.h"
+#include "WindFSActor.h"
+
+#include "WindFSCommon.h"
+#include "ApexRWLockable.h"
+#include "variable_oscillator.h"
+
+#include "ReadCheck.h"
+#include "WriteCheck.h"
+
+namespace nvidia
+{
+namespace apex
+{
+class RenderMeshActor;	
+}	
+namespace basicfs
+{
+
+class WindFSAsset;
+class BasicFSScene;
+class WindFSActorParams;
+
+class WindFSActorImpl : public BasicFSActor, public WindFSActor, public ApexRWLockable
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	/* WindFSActor methods */
+	WindFSActorImpl(const WindFSActorParams&, WindFSAsset&, ResourceList&, BasicFSScene&);
+	~WindFSActorImpl();
+
+	BasicFSAsset* 		getWindFSAsset() const;
+
+	PxMat44			getCurrentPose() const
+	{
+		READ_ZONE();
+		return PxMat44(mPose);
+	}
+
+	void					setCurrentPose(const PxTransform& pose)
+	{
+		WRITE_ZONE();
+		mPose = pose;
+		mFieldSamplerChanged = true;
+	}
+
+	PxVec3			getCurrentPosition() const
+	{
+		READ_ZONE();
+		return mPose.p;
+	}
+	void					setCurrentPosition(const PxVec3& pos)
+	{
+		WRITE_ZONE();
+		mPose.p = pos;
+		mFieldSamplerChanged = true;
+	}
+
+	void					setFieldStrength(float strength);
+	void					setFieldDirection(const PxVec3& direction);
+
+	float			getFieldStrength() const
+	{
+		READ_ZONE();
+		return mFieldStrength;
+	}
+	const PxVec3&	getFieldDirection() const
+	{
+		READ_ZONE();
+		return mFieldDirBasis.column0;
+	}
+
+	void					setEnabled(bool isEnabled)
+	{
+		WRITE_ZONE();
+		mFieldSamplerEnabled = isEnabled;
+	}
+
+	/* Renderable, RenderDataProvider */
+	void					updateRenderResources(bool rewriteBuffers, void* userRenderData);
+	void					dispatchRenderResources(UserRenderer& renderer);
+
+	PxBounds3				getBounds() const
+	{
+		return ApexRenderable::getBounds();
+	}
+
+	void					lockRenderResources()
+	{
+		ApexRenderable::renderDataLock();
+	}
+	void					unlockRenderResources()
+	{
+		ApexRenderable::renderDataUnLock();
+	}
+
+	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)
+	{
+		ApexActor::setEnableDebugVisualization(state);
+	}
+
+	Renderable*		getRenderable()
+	{
+		return this;
+	}
+	Actor*			getActor()
+	{
+		return this;
+	}
+
+	/* Resource, ApexResource */
+	void					release();
+
+	/* Actor, ApexActor */
+	void					destroy();
+	Asset*			getOwner() const;
+
+	virtual void			simulate(float dt);
+
+	virtual void			visualize();
+
+	/* FieldSamplerIntl */
+	virtual bool			updateFieldSampler(FieldShapeDescIntl& shapeDesc, bool& isEnabled);
+
+	virtual PxVec3 queryFieldSamplerVelocity() const
+	{
+		return mExecuteParams.fieldValue;
+	}
+
+	///Sets the uniform overall object scale
+	virtual void				setCurrentScale(float scale) 
+	{
+		WRITE_ZONE();
+		mScale = scale;
+		mFieldSamplerChanged = true;
+	}
+
+	//Retrieves the uniform overall object scale
+	virtual float				getCurrentScale(void) const
+	{
+		READ_ZONE();
+		return mScale;
+	}
+
+protected:
+	WindFSAsset*			mAsset;
+
+	PxMat33			mFieldDirBasis;
+	float			mFieldStrength;
+
+	variableOscillator*		mFieldDirectionVO1;
+	variableOscillator*		mFieldDirectionVO2;
+	variableOscillator*		mFieldStrengthVO;
+
+	float			mStrengthVar;
+	PxVec3			mLocalDirVar;
+
+	WindFSParams			mExecuteParams; 
+
+	friend class BasicFSScene;
+};
+
+class WindFSActorCPU : public WindFSActorImpl
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	WindFSActorCPU(const WindFSActorParams&, WindFSAsset&, ResourceList&, BasicFSScene&);
+	~WindFSActorCPU();
+
+	/* FieldSamplerIntl */
+	virtual void executeFieldSampler(const ExecuteData& data);
+
+private:
+};
+
+#if APEX_CUDA_SUPPORT
+
+class WindFSActorGPU : public WindFSActorCPU
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	WindFSActorGPU(const WindFSActorParams&, WindFSAsset&, ResourceList&, BasicFSScene&);
+	~WindFSActorGPU();
+
+	/* FieldSamplerIntl */
+	virtual bool updateFieldSampler(FieldShapeDescIntl& shapeDesc, bool& isEnabled);
+
+	virtual void getFieldSamplerCudaExecuteInfo(CudaExecuteInfo& info) const
+	{
+		info.executeType = 5;
+		info.executeParamsHandle = mParamsHandle;
+	}
+
+private:
+	ApexCudaConstMemGroup			mConstMemGroup;
+	InplaceHandle<WindFSParams>		mParamsHandle;
+
+};
+
+#endif
+
+}
+} // end namespace nvidia
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/WindFSAsset.h b/APEX_1.4/module/basicfs/include/WindFSAsset.h
new file mode 100644
index 00000000..4d29d0bd
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/WindFSAsset.h
@@ -0,0 +1,185 @@
+/*
+ * 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 __WIND_FS_ASSET_H__
+#define __WIND_FS_ASSET_H__
+
+#include "BasicFSAssetImpl.h"
+#include "WindFSAssetPreview.h"
+#include "WindFSAssetParams.h"
+#include "WindFSActorParams.h"
+#include "ApexAuthorableObject.h"
+
+namespace nvidia
+{
+namespace apex
+{
+class RenderMeshAsset;
+}
+namespace basicfs
+{
+
+class WindFSActorImpl;
+
+class WindFSAsset : public BasicFSAssetImpl
+{
+	friend class BasicFSAssetDummyAuthoring;
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	WindFSAsset(ModuleBasicFSImpl*, ResourceList&, const char*);
+	WindFSAsset(ModuleBasicFSImpl*, ResourceList&, NvParameterized::Interface*, const char*);
+	~WindFSAsset();
+
+	/* Asset */
+	AuthObjTypeID			getObjTypeID() const
+	{
+		return mAssetTypeID;
+	}
+	const char* 			getObjTypeName() const
+	{
+		return getClassName();
+	}
+
+	/* ApexInterface */
+	virtual void			release()
+	{
+		mModule->mSdk->releaseAsset(*this);
+	}
+
+	// TODO: implement forceLoadAssets
+	uint32_t					forceLoadAssets()
+	{
+		return 0;
+	}
+
+	NvParameterized::Interface* getAssetNvParameterized() const
+	{
+		return mParams;
+	}
+
+	NvParameterized::Interface* releaseAndReturnNvParameterizedInterface(void)
+	{
+		NvParameterized::Interface* ret = mParams;
+		mParams = NULL;
+		release();
+		return ret;
+	}
+
+	/* BasicFSAsset specific methods */
+	void                    destroy();
+
+	/**
+	* \brief Apply any changes that may been made to the NvParameterized::Interface on this asset.
+	*/
+	virtual void applyEditingChanges(void)
+	{
+		APEX_INVALID_OPERATION("Not yet implemented!");
+	}
+
+	WindFSPreview*	createWindFSPreview(const WindFSPreviewDesc& desc, AssetPreviewScene* previewScene);
+	WindFSPreview*	createWindFSPreviewImpl(const WindFSPreviewDesc& desc, WindFSAsset* TurboAsset, AssetPreviewScene* previewScene);
+	void				releaseWindFSPreview(WindFSPreview& preview);
+
+	NvParameterized::Interface* getDefaultActorDesc();
+	virtual Actor* createApexActor(const NvParameterized::Interface& /*parms*/, Scene& /*apexScene*/);
+
+	NvParameterized::Interface* getDefaultAssetPreviewDesc();
+	virtual AssetPreview* createApexAssetPreview(const NvParameterized::Interface& /*params*/, AssetPreviewScene* previewScene);
+
+	virtual bool isValidForActorCreation(const ::NvParameterized::Interface& /*parms*/, Scene& /*apexScene*/) const
+	{
+		return true; // todo implement this method
+	}
+
+	/* Typical asset members */
+	static const char* 			getClassName() // return to protected
+	{
+		return WIND_FS_AUTHORING_TYPE_NAME;
+	}
+
+protected:
+
+	static AuthObjTypeID		mAssetTypeID;
+
+	WindFSAssetParams*			mParams;
+	WindFSActorParams*			mDefaultActorParams;
+	WindFSPreviewParams*		mDefaultPreviewParams;
+
+	friend class ModuleBasicFSImpl;
+	friend class WindFSActorImpl;
+	friend class WindFSAssetPreview;
+	template <class T_Module, class T_Asset, class T_AssetAuthoring> friend class nvidia::apex::ApexAuthorableObject;
+
+};
+
+class WindFSAssetAuthoring : public WindFSAsset, public ApexAssetAuthoring, public BasicFSAssetAuthoring
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	WindFSAssetAuthoring(ModuleBasicFSImpl* m, ResourceList& l) :
+		WindFSAsset(m, l, "WindFSAssetAuthoring") {}
+
+	WindFSAssetAuthoring(ModuleBasicFSImpl* m, ResourceList& l, const char* name) :
+		WindFSAsset(m, l, name) {}
+
+	WindFSAssetAuthoring(ModuleBasicFSImpl* m, ResourceList& l, NvParameterized::Interface* params, const char* name) :
+		WindFSAsset(m, l, params, name) {}
+
+	~WindFSAssetAuthoring() {}
+	void                    destroy()
+	{
+		delete this;
+	}
+
+	/* AssetAuthoring */
+	const char* 			getName(void) const
+	{
+		return WindFSAsset::getName();
+	}
+	const char* 			getObjTypeName() const
+	{
+		return WindFSAsset::getClassName();
+	}
+	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 WindFSAsset::getAssetNvParameterized();
+	}
+
+	NvParameterized::Interface* releaseAndReturnNvParameterizedInterface(void)
+	{
+		return WindFSAsset::releaseAndReturnNvParameterizedInterface();
+	}
+
+};
+
+}
+} // end namespace nvidia::apex
+
+#endif
\ No newline at end of file
diff --git a/APEX_1.4/module/basicfs/include/WindFSAssetPreview.h b/APEX_1.4/module/basicfs/include/WindFSAssetPreview.h
new file mode 100644
index 00000000..4b2116b2
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/WindFSAssetPreview.h
@@ -0,0 +1,101 @@
+/*
+ * 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 __WIND_ASSET_PREVIEW_H__
+#define __WIND_ASSET_PREVIEW_H__
+
+#include "ApexPreview.h"
+#include "ApexRWLockable.h"
+#include "ApexSDKIntl.h"
+#include "WindFSPreview.h"
+#include "RenderDebugInterface.h"
+
+namespace nvidia
+{
+namespace basicfs
+{
+
+class WindFSAsset;
+
+/**
+\brief Descriptor for a WindFS Preview Asset
+*/
+class WindFSPreviewDesc
+{
+public:
+	WindFSPreviewDesc() :
+		mPose(PxMat44()),
+		mPreviewDetail(APEX_WIND::WIND_DRAW_FULL_DETAIL)
+	{
+		mPose = PxMat44(PxIdentity);
+	};
+
+	/**
+	\brief The pose that translates from preview coordinates to world coordinates.
+	*/
+	PxMat44			mPose;
+	/**
+	\brief The detail options of the preview drawing
+	*/
+	uint32_t			mPreviewDetail;
+};
+
+/*
+	APEX asset preview asset.
+	Preview.
+*/
+class WindFSAssetPreview : public WindFSPreview, public ApexResource, public ApexPreview, public ApexRWLockable
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	WindFSAssetPreview(const WindFSPreviewDesc& PreviewDesc, ApexSDK* myApexSDK, WindFSAsset* myAsset, AssetPreviewScene* previewScene);
+	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);
+
+private:
+
+	~WindFSAssetPreview();
+	PxMat44					mPose;						// the pose for the preview rendering
+	ApexSDK*						mApexSDK;					// pointer to the APEX SDK
+	WindFSAsset*					mAsset;						// our parent WindFS Asset
+	RenderDebugInterface*				mApexRenderDebug;			// Pointer to the RenderLines class to draw the
+	AssetPreviewScene*		mPreviewScene;
+
+	// preview stuff
+	uint32_t					mPreviewDetail;				// the detail options of the preview drawing
+
+
+//	void							setHalfLengthDimensions(PxVec3 halfLenDim);
+	void							setDetailLevel(uint32_t detail);
+
+	void							drawPreviewAssetInfo();
+	void							drawInfoLine(uint32_t lineNum, const char* str);
+};
+
+}
+} // namespace nvidia
+
+#endif // __NOISE_ASSET_PREVIEW_H__
diff --git a/APEX_1.4/module/basicfs/include/WindFSCommon.h b/APEX_1.4/module/basicfs/include/WindFSCommon.h
new file mode 100644
index 00000000..195cd02c
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/WindFSCommon.h
@@ -0,0 +1,43 @@
+/*
+ * 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 __WIND_FS_COMMON_H__
+#define __WIND_FS_COMMON_H__
+
+#include "../../fieldsampler/include/FieldSamplerCommon.h"
+#include "SimplexNoise.h"
+
+namespace nvidia
+{
+namespace basicfs
+{
+
+//struct WindFSParams
+#define INPLACE_TYPE_STRUCT_NAME WindFSParams
+#define INPLACE_TYPE_STRUCT_FIELDS \
+	INPLACE_TYPE_FIELD(PxVec3, fieldValue)
+#include INPLACE_TYPE_BUILD()
+
+
+PX_CUDA_CALLABLE PX_INLINE PxVec3 evalWind(const WindFSParams& params)
+{
+	return params.fieldValue;
+}
+
+PX_CUDA_CALLABLE PX_INLINE PxVec3 executeWindFS(const WindFSParams& params, const PxVec3& )
+{
+	return evalWind(params);
+}
+
+}
+} // namespace nvidia
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/autogen/AttractorFSActorParams.h b/APEX_1.4/module/basicfs/include/autogen/AttractorFSActorParams.h
new file mode 100644
index 00000000..ee709a7a
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/autogen/AttractorFSActorParams.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_AttractorFSActorParams_h
+#define HEADER_AttractorFSActorParams_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 basicfs
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace AttractorFSActorParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxTransform initialPose;
+	float initialScale;
+	NvParameterized::DummyStringStruct fieldBoundaryFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+
+};
+
+static const uint32_t checksum[] = { 0x4f2a3341, 0x2794b529, 0x17ac5081, 0xa5038a78, };
+
+} // namespace AttractorFSActorParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class AttractorFSActorParams : public NvParameterized::NvParameters, public AttractorFSActorParamsNS::ParametersStruct
+{
+public:
+	AttractorFSActorParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~AttractorFSActorParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("AttractorFSActorParams");
+	}
+
+	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(AttractorFSActorParamsNS::checksum);
+		return AttractorFSActorParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const AttractorFSActorParamsNS::ParametersStruct& parameters(void) const
+	{
+		AttractorFSActorParams* tmpThis = const_cast<AttractorFSActorParams*>(this);
+		return *(static_cast<AttractorFSActorParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	AttractorFSActorParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<AttractorFSActorParamsNS::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 AttractorFSActorParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		AttractorFSActorParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(AttractorFSActorParams), AttractorFSActorParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, AttractorFSActorParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class AttractorFSActorParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(AttractorFSActorParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, AttractorFSActorParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, AttractorFSActorParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, AttractorFSActorParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class AttractorFSActorParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of AttractorFSActorParams 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 (AttractorFSActorParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (AttractorFSActorParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (AttractorFSActorParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (AttractorFSActorParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (AttractorFSActorParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace basicfs
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/autogen/AttractorFSAssetParams.h b/APEX_1.4/module/basicfs/include/autogen/AttractorFSAssetParams.h
new file mode 100644
index 00000000..054949be
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/autogen/AttractorFSAssetParams.h
@@ -0,0 +1,237 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_AttractorFSAssetParams_h
+#define HEADER_AttractorFSAssetParams_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 basicfs
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace AttractorFSAssetParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float boundaryFadePercentage;
+	float radius;
+	float constFieldStrength;
+	float variableFieldStrength;
+	float fieldDragCoeff;
+	float fieldWeight;
+	NvParameterized::DummyStringStruct fieldBoundaryFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+
+};
+
+static const uint32_t checksum[] = { 0xa5c6fe76, 0x029893b4, 0x67ea6245, 0xb8f7fb2a, };
+
+} // namespace AttractorFSAssetParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class AttractorFSAssetParams : public NvParameterized::NvParameters, public AttractorFSAssetParamsNS::ParametersStruct
+{
+public:
+	AttractorFSAssetParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~AttractorFSAssetParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("AttractorFSAssetParams");
+	}
+
+	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(AttractorFSAssetParamsNS::checksum);
+		return AttractorFSAssetParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const AttractorFSAssetParamsNS::ParametersStruct& parameters(void) const
+	{
+		AttractorFSAssetParams* tmpThis = const_cast<AttractorFSAssetParams*>(this);
+		return *(static_cast<AttractorFSAssetParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	AttractorFSAssetParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<AttractorFSAssetParamsNS::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 AttractorFSAssetParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		AttractorFSAssetParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(AttractorFSAssetParams), AttractorFSAssetParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, AttractorFSAssetParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class AttractorFSAssetParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(AttractorFSAssetParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, AttractorFSAssetParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, AttractorFSAssetParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, AttractorFSAssetParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class AttractorFSAssetParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of AttractorFSAssetParams 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 (AttractorFSAssetParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (AttractorFSAssetParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (AttractorFSAssetParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (AttractorFSAssetParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (AttractorFSAssetParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace basicfs
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/autogen/AttractorFSPreviewParams.h b/APEX_1.4/module/basicfs/include/autogen/AttractorFSPreviewParams.h
new file mode 100644
index 00000000..7bf7e131
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/autogen/AttractorFSPreviewParams.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_AttractorFSPreviewParams_h
+#define HEADER_AttractorFSPreviewParams_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 basicfs
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace AttractorFSPreviewParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxMat44 globalPose;
+	bool drawShape;
+	bool drawAssetInfo;
+	uint64_t userData;
+
+};
+
+static const uint32_t checksum[] = { 0x8922c590, 0x18102a05, 0xf09b9b50, 0xdcef001a, };
+
+} // namespace AttractorFSPreviewParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class AttractorFSPreviewParams : public NvParameterized::NvParameters, public AttractorFSPreviewParamsNS::ParametersStruct
+{
+public:
+	AttractorFSPreviewParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~AttractorFSPreviewParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("AttractorFSPreviewParams");
+	}
+
+	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(AttractorFSPreviewParamsNS::checksum);
+		return AttractorFSPreviewParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const AttractorFSPreviewParamsNS::ParametersStruct& parameters(void) const
+	{
+		AttractorFSPreviewParams* tmpThis = const_cast<AttractorFSPreviewParams*>(this);
+		return *(static_cast<AttractorFSPreviewParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	AttractorFSPreviewParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<AttractorFSPreviewParamsNS::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 AttractorFSPreviewParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		AttractorFSPreviewParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(AttractorFSPreviewParams), AttractorFSPreviewParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, AttractorFSPreviewParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class AttractorFSPreviewParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(AttractorFSPreviewParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, AttractorFSPreviewParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, AttractorFSPreviewParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, AttractorFSPreviewParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class AttractorFSPreviewParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of AttractorFSPreviewParams 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 (AttractorFSPreviewParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (AttractorFSPreviewParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (AttractorFSPreviewParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (AttractorFSPreviewParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (AttractorFSPreviewParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace basicfs
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/autogen/BasicFSDebugRenderParams.h b/APEX_1.4/module/basicfs/include/autogen/BasicFSDebugRenderParams.h
new file mode 100644
index 00000000..3f6dbbbc
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/autogen/BasicFSDebugRenderParams.h
@@ -0,0 +1,251 @@
+// 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_BasicFSDebugRenderParams_h
+#define HEADER_BasicFSDebugRenderParams_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 basicfs
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicFSDebugRenderParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	bool VISUALIZE_JET_FS_ACTOR;
+	bool VISUALIZE_JET_FS_ACTOR_NAME;
+	bool VISUALIZE_JET_FS_SHAPE;
+	bool VISUALIZE_JET_FS_FIELD;
+	bool VISUALIZE_JET_FS_POSE;
+	float JET_FS_FIELD_SCALE;
+	bool VISUALIZE_ATTRACTOR_FS_ACTOR;
+	bool VISUALIZE_ATTRACTOR_FS_ACTOR_NAME;
+	bool VISUALIZE_ATTRACTOR_FS_SHAPE;
+	bool VISUALIZE_ATTRACTOR_FS_FIELD;
+	bool VISUALIZE_ATTRACTOR_FS_POSE;
+	bool VISUALIZE_VORTEX_FS_ACTOR;
+	bool VISUALIZE_VORTEX_FS_ACTOR_NAME;
+	bool VISUALIZE_VORTEX_FS_SHAPE;
+	bool VISUALIZE_VORTEX_FS_FIELD;
+	bool VISUALIZE_VORTEX_FS_POSE;
+	bool VISUALIZE_NOISE_FS_ACTOR;
+	bool VISUALIZE_NOISE_FS_ACTOR_NAME;
+	bool VISUALIZE_NOISE_FS_SHAPE;
+	bool VISUALIZE_NOISE_FS_POSE;
+	bool VISUALIZE_WIND_FS_ACTOR;
+	bool VISUALIZE_WIND_FS_ACTOR_NAME;
+
+};
+
+static const uint32_t checksum[] = { 0xb0169d27, 0x35d0161d, 0xa6b13602, 0x90135fb1, };
+
+} // namespace BasicFSDebugRenderParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicFSDebugRenderParams : public NvParameterized::NvParameters, public BasicFSDebugRenderParamsNS::ParametersStruct
+{
+public:
+	BasicFSDebugRenderParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicFSDebugRenderParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicFSDebugRenderParams");
+	}
+
+	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(BasicFSDebugRenderParamsNS::checksum);
+		return BasicFSDebugRenderParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicFSDebugRenderParamsNS::ParametersStruct& parameters(void) const
+	{
+		BasicFSDebugRenderParams* tmpThis = const_cast<BasicFSDebugRenderParams*>(this);
+		return *(static_cast<BasicFSDebugRenderParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicFSDebugRenderParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicFSDebugRenderParamsNS::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 BasicFSDebugRenderParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicFSDebugRenderParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicFSDebugRenderParams), BasicFSDebugRenderParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicFSDebugRenderParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicFSDebugRenderParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicFSDebugRenderParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicFSDebugRenderParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicFSDebugRenderParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicFSDebugRenderParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicFSDebugRenderParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicFSDebugRenderParams 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 (BasicFSDebugRenderParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicFSDebugRenderParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicFSDebugRenderParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicFSDebugRenderParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicFSDebugRenderParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace basicfs
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/autogen/BasicFSModuleParameters.h b/APEX_1.4/module/basicfs/include/autogen/BasicFSModuleParameters.h
new file mode 100644
index 00000000..28228223
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/autogen/BasicFSModuleParameters.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_BasicFSModuleParameters_h
+#define HEADER_BasicFSModuleParameters_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 basicfs
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicFSModuleParametersNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	uint32_t unused;
+
+};
+
+static const uint32_t checksum[] = { 0x5172e1d0, 0xd8897074, 0x2680816d, 0x73062129, };
+
+} // namespace BasicFSModuleParametersNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicFSModuleParameters : public NvParameterized::NvParameters, public BasicFSModuleParametersNS::ParametersStruct
+{
+public:
+	BasicFSModuleParameters(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicFSModuleParameters();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicFSModuleParameters");
+	}
+
+	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(BasicFSModuleParametersNS::checksum);
+		return BasicFSModuleParametersNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicFSModuleParametersNS::ParametersStruct& parameters(void) const
+	{
+		BasicFSModuleParameters* tmpThis = const_cast<BasicFSModuleParameters*>(this);
+		return *(static_cast<BasicFSModuleParametersNS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicFSModuleParametersNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicFSModuleParametersNS::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 BasicFSModuleParametersFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicFSModuleParameters::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicFSModuleParameters), BasicFSModuleParameters::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicFSModuleParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicFSModuleParameters");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicFSModuleParameters)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicFSModuleParameters)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicFSModuleParameters::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicFSModuleParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicFSModuleParameters");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicFSModuleParameters 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 (BasicFSModuleParameters*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicFSModuleParameters::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicFSModuleParameters::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicFSModuleParameters::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicFSModuleParameters::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace basicfs
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/autogen/JetFSActorParams.h b/APEX_1.4/module/basicfs/include/autogen/JetFSActorParams.h
new file mode 100644
index 00000000..3253b2ba
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/autogen/JetFSActorParams.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_JetFSActorParams_h
+#define HEADER_JetFSActorParams_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 basicfs
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace JetFSActorParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxTransform initialPose;
+	float initialScale;
+	NvParameterized::DummyStringStruct fieldBoundaryFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+
+};
+
+static const uint32_t checksum[] = { 0xa4d1a7f7, 0x7f6decb8, 0x56e05568, 0x7b6ddfd3, };
+
+} // namespace JetFSActorParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class JetFSActorParams : public NvParameterized::NvParameters, public JetFSActorParamsNS::ParametersStruct
+{
+public:
+	JetFSActorParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~JetFSActorParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("JetFSActorParams");
+	}
+
+	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(JetFSActorParamsNS::checksum);
+		return JetFSActorParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const JetFSActorParamsNS::ParametersStruct& parameters(void) const
+	{
+		JetFSActorParams* tmpThis = const_cast<JetFSActorParams*>(this);
+		return *(static_cast<JetFSActorParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	JetFSActorParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<JetFSActorParamsNS::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 JetFSActorParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		JetFSActorParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(JetFSActorParams), JetFSActorParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, JetFSActorParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class JetFSActorParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(JetFSActorParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, JetFSActorParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, JetFSActorParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, JetFSActorParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class JetFSActorParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of JetFSActorParams 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 (JetFSActorParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (JetFSActorParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (JetFSActorParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (JetFSActorParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (JetFSActorParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace basicfs
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/autogen/JetFSAssetParams.h b/APEX_1.4/module/basicfs/include/autogen/JetFSAssetParams.h
new file mode 100644
index 00000000..fc801115
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/autogen/JetFSAssetParams.h
@@ -0,0 +1,254 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_JetFSAssetParams_h
+#define HEADER_JetFSAssetParams_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 basicfs
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace JetFSAssetParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float defaultScale;
+	float boundaryFadePercentage;
+	physx::PxVec3 fieldDirection;
+	float fieldDirectionDeviationAngle;
+	float fieldDirectionOscillationPeriod;
+	float fieldStrength;
+	float fieldStrengthDeviationPercentage;
+	float fieldStrengthOscillationPeriod;
+	float gridShapeRadius;
+	float gridShapeHeight;
+	float gridBoundaryFadePercentage;
+	float nearRadius;
+	float pivotRadius;
+	float farRadius;
+	float directionalStretch;
+	float averageStartDistance;
+	float averageEndDistance;
+	float noisePercentage;
+	float noiseSpaceScale;
+	float noiseTimeScale;
+	uint32_t noiseOctaves;
+	float fieldDragCoeff;
+	float fieldWeight;
+	NvParameterized::DummyStringStruct fieldBoundaryFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+
+};
+
+static const uint32_t checksum[] = { 0x69e560ed, 0x4dd107de, 0x04ab3f89, 0x32270f6f, };
+
+} // namespace JetFSAssetParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class JetFSAssetParams : public NvParameterized::NvParameters, public JetFSAssetParamsNS::ParametersStruct
+{
+public:
+	JetFSAssetParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~JetFSAssetParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("JetFSAssetParams");
+	}
+
+	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(JetFSAssetParamsNS::checksum);
+		return JetFSAssetParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const JetFSAssetParamsNS::ParametersStruct& parameters(void) const
+	{
+		JetFSAssetParams* tmpThis = const_cast<JetFSAssetParams*>(this);
+		return *(static_cast<JetFSAssetParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	JetFSAssetParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<JetFSAssetParamsNS::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 JetFSAssetParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		JetFSAssetParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(JetFSAssetParams), JetFSAssetParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, JetFSAssetParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class JetFSAssetParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(JetFSAssetParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, JetFSAssetParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, JetFSAssetParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, JetFSAssetParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class JetFSAssetParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of JetFSAssetParams 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 (JetFSAssetParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (JetFSAssetParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (JetFSAssetParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (JetFSAssetParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (JetFSAssetParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace basicfs
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/autogen/JetFSPreviewParams.h b/APEX_1.4/module/basicfs/include/autogen/JetFSPreviewParams.h
new file mode 100644
index 00000000..66eb13d4
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/autogen/JetFSPreviewParams.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_JetFSPreviewParams_h
+#define HEADER_JetFSPreviewParams_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 basicfs
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace JetFSPreviewParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxMat44 globalPose;
+	bool drawShape;
+	bool drawAssetInfo;
+	uint64_t userData;
+
+};
+
+static const uint32_t checksum[] = { 0xd4ae1ca1, 0x104c2a39, 0xc7e092cd, 0xc962045f, };
+
+} // namespace JetFSPreviewParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class JetFSPreviewParams : public NvParameterized::NvParameters, public JetFSPreviewParamsNS::ParametersStruct
+{
+public:
+	JetFSPreviewParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~JetFSPreviewParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("JetFSPreviewParams");
+	}
+
+	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(JetFSPreviewParamsNS::checksum);
+		return JetFSPreviewParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const JetFSPreviewParamsNS::ParametersStruct& parameters(void) const
+	{
+		JetFSPreviewParams* tmpThis = const_cast<JetFSPreviewParams*>(this);
+		return *(static_cast<JetFSPreviewParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	JetFSPreviewParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<JetFSPreviewParamsNS::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 JetFSPreviewParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		JetFSPreviewParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(JetFSPreviewParams), JetFSPreviewParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, JetFSPreviewParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class JetFSPreviewParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(JetFSPreviewParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, JetFSPreviewParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, JetFSPreviewParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, JetFSPreviewParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class JetFSPreviewParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of JetFSPreviewParams 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 (JetFSPreviewParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (JetFSPreviewParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (JetFSPreviewParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (JetFSPreviewParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (JetFSPreviewParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace basicfs
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/autogen/ModuleBasicFSRegistration.h b/APEX_1.4/module/basicfs/include/autogen/ModuleBasicFSRegistration.h
new file mode 100644
index 00000000..6c065cb7
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/autogen/ModuleBasicFSRegistration.h
@@ -0,0 +1,162 @@
+/*
+ * 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_MODULEBASICFSREGISTRATIONH_H
+#define MODULE_MODULEBASICFSREGISTRATIONH_H
+
+#include "PsAllocator.h"
+#include "NvRegistrationsForTraitsBase.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "PxAssert.h"
+#include <stdint.h>
+
+// INCLUDE GENERATED FACTORIES
+#include "AttractorFSActorParams.h"
+#include "AttractorFSAssetParams.h"
+#include "AttractorFSPreviewParams.h"
+#include "BasicFSDebugRenderParams.h"
+#include "JetFSActorParams.h"
+#include "JetFSAssetParams.h"
+#include "JetFSPreviewParams.h"
+#include "BasicFSModuleParameters.h"
+#include "NoiseFSActorParams.h"
+#include "NoiseFSAssetParams.h"
+#include "NoiseFSPreviewParams.h"
+#include "VortexFSActorParams.h"
+#include "VortexFSAssetParams.h"
+#include "VortexFSPreviewParams.h"
+#include "WindFSActorParams.h"
+#include "WindFSAssetParams.h"
+#include "WindFSPreviewParams.h"
+
+
+// INCLUDE GENERATED CONVERSION
+
+
+namespace nvidia {
+namespace basicfs {
+
+
+class ModuleBasicFSRegistration : public NvParameterized::RegistrationsForTraitsBase
+{
+public:
+	static void invokeRegistration(NvParameterized::Traits* parameterizedTraits)
+	{
+		if (parameterizedTraits)
+		{
+			ModuleBasicFSRegistration().registerAll(*parameterizedTraits);
+		}
+	}
+
+	static void invokeUnregistration(NvParameterized::Traits* parameterizedTraits)
+	{
+		if (parameterizedTraits)
+		{
+			ModuleBasicFSRegistration().unregisterAll(*parameterizedTraits);
+		}
+	}
+
+	void registerAvailableFactories(NvParameterized::Traits& parameterizedTraits)
+	{
+		::NvParameterized::Factory* factoriesToRegister[] = {
+// REGISTER GENERATED FACTORIES
+			new nvidia::basicfs::AttractorFSActorParamsFactory(),
+			new nvidia::basicfs::AttractorFSAssetParamsFactory(),
+			new nvidia::basicfs::AttractorFSPreviewParamsFactory(),
+			new nvidia::basicfs::BasicFSDebugRenderParamsFactory(),
+			new nvidia::basicfs::JetFSActorParamsFactory(),
+			new nvidia::basicfs::JetFSAssetParamsFactory(),
+			new nvidia::basicfs::JetFSPreviewParamsFactory(),
+			new nvidia::basicfs::BasicFSModuleParametersFactory(),
+			new nvidia::basicfs::NoiseFSActorParamsFactory(),
+			new nvidia::basicfs::NoiseFSAssetParamsFactory(),
+			new nvidia::basicfs::NoiseFSPreviewParamsFactory(),
+			new nvidia::basicfs::VortexFSActorParamsFactory(),
+			new nvidia::basicfs::VortexFSAssetParamsFactory(),
+			new nvidia::basicfs::VortexFSPreviewParamsFactory(),
+			new nvidia::basicfs::WindFSActorParamsFactory(),
+			new nvidia::basicfs::WindFSAssetParamsFactory(),
+			new nvidia::basicfs::WindFSPreviewParamsFactory(),
+
+		};
+
+		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::basicfs::AttractorFSActorParamsFactory(),
+			new nvidia::basicfs::AttractorFSAssetParamsFactory(),
+			new nvidia::basicfs::AttractorFSPreviewParamsFactory(),
+			new nvidia::basicfs::BasicFSDebugRenderParamsFactory(),
+			new nvidia::basicfs::JetFSActorParamsFactory(),
+			new nvidia::basicfs::JetFSAssetParamsFactory(),
+			new nvidia::basicfs::JetFSPreviewParamsFactory(),
+			new nvidia::basicfs::BasicFSModuleParametersFactory(),
+			new nvidia::basicfs::NoiseFSActorParamsFactory(),
+			new nvidia::basicfs::NoiseFSAssetParamsFactory(),
+			new nvidia::basicfs::NoiseFSPreviewParamsFactory(),
+			new nvidia::basicfs::VortexFSActorParamsFactory(),
+			new nvidia::basicfs::VortexFSAssetParamsFactory(),
+			new nvidia::basicfs::VortexFSPreviewParamsFactory(),
+			new nvidia::basicfs::WindFSActorParamsFactory(),
+			new nvidia::basicfs::WindFSAssetParamsFactory(),
+			new nvidia::basicfs::WindFSPreviewParamsFactory(),
+
+		};
+
+		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::basicfs
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/autogen/NoiseFSActorParams.h b/APEX_1.4/module/basicfs/include/autogen/NoiseFSActorParams.h
new file mode 100644
index 00000000..ac8f4171
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/autogen/NoiseFSActorParams.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_NoiseFSActorParams_h
+#define HEADER_NoiseFSActorParams_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 basicfs
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace NoiseFSActorParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxTransform initialPose;
+	float initialScale;
+	NvParameterized::DummyStringStruct fieldBoundaryFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+
+};
+
+static const uint32_t checksum[] = { 0xe4c90c5a, 0x15924053, 0x3469b7ba, 0xb14315a6, };
+
+} // namespace NoiseFSActorParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class NoiseFSActorParams : public NvParameterized::NvParameters, public NoiseFSActorParamsNS::ParametersStruct
+{
+public:
+	NoiseFSActorParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~NoiseFSActorParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("NoiseFSActorParams");
+	}
+
+	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(NoiseFSActorParamsNS::checksum);
+		return NoiseFSActorParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const NoiseFSActorParamsNS::ParametersStruct& parameters(void) const
+	{
+		NoiseFSActorParams* tmpThis = const_cast<NoiseFSActorParams*>(this);
+		return *(static_cast<NoiseFSActorParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	NoiseFSActorParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<NoiseFSActorParamsNS::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 NoiseFSActorParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		NoiseFSActorParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(NoiseFSActorParams), NoiseFSActorParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, NoiseFSActorParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class NoiseFSActorParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(NoiseFSActorParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, NoiseFSActorParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, NoiseFSActorParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, NoiseFSActorParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class NoiseFSActorParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of NoiseFSActorParams 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 (NoiseFSActorParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (NoiseFSActorParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (NoiseFSActorParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (NoiseFSActorParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (NoiseFSActorParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace basicfs
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/autogen/NoiseFSAssetParams.h b/APEX_1.4/module/basicfs/include/autogen/NoiseFSAssetParams.h
new file mode 100644
index 00000000..734ecc4b
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/autogen/NoiseFSAssetParams.h
@@ -0,0 +1,247 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_NoiseFSAssetParams_h
+#define HEADER_NoiseFSAssetParams_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 basicfs
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace NoiseFSAssetParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float defaultScale;
+	physx::PxVec3 boundarySize;
+	float boundaryFadePercentage;
+	const char* fieldType;
+	float fieldDragCoeff;
+	float fieldWeight;
+	const char* noiseType;
+	uint32_t noiseSeed;
+	float noiseStrength;
+	physx::PxVec3 noiseSpacePeriod;
+	float noiseTimePeriod;
+	uint32_t noiseOctaves;
+	float noiseStrengthOctaveMultiplier;
+	physx::PxVec3 noiseSpacePeriodOctaveMultiplier;
+	float noiseTimePeriodOctaveMultiplier;
+	NvParameterized::DummyStringStruct fieldBoundaryFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+	bool useLocalSpace;
+
+};
+
+static const uint32_t checksum[] = { 0xd5a49209, 0xd5e62b90, 0x73aa7e86, 0xd57406b3, };
+
+} // namespace NoiseFSAssetParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class NoiseFSAssetParams : public NvParameterized::NvParameters, public NoiseFSAssetParamsNS::ParametersStruct
+{
+public:
+	NoiseFSAssetParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~NoiseFSAssetParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("NoiseFSAssetParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)2;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(NoiseFSAssetParamsNS::checksum);
+		return NoiseFSAssetParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const NoiseFSAssetParamsNS::ParametersStruct& parameters(void) const
+	{
+		NoiseFSAssetParams* tmpThis = const_cast<NoiseFSAssetParams*>(this);
+		return *(static_cast<NoiseFSAssetParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	NoiseFSAssetParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<NoiseFSAssetParamsNS::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 NoiseFSAssetParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		NoiseFSAssetParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(NoiseFSAssetParams), NoiseFSAssetParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, NoiseFSAssetParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class NoiseFSAssetParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(NoiseFSAssetParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, NoiseFSAssetParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, NoiseFSAssetParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, NoiseFSAssetParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class NoiseFSAssetParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of NoiseFSAssetParams 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 (NoiseFSAssetParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (NoiseFSAssetParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (NoiseFSAssetParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (NoiseFSAssetParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (NoiseFSAssetParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace basicfs
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/autogen/NoiseFSPreviewParams.h b/APEX_1.4/module/basicfs/include/autogen/NoiseFSPreviewParams.h
new file mode 100644
index 00000000..4e62be90
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/autogen/NoiseFSPreviewParams.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_NoiseFSPreviewParams_h
+#define HEADER_NoiseFSPreviewParams_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 basicfs
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace NoiseFSPreviewParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxMat44 globalPose;
+	bool drawShape;
+	bool drawAssetInfo;
+	uint64_t userData;
+
+};
+
+static const uint32_t checksum[] = { 0x4c188363, 0x012fd224, 0x5689640e, 0x104914de, };
+
+} // namespace NoiseFSPreviewParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class NoiseFSPreviewParams : public NvParameterized::NvParameters, public NoiseFSPreviewParamsNS::ParametersStruct
+{
+public:
+	NoiseFSPreviewParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~NoiseFSPreviewParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("NoiseFSPreviewParams");
+	}
+
+	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(NoiseFSPreviewParamsNS::checksum);
+		return NoiseFSPreviewParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const NoiseFSPreviewParamsNS::ParametersStruct& parameters(void) const
+	{
+		NoiseFSPreviewParams* tmpThis = const_cast<NoiseFSPreviewParams*>(this);
+		return *(static_cast<NoiseFSPreviewParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	NoiseFSPreviewParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<NoiseFSPreviewParamsNS::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 NoiseFSPreviewParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		NoiseFSPreviewParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(NoiseFSPreviewParams), NoiseFSPreviewParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, NoiseFSPreviewParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class NoiseFSPreviewParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(NoiseFSPreviewParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, NoiseFSPreviewParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, NoiseFSPreviewParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, NoiseFSPreviewParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class NoiseFSPreviewParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of NoiseFSPreviewParams 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 (NoiseFSPreviewParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (NoiseFSPreviewParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (NoiseFSPreviewParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (NoiseFSPreviewParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (NoiseFSPreviewParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace basicfs
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/autogen/VortexFSActorParams.h b/APEX_1.4/module/basicfs/include/autogen/VortexFSActorParams.h
new file mode 100644
index 00000000..89218f0b
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/autogen/VortexFSActorParams.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_VortexFSActorParams_h
+#define HEADER_VortexFSActorParams_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 basicfs
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace VortexFSActorParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxTransform initialPose;
+	float initialScale;
+	NvParameterized::DummyStringStruct fieldBoundaryFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+
+};
+
+static const uint32_t checksum[] = { 0x6551fe7f, 0xf22a11ba, 0x548415b0, 0xe1409901, };
+
+} // namespace VortexFSActorParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class VortexFSActorParams : public NvParameterized::NvParameters, public VortexFSActorParamsNS::ParametersStruct
+{
+public:
+	VortexFSActorParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~VortexFSActorParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("VortexFSActorParams");
+	}
+
+	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(VortexFSActorParamsNS::checksum);
+		return VortexFSActorParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const VortexFSActorParamsNS::ParametersStruct& parameters(void) const
+	{
+		VortexFSActorParams* tmpThis = const_cast<VortexFSActorParams*>(this);
+		return *(static_cast<VortexFSActorParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	VortexFSActorParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<VortexFSActorParamsNS::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 VortexFSActorParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		VortexFSActorParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(VortexFSActorParams), VortexFSActorParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, VortexFSActorParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VortexFSActorParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(VortexFSActorParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, VortexFSActorParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, VortexFSActorParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, VortexFSActorParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VortexFSActorParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of VortexFSActorParams 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 (VortexFSActorParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (VortexFSActorParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (VortexFSActorParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (VortexFSActorParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (VortexFSActorParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace basicfs
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/autogen/VortexFSAssetParams.h b/APEX_1.4/module/basicfs/include/autogen/VortexFSAssetParams.h
new file mode 100644
index 00000000..1a53d0ed
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/autogen/VortexFSAssetParams.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_VortexFSAssetParams_h
+#define HEADER_VortexFSAssetParams_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 basicfs
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace VortexFSAssetParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float boundaryFadePercentage;
+	physx::PxVec3 axis;
+	bool bottomSphericalForce;
+	bool topSphericalForce;
+	float height;
+	float bottomRadius;
+	float topRadius;
+	float rotationalStrength;
+	float radialStrength;
+	float liftStrength;
+	float fieldDragCoeff;
+	float fieldWeight;
+	NvParameterized::DummyStringStruct fieldBoundaryFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+
+};
+
+static const uint32_t checksum[] = { 0x14505c9d, 0xbc126a67, 0x5ee6862c, 0x8b6bbbf2, };
+
+} // namespace VortexFSAssetParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class VortexFSAssetParams : public NvParameterized::NvParameters, public VortexFSAssetParamsNS::ParametersStruct
+{
+public:
+	VortexFSAssetParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~VortexFSAssetParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("VortexFSAssetParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)2;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(VortexFSAssetParamsNS::checksum);
+		return VortexFSAssetParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const VortexFSAssetParamsNS::ParametersStruct& parameters(void) const
+	{
+		VortexFSAssetParams* tmpThis = const_cast<VortexFSAssetParams*>(this);
+		return *(static_cast<VortexFSAssetParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	VortexFSAssetParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<VortexFSAssetParamsNS::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 VortexFSAssetParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		VortexFSAssetParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(VortexFSAssetParams), VortexFSAssetParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, VortexFSAssetParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VortexFSAssetParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(VortexFSAssetParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, VortexFSAssetParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, VortexFSAssetParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, VortexFSAssetParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VortexFSAssetParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of VortexFSAssetParams 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 (VortexFSAssetParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (VortexFSAssetParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (VortexFSAssetParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (VortexFSAssetParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (VortexFSAssetParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace basicfs
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/autogen/VortexFSPreviewParams.h b/APEX_1.4/module/basicfs/include/autogen/VortexFSPreviewParams.h
new file mode 100644
index 00000000..5d210a2b
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/autogen/VortexFSPreviewParams.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_VortexFSPreviewParams_h
+#define HEADER_VortexFSPreviewParams_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 basicfs
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace VortexFSPreviewParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxMat44 globalPose;
+	bool drawShape;
+	bool drawAssetInfo;
+	uint64_t userData;
+
+};
+
+static const uint32_t checksum[] = { 0xbc265cbc, 0xf8125270, 0x2746f91e, 0xf4e63077, };
+
+} // namespace VortexFSPreviewParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class VortexFSPreviewParams : public NvParameterized::NvParameters, public VortexFSPreviewParamsNS::ParametersStruct
+{
+public:
+	VortexFSPreviewParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~VortexFSPreviewParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("VortexFSPreviewParams");
+	}
+
+	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(VortexFSPreviewParamsNS::checksum);
+		return VortexFSPreviewParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const VortexFSPreviewParamsNS::ParametersStruct& parameters(void) const
+	{
+		VortexFSPreviewParams* tmpThis = const_cast<VortexFSPreviewParams*>(this);
+		return *(static_cast<VortexFSPreviewParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	VortexFSPreviewParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<VortexFSPreviewParamsNS::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 VortexFSPreviewParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		VortexFSPreviewParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(VortexFSPreviewParams), VortexFSPreviewParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, VortexFSPreviewParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VortexFSPreviewParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(VortexFSPreviewParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, VortexFSPreviewParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, VortexFSPreviewParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, VortexFSPreviewParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VortexFSPreviewParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of VortexFSPreviewParams 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 (VortexFSPreviewParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (VortexFSPreviewParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (VortexFSPreviewParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (VortexFSPreviewParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (VortexFSPreviewParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace basicfs
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/autogen/WindFSActorParams.h b/APEX_1.4/module/basicfs/include/autogen/WindFSActorParams.h
new file mode 100644
index 00000000..00e75b12
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/autogen/WindFSActorParams.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_WindFSActorParams_h
+#define HEADER_WindFSActorParams_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 basicfs
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace WindFSActorParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxTransform initialPose;
+	float initialScale;
+	NvParameterized::DummyStringStruct fieldBoundaryFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+
+};
+
+static const uint32_t checksum[] = { 0xfbbdce26, 0x591f9e00, 0xc2836d8a, 0x30d980f8, };
+
+} // namespace WindFSActorParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class WindFSActorParams : public NvParameterized::NvParameters, public WindFSActorParamsNS::ParametersStruct
+{
+public:
+	WindFSActorParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~WindFSActorParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("WindFSActorParams");
+	}
+
+	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(WindFSActorParamsNS::checksum);
+		return WindFSActorParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const WindFSActorParamsNS::ParametersStruct& parameters(void) const
+	{
+		WindFSActorParams* tmpThis = const_cast<WindFSActorParams*>(this);
+		return *(static_cast<WindFSActorParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	WindFSActorParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<WindFSActorParamsNS::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 WindFSActorParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		WindFSActorParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(WindFSActorParams), WindFSActorParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, WindFSActorParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class WindFSActorParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(WindFSActorParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, WindFSActorParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, WindFSActorParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, WindFSActorParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class WindFSActorParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of WindFSActorParams 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 (WindFSActorParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (WindFSActorParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (WindFSActorParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (WindFSActorParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (WindFSActorParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace basicfs
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/autogen/WindFSAssetParams.h b/APEX_1.4/module/basicfs/include/autogen/WindFSAssetParams.h
new file mode 100644
index 00000000..e1c77e99
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/autogen/WindFSAssetParams.h
@@ -0,0 +1,239 @@
+// 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_WindFSAssetParams_h
+#define HEADER_WindFSAssetParams_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 basicfs
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace WindFSAssetParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxVec3 fieldDirection;
+	float fieldDirectionDeviationAngle;
+	float fieldDirectionOscillationPeriod;
+	float fieldStrength;
+	float fieldStrengthDeviationPercentage;
+	float fieldStrengthOscillationPeriod;
+	float fieldDragCoeff;
+	float fieldWeight;
+	NvParameterized::DummyStringStruct fieldBoundaryFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+
+};
+
+static const uint32_t checksum[] = { 0x3e5a69fc, 0x251178a3, 0x76c98ef0, 0x28e1658a, };
+
+} // namespace WindFSAssetParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class WindFSAssetParams : public NvParameterized::NvParameters, public WindFSAssetParamsNS::ParametersStruct
+{
+public:
+	WindFSAssetParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~WindFSAssetParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("WindFSAssetParams");
+	}
+
+	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(WindFSAssetParamsNS::checksum);
+		return WindFSAssetParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const WindFSAssetParamsNS::ParametersStruct& parameters(void) const
+	{
+		WindFSAssetParams* tmpThis = const_cast<WindFSAssetParams*>(this);
+		return *(static_cast<WindFSAssetParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	WindFSAssetParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<WindFSAssetParamsNS::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 WindFSAssetParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		WindFSAssetParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(WindFSAssetParams), WindFSAssetParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, WindFSAssetParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class WindFSAssetParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(WindFSAssetParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, WindFSAssetParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, WindFSAssetParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, WindFSAssetParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class WindFSAssetParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of WindFSAssetParams 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 (WindFSAssetParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (WindFSAssetParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (WindFSAssetParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (WindFSAssetParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (WindFSAssetParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace basicfs
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicfs/include/autogen/WindFSPreviewParams.h b/APEX_1.4/module/basicfs/include/autogen/WindFSPreviewParams.h
new file mode 100644
index 00000000..913f6010
--- /dev/null
+++ b/APEX_1.4/module/basicfs/include/autogen/WindFSPreviewParams.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_WindFSPreviewParams_h
+#define HEADER_WindFSPreviewParams_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 basicfs
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace WindFSPreviewParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxMat44 globalPose;
+	bool drawAssetInfo;
+	uint64_t userData;
+
+};
+
+static const uint32_t checksum[] = { 0xb4818bbc, 0x84a817f6, 0x02ddad4a, 0x91a3c5ec, };
+
+} // namespace WindFSPreviewParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class WindFSPreviewParams : public NvParameterized::NvParameters, public WindFSPreviewParamsNS::ParametersStruct
+{
+public:
+	WindFSPreviewParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~WindFSPreviewParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("WindFSPreviewParams");
+	}
+
+	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(WindFSPreviewParamsNS::checksum);
+		return WindFSPreviewParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const WindFSPreviewParamsNS::ParametersStruct& parameters(void) const
+	{
+		WindFSPreviewParams* tmpThis = const_cast<WindFSPreviewParams*>(this);
+		return *(static_cast<WindFSPreviewParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	WindFSPreviewParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<WindFSPreviewParamsNS::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 WindFSPreviewParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		WindFSPreviewParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(WindFSPreviewParams), WindFSPreviewParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, WindFSPreviewParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class WindFSPreviewParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(WindFSPreviewParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, WindFSPreviewParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, WindFSPreviewParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, WindFSPreviewParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class WindFSPreviewParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of WindFSPreviewParams 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 (WindFSPreviewParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (WindFSPreviewParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (WindFSPreviewParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (WindFSPreviewParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (WindFSPreviewParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace basicfs
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif