Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

47 files changed, 12167 insertions, 0 deletions

diff --git a/APEX_1.4/module/particles/include/EffectPackageActorImpl.h b/APEX_1.4/module/particles/include/EffectPackageActorImpl.h
new file mode 100644
index 00000000..f1aa168d
--- /dev/null
+++ b/APEX_1.4/module/particles/include/EffectPackageActorImpl.h
@@ -0,0 +1,922 @@
+/*
+ * 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 PARTICLES_EFFECT_PACKAGE_ACTOR_H
+
+#define PARTICLES_EFFECT_PACKAGE_ACTOR_H
+
+#include "ApexActor.h"
+#include "EffectPackageActor.h"
+#include "EffectPackageAssetImpl.h"
+#include "ParticlesBase.h"
+#include "Spline.h"
+#include "PxTransform.h"
+#include "ReadCheck.h"
+#include "WriteCheck.h"
+
+namespace nvidia
+{
+namespace apex
+{
+class Scene;
+}
+namespace turbulencefs
+{
+class ModuleTurbulenceFS;
+}
+
+namespace particles
+{
+
+enum VisState
+{
+	VS_TOO_CLOSE,
+	VS_ON_SCREEN,
+	VS_BEHIND_SCREEN,
+	VS_OFF_SCREEN,
+};
+
+class EffectPath : public shdfnd::UserAllocated
+{
+public:
+	enum Mode
+	{
+		EM_LOOP,
+		EM_PLAY_ONCE,
+		EM_PING_PONG
+	};
+	EffectPath(void);
+	~EffectPath(void);
+
+	bool init(RigidBodyEffectNS::EffectPath_Type &path);
+	float getSampleScaleSpline(void) const { return mSampleScaleSpline; };
+	float getSampleSpeedSpline(void) const { return mSampleSpeedSpline; };
+
+	void getSamplePoseSpline(PxTransform &pose)
+	{
+		if ( mPathSpline )
+		{
+			pose = pose * mSamplePoseSpline;
+		}
+	}
+
+	float sampleSpline(float stime);
+
+	Mode getMode(void) const
+	{
+		return mMode;
+	}
+
+	void computeSampleTime(float ctime,float duration);
+
+	float getPathDuration(void)
+	{
+		return mPathDuration;
+	}
+
+private:
+	Mode					mMode;
+	float					mPathDuration;
+	Spline					*mScaleSpline;
+	float					mSampleScaleSpline; // the scale value sampled from the spline curve
+	float					mSampleSpeedSpline;
+	Spline					*mSpeedSpline;
+	PxTransform		mPathRoot;
+	PxTransform		mSamplePoseSpline;
+	uint32_t			mRotationCount;
+	PxQuat			*mRotations;
+	SplineCurve				*mPathSpline;
+};
+
+class EffectData : public shdfnd::UserAllocated
+{
+public:
+	enum EffectState
+	{
+		ES_INITIAL_DELAY,
+		ES_ACTIVE,
+		ES_REPEAT_DELAY,
+		ES_DONE
+	};
+
+	EffectData(EffectType type,
+	           ApexSDK* sdk,
+	           Scene* scene,
+	           ParticlesScene* dscene,
+	           const char* assetName,
+	           const char* nameSpace,
+			   RigidBodyEffectNS::EffectProperties_Type &effectProperties);
+
+	virtual ~EffectData(void);
+	void releaseActor(void);
+
+	float getRandomTime(float baseTime);
+
+	EffectType getType(void) const
+	{
+		return mType;
+	}
+	virtual void release(void) = 0;
+	virtual void visualize(RenderDebugInterface* callback, bool solid) const = 0;
+	virtual bool refresh(const PxTransform& parent,
+						bool parentEnabled,
+						bool fromSetPose,
+						RenderVolume* renderVolume,
+						EmitterActor::EmitterValidateCallback *callback) = 0;
+
+	bool isDead(void) const
+	{
+		return mState == ES_DONE;
+	}
+
+	Actor* getEffectActor(void) const
+	{
+		return mActor;
+	}
+	Asset* getEffectAsset(void) const
+	{
+		return mAsset;
+	}
+
+	bool isEnabled(void) const
+	{
+		return mEnabled;
+	}
+
+	void setEnabled(bool state)
+	{
+		mEnabled = state;
+	}
+
+	bool simulate(float dtime, bool& reset);
+
+	uint32_t getRepeatCount(void) const
+	{
+		return mRepeatCount;
+	};
+	float getDuration(void) const
+	{
+		return mDuration;
+	};
+
+	float getRealDuration(void) const;
+
+	void setLocalPose(const PxTransform& p)
+	{
+		mLocalPose = p;
+	}
+	const PxTransform& getWorldPose(void) const
+	{
+		return mPose;
+	};
+	const PxTransform& getLocalPose(void) const
+	{
+		return mLocalPose;
+	};
+
+	Asset * getAsset(void) const { return mAsset; };
+
+	void setForceRenableEmitter(bool state)
+	{
+		mForceRenableEmitter = state;
+	}
+
+	bool getForceRenableEmitterSemaphore(void)
+	{
+		bool ret = mForceRenableEmitter;
+		mForceRenableEmitter = false;
+		return ret;
+	}
+
+	void setCurrentScale(float objectScale,EffectPath *parentPath)
+	{
+		mParentPath = parentPath;
+		mObjectScale = objectScale;
+	}
+
+	nvidia::apex::Scene *getApexScene(void) const
+	{
+		return mApexScene;
+	}
+
+	void getSamplePoseSpline(PxTransform &pose)
+	{
+		if ( mParentPath )
+		{
+			mParentPath->getSamplePoseSpline(pose);
+		}
+		if ( mEffectPath )
+		{
+			mEffectPath->getSamplePoseSpline(pose);
+		}
+	}
+
+	float getSampleScaleSpline(void) const
+	{
+		float parentScale = mParentPath ? mParentPath->getSampleScaleSpline() : 1;
+		float myScale = mEffectPath ? mEffectPath->getSampleScaleSpline() : 1;
+		return myScale*parentScale;
+	}
+
+	bool activePath(void) const
+	{
+		bool ret = false;
+		if ( mEffectPath || mParentPath )
+		{
+			ret = true;
+		}
+		return ret;
+	}
+
+	bool					mFirstRate: 1;
+	float					mObjectScale;
+	EffectPath				*mParentPath;
+	EffectPath				*mEffectPath;
+
+protected:
+	bool					mUseEmitterPool: 1;
+	bool					mEnabled: 1;
+	bool					mForceRenableEmitter:1;
+	EffectState				mState;
+	float					mRandomDeviation;
+	float					mSimulationTime;
+	float					mStateTime;
+	uint32_t					mStateCount;
+	const char*				mNameSpace;
+	ParticlesScene*			mParticlesScene;
+	Scene*			mApexScene;
+	ApexSDK*				mApexSDK;
+	Asset*			mAsset;
+	Actor*			mActor;
+	float					mInitialDelayTime;
+	float					mDuration;
+	uint32_t					mRepeatCount;
+	float					mRepeatDelay;
+	EffectType				mType;
+	PxTransform				mPose;				// world space pose
+	PxTransform				mLocalPose;			// local space pose
+};
+
+class EffectForceField : public EffectData
+{
+public:
+	EffectForceField(const char* parentName,
+	                 ForceFieldEffect* data,
+	                 ApexSDK& sdk,
+	                 Scene& scene,
+	                 ParticlesScene& dscene,
+	                 const PxTransform& rootPose,
+	                 bool parentEnabled);
+
+	virtual ~EffectForceField(void);
+
+	virtual void release(void)
+	{
+		delete this;
+	}
+
+	virtual void visualize(RenderDebugInterface* callback, bool solid) const;
+	virtual bool refresh(const PxTransform& parent, bool parentEnabled, bool fromSetPos, RenderVolume* renderVolume,EmitterActor::EmitterValidateCallback *callback);
+
+	ForceFieldEffect*		mData;
+};
+
+
+
+class EffectEmitter : public EffectData
+{
+public:
+	EffectEmitter(const char* parentName,
+	              const EmitterEffect* data,
+	              ApexSDK& sdk,
+	              Scene& scene,
+	              ParticlesScene& dscene,
+	              const PxTransform& rootPose,
+	              bool parentEnabled);
+
+	virtual ~EffectEmitter(void);
+
+	virtual void release(void)
+	{
+		delete this;
+	}
+	void computeVelocity(float dtime);
+	virtual void visualize(RenderDebugInterface* callback, bool solid) const;
+
+	virtual bool refresh(const PxTransform& parent, bool parentEnabled, bool fromSetPose, RenderVolume* renderVolume,EmitterActor::EmitterValidateCallback *callback);
+
+	float mRate;
+	float mLifetimeLow;
+	float mLifetimeHigh;
+	const EmitterEffect*		mData;
+	bool					mFirstVelocityFrame: 1;
+	bool					mHaveSetPosition;
+	PxVec3			mLastEmitterPosition;
+	float			mVelocityTime;
+	PxVec3			mEmitterVelocity;
+};
+
+class EffectHeatSource : public EffectData
+{
+public:
+	EffectHeatSource(const char* parentName,
+	                 HeatSourceEffect* data,
+	                 ApexSDK& sdk,
+	                 Scene& scene,
+	                 ParticlesScene& dscene,
+					 ModuleTurbulenceFS* moduleTurbulenceFS,
+	                 const PxTransform& rootPose,
+	                 bool parentEnabled);
+
+	virtual ~EffectHeatSource(void);
+
+	virtual void release(void)
+	{
+		delete this;
+	}
+
+	virtual void visualize(RenderDebugInterface* callback, bool solid) const;
+	virtual bool refresh(const PxTransform& parent, bool parentEnabled, bool fromSetPose, RenderVolume* renderVolume,EmitterActor::EmitterValidateCallback *callback);
+
+
+	float			mAverageTemperature;
+	float			mStandardDeviationTemperature;
+
+	ModuleTurbulenceFS*	mModuleTurbulenceFS;
+	HeatSourceEffect*		mData;
+};
+
+class EffectSubstanceSource : public EffectData
+{
+public:
+	EffectSubstanceSource(const char* parentName,
+		SubstanceSourceEffect* data,
+		ApexSDK& sdk,
+		Scene& scene,
+		ParticlesScene& dscene,
+		ModuleTurbulenceFS* moduleTurbulenceFS,
+		const PxTransform& rootPose,
+		bool parentEnabled);
+
+	virtual ~EffectSubstanceSource(void);
+
+	virtual void release(void)
+	{
+		delete this;
+	}
+
+	virtual void visualize(RenderDebugInterface* callback, bool solid) const;
+	virtual bool refresh(const PxTransform& parent, bool parentEnabled, bool fromSetPose, RenderVolume* renderVolume,EmitterActor::EmitterValidateCallback *callback);
+
+
+	float			mAverageDensity;
+	float			mStandardDeviationDensity;
+
+	ModuleTurbulenceFS*	mModuleTurbulenceFS;
+	SubstanceSourceEffect*		mData;
+};
+
+class EffectVelocitySource : public EffectData
+{
+public:
+	EffectVelocitySource(const char* parentName,
+		VelocitySourceEffect* data,
+		ApexSDK& sdk,
+		Scene& scene,
+		ParticlesScene& dscene,
+		ModuleTurbulenceFS* moduleTurbulenceFS,
+		const PxTransform& rootPose,
+		bool parentEnabled);
+
+	virtual ~EffectVelocitySource(void);
+
+	virtual void release(void)
+	{
+		delete this;
+	}
+
+	virtual void visualize(RenderDebugInterface* callback, bool solid) const;
+	virtual bool refresh(const PxTransform& parent, bool parentEnabled, bool fromSetPose, RenderVolume* renderVolume,EmitterActor::EmitterValidateCallback *callback);
+
+
+	float			mAverageVelocity;
+	float			mStandardDeviationVelocity;
+	ModuleTurbulenceFS*	mModuleTurbulenceFS;
+	VelocitySourceEffect*		mData;
+};
+
+class EffectFlameEmitter : public EffectData
+{
+public:
+	EffectFlameEmitter(const char* parentName,
+		FlameEmitterEffect* data,
+		ApexSDK& sdk,
+		Scene& scene,
+		ParticlesScene& dscene,
+		ModuleTurbulenceFS* moduleTurbulenceFS,
+		const PxTransform& rootPose,
+		bool parentEnabled);
+
+	virtual ~EffectFlameEmitter(void);
+
+	virtual void release(void)
+	{
+		delete this;
+	}
+
+	virtual void visualize(RenderDebugInterface* callback, bool solid) const;
+	virtual bool refresh(const PxTransform& parent, bool parentEnabled, bool fromSetPose, RenderVolume* renderVolume,EmitterActor::EmitterValidateCallback *callback);
+
+
+	ModuleTurbulenceFS*	mModuleTurbulenceFS;
+	FlameEmitterEffect*		mData;
+};
+
+
+class EffectTurbulenceFS : public EffectData
+{
+public:
+	EffectTurbulenceFS(const char* parentName,
+	                   TurbulenceFieldSamplerEffect* data,
+	                   ApexSDK& sdk,
+	                   Scene& scene,
+	                   ParticlesScene& dscene,
+					   ModuleTurbulenceFS* moduleTurbulenceFS,
+	                   const PxTransform& rootPose,
+	                   bool parentEnabled);
+
+	virtual ~EffectTurbulenceFS(void);
+
+	virtual void release(void)
+	{
+		delete this;
+	}
+
+	virtual void visualize(RenderDebugInterface* callback, bool solid) const;
+	virtual bool refresh(const PxTransform& parent, bool parentEnabled, bool fromSetPose, RenderVolume* renderVolume,EmitterActor::EmitterValidateCallback *callback);
+
+	ModuleTurbulenceFS*	mModuleTurbulenceFS;
+	TurbulenceFieldSamplerEffect*	mData;
+};
+
+class EffectJetFS : public EffectData
+{
+public:
+	EffectJetFS(const char* parentName,
+	            JetFieldSamplerEffect* data,
+	            ApexSDK& sdk,
+	            Scene& scene,
+	            ParticlesScene& dscene,
+	            const PxTransform& rootPose,
+	            bool parentEnabled);
+	virtual ~EffectJetFS(void);
+
+	virtual void release(void)
+	{
+		delete this;
+	}
+
+	virtual void visualize(RenderDebugInterface* callback, bool solid) const;
+	virtual bool refresh(const PxTransform& parent, bool parentEnabled, bool fromSetPose, RenderVolume* renderVolume,EmitterActor::EmitterValidateCallback *callback);
+
+	JetFieldSamplerEffect*	mData;
+};
+
+
+class EffectWindFS : public EffectData
+{
+public:
+	EffectWindFS(const char* parentName,
+		WindFieldSamplerEffect* data,
+		ApexSDK& sdk,
+		Scene& scene,
+		ParticlesScene& dscene,
+		const PxTransform& rootPose,
+		bool parentEnabled);
+	virtual ~EffectWindFS(void);
+
+	virtual void release(void)
+	{
+		delete this;
+	}
+
+	virtual void visualize(RenderDebugInterface* callback, bool solid) const;
+	virtual bool refresh(const PxTransform& parent, bool parentEnabled, bool fromSetPose, RenderVolume* renderVolume,EmitterActor::EmitterValidateCallback *callback);
+
+	WindFieldSamplerEffect*	mData;
+};
+
+class EffectRigidBody : public EffectData
+{
+public:
+	EffectRigidBody(const char* parentName,
+		RigidBodyEffect* data,
+		ApexSDK& sdk,
+		Scene& scene,
+		ParticlesScene& dscene,
+		const PxTransform& rootPose,
+		bool parentEnabled);
+	virtual ~EffectRigidBody(void);
+
+	virtual void release(void)
+	{
+		delete this;
+	}
+
+	void releaseRigidBody(void);
+
+	virtual void visualize(RenderDebugInterface* callback, bool solid) const;
+	virtual bool refresh(const PxTransform& parent, bool parentEnabled, bool fromSetPose, RenderVolume* renderVolume,EmitterActor::EmitterValidateCallback *callback);
+
+	RigidBodyEffect*	mData;
+	PxRigidDynamic		*mRigidDynamic;
+};
+
+class EffectNoiseFS : public EffectData
+{
+public:
+	EffectNoiseFS(const char* parentName,
+	              NoiseFieldSamplerEffect* data,
+	              ApexSDK& sdk,
+	              Scene& scene,
+	              ParticlesScene& dscene,
+	              const PxTransform& rootPose,
+	              bool parentEnabled);
+	virtual ~EffectNoiseFS(void);
+
+	virtual void release(void)
+	{
+		delete this;
+	}
+
+	virtual void visualize(RenderDebugInterface* callback, bool solid) const;
+	virtual bool refresh(const PxTransform& parent, bool parentEnabled, bool fromSetPose, RenderVolume* renderVolume,EmitterActor::EmitterValidateCallback *callback);
+
+	NoiseFieldSamplerEffect*	mData;
+};
+
+
+class EffectVortexFS : public EffectData
+{
+public:
+	EffectVortexFS(const char* parentName,
+	               VortexFieldSamplerEffect* data,
+	               ApexSDK& sdk,
+	               Scene& scene,
+	               ParticlesScene& dscene,
+	               const PxTransform& rootPose,
+	               bool parentEnabled);
+	virtual ~EffectVortexFS(void);
+
+	virtual void release(void)
+	{
+		delete this;
+	}
+
+	virtual void visualize(RenderDebugInterface* callback, bool solid) const;
+	virtual bool refresh(const PxTransform& parent, bool parentEnabled, bool fromSetPose, RenderVolume* renderVolume,EmitterActor::EmitterValidateCallback *callback);
+
+	VortexFieldSamplerEffect*	mData;
+};
+
+
+
+class EffectAttractorFS : public EffectData
+{
+public:
+	EffectAttractorFS(const char* parentName,
+	                  AttractorFieldSamplerEffect* data,
+	                  ApexSDK& sdk,
+	                  Scene& scene,
+	                  ParticlesScene& dscene,
+	                  const PxTransform& rootPose,
+	                  bool parentEnabled);
+
+	virtual ~EffectAttractorFS(void);
+
+	virtual void release(void)
+	{
+		delete this;
+	}
+
+	virtual void visualize(RenderDebugInterface* callback, bool solid) const;
+	virtual bool refresh(const PxTransform& parent, bool parentEnabled, bool fromSetPose, RenderVolume* renderVolume,EmitterActor::EmitterValidateCallback *callback);
+
+	AttractorFieldSamplerEffect*		mData;
+};
+
+
+class EffectPackageActorImpl : public EffectPackageActor, public shdfnd::UserAllocated, public ParticlesBase, public ApexRWLockable
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	EffectPackageActorImpl(EffectPackageAsset* asset,
+	                   const EffectPackageAssetParams* assetParams,
+	                   const EffectPackageActorParams* actorParams,
+	                   nvidia::apex::ApexSDK& sdk,
+	                   nvidia::apex::Scene& scene,
+	                   ParticlesScene& dynamicSystemScene,
+					   ModuleTurbulenceFS* moduleTurbulenceFS);
+
+	virtual ~EffectPackageActorImpl(void);
+
+	virtual ParticlesType getParticlesType(void) const
+	{
+		return ParticlesBase::DST_EFFECT_PACKAGE_ACTOR;
+	}
+
+	void updateParticles(float dtime);
+	void updatePoseAndBounds(bool screenCulling, bool znegative);
+
+	virtual void setPose(const PxTransform& pose);
+	virtual const PxTransform& getPose(void) const;
+	virtual void visualize(RenderDebugInterface* callback, bool solid) const;
+
+	virtual void refresh(void);
+	virtual void release(void);
+
+	virtual const char* getName(void) const;
+
+	virtual uint32_t getEffectCount(void) const; // returns the number of effects in the effect package
+	virtual EffectType getEffectType(uint32_t effectIndex) const; // return the type of effect.
+	virtual Actor* getEffectActor(uint32_t effectIndex) const; // return the base Actor pointer
+	virtual void setEmitterState(bool state); // set the state for all emitters in this effect package.
+	virtual uint32_t getActiveParticleCount(void) const; // return the total number of particles still active in this effect package.
+	virtual bool isStillEmitting(void) const; // return true if any emitters are still actively emitting particles.
+
+
+	/**
+	\brief Returns the name of the effect at this index.
+
+	\param [in] effectIndex : The effect number to refer to; must be less than the result of getEffectCount
+	*/
+	virtual const char* getEffectName(uint32_t effectIndex) const;
+
+	/**
+	\brief Returns true if this sub-effect is currently enabled.
+
+	\param [in] effectIndex : The effect number to refer to; must be less than the result of getEffectCount
+	*/
+	virtual bool isEffectEnabled(uint32_t effectIndex) const;
+
+	/**
+	\brief Set's the enabled state of this sub-effect
+
+	\param [in] effectIndex : The effect number to refer to; must be less than the result of getEffectCount
+	\param [in] state : Whether the effect should be enabled or not.
+	*/
+	virtual bool setEffectEnabled(uint32_t effectIndex, bool state);
+
+	/**
+	\brief Returns the pose of this sub-effect; returns as a a bool the active state of this effect.
+
+	\param [in] effectIndex : The effect number to refer to; must be less than the result of getEffectCount
+	\param [pose] : Contains the pose requested
+	\param [worldSpace] : Whether to return the pose in world-space or in parent-relative space.
+	*/
+	virtual bool getEffectPose(uint32_t effectIndex, PxTransform& pose, bool worldSpace);
+
+	/**
+	\brief Sets the pose of this sub-effect; returns as a a bool the active state of this effect.
+
+	\param [in] effectIndex : The effect number to refer to; must be less than the result of getEffectCount
+	\param [pose] : Contains the pose to be set
+	\param [worldSpace] : Whether to return the pose in world-space or in parent-relative space.
+	*/
+	virtual bool setEffectPose(uint32_t effectIndex, const PxTransform& pose, bool worldSpace);
+
+	virtual void setCurrentScale(float scale);
+
+	virtual float getCurrentScale(void) const
+	{
+		return mObjectScale;
+	}
+
+	virtual PxRigidDynamic* getEffectRigidDynamic(uint32_t effectIndex) const;
+
+	/**
+	\brief Returns the current lifetime of the particle.
+	*/
+	virtual float getCurrentLife(void) const;
+
+
+	virtual float getDuration(void) const;
+
+	/**
+	\brief Returns the owning asset
+	*/
+	virtual Asset* getOwner() const
+	{
+		READ_ZONE();
+		return mAsset;
+	}
+
+	/**
+	\brief Returns the range of possible values for physical Lod overwrite
+
+	\param [out] min		The minimum lod value
+	\param [out] max		The maximum lod value
+	\param [out] intOnly	Only integers are allowed if this is true, gets rounded to nearest
+
+	\note The max value can change with different graphical Lods
+	\see Actor::forceLod()
+	*/
+	virtual void getLodRange(float& min, float& max, bool& intOnly) const
+	{
+		READ_ZONE();
+		min = 0;
+		max = 100000;
+		intOnly = false;
+	}
+
+	/**
+	\brief Get current physical lod.
+	*/
+	virtual float getActiveLod() const
+	{
+		READ_ZONE();
+		return 0;
+	}
+
+	/**
+	\brief Force an APEX Actor to use a certian physical Lod
+
+	\param [in] lod	Overwrite the Lod system to use this Lod.
+
+	\note Setting the lod value to a negative number will turn off the overwrite and proceed with regular Lod computations
+	\see Actor::getLodRange()
+	*/
+	virtual void forceLod(float lod)
+	{
+		WRITE_ZONE();
+		PX_UNUSED(lod);
+	}
+
+	/**
+	\brief Selectively enables/disables debug visualization of a specific APEX actor.  Default value it true.
+	*/
+	virtual void setEnableDebugVisualization(bool state)
+	{
+		WRITE_ZONE();
+		ApexActor::setEnableDebugVisualization(state);
+	}
+
+	/**
+	\brief Ensure that all module-cached data is cached.
+	*/
+	virtual void cacheModuleData() const
+	{
+
+	}
+
+	virtual void setEnabled(bool state)
+	{
+		WRITE_ZONE();
+		mEnabled = state;
+		refresh();
+	}
+
+	bool getEnabled(void) const
+	{
+		READ_ZONE();
+		return mEnabled;
+	}
+
+	virtual void		setPhysXScene(PxScene* s)
+	{
+		mPhysXScene = s;
+	}
+	virtual PxScene*	getPhysXScene() const
+	{
+		return mPhysXScene;
+	}
+
+	float internalGetDuration(void);
+
+	virtual bool isAlive(void) const
+	{
+		READ_ZONE();
+		return mAlive;
+	}
+
+	virtual void fadeOut(float fadeTime)
+	{
+		WRITE_ZONE();
+		if (!mFadeOut)
+		{
+			mFadeOutTime = fadeTime;
+			mFadeOutDuration = 0;
+
+			if (mFadeIn)
+			{
+				float fadeLerp = mFadeInDuration / mFadeInTime;
+				if (fadeLerp > 1)
+				{
+					fadeLerp = 1;
+				}
+				mFadeOutDuration = 1 - (fadeLerp * mFadeOutTime);
+				mFadeIn = false;
+			}
+
+			mFadeOut = true;
+		}
+	}
+
+	virtual void fadeIn(float fadeTime)
+	{
+		WRITE_ZONE();
+		if (!mFadeIn)
+		{
+			mFadeInTime = fadeTime;
+			mFadeInDuration = 0;
+			mFadeIn = true;
+			if (mFadeOut)
+			{
+				float fadeLerp = mFadeOutDuration / mFadeOutTime;
+				if (fadeLerp > 1)
+				{
+					fadeLerp = 1;
+				}
+				mFadeInDuration = 1 - (fadeLerp * mFadeInTime);
+				mFadeOut = false;
+			}
+		}
+	}
+
+	virtual void                 setPreferredRenderVolume(RenderVolume* volume);
+
+	virtual const char * hasVolumeRenderMaterial(uint32_t &index) const;
+
+	virtual void setApexEmitterValidateCallback(EmitterActor::EmitterValidateCallback *callback)
+	{
+		WRITE_ZONE();
+		mEmitterValidateCallback = callback;
+	}
+
+	float getSampleScaleSpline(void) const
+	{
+		return mEffectPath ? mEffectPath->getSampleScaleSpline() : 1;
+	}
+
+	void getSamplePoseSpline(PxTransform &pose)
+	{
+		if ( mEffectPath )
+		{
+			mEffectPath->getSamplePoseSpline(pose);
+		}
+	}
+
+private:
+
+	physx::PxScene*			mPhysXScene;
+
+	EffectType getEffectType(const NvParameterized::Interface* iface);
+
+	bool						mAlive:1;
+	bool						mEnabled: 1;
+	bool						mVisible: 1;
+	bool						mEverVisible: 1;
+	bool						mFirstFrame: 1;
+	bool						mFadeOut: 1;
+	float						mFadeOutTime;
+	float						mFadeOutDuration;
+
+	bool						mFadeIn: 1;
+	float						mFadeInTime;
+	float						mFadeInDuration;
+
+	EmitterActor::EmitterValidateCallback *mEmitterValidateCallback;
+
+	float						mFadeTime;
+	float                       mNotVisibleTime;
+	VisState					mVisState;
+	float						mOffScreenTime;
+
+	PxTransform					mPose;
+	float						mObjectScale;
+	const EffectPackageAssetParams*	mData;
+	Array< EffectData* >		mEffects;
+	float                       mSimTime;
+	float						mCurrentLifeTime;
+	EffectPath					*mEffectPath;
+
+	nvidia::apex::Scene	*mScene;
+	ModuleTurbulenceFS		*mModuleTurbulenceFS;
+	EffectPackageAsset		*mAsset;
+	RenderVolume			*mRenderVolume;
+	bool						mRigidBodyChange;
+};
+
+} // end of particles namespace
+} // end of nvidia namespace
+
+#endif
diff --git a/APEX_1.4/module/particles/include/EffectPackageAssetImpl.h b/APEX_1.4/module/particles/include/EffectPackageAssetImpl.h
new file mode 100644
index 00000000..17ec14e9
--- /dev/null
+++ b/APEX_1.4/module/particles/include/EffectPackageAssetImpl.h
@@ -0,0 +1,238 @@
+/*
+ * 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 PARTICLES_EFFECT_PACKAGE_ASSET_H
+#define PARTICLES_EFFECT_PACKAGE_ASSET_H
+
+#include "Apex.h"
+#include "ApexUsingNamespace.h"
+#include "EffectPackageAsset.h"
+#include "EffectPackageActor.h"
+#include "ApexSDKHelpers.h"
+#include "ModuleParticlesImpl.h"
+#include "ApexAssetAuthoring.h"
+#include "ApexString.h"
+#include "ApexAssetTracker.h"
+#include "ApexAuthorableObject.h"
+#include "EffectPackageAssetParams.h"
+#include "ApexRWLockable.h"
+
+#include "ReadCheck.h"
+#include "WriteCheck.h"
+#include "ApexAuthorableObject.h"
+
+namespace nvidia
+{
+namespace particles
+{
+
+class EffectPackageActorImpl;
+class ModuleParticlesImpl;
+
+class EffectPackageAssetImpl : public EffectPackageAsset, public ApexResourceInterface, public ApexResource, public ApexRWLockable
+{
+	friend class EffectPackageAssetDummyAuthoring;
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	EffectPackageAssetImpl(ModuleParticlesImpl*, ResourceList&, const char* name);
+	EffectPackageAssetImpl(ModuleParticlesImpl*, ResourceList&, NvParameterized::Interface*, const char*);
+
+	~EffectPackageAssetImpl();
+
+	/* Asset */
+	const char* 					getName() const
+	{
+		READ_ZONE();
+		return mName.c_str();
+	}
+	AuthObjTypeID					getObjTypeID() const
+	{
+		READ_ZONE();
+		return mAssetTypeID;
+	}
+	const char* 					getObjTypeName() const
+	{
+		READ_ZONE();
+		return getClassName();
+	}
+
+	uint32_t					forceLoadAssets();
+
+	/* ApexResource */
+	virtual void					release();
+
+	/* ApexResourceInterface, ApexResource */
+	uint32_t					getListIndex() const
+	{
+		return m_listIndex;
+	}
+
+	void							setListIndex(class ResourceList& list, uint32_t index)
+	{
+		m_list = &list;
+		m_listIndex = index;
+	}
+
+	/* EffectPackageAsset specific methods */
+	void							releaseEffectPackageActor(EffectPackageActor&);
+	const EffectPackageAssetParams&	getEffectPackageParameters() const
+	{
+		return *mParams;
+	}
+	float					getDefaultScale() const
+	{
+		return 1;
+	}
+	void							destroy();
+
+	const NvParameterized::Interface* getAssetNvParameterized() const
+	{
+		READ_ZONE();
+		return mParams;
+	}
+
+	virtual float getDuration() const;
+	virtual bool useUniqueRenderVolume() const;
+
+	/**
+	 * \brief Releases the ApexAsset but returns the NvParameterized::Interface and *ownership* to the caller.
+	 */
+	virtual NvParameterized::Interface* releaseAndReturnNvParameterizedInterface()
+	{
+		WRITE_ZONE();
+		NvParameterized::Interface* ret = mParams;
+		mParams = NULL;
+		release();
+		return ret;
+	}
+	NvParameterized::Interface* getDefaultActorDesc();
+	NvParameterized::Interface* getDefaultAssetPreviewDesc();
+	virtual Actor* createApexActor(const NvParameterized::Interface& /*parms*/, Scene& /*apexScene*/);
+	virtual AssetPreview* createApexAssetPreview(const ::NvParameterized::Interface& /*params*/, AssetPreviewScene* /*previewScene*/)
+	{
+		WRITE_ZONE();
+		PX_ALWAYS_ASSERT();
+		return NULL;
+	}
+
+	virtual bool isValidForActorCreation(const ::NvParameterized::Interface& /*parms*/, Scene& /*apexScene*/) const
+	{
+		READ_ZONE();
+		return true; // TODO implement this method
+	}
+
+	virtual bool isDirty() const
+	{
+		READ_ZONE();
+		return false;
+	}
+
+	static AuthObjTypeID			mAssetTypeID;
+
+protected:
+	static const char* 				getClassName()
+	{
+		return PARTICLES_EFFECT_PACKAGE_AUTHORING_TYPE_NAME;
+	}
+
+	ModuleParticlesImpl*				mModule;
+
+	ResourceList					mEffectPackageActors;
+	ApexSimpleString				mName;
+	EffectPackageAssetParams*			mParams;
+	EffectPackageActorParams*			mDefaultActorParams;
+
+	void							initializeAssetNameTable();
+
+	friend class ModuleParticlesE;
+	friend class EffectPackageActorImpl;
+	template <class T_Module, class T_Asset, class T_AssetAuthoring> friend class nvidia::apex::ApexAuthorableObject;
+};
+
+#ifndef WITHOUT_APEX_AUTHORING
+class EffectPackageAssetAuthoringImpl : public EffectPackageAssetImpl, public ApexAssetAuthoring, public EffectPackageAssetAuthoring
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	/* EffectPackageAssetAuthoring */
+	EffectPackageAssetAuthoringImpl(ModuleParticlesImpl* m, ResourceList& l) :
+		EffectPackageAssetImpl(m, l, "EffectPackageAssetAuthoringImpl") {}
+
+	EffectPackageAssetAuthoringImpl(ModuleParticlesImpl* m, ResourceList& l, const char* name) :
+		EffectPackageAssetImpl(m, l, name) {}
+
+	EffectPackageAssetAuthoringImpl(ModuleParticlesImpl* m, ResourceList& l, NvParameterized::Interface* params, const char* name) :
+		EffectPackageAssetImpl(m, l, params, name) {}
+
+	~EffectPackageAssetAuthoringImpl() {}
+
+	void							destroy()
+	{
+		delete this;
+	}
+
+	/* AssetAuthoring */
+	const char* 					getName() const
+	{
+		READ_ZONE();
+		return EffectPackageAssetImpl::getName();
+	}
+	const char* 					getObjTypeName() const
+	{
+		READ_ZONE();
+		return EffectPackageAssetImpl::getClassName();
+	}
+	virtual bool					prepareForPlatform(nvidia::apex::PlatformTag)
+	{
+		WRITE_ZONE();
+		APEX_INVALID_OPERATION("Not Implemented.");
+		return false;
+	}
+
+	void setToolString(const char* toolName, const char* toolVersion, uint32_t toolChangelist)
+	{
+		WRITE_ZONE();
+		ApexAssetAuthoring::setToolString(toolName, toolVersion, toolChangelist);
+	}
+
+	// from ApexAssetAuthoring
+	virtual void setToolString(const char* toolString);
+
+	/* ApexResource */
+	virtual void					release()
+	{
+		mModule->mSdk->releaseAssetAuthoring(*this);
+	}
+
+	NvParameterized::Interface* getNvParameterized() const
+	{
+		return (NvParameterized::Interface*)getAssetNvParameterized();
+	}
+	/**
+	 * \brief Releases the ApexAsset but returns the NvParameterized::Interface and *ownership* to the caller.
+	 */
+	virtual NvParameterized::Interface* releaseAndReturnNvParameterizedInterface()
+	{
+		WRITE_ZONE();
+		NvParameterized::Interface* ret = mParams;
+		mParams = NULL;
+		release();
+		return ret;
+	}
+};
+#endif
+
+}
+} // end namespace nvidia
+
+#endif // PARTICLES_EFFECT_PACKAGE_ASSET_H
diff --git a/APEX_1.4/module/particles/include/ModuleParticlesImpl.h b/APEX_1.4/module/particles/include/ModuleParticlesImpl.h
new file mode 100644
index 00000000..5375a340
--- /dev/null
+++ b/APEX_1.4/module/particles/include/ModuleParticlesImpl.h
@@ -0,0 +1,308 @@
+/*
+ * 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_PARTICLES_IMPL_H__
+#define __MODULE_PARTICLES_IMPL_H__
+
+#include "Apex.h"
+#include "ModuleParticles.h"
+#include "ApexSDKIntl.h"
+#include "ModuleIntl.h"
+#include "ModuleBase.h"
+
+#include "ApexRWLockable.h"
+#include "ApexSDKHelpers.h"
+#include "ParticlesDebugRenderParams.h"
+#include "ParticlesModuleParameters.h"
+#include "EffectPackageGraphicsMaterialsParams.h"
+
+#include "EffectPackageAssetParams.h"
+#include "EffectPackageActorParams.h"
+
+#include "GraphicsMaterialData.h"
+#include "VolumeRenderMaterialData.h"
+#include "EmitterEffect.h"
+#include "RigidBodyEffect.h"
+
+#include "HeatSourceEffect.h"
+#include "SubstanceSourceEffect.h"
+#include "VelocitySourceEffect.h"
+#include "ForceFieldEffect.h"
+#include "JetFieldSamplerEffect.h"
+#include "WindFieldSamplerEffect.h"
+#include "NoiseFieldSamplerEffect.h"
+#include "VortexFieldSamplerEffect.h"
+#include "AttractorFieldSamplerEffect.h"
+#include "TurbulenceFieldSamplerEffect.h"
+#include "FlameEmitterEffect.h"
+
+#include "EffectPackageData.h"
+#include "AttractorFieldSamplerData.h"
+#include "JetFieldSamplerData.h"
+#include "WindFieldSamplerData.h"
+#include "NoiseFieldSamplerData.h"
+#include "VortexFieldSamplerData.h"
+#include "TurbulenceFieldSamplerData.h"
+#include "HeatSourceData.h"
+#include "SubstanceSourceData.h"
+#include "VelocitySourceData.h"
+#include "ForceFieldData.h"
+#include "EmitterData.h"
+#include "GraphicsEffectData.h"
+#include "ParticleSimulationData.h"
+#include "FlameEmitterData.h"
+
+#include "EffectPackageIOSDatabaseParams.h"
+#include "EffectPackageIOFXDatabaseParams.h"
+#include "EffectPackageEmitterDatabaseParams.h"
+#include "EffectPackageDatabaseParams.h"
+#include "EffectPackageFieldSamplerDatabaseParams.h"
+
+#include "ReadCheck.h"
+#include "WriteCheck.h"
+
+namespace nvidia
+{
+namespace apex
+{
+class SceneIntl;
+class ModuleTurbulenceFS;
+class EmitterActor;
+class EmitterAsset;
+}
+namespace particles
+{
+class ParticlesAsset;
+class ParticlesAssetAuthoring;
+class ParticlesScene;
+
+typedef Array< ModuleSceneIntl* > ModuleSceneVector;
+
+class ModuleParticlesDesc : public ApexDesc
+{
+public:
+
+	/**
+	\brief Constructor sets to default.
+	*/
+	PX_INLINE ModuleParticlesDesc()
+	{
+		setToDefault();
+	}
+	/**
+	\brief (re)sets the structure to the default.
+	*/
+	PX_INLINE void	setToDefault()
+	{
+		ApexDesc::setToDefault();
+		moduleValue = 0;
+	}
+
+	/**
+	Returns true if an object can be created using this descriptor.
+	*/
+	PX_INLINE bool	isValid() const
+	{
+		return ApexDesc::isValid();
+	}
+
+	/**
+	ModuleBase configurable parameter.
+	*/
+	uint32_t moduleValue;
+};
+
+
+class ModuleParticlesImpl : public ModuleParticles, public ModuleIntl, public ModuleBase, public ApexRWLockable
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	ModuleParticlesImpl(ApexSDKIntl* sdk);
+	~ModuleParticlesImpl();
+
+	void						init(const ModuleParticlesDesc& desc);
+
+	// base class methods
+	void						init(NvParameterized::Interface&) {}
+	NvParameterized::Interface* getDefaultModuleDesc();
+	void release()
+	{
+		ModuleBase::release();
+	}
+	void destroy();
+	const char*					getName() const
+	{
+		READ_ZONE();
+		return ModuleBase::getName();
+	}
+
+	virtual bool setEffectPackageGraphicsMaterialsDatabase(const NvParameterized::Interface* dataBase);
+
+	virtual const NvParameterized::Interface* getEffectPackageGraphicsMaterialsDatabase() const;
+
+	virtual bool setEffectPackageIOSDatabase(const NvParameterized::Interface* dataBase);
+	virtual bool setEffectPackageIOFXDatabase(const NvParameterized::Interface* dataBase);
+	virtual bool setEffectPackageEmitterDatabase(const NvParameterized::Interface* dataBase);
+	virtual bool setEffectPackageDatabase(const NvParameterized::Interface* dataBase);
+	virtual bool setEffectPackageFieldSamplerDatabase(const NvParameterized::Interface* dataBase);
+
+	virtual const NvParameterized::Interface* getEffectPackageIOSDatabase(void) const
+	{
+		READ_ZONE();
+		return mEffectPackageIOSDatabaseParams;
+	};
+	virtual const NvParameterized::Interface* getEffectPackageIOFXDatabase(void) const
+	{
+		READ_ZONE();
+		return mEffectPackageIOFXDatabaseParams;
+	};
+	virtual const NvParameterized::Interface* getEffectPackageEmitterDatabase(void) const
+	{
+		READ_ZONE();
+		return mEffectPackageEmitterDatabaseParams;
+	};
+	virtual const NvParameterized::Interface* getEffectPackageDatabase(void) const
+	{
+		READ_ZONE();
+		return mEffectPackageDatabaseParams;
+	};
+	virtual const NvParameterized::Interface* getEffectPackageFieldSamplerDatabase(void) const
+	{
+		READ_ZONE();
+		return mEffectPackageFieldSamplerDatabaseParams;
+	};
+
+	bool initParticleSimulationData(ParticleSimulationData* ed);
+
+	virtual NvParameterized::Interface* locateResource(const char* resourceName,		// the name of the resource
+	        const char* nameSpace);
+
+	virtual const char** getResourceNames(const char* nameSpace, uint32_t& nameCount, const char** &variants);
+
+	virtual const NvParameterized::Interface* locateGraphicsMaterialData(const char* name) const;
+	virtual const NvParameterized::Interface* locateVolumeRenderMaterialData(const char* name) const;
+
+
+	ModuleSceneIntl* 				createInternalModuleScene(SceneIntl&, RenderDebugInterface*);
+	void						releaseModuleSceneIntl(ModuleSceneIntl&);
+	uint32_t				forceLoadAssets();
+	AuthObjTypeID				getModuleID() const;
+	RenderableIterator* 	createRenderableIterator(const Scene&);
+
+	AuthObjTypeID             getParticlesAssetTypeID() const;
+
+	uint32_t				getModuleValue() const
+	{
+		return mModuleValue;
+	}
+
+	ModuleTurbulenceFS* getModuleTurbulenceFS(void)
+	{
+		return mTurbulenceModule;
+	}
+
+	ParticlesScene* 			getParticlesScene(const Scene& apexScene);
+
+	virtual void setEnableScreenCulling(bool state, bool znegative)
+	{
+		WRITE_ZONE();
+		mEnableScreenCulling = state;
+		mZnegative = znegative;
+	}
+
+	bool getEnableScreenCulling(void) const
+	{
+		return mEnableScreenCulling;
+	}
+
+	bool getZnegative(void) const
+	{
+		return mZnegative;
+	}
+
+	virtual void resetEmitterPool(void);
+
+	virtual void setUseEmitterPool(bool state)
+	{
+		WRITE_ZONE();
+		mUseEmitterPool = state;
+	}
+
+	virtual bool getUseEmitterPool(void) const
+	{
+		READ_ZONE();
+		return mUseEmitterPool;
+	}
+
+	PxMaterial *getDefaultMaterial(void) const
+	{
+		return mDefaultMaterial;
+	}
+
+	virtual void notifyReleaseSDK(void);
+
+	virtual void notifyChildGone(ModuleIntl* imodule);
+
+protected:
+	bool						mUseEmitterPool;
+	bool						mEnableScreenCulling;
+	bool						mZnegative;
+
+	ResourceList				mAuthorableObjects;
+	ResourceList				mEffectPackageAuthorableObjects;
+
+	ResourceList				mParticlesScenes;
+
+	uint32_t				mModuleValue;
+
+	friend class ParticlesAsset;
+
+	/**
+	\brief Used by the ParticleEffectTool to initialize the default database values for the editor
+	*/
+	virtual void initializeDefaultDatabases(void);
+
+	virtual nvidia::apex::Module* getModule(const char* moduleName);
+
+private:
+
+	bool fixFieldSamplerCollisionFilterNames(NvParameterized::Interface *fs);
+
+	bool fixupNamedReferences(void);
+
+	NvParameterized::Interface*									mEffectPackageIOSDatabaseParams;
+	NvParameterized::Interface*									mEffectPackageIOFXDatabaseParams;
+	NvParameterized::Interface*									mEffectPackageEmitterDatabaseParams;
+	NvParameterized::Interface*									mEffectPackageDatabaseParams;
+	NvParameterized::Interface*									mEffectPackageFieldSamplerDatabaseParams;
+
+	ParticlesModuleParameters*									mModuleParams;
+	NvParameterized::Interface*									mGraphicsMaterialsDatabase;
+	ModuleTurbulenceFS*							mTurbulenceModule;
+	ModuleSceneVector											mScenes;
+	Array< const char*>										mTempNames;
+	Array< const char*>										mTempVariantNames;
+
+	nvidia::apex::Module* 	mModuleBasicIos;			// Instantiate the BasicIOS module statically
+	nvidia::apex::Module* 	mModuleEmitter;				// Instantiate the Emitter module statically
+	nvidia::apex::Module* 	mModuleIofx;				// Instantiate the IOFX module statically
+	nvidia::apex::Module* 	mModuleFieldSampler;		// Instantiate the field sampler module statically
+	nvidia::apex::Module* 	mModuleBasicFS;				// Instantiate the BasicFS module statically
+	nvidia::apex::Module* 	mModuleParticleIos;			// PhysX 3.x only : Instantiate the ParticleIOS module
+	nvidia::apex::Module* 	mModuleForceField;			// PhysX 3.x only : Instantiate the ForceField module
+	PxMaterial		*mDefaultMaterial;
+};
+
+}
+} // end namespace nvidia
+
+#endif // __MODULE_PARTICLES_H__
diff --git a/APEX_1.4/module/particles/include/ModulePerfScope.h b/APEX_1.4/module/particles/include/ModulePerfScope.h
new file mode 100644
index 00000000..b3e30094
--- /dev/null
+++ b/APEX_1.4/module/particles/include/ModulePerfScope.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#ifndef __MODULE_PERF_SCOPE_H___
+#define __MODULE_PERF_SCOPE_H___
+
+#define MODULE_NAMESPACE particles
+#include "ModuleProfileCommon.h"
+
+#endif
diff --git a/APEX_1.4/module/particles/include/ParticlesBase.h b/APEX_1.4/module/particles/include/ParticlesBase.h
new file mode 100644
index 00000000..282934d8
--- /dev/null
+++ b/APEX_1.4/module/particles/include/ParticlesBase.h
@@ -0,0 +1,39 @@
+/*
+ * 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 PARTICLES_BASE_H
+
+#define PARTICLES_BASE_H
+
+#include "ApexActor.h"
+
+namespace nvidia
+{
+namespace particles
+{
+
+class ParticlesBase : public ApexActor
+{
+public:
+	enum ParticlesType
+	{
+		DST_EFFECT_PACKAGE_ACTOR,
+		DST_LAST
+	};
+
+	virtual ParticlesType getParticlesType() const = 0;
+
+};
+
+}
+}
+
+#endif
diff --git a/APEX_1.4/module/particles/include/ParticlesScene.h b/APEX_1.4/module/particles/include/ParticlesScene.h
new file mode 100644
index 00000000..0715e03d
--- /dev/null
+++ b/APEX_1.4/module/particles/include/ParticlesScene.h
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#ifndef __PARTICLES_SCENE_H__
+#define __PARTICLES_SCENE_H__
+
+#include "Apex.h"
+#include "PairFilter.h"
+#include "ModuleParticlesImpl.h"
+
+#include "ApexResource.h"
+#include "ApexContext.h"
+#include "ApexSDKHelpers.h"
+
+#include "RenderDebugInterface.h"
+#include "ApexSDKIntl.h"
+#include "ModuleIntl.h"
+
+#include "DebugRenderParams.h"
+#include "ParticlesDebugRenderParams.h"
+#include "PxTask.h"
+
+namespace nvidia
+{
+
+namespace apex
+{
+class SceneIntl;
+}
+namespace emitter
+{
+class EmitterActor;
+class EmitterAsset;
+}
+
+namespace particles
+{
+
+class ModuleParticlesImpl;
+
+#define EMITTER_FORGET_TIME 30
+
+class EmitterPool
+{
+public:
+	EmitterPool()
+	{
+		mEmitter = NULL;
+		mEmitterTime = 0;
+	}
+
+	EmitterPool(EmitterActor* emitterActor, float simTime);
+
+	~EmitterPool()
+	{
+	}
+
+	bool process(float simTime);
+	void releaseEmitter();
+
+	EmitterActor* mEmitter;
+	float				mEmitterTime;
+};
+
+typedef Array< EmitterPool > EmitterPoolVector;
+
+class ParticlesScene : public ModuleSceneIntl, public ApexContext, public ApexResourceInterface, public ApexResource
+{
+public:
+
+
+	ParticlesScene(ModuleParticlesImpl& module, SceneIntl& scene, RenderDebugInterface* renderDebug, ResourceList& list);
+	~ParticlesScene();
+
+
+
+	/* ModuleSceneIntl */
+	void						updateActors(float deltaTime);
+	void						submitTasks(float elapsedTime, float substepSize, uint32_t numSubSteps);
+	virtual	void				updateFromSimulate(float dt);
+
+	virtual void				visualize();
+	virtual void				fetchResults();
+	virtual void				fetchResultsPostRenderUnlock();
+
+	virtual void				setModulePhysXScene(PxScene* s);
+	virtual PxScene*			getModulePhysXScene() const
+	{
+		return mPhysXScene;
+	}
+
+	virtual Module*			getModule()
+	{
+		return mModule;
+	}
+
+	bool							lockRenderResources()
+	{
+		renderLockAllActors();	// Lock options not implemented yet
+		return true;
+	}
+
+	bool							unlockRenderResources()
+	{
+		renderUnLockAllActors();	// Lock options not implemented yet
+		return true;
+	}
+
+	/* ApexResourceInterface */
+	uint32_t						getListIndex() const
+	{
+		return m_listIndex;
+	}
+	void						setListIndex(ResourceList& list, uint32_t index)
+	{
+		m_listIndex = index;
+		m_list = &list;
+	}
+	virtual void				release()
+	{
+		mModule->releaseModuleSceneIntl(*this);
+	}
+
+	virtual SceneStats* 	getStats()
+	{
+		return NULL;
+	}
+
+
+	SceneIntl*                mApexScene;
+
+	ModuleParticlesImpl* getModuleParticles() const
+	{
+		return mModule;
+	}
+
+	void addToEmitterPool(EmitterActor* emitterActor);
+	EmitterActor* getEmitterFromPool(EmitterAsset* assert);
+
+	void resetEmitterPool();
+
+private:
+	void						destroy();
+
+	ModuleParticlesImpl* 				mModule;
+
+	PxScene*                    mPhysXScene;
+	RenderDebugInterface* 			mRenderDebug;
+
+	DebugRenderParams*			mDebugRenderParams;
+	ParticlesDebugRenderParams*	mParticlesDebugRenderParams;
+
+	class TaskUpdate : public PxTask
+	{
+	public:
+		TaskUpdate(ParticlesScene& owner) : mOwner(owner) {}
+		const char* getName() const
+		{
+			return "ParticlesScene::Update";
+		}
+		void run();
+
+	protected:
+		ParticlesScene& mOwner;
+
+	private:
+		TaskUpdate& operator=(const TaskUpdate&);
+	};
+
+	TaskUpdate						mUpdateTask;
+	friend class ModuleParticlesImpl;
+	friend class ParticlesActor;
+	friend class TaskUpdate;
+
+
+	float								mCheckTime;
+	float								mSimTime;
+	EmitterPoolVector					mEmitterPool;
+};
+
+}
+} // end namespace nvidia
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/AttractorFieldSamplerData.h b/APEX_1.4/module/particles/include/autogen/AttractorFieldSamplerData.h
new file mode 100644
index 00000000..1cd14d6c
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/AttractorFieldSamplerData.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_AttractorFieldSamplerData_h
+#define HEADER_AttractorFieldSamplerData_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace AttractorFieldSamplerDataNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* AttractorFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0xad0ce7f8, 0x2fb85c3b, 0x5bd65a2b, 0x570e1992, };
+
+} // namespace AttractorFieldSamplerDataNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class AttractorFieldSamplerData : public NvParameterized::NvParameters, public AttractorFieldSamplerDataNS::ParametersStruct
+{
+public:
+	AttractorFieldSamplerData(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~AttractorFieldSamplerData();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("AttractorFieldSamplerData");
+	}
+
+	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(AttractorFieldSamplerDataNS::checksum);
+		return AttractorFieldSamplerDataNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const AttractorFieldSamplerDataNS::ParametersStruct& parameters(void) const
+	{
+		AttractorFieldSamplerData* tmpThis = const_cast<AttractorFieldSamplerData*>(this);
+		return *(static_cast<AttractorFieldSamplerDataNS::ParametersStruct*>(tmpThis));
+	}
+
+	AttractorFieldSamplerDataNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<AttractorFieldSamplerDataNS::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 AttractorFieldSamplerDataFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		AttractorFieldSamplerData::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(AttractorFieldSamplerData), AttractorFieldSamplerData::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, AttractorFieldSamplerData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class AttractorFieldSamplerData");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(AttractorFieldSamplerData)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, AttractorFieldSamplerData)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, AttractorFieldSamplerData::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, AttractorFieldSamplerData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class AttractorFieldSamplerData");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of AttractorFieldSamplerData 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 (AttractorFieldSamplerData*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (AttractorFieldSamplerData::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (AttractorFieldSamplerData::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (AttractorFieldSamplerData::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (AttractorFieldSamplerData::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/AttractorFieldSamplerEffect.h b/APEX_1.4/module/particles/include/autogen/AttractorFieldSamplerEffect.h
new file mode 100644
index 00000000..45856b33
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/AttractorFieldSamplerEffect.h
@@ -0,0 +1,291 @@
+// 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_AttractorFieldSamplerEffect_h
+#define HEADER_AttractorFieldSamplerEffect_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace AttractorFieldSamplerEffectNS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* AttractorFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0x360b5cf0, 0x2facb742, 0x97891fde, 0xc949869a, };
+
+} // namespace AttractorFieldSamplerEffectNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class AttractorFieldSamplerEffect : public NvParameterized::NvParameters, public AttractorFieldSamplerEffectNS::ParametersStruct
+{
+public:
+	AttractorFieldSamplerEffect(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~AttractorFieldSamplerEffect();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("AttractorFieldSamplerEffect");
+	}
+
+	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(AttractorFieldSamplerEffectNS::checksum);
+		return AttractorFieldSamplerEffectNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const AttractorFieldSamplerEffectNS::ParametersStruct& parameters(void) const
+	{
+		AttractorFieldSamplerEffect* tmpThis = const_cast<AttractorFieldSamplerEffect*>(this);
+		return *(static_cast<AttractorFieldSamplerEffectNS::ParametersStruct*>(tmpThis));
+	}
+
+	AttractorFieldSamplerEffectNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<AttractorFieldSamplerEffectNS::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 AttractorFieldSamplerEffectFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		AttractorFieldSamplerEffect::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(AttractorFieldSamplerEffect), AttractorFieldSamplerEffect::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, AttractorFieldSamplerEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class AttractorFieldSamplerEffect");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(AttractorFieldSamplerEffect)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, AttractorFieldSamplerEffect)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, AttractorFieldSamplerEffect::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, AttractorFieldSamplerEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class AttractorFieldSamplerEffect");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of AttractorFieldSamplerEffect 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 (AttractorFieldSamplerEffect*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (AttractorFieldSamplerEffect::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (AttractorFieldSamplerEffect::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (AttractorFieldSamplerEffect::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (AttractorFieldSamplerEffect::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/EffectPackageActorParams.h b/APEX_1.4/module/particles/include/autogen/EffectPackageActorParams.h
new file mode 100644
index 00000000..1ea8d499
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/EffectPackageActorParams.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_EffectPackageActorParams_h
+#define HEADER_EffectPackageActorParams_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EffectPackageActorParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxTransform InitialPose;
+	float objectScale;
+	bool Enabled;
+
+};
+
+static const uint32_t checksum[] = { 0xb5e9f529, 0x94a2ff3d, 0x5955c2b8, 0x14b06ba4, };
+
+} // namespace EffectPackageActorParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageActorParams : public NvParameterized::NvParameters, public EffectPackageActorParamsNS::ParametersStruct
+{
+public:
+	EffectPackageActorParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageActorParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageActorParams");
+	}
+
+	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(EffectPackageActorParamsNS::checksum);
+		return EffectPackageActorParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageActorParamsNS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageActorParams* tmpThis = const_cast<EffectPackageActorParams*>(this);
+		return *(static_cast<EffectPackageActorParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageActorParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageActorParamsNS::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 EffectPackageActorParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageActorParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageActorParams), EffectPackageActorParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageActorParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageActorParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageActorParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageActorParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageActorParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageActorParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageActorParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageActorParams 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 (EffectPackageActorParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageActorParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageActorParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageActorParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageActorParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/EffectPackageAssetParams.h b/APEX_1.4/module/particles/include/autogen/EffectPackageAssetParams.h
new file mode 100644
index 00000000..e23bf878
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/EffectPackageAssetParams.h
@@ -0,0 +1,298 @@
+// 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_EffectPackageAssetParams_h
+#define HEADER_EffectPackageAssetParams_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EffectPackageAssetParamsNS
+{
+
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct LevelOfDetailSettings_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct LevelOfDetailSettings_Type
+{
+	bool UniqueRenderVolume;
+	float FadeDistanceBegin;
+	float FadeDistanceEnd;
+	bool RandomizeEmitterRate;
+	float FadeOutRate;
+	bool CullByDistance;
+	bool CullOffScreen;
+	float OffScreenCullTime;
+	float NonVisibleDeleteTime;
+	float ScreenCullSize;
+	float ScreenCullDistance;
+	bool FadeEmitterRate;
+	bool FadeAttractorFieldStrength;
+	bool FadeJetFieldStrength;
+	bool FadeTurbulenceVelocity;
+	bool FadeTurbulenceNoise;
+	bool FadeTurbulenceExternalVelocity;
+	bool FadeTurbulenceVelocityWeight;
+	bool FadeHeatSourceTemperature;
+	bool FadeForceFieldStrength;
+	bool FadeForceFieldScale;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+
+struct ParametersStruct
+{
+
+	LevelOfDetailSettings_Type LODSettings;
+	EffectPath_Type Path;
+	REF_DynamicArray1D_Type Effects;
+	NvParameterized::DummyStringStruct toolString;
+
+};
+
+static const uint32_t checksum[] = { 0xdfc6da4d, 0xdcc561ad, 0x411cf278, 0x3bdc08bc, };
+
+} // namespace EffectPackageAssetParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageAssetParams : public NvParameterized::NvParameters, public EffectPackageAssetParamsNS::ParametersStruct
+{
+public:
+	EffectPackageAssetParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageAssetParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageAssetParams");
+	}
+
+	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(EffectPackageAssetParamsNS::checksum);
+		return EffectPackageAssetParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageAssetParamsNS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageAssetParams* tmpThis = const_cast<EffectPackageAssetParams*>(this);
+		return *(static_cast<EffectPackageAssetParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageAssetParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageAssetParamsNS::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 EffectPackageAssetParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageAssetParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageAssetParams), EffectPackageAssetParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageAssetParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageAssetParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageAssetParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageAssetParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageAssetParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageAssetParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageAssetParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageAssetParams 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 (EffectPackageAssetParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageAssetParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageAssetParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageAssetParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageAssetParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/EffectPackageData.h b/APEX_1.4/module/particles/include/autogen/EffectPackageData.h
new file mode 100644
index 00000000..bff5bd6d
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/EffectPackageData.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_EffectPackageData_h
+#define HEADER_EffectPackageData_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EffectPackageDataNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* EffectPackage;
+
+};
+
+static const uint32_t checksum[] = { 0x5f619c90, 0xacc5a650, 0x66393099, 0x47b4a900, };
+
+} // namespace EffectPackageDataNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageData : public NvParameterized::NvParameters, public EffectPackageDataNS::ParametersStruct
+{
+public:
+	EffectPackageData(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageData();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageData");
+	}
+
+	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(EffectPackageDataNS::checksum);
+		return EffectPackageDataNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageDataNS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageData* tmpThis = const_cast<EffectPackageData*>(this);
+		return *(static_cast<EffectPackageDataNS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageDataNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageDataNS::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 EffectPackageDataFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageData::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageData), EffectPackageData::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageData");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageData)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageData)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageData::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageData");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageData 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 (EffectPackageData*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageData::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageData::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageData::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageData::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/EffectPackageDatabaseParams.h b/APEX_1.4/module/particles/include/autogen/EffectPackageDatabaseParams.h
new file mode 100644
index 00000000..0a3a674e
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/EffectPackageDatabaseParams.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_EffectPackageDatabaseParams_h
+#define HEADER_EffectPackageDatabaseParams_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EffectPackageDatabaseParamsNS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	REF_DynamicArray1D_Type EffectPackages;
+
+};
+
+static const uint32_t checksum[] = { 0xce64f369, 0x2fc860a4, 0x3c19c701, 0xcc66c5b3, };
+
+} // namespace EffectPackageDatabaseParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageDatabaseParams : public NvParameterized::NvParameters, public EffectPackageDatabaseParamsNS::ParametersStruct
+{
+public:
+	EffectPackageDatabaseParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageDatabaseParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageDatabaseParams");
+	}
+
+	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(EffectPackageDatabaseParamsNS::checksum);
+		return EffectPackageDatabaseParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageDatabaseParamsNS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageDatabaseParams* tmpThis = const_cast<EffectPackageDatabaseParams*>(this);
+		return *(static_cast<EffectPackageDatabaseParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageDatabaseParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageDatabaseParamsNS::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 EffectPackageDatabaseParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageDatabaseParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageDatabaseParams), EffectPackageDatabaseParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageDatabaseParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageDatabaseParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageDatabaseParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageDatabaseParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageDatabaseParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageDatabaseParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageDatabaseParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageDatabaseParams 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 (EffectPackageDatabaseParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageDatabaseParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageDatabaseParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageDatabaseParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageDatabaseParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/EffectPackageEmitterDatabaseParams.h b/APEX_1.4/module/particles/include/autogen/EffectPackageEmitterDatabaseParams.h
new file mode 100644
index 00000000..01278e96
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/EffectPackageEmitterDatabaseParams.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_EffectPackageEmitterDatabaseParams_h
+#define HEADER_EffectPackageEmitterDatabaseParams_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EffectPackageEmitterDatabaseParamsNS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	REF_DynamicArray1D_Type Emitters;
+
+};
+
+static const uint32_t checksum[] = { 0x03542e55, 0x98562f65, 0x397b5760, 0xc62eb3f2, };
+
+} // namespace EffectPackageEmitterDatabaseParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageEmitterDatabaseParams : public NvParameterized::NvParameters, public EffectPackageEmitterDatabaseParamsNS::ParametersStruct
+{
+public:
+	EffectPackageEmitterDatabaseParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageEmitterDatabaseParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageEmitterDatabaseParams");
+	}
+
+	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(EffectPackageEmitterDatabaseParamsNS::checksum);
+		return EffectPackageEmitterDatabaseParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageEmitterDatabaseParamsNS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageEmitterDatabaseParams* tmpThis = const_cast<EffectPackageEmitterDatabaseParams*>(this);
+		return *(static_cast<EffectPackageEmitterDatabaseParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageEmitterDatabaseParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageEmitterDatabaseParamsNS::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 EffectPackageEmitterDatabaseParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageEmitterDatabaseParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageEmitterDatabaseParams), EffectPackageEmitterDatabaseParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageEmitterDatabaseParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageEmitterDatabaseParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageEmitterDatabaseParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageEmitterDatabaseParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageEmitterDatabaseParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageEmitterDatabaseParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageEmitterDatabaseParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageEmitterDatabaseParams 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 (EffectPackageEmitterDatabaseParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageEmitterDatabaseParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageEmitterDatabaseParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageEmitterDatabaseParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageEmitterDatabaseParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/EffectPackageFieldSamplerDatabaseParams.h b/APEX_1.4/module/particles/include/autogen/EffectPackageFieldSamplerDatabaseParams.h
new file mode 100644
index 00000000..6248964f
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/EffectPackageFieldSamplerDatabaseParams.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_EffectPackageFieldSamplerDatabaseParams_h
+#define HEADER_EffectPackageFieldSamplerDatabaseParams_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EffectPackageFieldSamplerDatabaseParamsNS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	REF_DynamicArray1D_Type FieldSamplers;
+
+};
+
+static const uint32_t checksum[] = { 0x25f62eeb, 0xf4cccc87, 0xdcd32c61, 0x8fe20316, };
+
+} // namespace EffectPackageFieldSamplerDatabaseParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageFieldSamplerDatabaseParams : public NvParameterized::NvParameters, public EffectPackageFieldSamplerDatabaseParamsNS::ParametersStruct
+{
+public:
+	EffectPackageFieldSamplerDatabaseParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageFieldSamplerDatabaseParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageFieldSamplerDatabaseParams");
+	}
+
+	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(EffectPackageFieldSamplerDatabaseParamsNS::checksum);
+		return EffectPackageFieldSamplerDatabaseParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageFieldSamplerDatabaseParamsNS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageFieldSamplerDatabaseParams* tmpThis = const_cast<EffectPackageFieldSamplerDatabaseParams*>(this);
+		return *(static_cast<EffectPackageFieldSamplerDatabaseParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageFieldSamplerDatabaseParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageFieldSamplerDatabaseParamsNS::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 EffectPackageFieldSamplerDatabaseParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageFieldSamplerDatabaseParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageFieldSamplerDatabaseParams), EffectPackageFieldSamplerDatabaseParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageFieldSamplerDatabaseParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageFieldSamplerDatabaseParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageFieldSamplerDatabaseParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageFieldSamplerDatabaseParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageFieldSamplerDatabaseParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageFieldSamplerDatabaseParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageFieldSamplerDatabaseParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageFieldSamplerDatabaseParams 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 (EffectPackageFieldSamplerDatabaseParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageFieldSamplerDatabaseParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageFieldSamplerDatabaseParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageFieldSamplerDatabaseParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageFieldSamplerDatabaseParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/EffectPackageGraphicsMaterialsParams.h b/APEX_1.4/module/particles/include/autogen/EffectPackageGraphicsMaterialsParams.h
new file mode 100644
index 00000000..868b861b
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/EffectPackageGraphicsMaterialsParams.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_EffectPackageGraphicsMaterialsParams_h
+#define HEADER_EffectPackageGraphicsMaterialsParams_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EffectPackageGraphicsMaterialsParamsNS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	REF_DynamicArray1D_Type GraphicsMaterials;
+
+};
+
+static const uint32_t checksum[] = { 0x2d879f87, 0x7b8f475b, 0xd42bfe31, 0x27efcd68, };
+
+} // namespace EffectPackageGraphicsMaterialsParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageGraphicsMaterialsParams : public NvParameterized::NvParameters, public EffectPackageGraphicsMaterialsParamsNS::ParametersStruct
+{
+public:
+	EffectPackageGraphicsMaterialsParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageGraphicsMaterialsParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageGraphicsMaterialsParams");
+	}
+
+	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(EffectPackageGraphicsMaterialsParamsNS::checksum);
+		return EffectPackageGraphicsMaterialsParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageGraphicsMaterialsParamsNS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageGraphicsMaterialsParams* tmpThis = const_cast<EffectPackageGraphicsMaterialsParams*>(this);
+		return *(static_cast<EffectPackageGraphicsMaterialsParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageGraphicsMaterialsParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageGraphicsMaterialsParamsNS::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 EffectPackageGraphicsMaterialsParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageGraphicsMaterialsParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageGraphicsMaterialsParams), EffectPackageGraphicsMaterialsParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageGraphicsMaterialsParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageGraphicsMaterialsParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageGraphicsMaterialsParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageGraphicsMaterialsParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageGraphicsMaterialsParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageGraphicsMaterialsParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageGraphicsMaterialsParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageGraphicsMaterialsParams 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 (EffectPackageGraphicsMaterialsParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageGraphicsMaterialsParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageGraphicsMaterialsParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageGraphicsMaterialsParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageGraphicsMaterialsParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/EffectPackageIOFXDatabaseParams.h b/APEX_1.4/module/particles/include/autogen/EffectPackageIOFXDatabaseParams.h
new file mode 100644
index 00000000..0f778a42
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/EffectPackageIOFXDatabaseParams.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_EffectPackageIOFXDatabaseParams_h
+#define HEADER_EffectPackageIOFXDatabaseParams_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EffectPackageIOFXDatabaseParamsNS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	REF_DynamicArray1D_Type GraphicsEffects;
+
+};
+
+static const uint32_t checksum[] = { 0x012bd755, 0x3845c426, 0x155f44aa, 0xeba55527, };
+
+} // namespace EffectPackageIOFXDatabaseParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageIOFXDatabaseParams : public NvParameterized::NvParameters, public EffectPackageIOFXDatabaseParamsNS::ParametersStruct
+{
+public:
+	EffectPackageIOFXDatabaseParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageIOFXDatabaseParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageIOFXDatabaseParams");
+	}
+
+	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(EffectPackageIOFXDatabaseParamsNS::checksum);
+		return EffectPackageIOFXDatabaseParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageIOFXDatabaseParamsNS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageIOFXDatabaseParams* tmpThis = const_cast<EffectPackageIOFXDatabaseParams*>(this);
+		return *(static_cast<EffectPackageIOFXDatabaseParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageIOFXDatabaseParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageIOFXDatabaseParamsNS::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 EffectPackageIOFXDatabaseParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageIOFXDatabaseParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageIOFXDatabaseParams), EffectPackageIOFXDatabaseParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageIOFXDatabaseParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageIOFXDatabaseParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageIOFXDatabaseParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageIOFXDatabaseParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageIOFXDatabaseParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageIOFXDatabaseParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageIOFXDatabaseParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageIOFXDatabaseParams 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 (EffectPackageIOFXDatabaseParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageIOFXDatabaseParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageIOFXDatabaseParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageIOFXDatabaseParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageIOFXDatabaseParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/EffectPackageIOSDatabaseParams.h b/APEX_1.4/module/particles/include/autogen/EffectPackageIOSDatabaseParams.h
new file mode 100644
index 00000000..9e89b754
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/EffectPackageIOSDatabaseParams.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_EffectPackageIOSDatabaseParams_h
+#define HEADER_EffectPackageIOSDatabaseParams_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EffectPackageIOSDatabaseParamsNS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	REF_DynamicArray1D_Type ParticleSimulations;
+
+};
+
+static const uint32_t checksum[] = { 0x82cbc94b, 0xb6f4c8a5, 0x5a46ce63, 0x4663e5ca, };
+
+} // namespace EffectPackageIOSDatabaseParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageIOSDatabaseParams : public NvParameterized::NvParameters, public EffectPackageIOSDatabaseParamsNS::ParametersStruct
+{
+public:
+	EffectPackageIOSDatabaseParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageIOSDatabaseParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageIOSDatabaseParams");
+	}
+
+	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(EffectPackageIOSDatabaseParamsNS::checksum);
+		return EffectPackageIOSDatabaseParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageIOSDatabaseParamsNS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageIOSDatabaseParams* tmpThis = const_cast<EffectPackageIOSDatabaseParams*>(this);
+		return *(static_cast<EffectPackageIOSDatabaseParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageIOSDatabaseParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageIOSDatabaseParamsNS::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 EffectPackageIOSDatabaseParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageIOSDatabaseParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageIOSDatabaseParams), EffectPackageIOSDatabaseParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageIOSDatabaseParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageIOSDatabaseParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageIOSDatabaseParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageIOSDatabaseParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageIOSDatabaseParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageIOSDatabaseParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageIOSDatabaseParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageIOSDatabaseParams 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 (EffectPackageIOSDatabaseParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageIOSDatabaseParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageIOSDatabaseParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageIOSDatabaseParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageIOSDatabaseParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/EmitterData.h b/APEX_1.4/module/particles/include/autogen/EmitterData.h
new file mode 100644
index 00000000..7833a2ff
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/EmitterData.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_EmitterData_h
+#define HEADER_EmitterData_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EmitterDataNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* Emitter;
+
+};
+
+static const uint32_t checksum[] = { 0xeb7077c8, 0xa36b4a9f, 0x9095c1de, 0xc60abbf7, };
+
+} // namespace EmitterDataNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EmitterData : public NvParameterized::NvParameters, public EmitterDataNS::ParametersStruct
+{
+public:
+	EmitterData(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EmitterData();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EmitterData");
+	}
+
+	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(EmitterDataNS::checksum);
+		return EmitterDataNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EmitterDataNS::ParametersStruct& parameters(void) const
+	{
+		EmitterData* tmpThis = const_cast<EmitterData*>(this);
+		return *(static_cast<EmitterDataNS::ParametersStruct*>(tmpThis));
+	}
+
+	EmitterDataNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EmitterDataNS::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 EmitterDataFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EmitterData::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EmitterData), EmitterData::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EmitterData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterData");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EmitterData)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EmitterData)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EmitterData::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EmitterData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterData");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EmitterData 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 (EmitterData*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EmitterData::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EmitterData::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EmitterData::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EmitterData::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/EmitterEffect.h b/APEX_1.4/module/particles/include/autogen/EmitterEffect.h
new file mode 100644
index 00000000..50f8916f
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/EmitterEffect.h
@@ -0,0 +1,307 @@
+// 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_EmitterEffect_h
+#define HEADER_EmitterEffect_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace EmitterEffectNS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+struct EmitterVelocityAdjust_Type;
+struct EmitterVelocityProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct EmitterVelocityAdjust_Type
+{
+	bool AdjustEnabled;
+	float VelocityLow;
+	float VelocityHigh;
+	float LowValue;
+	float HighValue;
+};
+struct EmitterVelocityProperties_Type
+{
+	EmitterVelocityAdjust_Type AdjustLifetime;
+	EmitterVelocityAdjust_Type AdjustEmitterRate;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	EmitterVelocityProperties_Type EmitterVelocityChanges;
+	NvParameterized::Interface* Emitter;
+
+};
+
+static const uint32_t checksum[] = { 0x6625c413, 0xed57cae4, 0x3c9d8836, 0xf4105a87, };
+
+} // namespace EmitterEffectNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EmitterEffect : public NvParameterized::NvParameters, public EmitterEffectNS::ParametersStruct
+{
+public:
+	EmitterEffect(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EmitterEffect();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EmitterEffect");
+	}
+
+	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(EmitterEffectNS::checksum);
+		return EmitterEffectNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EmitterEffectNS::ParametersStruct& parameters(void) const
+	{
+		EmitterEffect* tmpThis = const_cast<EmitterEffect*>(this);
+		return *(static_cast<EmitterEffectNS::ParametersStruct*>(tmpThis));
+	}
+
+	EmitterEffectNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EmitterEffectNS::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 EmitterEffectFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EmitterEffect::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EmitterEffect), EmitterEffect::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EmitterEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterEffect");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EmitterEffect)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EmitterEffect)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EmitterEffect::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EmitterEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterEffect");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EmitterEffect 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 (EmitterEffect*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EmitterEffect::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EmitterEffect::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EmitterEffect::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EmitterEffect::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/FlameEmitterData.h b/APEX_1.4/module/particles/include/autogen/FlameEmitterData.h
new file mode 100644
index 00000000..863eb4f3
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/FlameEmitterData.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_FlameEmitterData_h
+#define HEADER_FlameEmitterData_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace FlameEmitterDataNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* FlameEmitter;
+
+};
+
+static const uint32_t checksum[] = { 0x90a03422, 0x50c8e759, 0xf9df589f, 0x56836e65, };
+
+} // namespace FlameEmitterDataNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class FlameEmitterData : public NvParameterized::NvParameters, public FlameEmitterDataNS::ParametersStruct
+{
+public:
+	FlameEmitterData(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~FlameEmitterData();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("FlameEmitterData");
+	}
+
+	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(FlameEmitterDataNS::checksum);
+		return FlameEmitterDataNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const FlameEmitterDataNS::ParametersStruct& parameters(void) const
+	{
+		FlameEmitterData* tmpThis = const_cast<FlameEmitterData*>(this);
+		return *(static_cast<FlameEmitterDataNS::ParametersStruct*>(tmpThis));
+	}
+
+	FlameEmitterDataNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<FlameEmitterDataNS::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 FlameEmitterDataFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		FlameEmitterData::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(FlameEmitterData), FlameEmitterData::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, FlameEmitterData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class FlameEmitterData");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(FlameEmitterData)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, FlameEmitterData)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, FlameEmitterData::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, FlameEmitterData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class FlameEmitterData");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of FlameEmitterData 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 (FlameEmitterData*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (FlameEmitterData::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (FlameEmitterData::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (FlameEmitterData::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (FlameEmitterData::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/FlameEmitterEffect.h b/APEX_1.4/module/particles/include/autogen/FlameEmitterEffect.h
new file mode 100644
index 00000000..2fdcd943
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/FlameEmitterEffect.h
@@ -0,0 +1,291 @@
+// 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_FlameEmitterEffect_h
+#define HEADER_FlameEmitterEffect_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace FlameEmitterEffectNS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* FlameEmitter;
+
+};
+
+static const uint32_t checksum[] = { 0xb3b9f3eb, 0xe8fbc19a, 0xb1474af1, 0xf5ede5b6, };
+
+} // namespace FlameEmitterEffectNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class FlameEmitterEffect : public NvParameterized::NvParameters, public FlameEmitterEffectNS::ParametersStruct
+{
+public:
+	FlameEmitterEffect(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~FlameEmitterEffect();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("FlameEmitterEffect");
+	}
+
+	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(FlameEmitterEffectNS::checksum);
+		return FlameEmitterEffectNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const FlameEmitterEffectNS::ParametersStruct& parameters(void) const
+	{
+		FlameEmitterEffect* tmpThis = const_cast<FlameEmitterEffect*>(this);
+		return *(static_cast<FlameEmitterEffectNS::ParametersStruct*>(tmpThis));
+	}
+
+	FlameEmitterEffectNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<FlameEmitterEffectNS::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 FlameEmitterEffectFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		FlameEmitterEffect::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(FlameEmitterEffect), FlameEmitterEffect::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, FlameEmitterEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class FlameEmitterEffect");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(FlameEmitterEffect)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, FlameEmitterEffect)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, FlameEmitterEffect::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, FlameEmitterEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class FlameEmitterEffect");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of FlameEmitterEffect 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 (FlameEmitterEffect*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (FlameEmitterEffect::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (FlameEmitterEffect::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (FlameEmitterEffect::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (FlameEmitterEffect::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/ForceFieldData.h b/APEX_1.4/module/particles/include/autogen/ForceFieldData.h
new file mode 100644
index 00000000..0e081b37
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/ForceFieldData.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_ForceFieldData_h
+#define HEADER_ForceFieldData_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ForceFieldDataNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* ForceField;
+
+};
+
+static const uint32_t checksum[] = { 0x0c7aa318, 0x555a616b, 0x584651f3, 0xec048707, };
+
+} // namespace ForceFieldDataNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ForceFieldData : public NvParameterized::NvParameters, public ForceFieldDataNS::ParametersStruct
+{
+public:
+	ForceFieldData(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ForceFieldData();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ForceFieldData");
+	}
+
+	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(ForceFieldDataNS::checksum);
+		return ForceFieldDataNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ForceFieldDataNS::ParametersStruct& parameters(void) const
+	{
+		ForceFieldData* tmpThis = const_cast<ForceFieldData*>(this);
+		return *(static_cast<ForceFieldDataNS::ParametersStruct*>(tmpThis));
+	}
+
+	ForceFieldDataNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ForceFieldDataNS::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 ForceFieldDataFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ForceFieldData::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ForceFieldData), ForceFieldData::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ForceFieldData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldData");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ForceFieldData)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ForceFieldData)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ForceFieldData::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ForceFieldData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldData");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ForceFieldData 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 (ForceFieldData*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ForceFieldData::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ForceFieldData::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ForceFieldData::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ForceFieldData::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/ForceFieldEffect.h b/APEX_1.4/module/particles/include/autogen/ForceFieldEffect.h
new file mode 100644
index 00000000..86d18114
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/ForceFieldEffect.h
@@ -0,0 +1,291 @@
+// 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_ForceFieldEffect_h
+#define HEADER_ForceFieldEffect_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ForceFieldEffectNS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* ForceField;
+
+};
+
+static const uint32_t checksum[] = { 0x2b5fd898, 0x8edc0468, 0x993e03e6, 0x7223fc69, };
+
+} // namespace ForceFieldEffectNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ForceFieldEffect : public NvParameterized::NvParameters, public ForceFieldEffectNS::ParametersStruct
+{
+public:
+	ForceFieldEffect(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ForceFieldEffect();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ForceFieldEffect");
+	}
+
+	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(ForceFieldEffectNS::checksum);
+		return ForceFieldEffectNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ForceFieldEffectNS::ParametersStruct& parameters(void) const
+	{
+		ForceFieldEffect* tmpThis = const_cast<ForceFieldEffect*>(this);
+		return *(static_cast<ForceFieldEffectNS::ParametersStruct*>(tmpThis));
+	}
+
+	ForceFieldEffectNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ForceFieldEffectNS::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 ForceFieldEffectFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ForceFieldEffect::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ForceFieldEffect), ForceFieldEffect::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ForceFieldEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldEffect");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ForceFieldEffect)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ForceFieldEffect)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ForceFieldEffect::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ForceFieldEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldEffect");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ForceFieldEffect 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 (ForceFieldEffect*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ForceFieldEffect::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ForceFieldEffect::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ForceFieldEffect::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ForceFieldEffect::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/GraphicsEffectData.h b/APEX_1.4/module/particles/include/autogen/GraphicsEffectData.h
new file mode 100644
index 00000000..85bf8bad
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/GraphicsEffectData.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_GraphicsEffectData_h
+#define HEADER_GraphicsEffectData_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace GraphicsEffectDataNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* IOFX;
+
+};
+
+static const uint32_t checksum[] = { 0xe35d59af, 0xb5a73c73, 0x8c86843a, 0x40cac44d, };
+
+} // namespace GraphicsEffectDataNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class GraphicsEffectData : public NvParameterized::NvParameters, public GraphicsEffectDataNS::ParametersStruct
+{
+public:
+	GraphicsEffectData(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~GraphicsEffectData();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("GraphicsEffectData");
+	}
+
+	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(GraphicsEffectDataNS::checksum);
+		return GraphicsEffectDataNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const GraphicsEffectDataNS::ParametersStruct& parameters(void) const
+	{
+		GraphicsEffectData* tmpThis = const_cast<GraphicsEffectData*>(this);
+		return *(static_cast<GraphicsEffectDataNS::ParametersStruct*>(tmpThis));
+	}
+
+	GraphicsEffectDataNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<GraphicsEffectDataNS::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 GraphicsEffectDataFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		GraphicsEffectData::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(GraphicsEffectData), GraphicsEffectData::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, GraphicsEffectData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GraphicsEffectData");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(GraphicsEffectData)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, GraphicsEffectData)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, GraphicsEffectData::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, GraphicsEffectData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GraphicsEffectData");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of GraphicsEffectData 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 (GraphicsEffectData*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (GraphicsEffectData::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (GraphicsEffectData::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (GraphicsEffectData::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (GraphicsEffectData::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/GraphicsMaterialData.h b/APEX_1.4/module/particles/include/autogen/GraphicsMaterialData.h
new file mode 100644
index 00000000..b1f49747
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/GraphicsMaterialData.h
@@ -0,0 +1,252 @@
+// 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_GraphicsMaterialData_h
+#define HEADER_GraphicsMaterialData_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace GraphicsMaterialDataNS
+{
+
+struct FrustumPSM_Type;
+
+struct FrustumPSM_Type
+{
+	bool ShowFrustum;
+	float FrustumDepth;
+	float FrustumSize;
+};
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::DummyStringStruct ApplicationMaterialName;
+	NvParameterized::DummyStringStruct UserProperties;
+	const char* RenderTechnique;
+	NvParameterized::DummyStringStruct DiffuseTexture;
+	uint32_t CellColumn;
+	uint32_t CellRow;
+	uint32_t CellCount;
+	bool CrossBlend;
+	float ColorMultiplier;
+	bool UsePSM;
+	const char* Resolution;
+	uint32_t FullResPercent;
+	uint32_t HalfResPercent;
+	float PSM_ShadowBias;
+	FrustumPSM_Type PSM_Frustum;
+
+};
+
+static const uint32_t checksum[] = { 0xbf6d3670, 0xa7e5523c, 0xb276fd23, 0x81d15eb6, };
+
+} // namespace GraphicsMaterialDataNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class GraphicsMaterialData : public NvParameterized::NvParameters, public GraphicsMaterialDataNS::ParametersStruct
+{
+public:
+	GraphicsMaterialData(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~GraphicsMaterialData();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("GraphicsMaterialData");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)4;
+
+	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(GraphicsMaterialDataNS::checksum);
+		return GraphicsMaterialDataNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const GraphicsMaterialDataNS::ParametersStruct& parameters(void) const
+	{
+		GraphicsMaterialData* tmpThis = const_cast<GraphicsMaterialData*>(this);
+		return *(static_cast<GraphicsMaterialDataNS::ParametersStruct*>(tmpThis));
+	}
+
+	GraphicsMaterialDataNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<GraphicsMaterialDataNS::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 GraphicsMaterialDataFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		GraphicsMaterialData::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(GraphicsMaterialData), GraphicsMaterialData::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, GraphicsMaterialData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GraphicsMaterialData");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(GraphicsMaterialData)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, GraphicsMaterialData)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, GraphicsMaterialData::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, GraphicsMaterialData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GraphicsMaterialData");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of GraphicsMaterialData 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 (GraphicsMaterialData*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (GraphicsMaterialData::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (GraphicsMaterialData::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (GraphicsMaterialData::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (GraphicsMaterialData::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/HeatSourceData.h b/APEX_1.4/module/particles/include/autogen/HeatSourceData.h
new file mode 100644
index 00000000..94a9cbaf
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/HeatSourceData.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_HeatSourceData_h
+#define HEADER_HeatSourceData_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace HeatSourceDataNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* HeatSource;
+
+};
+
+static const uint32_t checksum[] = { 0x95cb6853, 0x83e850af, 0xe32f27b8, 0xc0ec3b33, };
+
+} // namespace HeatSourceDataNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class HeatSourceData : public NvParameterized::NvParameters, public HeatSourceDataNS::ParametersStruct
+{
+public:
+	HeatSourceData(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~HeatSourceData();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("HeatSourceData");
+	}
+
+	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(HeatSourceDataNS::checksum);
+		return HeatSourceDataNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const HeatSourceDataNS::ParametersStruct& parameters(void) const
+	{
+		HeatSourceData* tmpThis = const_cast<HeatSourceData*>(this);
+		return *(static_cast<HeatSourceDataNS::ParametersStruct*>(tmpThis));
+	}
+
+	HeatSourceDataNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<HeatSourceDataNS::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 HeatSourceDataFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		HeatSourceData::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(HeatSourceData), HeatSourceData::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, HeatSourceData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class HeatSourceData");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(HeatSourceData)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, HeatSourceData)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, HeatSourceData::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, HeatSourceData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class HeatSourceData");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of HeatSourceData 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 (HeatSourceData*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (HeatSourceData::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (HeatSourceData::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (HeatSourceData::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (HeatSourceData::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/HeatSourceEffect.h b/APEX_1.4/module/particles/include/autogen/HeatSourceEffect.h
new file mode 100644
index 00000000..d8a85408
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/HeatSourceEffect.h
@@ -0,0 +1,291 @@
+// 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_HeatSourceEffect_h
+#define HEADER_HeatSourceEffect_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace HeatSourceEffectNS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* HeatSource;
+
+};
+
+static const uint32_t checksum[] = { 0x36c6c535, 0xacde2d3c, 0x02d6822e, 0x61a889a1, };
+
+} // namespace HeatSourceEffectNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class HeatSourceEffect : public NvParameterized::NvParameters, public HeatSourceEffectNS::ParametersStruct
+{
+public:
+	HeatSourceEffect(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~HeatSourceEffect();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("HeatSourceEffect");
+	}
+
+	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(HeatSourceEffectNS::checksum);
+		return HeatSourceEffectNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const HeatSourceEffectNS::ParametersStruct& parameters(void) const
+	{
+		HeatSourceEffect* tmpThis = const_cast<HeatSourceEffect*>(this);
+		return *(static_cast<HeatSourceEffectNS::ParametersStruct*>(tmpThis));
+	}
+
+	HeatSourceEffectNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<HeatSourceEffectNS::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 HeatSourceEffectFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		HeatSourceEffect::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(HeatSourceEffect), HeatSourceEffect::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, HeatSourceEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class HeatSourceEffect");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(HeatSourceEffect)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, HeatSourceEffect)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, HeatSourceEffect::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, HeatSourceEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class HeatSourceEffect");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of HeatSourceEffect 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 (HeatSourceEffect*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (HeatSourceEffect::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (HeatSourceEffect::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (HeatSourceEffect::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (HeatSourceEffect::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/JetFieldSamplerData.h b/APEX_1.4/module/particles/include/autogen/JetFieldSamplerData.h
new file mode 100644
index 00000000..d54063c7
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/JetFieldSamplerData.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_JetFieldSamplerData_h
+#define HEADER_JetFieldSamplerData_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace JetFieldSamplerDataNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* JetFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0x03f96027, 0x2e12817c, 0xbde0a2fa, 0xc47c7a9d, };
+
+} // namespace JetFieldSamplerDataNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class JetFieldSamplerData : public NvParameterized::NvParameters, public JetFieldSamplerDataNS::ParametersStruct
+{
+public:
+	JetFieldSamplerData(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~JetFieldSamplerData();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("JetFieldSamplerData");
+	}
+
+	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(JetFieldSamplerDataNS::checksum);
+		return JetFieldSamplerDataNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const JetFieldSamplerDataNS::ParametersStruct& parameters(void) const
+	{
+		JetFieldSamplerData* tmpThis = const_cast<JetFieldSamplerData*>(this);
+		return *(static_cast<JetFieldSamplerDataNS::ParametersStruct*>(tmpThis));
+	}
+
+	JetFieldSamplerDataNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<JetFieldSamplerDataNS::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 JetFieldSamplerDataFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		JetFieldSamplerData::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(JetFieldSamplerData), JetFieldSamplerData::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, JetFieldSamplerData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class JetFieldSamplerData");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(JetFieldSamplerData)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, JetFieldSamplerData)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, JetFieldSamplerData::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, JetFieldSamplerData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class JetFieldSamplerData");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of JetFieldSamplerData 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 (JetFieldSamplerData*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (JetFieldSamplerData::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (JetFieldSamplerData::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (JetFieldSamplerData::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (JetFieldSamplerData::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/JetFieldSamplerEffect.h b/APEX_1.4/module/particles/include/autogen/JetFieldSamplerEffect.h
new file mode 100644
index 00000000..4823e5e7
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/JetFieldSamplerEffect.h
@@ -0,0 +1,291 @@
+// 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_JetFieldSamplerEffect_h
+#define HEADER_JetFieldSamplerEffect_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace JetFieldSamplerEffectNS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* JetFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0x7b0238b8, 0xac56941a, 0x7b0fd303, 0x27182e77, };
+
+} // namespace JetFieldSamplerEffectNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class JetFieldSamplerEffect : public NvParameterized::NvParameters, public JetFieldSamplerEffectNS::ParametersStruct
+{
+public:
+	JetFieldSamplerEffect(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~JetFieldSamplerEffect();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("JetFieldSamplerEffect");
+	}
+
+	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(JetFieldSamplerEffectNS::checksum);
+		return JetFieldSamplerEffectNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const JetFieldSamplerEffectNS::ParametersStruct& parameters(void) const
+	{
+		JetFieldSamplerEffect* tmpThis = const_cast<JetFieldSamplerEffect*>(this);
+		return *(static_cast<JetFieldSamplerEffectNS::ParametersStruct*>(tmpThis));
+	}
+
+	JetFieldSamplerEffectNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<JetFieldSamplerEffectNS::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 JetFieldSamplerEffectFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		JetFieldSamplerEffect::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(JetFieldSamplerEffect), JetFieldSamplerEffect::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, JetFieldSamplerEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class JetFieldSamplerEffect");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(JetFieldSamplerEffect)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, JetFieldSamplerEffect)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, JetFieldSamplerEffect::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, JetFieldSamplerEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class JetFieldSamplerEffect");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of JetFieldSamplerEffect 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 (JetFieldSamplerEffect*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (JetFieldSamplerEffect::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (JetFieldSamplerEffect::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (JetFieldSamplerEffect::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (JetFieldSamplerEffect::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/ModuleParticlesRegistration.h b/APEX_1.4/module/particles/include/autogen/ModuleParticlesRegistration.h
new file mode 100644
index 00000000..26d65092
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/ModuleParticlesRegistration.h
@@ -0,0 +1,231 @@
+/*
+ * 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_MODULEPARTICLESREGISTRATIONH_H
+#define MODULE_MODULEPARTICLESREGISTRATIONH_H
+
+#include "PsAllocator.h"
+#include "NvRegistrationsForTraitsBase.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "PxAssert.h"
+#include <stdint.h>
+
+// INCLUDE GENERATED FACTORIES
+#include "EffectPackageActorParams.h"
+#include "EffectPackageAssetParams.h"
+#include "HeatSourceEffect.h"
+#include "EmitterEffect.h"
+#include "ForceFieldEffect.h"
+#include "TurbulenceFieldSamplerEffect.h"
+#include "AttractorFieldSamplerEffect.h"
+#include "JetFieldSamplerEffect.h"
+#include "NoiseFieldSamplerEffect.h"
+#include "VortexFieldSamplerEffect.h"
+#include "SubstanceSourceEffect.h"
+#include "WindFieldSamplerEffect.h"
+#include "RigidBodyEffect.h"
+#include "VelocitySourceEffect.h"
+#include "FlameEmitterEffect.h"
+#include "EffectPackageDatabaseParams.h"
+#include "EffectPackageData.h"
+#include "ParticlesDebugRenderParams.h"
+#include "EffectPackageEmitterDatabaseParams.h"
+#include "EmitterData.h"
+#include "EffectPackageFieldSamplerDatabaseParams.h"
+#include "AttractorFieldSamplerData.h"
+#include "HeatSourceData.h"
+#include "JetFieldSamplerData.h"
+#include "TurbulenceFieldSamplerData.h"
+#include "ForceFieldData.h"
+#include "NoiseFieldSamplerData.h"
+#include "VortexFieldSamplerData.h"
+#include "SubstanceSourceData.h"
+#include "WindFieldSamplerData.h"
+#include "VelocitySourceData.h"
+#include "FlameEmitterData.h"
+#include "EffectPackageGraphicsMaterialsParams.h"
+#include "GraphicsMaterialData.h"
+#include "VolumeRenderMaterialData.h"
+#include "EffectPackageIOFXDatabaseParams.h"
+#include "GraphicsEffectData.h"
+#include "EffectPackageIOSDatabaseParams.h"
+#include "ParticleSimulationData.h"
+#include "ParticlesModuleParameters.h"
+
+
+// INCLUDE GENERATED CONVERSION
+
+
+namespace nvidia {
+namespace particles {
+
+
+class ModuleParticlesRegistration : public NvParameterized::RegistrationsForTraitsBase
+{
+public:
+	static void invokeRegistration(NvParameterized::Traits* parameterizedTraits)
+	{
+		if (parameterizedTraits)
+		{
+			ModuleParticlesRegistration().registerAll(*parameterizedTraits);
+		}
+	}
+
+	static void invokeUnregistration(NvParameterized::Traits* parameterizedTraits)
+	{
+		if (parameterizedTraits)
+		{
+			ModuleParticlesRegistration().unregisterAll(*parameterizedTraits);
+		}
+	}
+
+	void registerAvailableFactories(NvParameterized::Traits& parameterizedTraits)
+	{
+		::NvParameterized::Factory* factoriesToRegister[] = {
+// REGISTER GENERATED FACTORIES
+			new nvidia::particles::EffectPackageActorParamsFactory(),
+			new nvidia::particles::EffectPackageAssetParamsFactory(),
+			new nvidia::particles::HeatSourceEffectFactory(),
+			new nvidia::particles::EmitterEffectFactory(),
+			new nvidia::particles::ForceFieldEffectFactory(),
+			new nvidia::particles::TurbulenceFieldSamplerEffectFactory(),
+			new nvidia::particles::AttractorFieldSamplerEffectFactory(),
+			new nvidia::particles::JetFieldSamplerEffectFactory(),
+			new nvidia::particles::NoiseFieldSamplerEffectFactory(),
+			new nvidia::particles::VortexFieldSamplerEffectFactory(),
+			new nvidia::particles::SubstanceSourceEffectFactory(),
+			new nvidia::particles::WindFieldSamplerEffectFactory(),
+			new nvidia::particles::RigidBodyEffectFactory(),
+			new nvidia::particles::VelocitySourceEffectFactory(),
+			new nvidia::particles::FlameEmitterEffectFactory(),
+			new nvidia::particles::EffectPackageDatabaseParamsFactory(),
+			new nvidia::particles::EffectPackageDataFactory(),
+			new nvidia::particles::ParticlesDebugRenderParamsFactory(),
+			new nvidia::particles::EffectPackageEmitterDatabaseParamsFactory(),
+			new nvidia::particles::EmitterDataFactory(),
+			new nvidia::particles::EffectPackageFieldSamplerDatabaseParamsFactory(),
+			new nvidia::particles::AttractorFieldSamplerDataFactory(),
+			new nvidia::particles::HeatSourceDataFactory(),
+			new nvidia::particles::JetFieldSamplerDataFactory(),
+			new nvidia::particles::TurbulenceFieldSamplerDataFactory(),
+			new nvidia::particles::ForceFieldDataFactory(),
+			new nvidia::particles::NoiseFieldSamplerDataFactory(),
+			new nvidia::particles::VortexFieldSamplerDataFactory(),
+			new nvidia::particles::SubstanceSourceDataFactory(),
+			new nvidia::particles::WindFieldSamplerDataFactory(),
+			new nvidia::particles::VelocitySourceDataFactory(),
+			new nvidia::particles::FlameEmitterDataFactory(),
+			new nvidia::particles::EffectPackageGraphicsMaterialsParamsFactory(),
+			new nvidia::particles::GraphicsMaterialDataFactory(),
+			new nvidia::particles::VolumeRenderMaterialDataFactory(),
+			new nvidia::particles::EffectPackageIOFXDatabaseParamsFactory(),
+			new nvidia::particles::GraphicsEffectDataFactory(),
+			new nvidia::particles::EffectPackageIOSDatabaseParamsFactory(),
+			new nvidia::particles::ParticleSimulationDataFactory(),
+			new nvidia::particles::ParticlesModuleParametersFactory(),
+
+		};
+
+		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::particles::EffectPackageActorParamsFactory(),
+			new nvidia::particles::EffectPackageAssetParamsFactory(),
+			new nvidia::particles::HeatSourceEffectFactory(),
+			new nvidia::particles::EmitterEffectFactory(),
+			new nvidia::particles::ForceFieldEffectFactory(),
+			new nvidia::particles::TurbulenceFieldSamplerEffectFactory(),
+			new nvidia::particles::AttractorFieldSamplerEffectFactory(),
+			new nvidia::particles::JetFieldSamplerEffectFactory(),
+			new nvidia::particles::NoiseFieldSamplerEffectFactory(),
+			new nvidia::particles::VortexFieldSamplerEffectFactory(),
+			new nvidia::particles::SubstanceSourceEffectFactory(),
+			new nvidia::particles::WindFieldSamplerEffectFactory(),
+			new nvidia::particles::RigidBodyEffectFactory(),
+			new nvidia::particles::VelocitySourceEffectFactory(),
+			new nvidia::particles::FlameEmitterEffectFactory(),
+			new nvidia::particles::EffectPackageDatabaseParamsFactory(),
+			new nvidia::particles::EffectPackageDataFactory(),
+			new nvidia::particles::ParticlesDebugRenderParamsFactory(),
+			new nvidia::particles::EffectPackageEmitterDatabaseParamsFactory(),
+			new nvidia::particles::EmitterDataFactory(),
+			new nvidia::particles::EffectPackageFieldSamplerDatabaseParamsFactory(),
+			new nvidia::particles::AttractorFieldSamplerDataFactory(),
+			new nvidia::particles::HeatSourceDataFactory(),
+			new nvidia::particles::JetFieldSamplerDataFactory(),
+			new nvidia::particles::TurbulenceFieldSamplerDataFactory(),
+			new nvidia::particles::ForceFieldDataFactory(),
+			new nvidia::particles::NoiseFieldSamplerDataFactory(),
+			new nvidia::particles::VortexFieldSamplerDataFactory(),
+			new nvidia::particles::SubstanceSourceDataFactory(),
+			new nvidia::particles::WindFieldSamplerDataFactory(),
+			new nvidia::particles::VelocitySourceDataFactory(),
+			new nvidia::particles::FlameEmitterDataFactory(),
+			new nvidia::particles::EffectPackageGraphicsMaterialsParamsFactory(),
+			new nvidia::particles::GraphicsMaterialDataFactory(),
+			new nvidia::particles::VolumeRenderMaterialDataFactory(),
+			new nvidia::particles::EffectPackageIOFXDatabaseParamsFactory(),
+			new nvidia::particles::GraphicsEffectDataFactory(),
+			new nvidia::particles::EffectPackageIOSDatabaseParamsFactory(),
+			new nvidia::particles::ParticleSimulationDataFactory(),
+			new nvidia::particles::ParticlesModuleParametersFactory(),
+
+		};
+
+		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::particles
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/NoiseFieldSamplerData.h b/APEX_1.4/module/particles/include/autogen/NoiseFieldSamplerData.h
new file mode 100644
index 00000000..4cc74c37
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/NoiseFieldSamplerData.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_NoiseFieldSamplerData_h
+#define HEADER_NoiseFieldSamplerData_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace NoiseFieldSamplerDataNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* NoiseFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0xbdfbe8fa, 0xb764fe79, 0xb6ab4054, 0x6b459674, };
+
+} // namespace NoiseFieldSamplerDataNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class NoiseFieldSamplerData : public NvParameterized::NvParameters, public NoiseFieldSamplerDataNS::ParametersStruct
+{
+public:
+	NoiseFieldSamplerData(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~NoiseFieldSamplerData();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("NoiseFieldSamplerData");
+	}
+
+	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(NoiseFieldSamplerDataNS::checksum);
+		return NoiseFieldSamplerDataNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const NoiseFieldSamplerDataNS::ParametersStruct& parameters(void) const
+	{
+		NoiseFieldSamplerData* tmpThis = const_cast<NoiseFieldSamplerData*>(this);
+		return *(static_cast<NoiseFieldSamplerDataNS::ParametersStruct*>(tmpThis));
+	}
+
+	NoiseFieldSamplerDataNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<NoiseFieldSamplerDataNS::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 NoiseFieldSamplerDataFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		NoiseFieldSamplerData::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(NoiseFieldSamplerData), NoiseFieldSamplerData::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, NoiseFieldSamplerData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class NoiseFieldSamplerData");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(NoiseFieldSamplerData)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, NoiseFieldSamplerData)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, NoiseFieldSamplerData::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, NoiseFieldSamplerData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class NoiseFieldSamplerData");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of NoiseFieldSamplerData 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 (NoiseFieldSamplerData*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (NoiseFieldSamplerData::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (NoiseFieldSamplerData::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (NoiseFieldSamplerData::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (NoiseFieldSamplerData::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/NoiseFieldSamplerEffect.h b/APEX_1.4/module/particles/include/autogen/NoiseFieldSamplerEffect.h
new file mode 100644
index 00000000..01aa6ef2
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/NoiseFieldSamplerEffect.h
@@ -0,0 +1,291 @@
+// 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_NoiseFieldSamplerEffect_h
+#define HEADER_NoiseFieldSamplerEffect_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace NoiseFieldSamplerEffectNS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* NoiseFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0x5618cee8, 0xe4396e4b, 0x83c38fec, 0x332388c5, };
+
+} // namespace NoiseFieldSamplerEffectNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class NoiseFieldSamplerEffect : public NvParameterized::NvParameters, public NoiseFieldSamplerEffectNS::ParametersStruct
+{
+public:
+	NoiseFieldSamplerEffect(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~NoiseFieldSamplerEffect();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("NoiseFieldSamplerEffect");
+	}
+
+	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(NoiseFieldSamplerEffectNS::checksum);
+		return NoiseFieldSamplerEffectNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const NoiseFieldSamplerEffectNS::ParametersStruct& parameters(void) const
+	{
+		NoiseFieldSamplerEffect* tmpThis = const_cast<NoiseFieldSamplerEffect*>(this);
+		return *(static_cast<NoiseFieldSamplerEffectNS::ParametersStruct*>(tmpThis));
+	}
+
+	NoiseFieldSamplerEffectNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<NoiseFieldSamplerEffectNS::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 NoiseFieldSamplerEffectFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		NoiseFieldSamplerEffect::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(NoiseFieldSamplerEffect), NoiseFieldSamplerEffect::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, NoiseFieldSamplerEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class NoiseFieldSamplerEffect");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(NoiseFieldSamplerEffect)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, NoiseFieldSamplerEffect)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, NoiseFieldSamplerEffect::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, NoiseFieldSamplerEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class NoiseFieldSamplerEffect");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of NoiseFieldSamplerEffect 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 (NoiseFieldSamplerEffect*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (NoiseFieldSamplerEffect::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (NoiseFieldSamplerEffect::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (NoiseFieldSamplerEffect::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (NoiseFieldSamplerEffect::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/ParticleSimulationData.h b/APEX_1.4/module/particles/include/autogen/ParticleSimulationData.h
new file mode 100644
index 00000000..3e9343df
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/ParticleSimulationData.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_ParticleSimulationData_h
+#define HEADER_ParticleSimulationData_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ParticleSimulationDataNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* IOS;
+
+};
+
+static const uint32_t checksum[] = { 0x4ca98ba8, 0x2d988101, 0xc0f27951, 0x9b625d89, };
+
+} // namespace ParticleSimulationDataNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ParticleSimulationData : public NvParameterized::NvParameters, public ParticleSimulationDataNS::ParametersStruct
+{
+public:
+	ParticleSimulationData(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ParticleSimulationData();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ParticleSimulationData");
+	}
+
+	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(ParticleSimulationDataNS::checksum);
+		return ParticleSimulationDataNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ParticleSimulationDataNS::ParametersStruct& parameters(void) const
+	{
+		ParticleSimulationData* tmpThis = const_cast<ParticleSimulationData*>(this);
+		return *(static_cast<ParticleSimulationDataNS::ParametersStruct*>(tmpThis));
+	}
+
+	ParticleSimulationDataNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ParticleSimulationDataNS::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 ParticleSimulationDataFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ParticleSimulationData::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ParticleSimulationData), ParticleSimulationData::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ParticleSimulationData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ParticleSimulationData");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ParticleSimulationData)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ParticleSimulationData)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ParticleSimulationData::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ParticleSimulationData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ParticleSimulationData");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ParticleSimulationData 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 (ParticleSimulationData*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ParticleSimulationData::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ParticleSimulationData::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ParticleSimulationData::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ParticleSimulationData::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/ParticlesDebugRenderParams.h b/APEX_1.4/module/particles/include/autogen/ParticlesDebugRenderParams.h
new file mode 100644
index 00000000..f660872e
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/ParticlesDebugRenderParams.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_ParticlesDebugRenderParams_h
+#define HEADER_ParticlesDebugRenderParams_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ParticlesDebugRenderParamsNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	bool VISUALIZE_HEAT_SOURCE_ACTOR;
+	bool VISUALIZE_EFFECT_PACKAGE_ACTOR;
+
+};
+
+static const uint32_t checksum[] = { 0x85e707bb, 0x319491d5, 0x1be4a6e4, 0x78bfbdf4, };
+
+} // namespace ParticlesDebugRenderParamsNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ParticlesDebugRenderParams : public NvParameterized::NvParameters, public ParticlesDebugRenderParamsNS::ParametersStruct
+{
+public:
+	ParticlesDebugRenderParams(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ParticlesDebugRenderParams();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ParticlesDebugRenderParams");
+	}
+
+	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(ParticlesDebugRenderParamsNS::checksum);
+		return ParticlesDebugRenderParamsNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ParticlesDebugRenderParamsNS::ParametersStruct& parameters(void) const
+	{
+		ParticlesDebugRenderParams* tmpThis = const_cast<ParticlesDebugRenderParams*>(this);
+		return *(static_cast<ParticlesDebugRenderParamsNS::ParametersStruct*>(tmpThis));
+	}
+
+	ParticlesDebugRenderParamsNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ParticlesDebugRenderParamsNS::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 ParticlesDebugRenderParamsFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ParticlesDebugRenderParams::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ParticlesDebugRenderParams), ParticlesDebugRenderParams::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ParticlesDebugRenderParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ParticlesDebugRenderParams");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ParticlesDebugRenderParams)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ParticlesDebugRenderParams)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ParticlesDebugRenderParams::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ParticlesDebugRenderParams::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ParticlesDebugRenderParams");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ParticlesDebugRenderParams 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 (ParticlesDebugRenderParams*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ParticlesDebugRenderParams::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ParticlesDebugRenderParams::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ParticlesDebugRenderParams::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ParticlesDebugRenderParams::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/ParticlesModuleParameters.h b/APEX_1.4/module/particles/include/autogen/ParticlesModuleParameters.h
new file mode 100644
index 00000000..87dc6397
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/ParticlesModuleParameters.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_ParticlesModuleParameters_h
+#define HEADER_ParticlesModuleParameters_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace ParticlesModuleParametersNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	uint32_t unused;
+
+};
+
+static const uint32_t checksum[] = { 0xb5f7f96c, 0x545549c7, 0xb6efe84c, 0x4bdc0f31, };
+
+} // namespace ParticlesModuleParametersNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ParticlesModuleParameters : public NvParameterized::NvParameters, public ParticlesModuleParametersNS::ParametersStruct
+{
+public:
+	ParticlesModuleParameters(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ParticlesModuleParameters();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ParticlesModuleParameters");
+	}
+
+	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(ParticlesModuleParametersNS::checksum);
+		return ParticlesModuleParametersNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ParticlesModuleParametersNS::ParametersStruct& parameters(void) const
+	{
+		ParticlesModuleParameters* tmpThis = const_cast<ParticlesModuleParameters*>(this);
+		return *(static_cast<ParticlesModuleParametersNS::ParametersStruct*>(tmpThis));
+	}
+
+	ParticlesModuleParametersNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ParticlesModuleParametersNS::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 ParticlesModuleParametersFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ParticlesModuleParameters::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ParticlesModuleParameters), ParticlesModuleParameters::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ParticlesModuleParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ParticlesModuleParameters");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ParticlesModuleParameters)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ParticlesModuleParameters)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ParticlesModuleParameters::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ParticlesModuleParameters::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ParticlesModuleParameters");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ParticlesModuleParameters 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 (ParticlesModuleParameters*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ParticlesModuleParameters::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ParticlesModuleParameters::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ParticlesModuleParameters::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ParticlesModuleParameters::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/RigidBodyEffect.h b/APEX_1.4/module/particles/include/autogen/RigidBodyEffect.h
new file mode 100644
index 00000000..3c3a8edb
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/RigidBodyEffect.h
@@ -0,0 +1,300 @@
+// 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_RigidBodyEffect_h
+#define HEADER_RigidBodyEffect_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace RigidBodyEffectNS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	const char* Type;
+	NvParameterized::DummyStringStruct CollisionFilterDataName;
+	bool Dynamic;
+	bool Gravity;
+	physx::PxVec3 Extents;
+	float Mass;
+	physx::PxVec3 InitialLinearVelocity;
+	physx::PxVec3 InitialAngularVelocity;
+	float LinearDamping;
+	float AngularDamping;
+
+};
+
+static const uint32_t checksum[] = { 0x9a107d98, 0x19620918, 0x9994ec69, 0x14939e5c, };
+
+} // namespace RigidBodyEffectNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class RigidBodyEffect : public NvParameterized::NvParameters, public RigidBodyEffectNS::ParametersStruct
+{
+public:
+	RigidBodyEffect(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~RigidBodyEffect();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("RigidBodyEffect");
+	}
+
+	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(RigidBodyEffectNS::checksum);
+		return RigidBodyEffectNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const RigidBodyEffectNS::ParametersStruct& parameters(void) const
+	{
+		RigidBodyEffect* tmpThis = const_cast<RigidBodyEffect*>(this);
+		return *(static_cast<RigidBodyEffectNS::ParametersStruct*>(tmpThis));
+	}
+
+	RigidBodyEffectNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<RigidBodyEffectNS::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 RigidBodyEffectFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		RigidBodyEffect::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(RigidBodyEffect), RigidBodyEffect::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, RigidBodyEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RigidBodyEffect");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(RigidBodyEffect)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, RigidBodyEffect)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, RigidBodyEffect::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, RigidBodyEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RigidBodyEffect");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of RigidBodyEffect 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 (RigidBodyEffect*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (RigidBodyEffect::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (RigidBodyEffect::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (RigidBodyEffect::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (RigidBodyEffect::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/SubstanceSourceData.h b/APEX_1.4/module/particles/include/autogen/SubstanceSourceData.h
new file mode 100644
index 00000000..d6682bf2
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/SubstanceSourceData.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_SubstanceSourceData_h
+#define HEADER_SubstanceSourceData_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace SubstanceSourceDataNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* SubstanceSource;
+
+};
+
+static const uint32_t checksum[] = { 0x79f6e8ac, 0x0efbf6f6, 0x9823c17d, 0x1736b4d9, };
+
+} // namespace SubstanceSourceDataNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class SubstanceSourceData : public NvParameterized::NvParameters, public SubstanceSourceDataNS::ParametersStruct
+{
+public:
+	SubstanceSourceData(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~SubstanceSourceData();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("SubstanceSourceData");
+	}
+
+	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(SubstanceSourceDataNS::checksum);
+		return SubstanceSourceDataNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const SubstanceSourceDataNS::ParametersStruct& parameters(void) const
+	{
+		SubstanceSourceData* tmpThis = const_cast<SubstanceSourceData*>(this);
+		return *(static_cast<SubstanceSourceDataNS::ParametersStruct*>(tmpThis));
+	}
+
+	SubstanceSourceDataNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<SubstanceSourceDataNS::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 SubstanceSourceDataFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		SubstanceSourceData::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(SubstanceSourceData), SubstanceSourceData::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, SubstanceSourceData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SubstanceSourceData");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(SubstanceSourceData)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, SubstanceSourceData)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, SubstanceSourceData::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, SubstanceSourceData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SubstanceSourceData");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of SubstanceSourceData 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 (SubstanceSourceData*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (SubstanceSourceData::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (SubstanceSourceData::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (SubstanceSourceData::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (SubstanceSourceData::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/SubstanceSourceEffect.h b/APEX_1.4/module/particles/include/autogen/SubstanceSourceEffect.h
new file mode 100644
index 00000000..48d2216a
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/SubstanceSourceEffect.h
@@ -0,0 +1,291 @@
+// 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_SubstanceSourceEffect_h
+#define HEADER_SubstanceSourceEffect_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace SubstanceSourceEffectNS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* SubstanceSource;
+
+};
+
+static const uint32_t checksum[] = { 0x171c45ff, 0xd18f749a, 0xeaca4f46, 0xec9ce317, };
+
+} // namespace SubstanceSourceEffectNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class SubstanceSourceEffect : public NvParameterized::NvParameters, public SubstanceSourceEffectNS::ParametersStruct
+{
+public:
+	SubstanceSourceEffect(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~SubstanceSourceEffect();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("SubstanceSourceEffect");
+	}
+
+	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(SubstanceSourceEffectNS::checksum);
+		return SubstanceSourceEffectNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const SubstanceSourceEffectNS::ParametersStruct& parameters(void) const
+	{
+		SubstanceSourceEffect* tmpThis = const_cast<SubstanceSourceEffect*>(this);
+		return *(static_cast<SubstanceSourceEffectNS::ParametersStruct*>(tmpThis));
+	}
+
+	SubstanceSourceEffectNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<SubstanceSourceEffectNS::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 SubstanceSourceEffectFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		SubstanceSourceEffect::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(SubstanceSourceEffect), SubstanceSourceEffect::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, SubstanceSourceEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SubstanceSourceEffect");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(SubstanceSourceEffect)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, SubstanceSourceEffect)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, SubstanceSourceEffect::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, SubstanceSourceEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SubstanceSourceEffect");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of SubstanceSourceEffect 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 (SubstanceSourceEffect*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (SubstanceSourceEffect::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (SubstanceSourceEffect::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (SubstanceSourceEffect::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (SubstanceSourceEffect::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/TurbulenceFieldSamplerData.h b/APEX_1.4/module/particles/include/autogen/TurbulenceFieldSamplerData.h
new file mode 100644
index 00000000..1612d87f
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/TurbulenceFieldSamplerData.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_TurbulenceFieldSamplerData_h
+#define HEADER_TurbulenceFieldSamplerData_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace TurbulenceFieldSamplerDataNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* TurbulenceFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0xac373033, 0x567939b2, 0xb61686da, 0x6b9b1a7b, };
+
+} // namespace TurbulenceFieldSamplerDataNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class TurbulenceFieldSamplerData : public NvParameterized::NvParameters, public TurbulenceFieldSamplerDataNS::ParametersStruct
+{
+public:
+	TurbulenceFieldSamplerData(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~TurbulenceFieldSamplerData();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("TurbulenceFieldSamplerData");
+	}
+
+	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(TurbulenceFieldSamplerDataNS::checksum);
+		return TurbulenceFieldSamplerDataNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const TurbulenceFieldSamplerDataNS::ParametersStruct& parameters(void) const
+	{
+		TurbulenceFieldSamplerData* tmpThis = const_cast<TurbulenceFieldSamplerData*>(this);
+		return *(static_cast<TurbulenceFieldSamplerDataNS::ParametersStruct*>(tmpThis));
+	}
+
+	TurbulenceFieldSamplerDataNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<TurbulenceFieldSamplerDataNS::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 TurbulenceFieldSamplerDataFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		TurbulenceFieldSamplerData::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(TurbulenceFieldSamplerData), TurbulenceFieldSamplerData::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, TurbulenceFieldSamplerData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class TurbulenceFieldSamplerData");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(TurbulenceFieldSamplerData)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, TurbulenceFieldSamplerData)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, TurbulenceFieldSamplerData::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, TurbulenceFieldSamplerData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class TurbulenceFieldSamplerData");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of TurbulenceFieldSamplerData 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 (TurbulenceFieldSamplerData*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (TurbulenceFieldSamplerData::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (TurbulenceFieldSamplerData::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (TurbulenceFieldSamplerData::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (TurbulenceFieldSamplerData::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/TurbulenceFieldSamplerEffect.h b/APEX_1.4/module/particles/include/autogen/TurbulenceFieldSamplerEffect.h
new file mode 100644
index 00000000..4f4b896a
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/TurbulenceFieldSamplerEffect.h
@@ -0,0 +1,291 @@
+// 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_TurbulenceFieldSamplerEffect_h
+#define HEADER_TurbulenceFieldSamplerEffect_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace TurbulenceFieldSamplerEffectNS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* TurbulenceFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0x34739060, 0xd18c9ccf, 0xba454bf5, 0x78f5ddbb, };
+
+} // namespace TurbulenceFieldSamplerEffectNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class TurbulenceFieldSamplerEffect : public NvParameterized::NvParameters, public TurbulenceFieldSamplerEffectNS::ParametersStruct
+{
+public:
+	TurbulenceFieldSamplerEffect(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~TurbulenceFieldSamplerEffect();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("TurbulenceFieldSamplerEffect");
+	}
+
+	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(TurbulenceFieldSamplerEffectNS::checksum);
+		return TurbulenceFieldSamplerEffectNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const TurbulenceFieldSamplerEffectNS::ParametersStruct& parameters(void) const
+	{
+		TurbulenceFieldSamplerEffect* tmpThis = const_cast<TurbulenceFieldSamplerEffect*>(this);
+		return *(static_cast<TurbulenceFieldSamplerEffectNS::ParametersStruct*>(tmpThis));
+	}
+
+	TurbulenceFieldSamplerEffectNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<TurbulenceFieldSamplerEffectNS::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 TurbulenceFieldSamplerEffectFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		TurbulenceFieldSamplerEffect::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(TurbulenceFieldSamplerEffect), TurbulenceFieldSamplerEffect::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, TurbulenceFieldSamplerEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class TurbulenceFieldSamplerEffect");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(TurbulenceFieldSamplerEffect)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, TurbulenceFieldSamplerEffect)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, TurbulenceFieldSamplerEffect::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, TurbulenceFieldSamplerEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class TurbulenceFieldSamplerEffect");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of TurbulenceFieldSamplerEffect 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 (TurbulenceFieldSamplerEffect*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (TurbulenceFieldSamplerEffect::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (TurbulenceFieldSamplerEffect::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (TurbulenceFieldSamplerEffect::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (TurbulenceFieldSamplerEffect::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/VelocitySourceData.h b/APEX_1.4/module/particles/include/autogen/VelocitySourceData.h
new file mode 100644
index 00000000..51397dde
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/VelocitySourceData.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_VelocitySourceData_h
+#define HEADER_VelocitySourceData_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace VelocitySourceDataNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* VelocitySource;
+
+};
+
+static const uint32_t checksum[] = { 0x1d529c10, 0x109f65ed, 0xa3531c3a, 0x99ada8f2, };
+
+} // namespace VelocitySourceDataNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class VelocitySourceData : public NvParameterized::NvParameters, public VelocitySourceDataNS::ParametersStruct
+{
+public:
+	VelocitySourceData(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~VelocitySourceData();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("VelocitySourceData");
+	}
+
+	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(VelocitySourceDataNS::checksum);
+		return VelocitySourceDataNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const VelocitySourceDataNS::ParametersStruct& parameters(void) const
+	{
+		VelocitySourceData* tmpThis = const_cast<VelocitySourceData*>(this);
+		return *(static_cast<VelocitySourceDataNS::ParametersStruct*>(tmpThis));
+	}
+
+	VelocitySourceDataNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<VelocitySourceDataNS::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 VelocitySourceDataFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		VelocitySourceData::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(VelocitySourceData), VelocitySourceData::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, VelocitySourceData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VelocitySourceData");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(VelocitySourceData)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, VelocitySourceData)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, VelocitySourceData::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, VelocitySourceData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VelocitySourceData");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of VelocitySourceData 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 (VelocitySourceData*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (VelocitySourceData::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (VelocitySourceData::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (VelocitySourceData::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (VelocitySourceData::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/VelocitySourceEffect.h b/APEX_1.4/module/particles/include/autogen/VelocitySourceEffect.h
new file mode 100644
index 00000000..60285028
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/VelocitySourceEffect.h
@@ -0,0 +1,291 @@
+// 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_VelocitySourceEffect_h
+#define HEADER_VelocitySourceEffect_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace VelocitySourceEffectNS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* VelocitySource;
+
+};
+
+static const uint32_t checksum[] = { 0x26b72ab9, 0x777ca701, 0x04b00529, 0xf38de506, };
+
+} // namespace VelocitySourceEffectNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class VelocitySourceEffect : public NvParameterized::NvParameters, public VelocitySourceEffectNS::ParametersStruct
+{
+public:
+	VelocitySourceEffect(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~VelocitySourceEffect();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("VelocitySourceEffect");
+	}
+
+	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(VelocitySourceEffectNS::checksum);
+		return VelocitySourceEffectNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const VelocitySourceEffectNS::ParametersStruct& parameters(void) const
+	{
+		VelocitySourceEffect* tmpThis = const_cast<VelocitySourceEffect*>(this);
+		return *(static_cast<VelocitySourceEffectNS::ParametersStruct*>(tmpThis));
+	}
+
+	VelocitySourceEffectNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<VelocitySourceEffectNS::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 VelocitySourceEffectFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		VelocitySourceEffect::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(VelocitySourceEffect), VelocitySourceEffect::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, VelocitySourceEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VelocitySourceEffect");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(VelocitySourceEffect)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, VelocitySourceEffect)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, VelocitySourceEffect::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, VelocitySourceEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VelocitySourceEffect");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of VelocitySourceEffect 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 (VelocitySourceEffect*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (VelocitySourceEffect::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (VelocitySourceEffect::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (VelocitySourceEffect::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (VelocitySourceEffect::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/VolumeRenderMaterialData.h b/APEX_1.4/module/particles/include/autogen/VolumeRenderMaterialData.h
new file mode 100644
index 00000000..e55cf3e2
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/VolumeRenderMaterialData.h
@@ -0,0 +1,275 @@
+// 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_VolumeRenderMaterialData_h
+#define HEADER_VolumeRenderMaterialData_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace VolumeRenderMaterialDataNS
+{
+
+struct colorLifeStruct_Type;
+
+struct colorLifeStruct_DynamicArray1D_Type
+{
+	colorLifeStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct colorLifeStruct_Type
+{
+	float density;
+	physx::PxVec4 color;
+};
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::DummyStringStruct ApplicationMaterialName;
+	NvParameterized::DummyStringStruct UserProperties;
+	const char* RenderMode;
+	const char* RenderMethod;
+	const char* ResolutionScale;
+	const char* FillMode;
+	bool GenerateShadows;
+	bool BlurShadows;
+	bool GenerateMipmaps;
+	bool EnableStencilOpt;
+	float StepScale;
+	float Density;
+	float EdgeFade;
+	float OpacityThreshold;
+	float RayJitter;
+	float IsoValue;
+	float IsoValueSign;
+	uint32_t ShadowSamples;
+	float ShadowDistance;
+	float ShadowDensity;
+	float ShadowJitter;
+	float ShadowAmount;
+	physx::PxVec3 LightDir;
+	physx::PxVec4 LightColor;
+	float BlockEmptyThreshold;
+	bool ReadDepth;
+	float ColorMapScale;
+	float ColorMapOffset;
+	colorLifeStruct_DynamicArray1D_Type ColorMap;
+	float TextureRangeMin;
+	float TextureRangeMax;
+
+};
+
+static const uint32_t checksum[] = { 0xfb381de2, 0xf2cfee66, 0x5b5fbef9, 0x9199ccee, };
+
+} // namespace VolumeRenderMaterialDataNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class VolumeRenderMaterialData : public NvParameterized::NvParameters, public VolumeRenderMaterialDataNS::ParametersStruct
+{
+public:
+	VolumeRenderMaterialData(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~VolumeRenderMaterialData();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("VolumeRenderMaterialData");
+	}
+
+	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(VolumeRenderMaterialDataNS::checksum);
+		return VolumeRenderMaterialDataNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const VolumeRenderMaterialDataNS::ParametersStruct& parameters(void) const
+	{
+		VolumeRenderMaterialData* tmpThis = const_cast<VolumeRenderMaterialData*>(this);
+		return *(static_cast<VolumeRenderMaterialDataNS::ParametersStruct*>(tmpThis));
+	}
+
+	VolumeRenderMaterialDataNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<VolumeRenderMaterialDataNS::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 VolumeRenderMaterialDataFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		VolumeRenderMaterialData::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(VolumeRenderMaterialData), VolumeRenderMaterialData::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, VolumeRenderMaterialData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VolumeRenderMaterialData");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(VolumeRenderMaterialData)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, VolumeRenderMaterialData)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, VolumeRenderMaterialData::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, VolumeRenderMaterialData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VolumeRenderMaterialData");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of VolumeRenderMaterialData 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 (VolumeRenderMaterialData*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (VolumeRenderMaterialData::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (VolumeRenderMaterialData::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (VolumeRenderMaterialData::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (VolumeRenderMaterialData::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/VortexFieldSamplerData.h b/APEX_1.4/module/particles/include/autogen/VortexFieldSamplerData.h
new file mode 100644
index 00000000..962e5ee4
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/VortexFieldSamplerData.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_VortexFieldSamplerData_h
+#define HEADER_VortexFieldSamplerData_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace VortexFieldSamplerDataNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* VortexFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0xe1494a82, 0xeb4d703f, 0xa17e8922, 0x25b15901, };
+
+} // namespace VortexFieldSamplerDataNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class VortexFieldSamplerData : public NvParameterized::NvParameters, public VortexFieldSamplerDataNS::ParametersStruct
+{
+public:
+	VortexFieldSamplerData(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~VortexFieldSamplerData();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("VortexFieldSamplerData");
+	}
+
+	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(VortexFieldSamplerDataNS::checksum);
+		return VortexFieldSamplerDataNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const VortexFieldSamplerDataNS::ParametersStruct& parameters(void) const
+	{
+		VortexFieldSamplerData* tmpThis = const_cast<VortexFieldSamplerData*>(this);
+		return *(static_cast<VortexFieldSamplerDataNS::ParametersStruct*>(tmpThis));
+	}
+
+	VortexFieldSamplerDataNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<VortexFieldSamplerDataNS::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 VortexFieldSamplerDataFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		VortexFieldSamplerData::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(VortexFieldSamplerData), VortexFieldSamplerData::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, VortexFieldSamplerData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VortexFieldSamplerData");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(VortexFieldSamplerData)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, VortexFieldSamplerData)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, VortexFieldSamplerData::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, VortexFieldSamplerData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VortexFieldSamplerData");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of VortexFieldSamplerData 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 (VortexFieldSamplerData*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (VortexFieldSamplerData::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (VortexFieldSamplerData::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (VortexFieldSamplerData::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (VortexFieldSamplerData::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/VortexFieldSamplerEffect.h b/APEX_1.4/module/particles/include/autogen/VortexFieldSamplerEffect.h
new file mode 100644
index 00000000..444ab3bc
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/VortexFieldSamplerEffect.h
@@ -0,0 +1,291 @@
+// 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_VortexFieldSamplerEffect_h
+#define HEADER_VortexFieldSamplerEffect_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace VortexFieldSamplerEffectNS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* VortexFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0x2be885a4, 0xf50fd36f, 0xe78facab, 0xc365bd58, };
+
+} // namespace VortexFieldSamplerEffectNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class VortexFieldSamplerEffect : public NvParameterized::NvParameters, public VortexFieldSamplerEffectNS::ParametersStruct
+{
+public:
+	VortexFieldSamplerEffect(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~VortexFieldSamplerEffect();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("VortexFieldSamplerEffect");
+	}
+
+	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(VortexFieldSamplerEffectNS::checksum);
+		return VortexFieldSamplerEffectNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const VortexFieldSamplerEffectNS::ParametersStruct& parameters(void) const
+	{
+		VortexFieldSamplerEffect* tmpThis = const_cast<VortexFieldSamplerEffect*>(this);
+		return *(static_cast<VortexFieldSamplerEffectNS::ParametersStruct*>(tmpThis));
+	}
+
+	VortexFieldSamplerEffectNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<VortexFieldSamplerEffectNS::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 VortexFieldSamplerEffectFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		VortexFieldSamplerEffect::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(VortexFieldSamplerEffect), VortexFieldSamplerEffect::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, VortexFieldSamplerEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VortexFieldSamplerEffect");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(VortexFieldSamplerEffect)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, VortexFieldSamplerEffect)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, VortexFieldSamplerEffect::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, VortexFieldSamplerEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VortexFieldSamplerEffect");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of VortexFieldSamplerEffect 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 (VortexFieldSamplerEffect*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (VortexFieldSamplerEffect::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (VortexFieldSamplerEffect::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (VortexFieldSamplerEffect::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (VortexFieldSamplerEffect::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/WindFieldSamplerData.h b/APEX_1.4/module/particles/include/autogen/WindFieldSamplerData.h
new file mode 100644
index 00000000..00876e35
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/WindFieldSamplerData.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_WindFieldSamplerData_h
+#define HEADER_WindFieldSamplerData_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace WindFieldSamplerDataNS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* WindFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0xe5c5674e, 0x58f8377e, 0xc3b4e486, 0x2cbdd0bc, };
+
+} // namespace WindFieldSamplerDataNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class WindFieldSamplerData : public NvParameterized::NvParameters, public WindFieldSamplerDataNS::ParametersStruct
+{
+public:
+	WindFieldSamplerData(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~WindFieldSamplerData();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("WindFieldSamplerData");
+	}
+
+	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(WindFieldSamplerDataNS::checksum);
+		return WindFieldSamplerDataNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const WindFieldSamplerDataNS::ParametersStruct& parameters(void) const
+	{
+		WindFieldSamplerData* tmpThis = const_cast<WindFieldSamplerData*>(this);
+		return *(static_cast<WindFieldSamplerDataNS::ParametersStruct*>(tmpThis));
+	}
+
+	WindFieldSamplerDataNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<WindFieldSamplerDataNS::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 WindFieldSamplerDataFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		WindFieldSamplerData::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(WindFieldSamplerData), WindFieldSamplerData::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, WindFieldSamplerData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class WindFieldSamplerData");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(WindFieldSamplerData)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, WindFieldSamplerData)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, WindFieldSamplerData::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, WindFieldSamplerData::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class WindFieldSamplerData");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of WindFieldSamplerData 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 (WindFieldSamplerData*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (WindFieldSamplerData::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (WindFieldSamplerData::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (WindFieldSamplerData::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (WindFieldSamplerData::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/particles/include/autogen/WindFieldSamplerEffect.h b/APEX_1.4/module/particles/include/autogen/WindFieldSamplerEffect.h
new file mode 100644
index 00000000..9b4c9f61
--- /dev/null
+++ b/APEX_1.4/module/particles/include/autogen/WindFieldSamplerEffect.h
@@ -0,0 +1,291 @@
+// 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_WindFieldSamplerEffect_h
+#define HEADER_WindFieldSamplerEffect_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 particles
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace WindFieldSamplerEffectNS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* WindFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0x98b44af2, 0xea3bf59f, 0xa34c5161, 0x0a087624, };
+
+} // namespace WindFieldSamplerEffectNS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class WindFieldSamplerEffect : public NvParameterized::NvParameters, public WindFieldSamplerEffectNS::ParametersStruct
+{
+public:
+	WindFieldSamplerEffect(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~WindFieldSamplerEffect();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("WindFieldSamplerEffect");
+	}
+
+	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(WindFieldSamplerEffectNS::checksum);
+		return WindFieldSamplerEffectNS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const WindFieldSamplerEffectNS::ParametersStruct& parameters(void) const
+	{
+		WindFieldSamplerEffect* tmpThis = const_cast<WindFieldSamplerEffect*>(this);
+		return *(static_cast<WindFieldSamplerEffectNS::ParametersStruct*>(tmpThis));
+	}
+
+	WindFieldSamplerEffectNS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<WindFieldSamplerEffectNS::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 WindFieldSamplerEffectFactory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		WindFieldSamplerEffect::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(WindFieldSamplerEffect), WindFieldSamplerEffect::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, WindFieldSamplerEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class WindFieldSamplerEffect");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(WindFieldSamplerEffect)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, WindFieldSamplerEffect)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, WindFieldSamplerEffect::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, WindFieldSamplerEffect::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class WindFieldSamplerEffect");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of WindFieldSamplerEffect 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 (WindFieldSamplerEffect*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (WindFieldSamplerEffect::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (WindFieldSamplerEffect::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (WindFieldSamplerEffect::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (WindFieldSamplerEffect::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace particles
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif