Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

17 files changed, 4079 insertions, 0 deletions

diff --git a/APEX_1.4/module/emitter/include/autogen/ApexEmitterActorParameters.h b/APEX_1.4/module/emitter/include/autogen/ApexEmitterActorParameters.h
new file mode 100644
index 00000000..1a3b2a2e
--- /dev/null
+++ b/APEX_1.4/module/emitter/include/autogen/ApexEmitterActorParameters.h
@@ -0,0 +1,236 @@
+// 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_ApexEmitterActorParameters_h
+#define HEADER_ApexEmitterActorParameters_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 emitter
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ApexEmitterActorParametersNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxTransform initialPose;
+	float initialScale;
+	physx::PxTransform attachRelativePose;
+	bool emitAssetParticles;
+	NvParameterized::DummyStringStruct overlapTestGroupMaskName;
+	NvParameterized::DummyStringStruct overlapTestGroupsMask128Name;
+	float emitterDuration;
+
+};
+
+static const uint32_t checksum[] = { 0x8bce9917, 0xda429410, 0xa3ec8f9b, 0x8e2223cf, };
+
+} // namespace ApexEmitterActorParametersNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ApexEmitterActorParameters : public NvParameterized::NvParameters, public ApexEmitterActorParametersNS::ParametersStruct
+{
+public:
+	ApexEmitterActorParameters(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ApexEmitterActorParameters();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ApexEmitterActorParameters");
+	}
+
+	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(ApexEmitterActorParametersNS::checksum);
+		return ApexEmitterActorParametersNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ApexEmitterActorParametersNS::ParametersStruct& parameters(void) const
+	{
+		ApexEmitterActorParameters* tmpThis = const_cast<ApexEmitterActorParameters*>(this);
+		return *(static_cast<ApexEmitterActorParametersNS::ParametersStruct*>(tmpThis));
+	}
+
+	ApexEmitterActorParametersNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ApexEmitterActorParametersNS::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 ApexEmitterActorParametersFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ApexEmitterActorParameters::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ApexEmitterActorParameters), ApexEmitterActorParameters::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ApexEmitterActorParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ApexEmitterActorParameters");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ApexEmitterActorParameters)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ApexEmitterActorParameters)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ApexEmitterActorParameters::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ApexEmitterActorParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ApexEmitterActorParameters");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ApexEmitterActorParameters 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 (ApexEmitterActorParameters*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ApexEmitterActorParameters::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ApexEmitterActorParameters::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ApexEmitterActorParameters::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ApexEmitterActorParameters::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace emitter
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/emitter/include/autogen/ApexEmitterAssetParameters.h b/APEX_1.4/module/emitter/include/autogen/ApexEmitterAssetParameters.h
new file mode 100644
index 00000000..accfc5e8
--- /dev/null
+++ b/APEX_1.4/module/emitter/include/autogen/ApexEmitterAssetParameters.h
@@ -0,0 +1,269 @@
+// 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_ApexEmitterAssetParameters_h
+#define HEADER_ApexEmitterAssetParameters_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 emitter
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ApexEmitterAssetParametersNS
+{
+
+struct emitterLodParamDesc_Type;
+struct rateVsTimeCurvePoint_Type;
+
+struct rateVsTimeCurvePoint_DynamicArray1D_Type
+{
+	rateVsTimeCurvePoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct emitterLodParamDesc_Type
+{
+	uint32_t version;
+	float maxDistance;
+	float distanceWeight;
+	float speedWeight;
+	float lifeWeight;
+	float separationWeight;
+	float bias;
+};
+struct rateVsTimeCurvePoint_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	float density;
+	float rate;
+	float lifetimeLow;
+	float lifetimeHigh;
+	physx::PxVec3 velocityLow;
+	physx::PxVec3 velocityHigh;
+	uint32_t maxSamples;
+	emitterLodParamDesc_Type lodParamDesc;
+	NvParameterized::Interface* iofxAssetName;
+	NvParameterized::Interface* iosAssetName;
+	NvParameterized::Interface* geometryType;
+	float emitterDuration;
+	float emitterVelocityScale;
+	uint32_t minSamplingFPS;
+	rateVsTimeCurvePoint_DynamicArray1D_Type rateVsTimeCurvePoints;
+
+};
+
+static const uint32_t checksum[] = { 0x1835d790, 0xa1bfdb02, 0xf76e9154, 0xae351ee1, };
+
+} // namespace ApexEmitterAssetParametersNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ApexEmitterAssetParameters : public NvParameterized::NvParameters, public ApexEmitterAssetParametersNS::ParametersStruct
+{
+public:
+	ApexEmitterAssetParameters(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ApexEmitterAssetParameters();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ApexEmitterAssetParameters");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)8;
+
+	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(ApexEmitterAssetParametersNS::checksum);
+		return ApexEmitterAssetParametersNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ApexEmitterAssetParametersNS::ParametersStruct& parameters(void) const
+	{
+		ApexEmitterAssetParameters* tmpThis = const_cast<ApexEmitterAssetParameters*>(this);
+		return *(static_cast<ApexEmitterAssetParametersNS::ParametersStruct*>(tmpThis));
+	}
+
+	ApexEmitterAssetParametersNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ApexEmitterAssetParametersNS::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 ApexEmitterAssetParametersFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ApexEmitterAssetParameters::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ApexEmitterAssetParameters), ApexEmitterAssetParameters::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ApexEmitterAssetParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ApexEmitterAssetParameters");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ApexEmitterAssetParameters)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ApexEmitterAssetParameters)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ApexEmitterAssetParameters::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ApexEmitterAssetParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ApexEmitterAssetParameters");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ApexEmitterAssetParameters 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 (ApexEmitterAssetParameters*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ApexEmitterAssetParameters::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ApexEmitterAssetParameters::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ApexEmitterAssetParameters::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ApexEmitterAssetParameters::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace emitter
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/emitter/include/autogen/EmitterAssetPreviewParameters.h b/APEX_1.4/module/emitter/include/autogen/EmitterAssetPreviewParameters.h
new file mode 100644
index 00000000..eb5367d0
--- /dev/null
+++ b/APEX_1.4/module/emitter/include/autogen/EmitterAssetPreviewParameters.h
@@ -0,0 +1,231 @@
+// 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_EmitterAssetPreviewParameters_h
+#define HEADER_EmitterAssetPreviewParameters_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 emitter
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EmitterAssetPreviewParametersNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxTransform pose;
+	float scale;
+
+};
+
+static const uint32_t checksum[] = { 0x13ebeb0d, 0xd2df2f41, 0x19fe6d06, 0x63eac053, };
+
+} // namespace EmitterAssetPreviewParametersNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EmitterAssetPreviewParameters : public NvParameterized::NvParameters, public EmitterAssetPreviewParametersNS::ParametersStruct
+{
+public:
+	EmitterAssetPreviewParameters(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EmitterAssetPreviewParameters();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EmitterAssetPreviewParameters");
+	}
+
+	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(EmitterAssetPreviewParametersNS::checksum);
+		return EmitterAssetPreviewParametersNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EmitterAssetPreviewParametersNS::ParametersStruct& parameters(void) const
+	{
+		EmitterAssetPreviewParameters* tmpThis = const_cast<EmitterAssetPreviewParameters*>(this);
+		return *(static_cast<EmitterAssetPreviewParametersNS::ParametersStruct*>(tmpThis));
+	}
+
+	EmitterAssetPreviewParametersNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EmitterAssetPreviewParametersNS::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 EmitterAssetPreviewParametersFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EmitterAssetPreviewParameters::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EmitterAssetPreviewParameters), EmitterAssetPreviewParameters::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EmitterAssetPreviewParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterAssetPreviewParameters");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EmitterAssetPreviewParameters)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EmitterAssetPreviewParameters)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EmitterAssetPreviewParameters::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EmitterAssetPreviewParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterAssetPreviewParameters");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EmitterAssetPreviewParameters 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 (EmitterAssetPreviewParameters*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EmitterAssetPreviewParameters::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EmitterAssetPreviewParameters::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EmitterAssetPreviewParameters::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EmitterAssetPreviewParameters::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace emitter
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/emitter/include/autogen/EmitterDebugRenderParams.h b/APEX_1.4/module/emitter/include/autogen/EmitterDebugRenderParams.h
new file mode 100644
index 00000000..d6b52119
--- /dev/null
+++ b/APEX_1.4/module/emitter/include/autogen/EmitterDebugRenderParams.h
@@ -0,0 +1,260 @@
+// 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_EmitterDebugRenderParams_h
+#define HEADER_EmitterDebugRenderParams_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 emitter
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EmitterDebugRenderParamsNS
+{
+
+struct ApexEmitterParameters_Type;
+struct GroundEmitterParameters_Type;
+struct ImpactEmitterParameters_Type;
+
+struct ApexEmitterParameters_Type
+{
+	bool VISUALIZE_APEX_EMITTER_ACTOR;
+	bool VISUALIZE_TOTAL_INJECTED_AABB;
+	bool VISUALIZE_APEX_EMITTER_ACTOR_POSE;
+	float THRESHOLD_DISTANCE_APEX_EMITTER_ACTOR_POSE;
+	bool VISUALIZE_APEX_EMITTER_ACTOR_NAME;
+	float THRESHOLD_DISTANCE_APEX_EMITTER_ACTOR_NAME;
+};
+struct GroundEmitterParameters_Type
+{
+	bool VISUALIZE_GROUND_EMITTER_ACTOR;
+	bool VISUALIZE_GROUND_EMITTER_SPHERE;
+	bool VISUALIZE_GROUND_EMITTER_GRID;
+	bool VISUALIZE_GROUND_EMITTER_RAYCAST;
+	bool VISUALIZE_GROUND_EMITTER_ACTOR_POSE;
+	bool VISUALIZE_GROUND_EMITTER_ACTOR_NAME;
+};
+struct ImpactEmitterParameters_Type
+{
+	bool VISUALIZE_IMPACT_EMITTER_ACTOR;
+	bool VISUALIZE_IMPACT_EMITTER_RAYCAST;
+	bool VISUALIZE_IMPACT_EMITTER_ACTOR_NAME;
+	float THRESHOLD_DISTANCE_IMPACT_EMITTER_ACTOR_NAME;
+};
+
+struct ParametersStruct
+{
+
+	ApexEmitterParameters_Type apexEmitterParameters;
+	GroundEmitterParameters_Type groundEmitterParameters;
+	ImpactEmitterParameters_Type impactEmitterParameters;
+
+};
+
+static const uint32_t checksum[] = { 0xbb1ad1fe, 0xd2ead5bd, 0x3bbab888, 0x61ee4e9a, };
+
+} // namespace EmitterDebugRenderParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EmitterDebugRenderParams : public NvParameterized::NvParameters, public EmitterDebugRenderParamsNS::ParametersStruct
+{
+public:
+	EmitterDebugRenderParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EmitterDebugRenderParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EmitterDebugRenderParams");
+	}
+
+	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(EmitterDebugRenderParamsNS::checksum);
+		return EmitterDebugRenderParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EmitterDebugRenderParamsNS::ParametersStruct& parameters(void) const
+	{
+		EmitterDebugRenderParams* tmpThis = const_cast<EmitterDebugRenderParams*>(this);
+		return *(static_cast<EmitterDebugRenderParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	EmitterDebugRenderParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EmitterDebugRenderParamsNS::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 EmitterDebugRenderParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EmitterDebugRenderParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EmitterDebugRenderParams), EmitterDebugRenderParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EmitterDebugRenderParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterDebugRenderParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EmitterDebugRenderParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EmitterDebugRenderParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EmitterDebugRenderParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EmitterDebugRenderParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterDebugRenderParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EmitterDebugRenderParams 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 (EmitterDebugRenderParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EmitterDebugRenderParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EmitterDebugRenderParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EmitterDebugRenderParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EmitterDebugRenderParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace emitter
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/emitter/include/autogen/EmitterGeomBoxParams.h b/APEX_1.4/module/emitter/include/autogen/EmitterGeomBoxParams.h
new file mode 100644
index 00000000..c1ef1e56
--- /dev/null
+++ b/APEX_1.4/module/emitter/include/autogen/EmitterGeomBoxParams.h
@@ -0,0 +1,231 @@
+// 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_EmitterGeomBoxParams_h
+#define HEADER_EmitterGeomBoxParams_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 emitter
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EmitterGeomBoxParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	const char* emitterType;
+	physx::PxVec3 extents;
+
+};
+
+static const uint32_t checksum[] = { 0x27d775c2, 0xfe93d203, 0xcf7ddf42, 0x77074efc, };
+
+} // namespace EmitterGeomBoxParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EmitterGeomBoxParams : public NvParameterized::NvParameters, public EmitterGeomBoxParamsNS::ParametersStruct
+{
+public:
+	EmitterGeomBoxParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EmitterGeomBoxParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EmitterGeomBoxParams");
+	}
+
+	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(EmitterGeomBoxParamsNS::checksum);
+		return EmitterGeomBoxParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EmitterGeomBoxParamsNS::ParametersStruct& parameters(void) const
+	{
+		EmitterGeomBoxParams* tmpThis = const_cast<EmitterGeomBoxParams*>(this);
+		return *(static_cast<EmitterGeomBoxParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	EmitterGeomBoxParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EmitterGeomBoxParamsNS::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 EmitterGeomBoxParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EmitterGeomBoxParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EmitterGeomBoxParams), EmitterGeomBoxParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EmitterGeomBoxParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterGeomBoxParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EmitterGeomBoxParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EmitterGeomBoxParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EmitterGeomBoxParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EmitterGeomBoxParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterGeomBoxParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EmitterGeomBoxParams 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 (EmitterGeomBoxParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EmitterGeomBoxParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EmitterGeomBoxParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EmitterGeomBoxParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EmitterGeomBoxParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace emitter
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/emitter/include/autogen/EmitterGeomCylinderParams.h b/APEX_1.4/module/emitter/include/autogen/EmitterGeomCylinderParams.h
new file mode 100644
index 00000000..3edf8bfe
--- /dev/null
+++ b/APEX_1.4/module/emitter/include/autogen/EmitterGeomCylinderParams.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_EmitterGeomCylinderParams_h
+#define HEADER_EmitterGeomCylinderParams_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 emitter
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EmitterGeomCylinderParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	const char* emitterType;
+	float radius;
+	float height;
+
+};
+
+static const uint32_t checksum[] = { 0xeb300980, 0x72a774b1, 0xa1ae40e5, 0xb586df5e, };
+
+} // namespace EmitterGeomCylinderParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EmitterGeomCylinderParams : public NvParameterized::NvParameters, public EmitterGeomCylinderParamsNS::ParametersStruct
+{
+public:
+	EmitterGeomCylinderParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EmitterGeomCylinderParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EmitterGeomCylinderParams");
+	}
+
+	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(EmitterGeomCylinderParamsNS::checksum);
+		return EmitterGeomCylinderParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EmitterGeomCylinderParamsNS::ParametersStruct& parameters(void) const
+	{
+		EmitterGeomCylinderParams* tmpThis = const_cast<EmitterGeomCylinderParams*>(this);
+		return *(static_cast<EmitterGeomCylinderParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	EmitterGeomCylinderParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EmitterGeomCylinderParamsNS::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 EmitterGeomCylinderParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EmitterGeomCylinderParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EmitterGeomCylinderParams), EmitterGeomCylinderParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EmitterGeomCylinderParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterGeomCylinderParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EmitterGeomCylinderParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EmitterGeomCylinderParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EmitterGeomCylinderParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EmitterGeomCylinderParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterGeomCylinderParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EmitterGeomCylinderParams 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 (EmitterGeomCylinderParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EmitterGeomCylinderParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EmitterGeomCylinderParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EmitterGeomCylinderParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EmitterGeomCylinderParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace emitter
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/emitter/include/autogen/EmitterGeomExplicitParams.h b/APEX_1.4/module/emitter/include/autogen/EmitterGeomExplicitParams.h
new file mode 100644
index 00000000..d7fb5575
--- /dev/null
+++ b/APEX_1.4/module/emitter/include/autogen/EmitterGeomExplicitParams.h
@@ -0,0 +1,305 @@
+// 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_EmitterGeomExplicitParams_h
+#define HEADER_EmitterGeomExplicitParams_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 emitter
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EmitterGeomExplicitParamsNS
+{
+
+struct PointParams_Type;
+struct ExplicitPoints_Type;
+struct SphereParams_Type;
+struct ExplicitSpheres_Type;
+struct EllipsoidParams_Type;
+struct ExplicitEllipsoids_Type;
+
+struct PointParams_DynamicArray1D_Type
+{
+	PointParams_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct VEC3_DynamicArray1D_Type
+{
+	physx::PxVec3* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct SphereParams_DynamicArray1D_Type
+{
+	SphereParams_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct EllipsoidParams_DynamicArray1D_Type
+{
+	EllipsoidParams_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct PointParams_Type
+{
+	physx::PxVec3 position;
+	bool doDetectOverlaps;
+};
+struct ExplicitPoints_Type
+{
+	PointParams_DynamicArray1D_Type positions;
+	VEC3_DynamicArray1D_Type velocities;
+};
+struct SphereParams_Type
+{
+	physx::PxVec3 center;
+	float radius;
+	bool doDetectOverlaps;
+};
+struct EllipsoidParams_Type
+{
+	physx::PxVec3 center;
+	float radius;
+	physx::PxVec3 normal;
+	float polarRadius;
+	bool doDetectOverlaps;
+};
+struct ExplicitEllipsoids_Type
+{
+	EllipsoidParams_DynamicArray1D_Type positions;
+	VEC3_DynamicArray1D_Type velocities;
+};
+struct ExplicitSpheres_Type
+{
+	SphereParams_DynamicArray1D_Type positions;
+	VEC3_DynamicArray1D_Type velocities;
+};
+
+struct ParametersStruct
+{
+
+	float distance;
+	ExplicitPoints_Type points;
+	ExplicitSpheres_Type spheres;
+	ExplicitEllipsoids_Type ellipsoids;
+
+};
+
+static const uint32_t checksum[] = { 0xe09894f3, 0xce4efef3, 0x4e950875, 0x6ea40ff1, };
+
+} // namespace EmitterGeomExplicitParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EmitterGeomExplicitParams : public NvParameterized::NvParameters, public EmitterGeomExplicitParamsNS::ParametersStruct
+{
+public:
+	EmitterGeomExplicitParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EmitterGeomExplicitParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EmitterGeomExplicitParams");
+	}
+
+	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(EmitterGeomExplicitParamsNS::checksum);
+		return EmitterGeomExplicitParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EmitterGeomExplicitParamsNS::ParametersStruct& parameters(void) const
+	{
+		EmitterGeomExplicitParams* tmpThis = const_cast<EmitterGeomExplicitParams*>(this);
+		return *(static_cast<EmitterGeomExplicitParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	EmitterGeomExplicitParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EmitterGeomExplicitParamsNS::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 EmitterGeomExplicitParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EmitterGeomExplicitParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EmitterGeomExplicitParams), EmitterGeomExplicitParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EmitterGeomExplicitParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterGeomExplicitParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EmitterGeomExplicitParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EmitterGeomExplicitParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EmitterGeomExplicitParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EmitterGeomExplicitParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterGeomExplicitParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EmitterGeomExplicitParams 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 (EmitterGeomExplicitParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EmitterGeomExplicitParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EmitterGeomExplicitParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EmitterGeomExplicitParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EmitterGeomExplicitParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace emitter
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/emitter/include/autogen/EmitterGeomSphereParams.h b/APEX_1.4/module/emitter/include/autogen/EmitterGeomSphereParams.h
new file mode 100644
index 00000000..81d9ac99
--- /dev/null
+++ b/APEX_1.4/module/emitter/include/autogen/EmitterGeomSphereParams.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_EmitterGeomSphereParams_h
+#define HEADER_EmitterGeomSphereParams_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 emitter
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EmitterGeomSphereParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	const char* emitterType;
+	float radius;
+	float hemisphere;
+
+};
+
+static const uint32_t checksum[] = { 0x79a261ec, 0x91a7400d, 0xfb6ba037, 0x3c13e11f, };
+
+} // namespace EmitterGeomSphereParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EmitterGeomSphereParams : public NvParameterized::NvParameters, public EmitterGeomSphereParamsNS::ParametersStruct
+{
+public:
+	EmitterGeomSphereParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EmitterGeomSphereParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EmitterGeomSphereParams");
+	}
+
+	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(EmitterGeomSphereParamsNS::checksum);
+		return EmitterGeomSphereParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EmitterGeomSphereParamsNS::ParametersStruct& parameters(void) const
+	{
+		EmitterGeomSphereParams* tmpThis = const_cast<EmitterGeomSphereParams*>(this);
+		return *(static_cast<EmitterGeomSphereParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	EmitterGeomSphereParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EmitterGeomSphereParamsNS::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 EmitterGeomSphereParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EmitterGeomSphereParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EmitterGeomSphereParams), EmitterGeomSphereParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EmitterGeomSphereParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterGeomSphereParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EmitterGeomSphereParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EmitterGeomSphereParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EmitterGeomSphereParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EmitterGeomSphereParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterGeomSphereParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EmitterGeomSphereParams 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 (EmitterGeomSphereParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EmitterGeomSphereParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EmitterGeomSphereParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EmitterGeomSphereParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EmitterGeomSphereParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace emitter
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/emitter/include/autogen/EmitterGeomSphereShellParams.h b/APEX_1.4/module/emitter/include/autogen/EmitterGeomSphereShellParams.h
new file mode 100644
index 00000000..ec0e7191
--- /dev/null
+++ b/APEX_1.4/module/emitter/include/autogen/EmitterGeomSphereShellParams.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_EmitterGeomSphereShellParams_h
+#define HEADER_EmitterGeomSphereShellParams_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 emitter
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EmitterGeomSphereShellParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	const char* emitterType;
+	float radius;
+	float shellThickness;
+	float hemisphere;
+
+};
+
+static const uint32_t checksum[] = { 0xa7e5ed8e, 0xbce14b67, 0x71503704, 0x616eed9e, };
+
+} // namespace EmitterGeomSphereShellParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EmitterGeomSphereShellParams : public NvParameterized::NvParameters, public EmitterGeomSphereShellParamsNS::ParametersStruct
+{
+public:
+	EmitterGeomSphereShellParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EmitterGeomSphereShellParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EmitterGeomSphereShellParams");
+	}
+
+	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(EmitterGeomSphereShellParamsNS::checksum);
+		return EmitterGeomSphereShellParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EmitterGeomSphereShellParamsNS::ParametersStruct& parameters(void) const
+	{
+		EmitterGeomSphereShellParams* tmpThis = const_cast<EmitterGeomSphereShellParams*>(this);
+		return *(static_cast<EmitterGeomSphereShellParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	EmitterGeomSphereShellParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EmitterGeomSphereShellParamsNS::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 EmitterGeomSphereShellParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EmitterGeomSphereShellParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EmitterGeomSphereShellParams), EmitterGeomSphereShellParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EmitterGeomSphereShellParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterGeomSphereShellParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EmitterGeomSphereShellParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EmitterGeomSphereShellParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EmitterGeomSphereShellParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EmitterGeomSphereShellParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterGeomSphereShellParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EmitterGeomSphereShellParams 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 (EmitterGeomSphereShellParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EmitterGeomSphereShellParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EmitterGeomSphereShellParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EmitterGeomSphereShellParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EmitterGeomSphereShellParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace emitter
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/emitter/include/autogen/EmitterModuleParameters.h b/APEX_1.4/module/emitter/include/autogen/EmitterModuleParameters.h
new file mode 100644
index 00000000..48c7bbf0
--- /dev/null
+++ b/APEX_1.4/module/emitter/include/autogen/EmitterModuleParameters.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_EmitterModuleParameters_h
+#define HEADER_EmitterModuleParameters_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 emitter
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EmitterModuleParametersNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	uint32_t unused;
+
+};
+
+static const uint32_t checksum[] = { 0xa747fb88, 0x02cb8a6c, 0xc4b8a1de, 0x0263bab7, };
+
+} // namespace EmitterModuleParametersNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EmitterModuleParameters : public NvParameterized::NvParameters, public EmitterModuleParametersNS::ParametersStruct
+{
+public:
+	EmitterModuleParameters(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EmitterModuleParameters();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EmitterModuleParameters");
+	}
+
+	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(EmitterModuleParametersNS::checksum);
+		return EmitterModuleParametersNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EmitterModuleParametersNS::ParametersStruct& parameters(void) const
+	{
+		EmitterModuleParameters* tmpThis = const_cast<EmitterModuleParameters*>(this);
+		return *(static_cast<EmitterModuleParametersNS::ParametersStruct*>(tmpThis));
+	}
+
+	EmitterModuleParametersNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EmitterModuleParametersNS::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 EmitterModuleParametersFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EmitterModuleParameters::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EmitterModuleParameters), EmitterModuleParameters::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EmitterModuleParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterModuleParameters");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EmitterModuleParameters)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EmitterModuleParameters)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EmitterModuleParameters::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EmitterModuleParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterModuleParameters");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EmitterModuleParameters 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 (EmitterModuleParameters*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EmitterModuleParameters::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EmitterModuleParameters::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EmitterModuleParameters::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EmitterModuleParameters::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace emitter
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/emitter/include/autogen/GroundEmitterActorParameters.h b/APEX_1.4/module/emitter/include/autogen/GroundEmitterActorParameters.h
new file mode 100644
index 00000000..7eaef20d
--- /dev/null
+++ b/APEX_1.4/module/emitter/include/autogen/GroundEmitterActorParameters.h
@@ -0,0 +1,238 @@
+// 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_GroundEmitterActorParameters_h
+#define HEADER_GroundEmitterActorParameters_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 emitter
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace GroundEmitterActorParametersNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float density;
+	float radius;
+	physx::PxVec3 upDirection;
+	float raycastHeight;
+	float spawnHeight;
+	uint32_t maxRaycastsPerFrame;
+	NvParameterized::DummyStringStruct raycastCollisionGroupMaskName;
+	physx::PxVec3 attachRelativePosition;
+	physx::PxTransform globalPose;
+
+};
+
+static const uint32_t checksum[] = { 0xd3e25aee, 0x7c2db6c5, 0x857bb739, 0xd8a21775, };
+
+} // namespace GroundEmitterActorParametersNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class GroundEmitterActorParameters : public NvParameterized::NvParameters, public GroundEmitterActorParametersNS::ParametersStruct
+{
+public:
+	GroundEmitterActorParameters(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~GroundEmitterActorParameters();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("GroundEmitterActorParameters");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)3;
+
+	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(GroundEmitterActorParametersNS::checksum);
+		return GroundEmitterActorParametersNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const GroundEmitterActorParametersNS::ParametersStruct& parameters(void) const
+	{
+		GroundEmitterActorParameters* tmpThis = const_cast<GroundEmitterActorParameters*>(this);
+		return *(static_cast<GroundEmitterActorParametersNS::ParametersStruct*>(tmpThis));
+	}
+
+	GroundEmitterActorParametersNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<GroundEmitterActorParametersNS::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 GroundEmitterActorParametersFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		GroundEmitterActorParameters::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(GroundEmitterActorParameters), GroundEmitterActorParameters::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, GroundEmitterActorParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GroundEmitterActorParameters");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(GroundEmitterActorParameters)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, GroundEmitterActorParameters)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, GroundEmitterActorParameters::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, GroundEmitterActorParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GroundEmitterActorParameters");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of GroundEmitterActorParameters 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 (GroundEmitterActorParameters*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (GroundEmitterActorParameters::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (GroundEmitterActorParameters::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (GroundEmitterActorParameters::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (GroundEmitterActorParameters::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace emitter
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/emitter/include/autogen/GroundEmitterAssetParameters.h b/APEX_1.4/module/emitter/include/autogen/GroundEmitterAssetParameters.h
new file mode 100644
index 00000000..59204959
--- /dev/null
+++ b/APEX_1.4/module/emitter/include/autogen/GroundEmitterAssetParameters.h
@@ -0,0 +1,269 @@
+// 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_GroundEmitterAssetParameters_h
+#define HEADER_GroundEmitterAssetParameters_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 emitter
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace GroundEmitterAssetParametersNS
+{
+
+struct emitterLodParamDesc_Type;
+struct materialFactoryMapping_Type;
+
+struct materialFactoryMapping_DynamicArray1D_Type
+{
+	materialFactoryMapping_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct emitterLodParamDesc_Type
+{
+	uint32_t version;
+	float maxDistance;
+	float distanceWeight;
+	float speedWeight;
+	float lifeWeight;
+	float separationWeight;
+	float bias;
+};
+struct materialFactoryMapping_Type
+{
+	NvParameterized::Interface* iofxAssetName;
+	NvParameterized::Interface* iosAssetName;
+	NvParameterized::DummyStringStruct physMatName;
+	float weight;
+	float maxSlopeAngle;
+	emitterLodParamDesc_Type lodParamDesc;
+};
+
+struct ParametersStruct
+{
+
+	float density;
+	float lifetimeLow;
+	float lifetimeHigh;
+	physx::PxVec3 velocityLow;
+	physx::PxVec3 velocityHigh;
+	float radius;
+	float raycastHeight;
+	float spawnHeight;
+	uint32_t maxRaycastsPerFrame;
+	NvParameterized::DummyStringStruct raycastCollisionGroupMaskName;
+	materialFactoryMapping_DynamicArray1D_Type materialFactoryMapList;
+
+};
+
+static const uint32_t checksum[] = { 0xfc4571c0, 0x0157d03c, 0xb1fe5ac6, 0xd7d25449, };
+
+} // namespace GroundEmitterAssetParametersNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class GroundEmitterAssetParameters : public NvParameterized::NvParameters, public GroundEmitterAssetParametersNS::ParametersStruct
+{
+public:
+	GroundEmitterAssetParameters(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~GroundEmitterAssetParameters();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("GroundEmitterAssetParameters");
+	}
+
+	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(GroundEmitterAssetParametersNS::checksum);
+		return GroundEmitterAssetParametersNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const GroundEmitterAssetParametersNS::ParametersStruct& parameters(void) const
+	{
+		GroundEmitterAssetParameters* tmpThis = const_cast<GroundEmitterAssetParameters*>(this);
+		return *(static_cast<GroundEmitterAssetParametersNS::ParametersStruct*>(tmpThis));
+	}
+
+	GroundEmitterAssetParametersNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<GroundEmitterAssetParametersNS::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 GroundEmitterAssetParametersFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		GroundEmitterAssetParameters::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(GroundEmitterAssetParameters), GroundEmitterAssetParameters::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, GroundEmitterAssetParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GroundEmitterAssetParameters");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(GroundEmitterAssetParameters)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, GroundEmitterAssetParameters)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, GroundEmitterAssetParameters::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, GroundEmitterAssetParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GroundEmitterAssetParameters");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of GroundEmitterAssetParameters 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 (GroundEmitterAssetParameters*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (GroundEmitterAssetParameters::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (GroundEmitterAssetParameters::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (GroundEmitterAssetParameters::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (GroundEmitterAssetParameters::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace emitter
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/emitter/include/autogen/ImpactEmitterActorParameters.h b/APEX_1.4/module/emitter/include/autogen/ImpactEmitterActorParameters.h
new file mode 100644
index 00000000..4e76bb85
--- /dev/null
+++ b/APEX_1.4/module/emitter/include/autogen/ImpactEmitterActorParameters.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_ImpactEmitterActorParameters_h
+#define HEADER_ImpactEmitterActorParameters_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 emitter
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ImpactEmitterActorParametersNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::Interface* explosionEnv;
+
+};
+
+static const uint32_t checksum[] = { 0x6785e5a5, 0x2d0171c3, 0xecd991a6, 0xeebe4e58, };
+
+} // namespace ImpactEmitterActorParametersNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ImpactEmitterActorParameters : public NvParameterized::NvParameters, public ImpactEmitterActorParametersNS::ParametersStruct
+{
+public:
+	ImpactEmitterActorParameters(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ImpactEmitterActorParameters();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ImpactEmitterActorParameters");
+	}
+
+	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(ImpactEmitterActorParametersNS::checksum);
+		return ImpactEmitterActorParametersNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ImpactEmitterActorParametersNS::ParametersStruct& parameters(void) const
+	{
+		ImpactEmitterActorParameters* tmpThis = const_cast<ImpactEmitterActorParameters*>(this);
+		return *(static_cast<ImpactEmitterActorParametersNS::ParametersStruct*>(tmpThis));
+	}
+
+	ImpactEmitterActorParametersNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ImpactEmitterActorParametersNS::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 ImpactEmitterActorParametersFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ImpactEmitterActorParameters::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ImpactEmitterActorParameters), ImpactEmitterActorParameters::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ImpactEmitterActorParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ImpactEmitterActorParameters");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ImpactEmitterActorParameters)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ImpactEmitterActorParameters)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ImpactEmitterActorParameters::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ImpactEmitterActorParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ImpactEmitterActorParameters");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ImpactEmitterActorParameters 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 (ImpactEmitterActorParameters*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ImpactEmitterActorParameters::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ImpactEmitterActorParameters::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ImpactEmitterActorParameters::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ImpactEmitterActorParameters::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace emitter
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/emitter/include/autogen/ImpactEmitterAssetParameters.h b/APEX_1.4/module/emitter/include/autogen/ImpactEmitterAssetParameters.h
new file mode 100644
index 00000000..c931713a
--- /dev/null
+++ b/APEX_1.4/module/emitter/include/autogen/ImpactEmitterAssetParameters.h
@@ -0,0 +1,238 @@
+// 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_ImpactEmitterAssetParameters_h
+#define HEADER_ImpactEmitterAssetParameters_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 emitter
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ImpactEmitterAssetParametersNS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	REF_DynamicArray1D_Type eventSetList;
+
+};
+
+static const uint32_t checksum[] = { 0x5b78e967, 0xd4e18888, 0xaac77873, 0xef2e1cba, };
+
+} // namespace ImpactEmitterAssetParametersNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ImpactEmitterAssetParameters : public NvParameterized::NvParameters, public ImpactEmitterAssetParametersNS::ParametersStruct
+{
+public:
+	ImpactEmitterAssetParameters(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ImpactEmitterAssetParameters();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ImpactEmitterAssetParameters");
+	}
+
+	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(ImpactEmitterAssetParametersNS::checksum);
+		return ImpactEmitterAssetParametersNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ImpactEmitterAssetParametersNS::ParametersStruct& parameters(void) const
+	{
+		ImpactEmitterAssetParameters* tmpThis = const_cast<ImpactEmitterAssetParameters*>(this);
+		return *(static_cast<ImpactEmitterAssetParametersNS::ParametersStruct*>(tmpThis));
+	}
+
+	ImpactEmitterAssetParametersNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ImpactEmitterAssetParametersNS::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 ImpactEmitterAssetParametersFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ImpactEmitterAssetParameters::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ImpactEmitterAssetParameters), ImpactEmitterAssetParameters::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ImpactEmitterAssetParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ImpactEmitterAssetParameters");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ImpactEmitterAssetParameters)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ImpactEmitterAssetParameters)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ImpactEmitterAssetParameters::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ImpactEmitterAssetParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ImpactEmitterAssetParameters");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ImpactEmitterAssetParameters 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 (ImpactEmitterAssetParameters*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ImpactEmitterAssetParameters::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ImpactEmitterAssetParameters::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ImpactEmitterAssetParameters::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ImpactEmitterAssetParameters::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace emitter
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/emitter/include/autogen/ImpactExplosionEvent.h b/APEX_1.4/module/emitter/include/autogen/ImpactExplosionEvent.h
new file mode 100644
index 00000000..44025781
--- /dev/null
+++ b/APEX_1.4/module/emitter/include/autogen/ImpactExplosionEvent.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_ImpactExplosionEvent_h
+#define HEADER_ImpactExplosionEvent_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 emitter
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ImpactExplosionEventNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct eventSetName;
+	NvParameterized::Interface* explosionAssetName;
+	float delay;
+	float duration;
+
+};
+
+static const uint32_t checksum[] = { 0x74920db4, 0x81c601e1, 0x4eda208e, 0xdc255cd6, };
+
+} // namespace ImpactExplosionEventNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ImpactExplosionEvent : public NvParameterized::NvParameters, public ImpactExplosionEventNS::ParametersStruct
+{
+public:
+	ImpactExplosionEvent(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ImpactExplosionEvent();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ImpactExplosionEvent");
+	}
+
+	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(ImpactExplosionEventNS::checksum);
+		return ImpactExplosionEventNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ImpactExplosionEventNS::ParametersStruct& parameters(void) const
+	{
+		ImpactExplosionEvent* tmpThis = const_cast<ImpactExplosionEvent*>(this);
+		return *(static_cast<ImpactExplosionEventNS::ParametersStruct*>(tmpThis));
+	}
+
+	ImpactExplosionEventNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ImpactExplosionEventNS::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 ImpactExplosionEventFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ImpactExplosionEvent::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ImpactExplosionEvent), ImpactExplosionEvent::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ImpactExplosionEvent::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ImpactExplosionEvent");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ImpactExplosionEvent)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ImpactExplosionEvent)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ImpactExplosionEvent::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ImpactExplosionEvent::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ImpactExplosionEvent");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ImpactExplosionEvent 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 (ImpactExplosionEvent*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ImpactExplosionEvent::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ImpactExplosionEvent::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ImpactExplosionEvent::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ImpactExplosionEvent::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace emitter
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/emitter/include/autogen/ImpactObjectEvent.h b/APEX_1.4/module/emitter/include/autogen/ImpactObjectEvent.h
new file mode 100644
index 00000000..f40c7175
--- /dev/null
+++ b/APEX_1.4/module/emitter/include/autogen/ImpactObjectEvent.h
@@ -0,0 +1,253 @@
+// 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_ImpactObjectEvent_h
+#define HEADER_ImpactObjectEvent_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 emitter
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ImpactObjectEventNS
+{
+
+struct emitterLodParamDesc_Type;
+
+struct emitterLodParamDesc_Type
+{
+	uint32_t version;
+	float maxDistance;
+	float distanceWeight;
+	float speedWeight;
+	float lifeWeight;
+	float separationWeight;
+	float bias;
+};
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct eventSetName;
+	NvParameterized::Interface* iofxAssetName;
+	NvParameterized::Interface* iosAssetName;
+	float angleLow;
+	float angleHigh;
+	float speedLow;
+	float speedHigh;
+	float lifeLow;
+	float lifeHigh;
+	float delay;
+	uint32_t particleSpawnCount;
+	const char* impactAxis;
+	emitterLodParamDesc_Type lodParamDesc;
+
+};
+
+static const uint32_t checksum[] = { 0x14e70046, 0x8f02f0ce, 0x13040374, 0x46d00400, };
+
+} // namespace ImpactObjectEventNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ImpactObjectEvent : public NvParameterized::NvParameters, public ImpactObjectEventNS::ParametersStruct
+{
+public:
+	ImpactObjectEvent(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ImpactObjectEvent();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ImpactObjectEvent");
+	}
+
+	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(ImpactObjectEventNS::checksum);
+		return ImpactObjectEventNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ImpactObjectEventNS::ParametersStruct& parameters(void) const
+	{
+		ImpactObjectEvent* tmpThis = const_cast<ImpactObjectEvent*>(this);
+		return *(static_cast<ImpactObjectEventNS::ParametersStruct*>(tmpThis));
+	}
+
+	ImpactObjectEventNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ImpactObjectEventNS::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 ImpactObjectEventFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ImpactObjectEvent::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ImpactObjectEvent), ImpactObjectEvent::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ImpactObjectEvent::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ImpactObjectEvent");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ImpactObjectEvent)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ImpactObjectEvent)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ImpactObjectEvent::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ImpactObjectEvent::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ImpactObjectEvent");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ImpactObjectEvent 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 (ImpactObjectEvent*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ImpactObjectEvent::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ImpactObjectEvent::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ImpactObjectEvent::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ImpactObjectEvent::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace emitter
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/emitter/include/autogen/ModuleEmitterRegistration.h b/APEX_1.4/module/emitter/include/autogen/ModuleEmitterRegistration.h
new file mode 100644
index 00000000..f1a71eee
--- /dev/null
+++ b/APEX_1.4/module/emitter/include/autogen/ModuleEmitterRegistration.h
@@ -0,0 +1,159 @@
+/*
+ * 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_MODULEEMITTERREGISTRATIONH_H
+#define MODULE_MODULEEMITTERREGISTRATIONH_H
+
+#include "PsAllocator.h"
+#include "NvRegistrationsForTraitsBase.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "PxAssert.h"
+#include <stdint.h>
+
+// INCLUDE GENERATED FACTORIES
+#include "ApexEmitterAssetParameters.h"
+#include "EmitterGeomBoxParams.h"
+#include "EmitterGeomExplicitParams.h"
+#include "EmitterGeomSphereShellParams.h"
+#include "EmitterGeomSphereParams.h"
+#include "EmitterGeomCylinderParams.h"
+#include "ApexEmitterActorParameters.h"
+#include "ImpactEmitterActorParameters.h"
+#include "GroundEmitterActorParameters.h"
+#include "EmitterAssetPreviewParameters.h"
+#include "EmitterDebugRenderParams.h"
+#include "GroundEmitterAssetParameters.h"
+#include "ImpactEmitterAssetParameters.h"
+#include "ImpactExplosionEvent.h"
+#include "ImpactObjectEvent.h"
+#include "EmitterModuleParameters.h"
+
+
+// INCLUDE GENERATED CONVERSION
+
+
+namespace nvidia {
+namespace emitter {
+
+
+class ModuleEmitterRegistration : public NvParameterized::RegistrationsForTraitsBase
+{
+public:
+	static void invokeRegistration(NvParameterized::Traits* parameterizedTraits)
+	{
+		if (parameterizedTraits)
+		{
+			ModuleEmitterRegistration().registerAll(*parameterizedTraits);
+		}
+	}
+
+	static void invokeUnregistration(NvParameterized::Traits* parameterizedTraits)
+	{
+		if (parameterizedTraits)
+		{
+			ModuleEmitterRegistration().unregisterAll(*parameterizedTraits);
+		}
+	}
+
+	void registerAvailableFactories(NvParameterized::Traits& parameterizedTraits)
+	{
+		::NvParameterized::Factory* factoriesToRegister[] = {
+// REGISTER GENERATED FACTORIES
+			new nvidia::emitter::ApexEmitterAssetParametersFactory(),
+			new nvidia::emitter::EmitterGeomBoxParamsFactory(),
+			new nvidia::emitter::EmitterGeomExplicitParamsFactory(),
+			new nvidia::emitter::EmitterGeomSphereShellParamsFactory(),
+			new nvidia::emitter::EmitterGeomSphereParamsFactory(),
+			new nvidia::emitter::EmitterGeomCylinderParamsFactory(),
+			new nvidia::emitter::ApexEmitterActorParametersFactory(),
+			new nvidia::emitter::ImpactEmitterActorParametersFactory(),
+			new nvidia::emitter::GroundEmitterActorParametersFactory(),
+			new nvidia::emitter::EmitterAssetPreviewParametersFactory(),
+			new nvidia::emitter::EmitterDebugRenderParamsFactory(),
+			new nvidia::emitter::GroundEmitterAssetParametersFactory(),
+			new nvidia::emitter::ImpactEmitterAssetParametersFactory(),
+			new nvidia::emitter::ImpactExplosionEventFactory(),
+			new nvidia::emitter::ImpactObjectEventFactory(),
+			new nvidia::emitter::EmitterModuleParametersFactory(),
+
+		};
+
+		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::emitter::ApexEmitterAssetParametersFactory(),
+			new nvidia::emitter::EmitterGeomBoxParamsFactory(),
+			new nvidia::emitter::EmitterGeomExplicitParamsFactory(),
+			new nvidia::emitter::EmitterGeomSphereShellParamsFactory(),
+			new nvidia::emitter::EmitterGeomSphereParamsFactory(),
+			new nvidia::emitter::EmitterGeomCylinderParamsFactory(),
+			new nvidia::emitter::ApexEmitterActorParametersFactory(),
+			new nvidia::emitter::ImpactEmitterActorParametersFactory(),
+			new nvidia::emitter::GroundEmitterActorParametersFactory(),
+			new nvidia::emitter::EmitterAssetPreviewParametersFactory(),
+			new nvidia::emitter::EmitterDebugRenderParamsFactory(),
+			new nvidia::emitter::GroundEmitterAssetParametersFactory(),
+			new nvidia::emitter::ImpactEmitterAssetParametersFactory(),
+			new nvidia::emitter::ImpactExplosionEventFactory(),
+			new nvidia::emitter::ImpactObjectEventFactory(),
+			new nvidia::emitter::EmitterModuleParametersFactory(),
+
+		};
+
+		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::emitter
+
+#endif