Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

18 files changed, 4192 insertions, 0 deletions

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