Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

4 files changed, 723 insertions, 0 deletions

diff --git a/APEX_1.4/include/particles/EffectPackageActor.h b/APEX_1.4/include/particles/EffectPackageActor.h
new file mode 100644
index 00000000..cbe60bc9
--- /dev/null
+++ b/APEX_1.4/include/particles/EffectPackageActor.h
@@ -0,0 +1,299 @@
+/*
+ * 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 EFFECT_PACKAGE_ACTOR_H
+#define EFFECT_PACKAGE_ACTOR_H
+
+#include "Actor.h"
+#include "EmitterActor.h"
+
+/*!
+\file
+\brief An EffectPackageActor represents an instantiation of a collection of related particle actors
+The EffectPackage system allows for multiple related particle actors to be instantiated as a single
+unit with a single root pose transform.  This can be one or more emitters as well as associated
+field samplers, heat sources, etc.  This single instantiation can be subject to level of detail culling
+and otherwise manipulated as a single unit.
+
+EffectPackages are authored using the 'ParticleEffectTool' which allows the developer to rapidly
+prototype a combined 'particle effect'.  This is a PhysX 3.x only feature.
+*/
+
+struct ID3D11ShaderResourceView;
+struct ID3D11DeviceContext;
+
+namespace physx
+{
+	class PxRigidDynamic;
+}
+
+namespace nvidia
+{
+
+namespace general_renderdebug4
+{
+///Forward reference the RenderDebugInterface class
+class RenderDebugInterface;
+};
+
+namespace apex
+{
+
+/**
+	This enum is used to identity what 'type' of effect
+*/
+enum EffectType
+{
+	ET_EMITTER,
+	ET_HEAT_SOURCE,
+	ET_SUBSTANCE_SOURCE,
+	ET_TURBULENCE_FS,
+	ET_JET_FS,
+	ET_ATTRACTOR_FS,
+	ET_FORCE_FIELD,
+	ET_NOISE_FS,
+	ET_VORTEX_FS,
+	ET_WIND_FS,
+	ET_RIGID_BODY,
+	ET_VELOCITY_SOURCE,
+	ET_FLAME_EMITTER,
+	ET_LAST
+};
+
+class Actor;
+class RenderVolume;
+
+/**
+\brief Defines the EffectPackageActor API which is instantiated from an EffectPackageAsset
+*/
+class EffectPackageActor : public Actor
+{
+public:
+
+	/**
+	\brief Fade out the EffectPackageActor over a period of time.
+	This method will cause the actors within the EffectPackage to be 'faded out' over a period of time.
+	The EffectPackageAsset will define how this fadeOut operation is to be applied.  Some actors may
+	simply be turned off over this duration while others are modulated in some way.  For example, by default,
+	emitter actors will have their emitter rate reduced over this duration so they do not appear to
+	immediately cut off
+
+	\param [in] fadetime : The duration to fade out the associated effects in seconds
+	*/
+	virtual void fadeOut(float fadetime) = 0;
+
+	/**
+	\brief Fade in the EffectPackageActor over a period of time.
+	This method will cause the associated effects to be faded in over a period of time.
+	It will begin the linear interpolation fade process relative to the current fade time.
+	Meaning if you had previously specified a fadeOut duration of 1 second but then execute
+	a fadeIn just a 1/2 second later, will will begin fading in from a 50% level; not zero.
+
+	\param [in] fadetime : The duration to fade this effect in, in seconds
+	*/
+	virtual void fadeIn(float fadetime) = 0;
+
+	/**
+	\brief Returns the number of effects within this effect package.
+	*/
+	virtual uint32_t getEffectCount() const = 0;
+
+	/**
+	\brief Returns the type of effect at this index location
+
+	\param [in] effectIndex : The effect number to refer to; must be less than the result of getEffectCount
+	*/
+	virtual EffectType getEffectType(uint32_t effectIndex) const = 0;
+
+	/**
+	\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 = 0;
+
+	/**
+	\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 = 0;
+
+	/**
+	\brief Sets 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) = 0;
+
+	/**
+	\brief Sets the over all effect scale, this is a uniform scaling factor.
+
+	\param [in] scale : The uniform scale to apply to all effects in this effect package
+	*/
+	virtual void setCurrentScale(float scale) = 0;
+
+	/**
+	\brief Gets the current overall uniform effect scale
+	*/
+	virtual float getCurrentScale(void) const = 0;
+
+	/**
+	\brief Returns the pose of this sub-effect; returns as 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) = 0;
+
+	/**
+	\brief Sets the pose of this sub-effect; returns as 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) = 0;
+
+	/**
+	\brief Returns the base Actor pointer for this effect.
+	Use this method if you need direct access to the base Actor pointer relative to this
+	effect.  You must use 'getEffectType' to know what type of actor this is referring to before
+	you cast it to either an emitter, or heat source, or turbulence actor, etc.
+	It is important to note that the application cannot cache this pointer as it may be deleted in
+	subsequent frames due to level of detail calculations or timing values such as fade out operations.
+
+	\param [in] effectIndex : The effect number to refer to; must be less than the result of getEffectCount
+
+	\return Returns the Actor pointer for this effect.  This may be NULL if that effect is not currently active.
+	*/
+	virtual Actor* getEffectActor(uint32_t effectIndex) const  = 0;
+
+	/**
+	\brief Returns the base PxRigidDynamic actor pointer for this effect.
+	Use this method if you need direct access to the base PxRigidDynamic actor pointer relative to this
+	effect.  
+
+	\param [in] effectIndex : The effect number to refer to; must be less than the result of getEffectCount, must be a rigid dynamic effect
+
+	\return Returns the PxRigidDynamic pointer for this effect.  This may be NULL if that effect is not currently active.
+	*/
+	virtual PxRigidDynamic* getEffectRigidDynamic(uint32_t effectIndex) const  = 0;
+
+	/**
+	\brief Forces the state of all emitters associated with this effect package to be on or off.
+	This method allows the application to manually force all emitters to be active or inactive
+	based on an explicit call.
+
+	\param [state] : Determines whether to set all emitters on or off
+	*/
+	virtual void setEmitterState(bool state) = 0;
+
+	/**
+	\brief A helper method to return the active number of particles being simulated by all related effects in this EffectPackageActor
+
+	\return Returns the number of particles active relative to this EffectPackageActor
+	*/
+	virtual uint32_t getActiveParticleCount() const = 0;
+
+	/**
+	\brief This helper method reports if any emitters within this EffectPackageActor are still actively emitting particles.
+
+	This method allows the application to determine whether or not any emitters are actively running
+	relative to this actor.  Typically this would be used to defer deleting an effect while it is still active.
+
+	\return Returns true if any emitters in the actor are still active.
+	*/
+	virtual bool isStillEmitting() const = 0;
+
+	/**
+	Returns true if any portion of the effect is still considered 'alive' based on LOD and duration settings.
+	*/
+	virtual bool isAlive(void) const = 0;
+
+	/**
+	\brief Allows the application to manually enable this EffectPackageActor
+
+	This method is used by the application to manually force the EffectPackageActor to be enabled.
+	This is generally used based on some kind of game logic where the EffectPackageActor has been
+	pre-allocated and placed into the world but is initially inactive until some event occurs.
+
+	\param [state] Set the current enabled state to true or false
+	*/
+	virtual void setEnabled(bool state) = 0;
+
+	/**
+	\brief Returns the current enabled state for this actor
+	*/
+	virtual bool getEnabled() const = 0;
+
+	/**
+	\brief Sets the root pose for this EffectPackageActor
+	It's important to note that child-relative poses for each sub-component in an EffectPackageActor
+	are authored in the ParticleEffectTool.
+
+	\param [pose] : Sets the current root pose for this EffectPackageActor
+	*/
+	virtual void setPose(const PxTransform& pose) = 0;
+
+	/**
+	\brief Returns the current root pose for this EffectPackageActor
+	*/
+	virtual const PxTransform& getPose() const = 0;
+
+	/**
+	\brief This method is used by the ParticleEffectTool to refresh a currently running effect with real-time property changes
+	*/
+	virtual void refresh() = 0;
+
+	/**
+	\brief Releases this EffectPackageActor and all associated children effects
+	*/
+	virtual void release() = 0;
+
+	/**
+	\brief A convenient helper method to return the name of the asset used to to create this actor.
+	*/
+	virtual const char* getName() const = 0;
+
+	/**
+	\brief returns the duration of the effect; accounting for maximum duration of each sub-effect.  A duration of 'zero' means it is an infinite lifetime effect.
+	*/
+	virtual float getDuration() const = 0;
+
+	/**
+	\brief Returns the current lifetime of the particle.
+	*/
+	virtual float getCurrentLife() const = 0;
+
+	/**
+	\brief Sets the preferred render volume for emitters in this effect package
+	*/
+	virtual void                 setPreferredRenderVolume(RenderVolume* volume) = 0;
+
+	/**
+	\brief Returns true if this effect package contains a turbulence effect that specifies a volume-render material; if so then the application may want to set up volume rendering
+	*/
+	virtual const char * hasVolumeRenderMaterial(uint32_t &index) const = 0;
+
+	/**
+	\brief Sets the emitter validation callback for any newly created emitter actors.
+	*/
+	virtual void setApexEmitterValidateCallback(EmitterActor::EmitterValidateCallback *callback) = 0;
+};
+
+
+}; // end of apex namespace
+}; // end of physx namespace
+
+#endif
diff --git a/APEX_1.4/include/particles/EffectPackageAsset.h b/APEX_1.4/include/particles/EffectPackageAsset.h
new file mode 100644
index 00000000..6e666443
--- /dev/null
+++ b/APEX_1.4/include/particles/EffectPackageAsset.h
@@ -0,0 +1,64 @@
+/*
+ * 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 EFFECT_PACKAGE_ASSET_H
+#define EFFECT_PACKAGE_ASSET_H
+
+#include "Apex.h"
+
+namespace nvidia
+{
+namespace apex
+{
+
+PX_PUSH_PACK_DEFAULT
+
+#define PARTICLES_EFFECT_PACKAGE_AUTHORING_TYPE_NAME "EffectPackageAsset"
+
+/**
+\brief Describes an EffectPackageAsset; a collection of particle related effects (emitters, field samplers, etc.)
+*/
+class EffectPackageAsset : public Asset
+{
+protected:
+
+	virtual ~EffectPackageAsset() {}
+
+public:
+	/**
+	\brief returns the duration of the effect; accounting for maximum duration of each sub-effect.  A duration of 'zero' means it is an infinite lifetime effect.
+	*/
+	virtual float getDuration() const = 0;
+
+	/**
+	\brief This method returns true if the authored asset has the 'hint' set to indicate the actors should be created with a unique render volume.
+	*/
+	virtual bool useUniqueRenderVolume() const = 0;
+
+
+}; //
+
+/**
+ \brief Describes an EffectPackageAssetAuthoring class; not currently used.  The ParticleEffectTool is used to
+		author EffectPackageAssets
+ */
+class EffectPackageAssetAuthoring : public AssetAuthoring
+{
+protected:
+	virtual ~EffectPackageAssetAuthoring() {}
+};
+
+PX_POP_PACK
+
+} // end of apex namespace
+} // end of nvidia namespace
+
+#endif
diff --git a/APEX_1.4/include/particles/ModuleParticles.h b/APEX_1.4/include/particles/ModuleParticles.h
new file mode 100644
index 00000000..0040f974
--- /dev/null
+++ b/APEX_1.4/include/particles/ModuleParticles.h
@@ -0,0 +1,268 @@
+/*
+ * 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_H
+#define MODULE_PARTICLES_H
+
+#include "Apex.h"
+
+
+namespace nvidia
+{
+
+
+namespace apex
+{
+
+PX_PUSH_PACK_DEFAULT
+
+class Module;
+class Scene;
+class EffectPackageActor;
+/**
+\brief Defines the API for the Particles Module
+
+The particles module combines the features of a number of particle related APEX modules
+into one location; with the exception of APEX turbulence.  It also provides support for
+the EffectPackage actor and asset as well as integration with the ParticleEffectAuthoring
+tool.
+
+Loading the APEX Particles module will now automatically cause the following related modules
+to be instantiated.
+
+APEX_Emitter
+APEX_BasicIOS
+APEX_IOFX
+APEX_FieldSampler
+APEX_BasicIOS
+APEX_ParticleIOS
+APEX_ForceField
+
+These modules are no longer loaded as separate DLLs and instantiated individually like they were
+prior to APEX 1.3.  Instead simply loading the APEX_Particles DLL or calling 'instantiateModuleParticles'
+will cause the other particle related modules to be loaded.
+
+The rationale for making this change was to simplify the startup/shutdown sequence for applications
+using APEX particle related effects.  It also dramatically simplifies the distribution process for
+developers as they now only have to deal with a single DLL rather than as many as 8 which were
+required before.
+
+The turbulence module was not folded into the unified APEX_Particles module at this time since
+the source code for it is not yet made available to licensees.
+
+It is important to note that since the APEX_Particles module does not load the Turbulence module,
+the application *must* load the Turbulence module first so that it will already be registered.
+*/
+class ModuleParticles : public Module
+{
+public:
+
+	/**
+	\brief Return one of the particle related modules, by name, created by the particles module
+	*/
+	virtual nvidia::apex::Module* getModule(const char* moduleName) = 0;
+
+	/**
+	\brief Registers and adds either a single GraphicsMaterial definition or an entire array of them to the particles module.
+
+	The EffectPackage system works with a set of predefined assets which have been authored using
+	the ParticleEffectTool.  This method adds or revises either a single asset or an array of assets.
+	When an EffectPackageActor is instantiated it may refer to assets which have been previously authored and
+	registered using this method.
+
+	\return Returns true if during the registration of this asset the contents were modified.
+	*/
+	virtual bool setEffectPackageGraphicsMaterialsDatabase(const NvParameterized::Interface* dataBase) = 0;
+
+	/**
+	\brief Registers and adds either a single IOS definition or an entire array of them to the particles module.
+
+	The EffectPackage system works with a set of predefined assets which have been authored using
+	the ParticleEffectTool.  This method adds or revises either a single asset or an array of assets.
+	When an EffectPackageActor is instantiated it may refer to assets which have been previously authored and
+	registered using this method.
+
+	\return Returns true if during the registration of this asset the contents were modified.
+	*/
+	virtual bool setEffectPackageIOSDatabase(const NvParameterized::Interface* dataBase) = 0;
+
+	/**
+	\brief Registers and adds either a single IOFX definition or an entire array of them to the particles module.
+
+	The EffectPackage system works with a set of predefined assets which have been authored using
+	the ParticleEffectTool.  This method adds or revises either a single asset or an array of assets.
+	When an EffectPackageActor is instantiated it may refer to assets which have been previously authored and
+	registered using this method.
+
+	\return Returns true if during the registration of this asset the contents were modified.
+	*/
+	virtual bool setEffectPackageIOFXDatabase(const NvParameterized::Interface* dataBase) = 0;
+
+	/**
+	\brief Registers and adds either a single Emitter definition or an entire array of them to the particles module.
+
+	The EffectPackage system works with a set of predefined assets which have been authored using
+	the ParticleEffectTool.  This method adds or revises either a single asset or an array of assets.
+	When an EffectPackageActor is instantiated it may refer to assets which have been previously authored and
+	registered using this method.
+
+	\return Returns true if during the registration of this asset the contents were modified.
+	*/
+	virtual bool setEffectPackageEmitterDatabase(const NvParameterized::Interface* dataBase) = 0;
+
+	/**
+	\brief Registers and adds either a single EffectPackage definition or an entire array of them to the particles module.
+
+	The EffectPackage system works with a set of predefined assets which have been authored using
+	the ParticleEffectTool.  This method adds or revises either a single asset or an array of assets.
+	When an EffectPackageActor is instantiated it may refer to assets which have been previously authored and
+	registered using this method.
+
+	\return Returns true if during the registration of this asset the contents were modified.
+	*/
+	virtual bool setEffectPackageDatabase(const NvParameterized::Interface* dataBase) = 0;
+
+	/**
+	\brief Registers and adds either a single FieldSampler definition or an entire array of them to the particles module.
+
+	The EffectPackage system works with a set of predefined assets which have been authored using
+	the ParticleEffectTool.  This method adds or revises either a single asset or an array of assets.
+	When an EffectPackageActor is instantiated it may refer to assets which have been previously authored and
+	registered using this method.
+
+	\return Returns true if during the registration of this asset the contents were modified.
+	*/
+	virtual bool setEffectPackageFieldSamplerDatabase(const NvParameterized::Interface* dataBase) = 0;
+
+	/**
+	\brief Returns the NvParameterized::Interface representing the array of GraphicsMaterial assets registered by the Paricles modules
+	*/
+	virtual const NvParameterized::Interface* getEffectPackageGraphicsMaterialsDatabase() const = 0;
+
+	/**
+	\brief Returns the NvParameterized::Interface representing the array of IOS assets registered by the Paricles modules
+	*/
+	virtual const NvParameterized::Interface* getEffectPackageIOSDatabase() const = 0;
+
+	/**
+	\brief Returns the NvParameterized::Interface representing the array of IOFX assets registered by the Paricles modules
+	*/
+	virtual const NvParameterized::Interface* getEffectPackageIOFXDatabase() const = 0;
+
+	/**
+	\brief Returns the NvParameterized::Interface representing the array of Emitter assets registered by the Paricles modules
+	*/
+	virtual const NvParameterized::Interface* getEffectPackageEmitterDatabase() const = 0;
+
+	/**
+	\brief Returns the NvParameterized::Interface representing the array of EffectPackage assets registered by the Paricles modules
+	*/
+	virtual const NvParameterized::Interface* getEffectPackageDatabase() const = 0;
+
+	/**
+	\brief Returns the NvParameterized::Interface representing the array of FieldSampler assets registered by the Paricles modules
+	*/
+	virtual const NvParameterized::Interface* getEffectPackageFieldSamplerDatabase() const = 0;
+
+	/**
+	\brief This helper method will return the NvParameterized::Interface for a previously defined 'GraphicsMaterial'
+	This 'GraphicsMaterial' contains settings which were defined in the ParticleEffectTool.  The ParticleEffectTool
+	will let the user define things like a source texture, a blend mode, user properties, and celled animation settings,
+	relative to a particular named material.  The application can use all of these settings or none of them as they prefer.
+	These settings are used by the ParticleEffectTool to provide a prototype visualization of a sprite based particle effect.
+
+	\param [in] name : The name of the predefined graphics material
+
+	\return A pointer to the NvParameterized::Interface representing this material or NULL if not found.
+	*/
+	virtual const NvParameterized::Interface* locateGraphicsMaterialData(const char* name) const = 0;
+
+	/**
+	\brief This helper method will return the NvParameterized::Interface data for a predefined asset in one of the registered 'databases'
+	When an application gets a callback asking for an asset which was authored using the ParticleEffectTool it can use
+	this method to extract the current parameter data necessary to create that asset.
+
+	\param [in] resourceName : The name of the previously defined/registered asset
+	\param [in] nameSpace : The namespace of the asset.
+
+	\return Returns the NvParamterized::Interface pointer for that asset or NULL if not found.
+	*/
+	virtual NvParameterized::Interface* locateResource(const char* resourceName,
+	        const char* nameSpace) = 0;
+
+
+	/**
+	\brief This is a helper method to return the names of all assets registered relative to a particular namespace.
+
+	\param [in] nameSpace : The namespace of the asset type we are searching for.
+	\param [in] nameCount : A reference to a counter which will contain the number of assets found matching this namespace
+	\param [in] variants : A reference to an array of const char pointers which will contain what reference variant each returned asset matches.
+
+	\return Returns an array of const char pointers representing the asset names matching this resource type.
+	*/
+	virtual const char** getResourceNames(const char* nameSpace, uint32_t& nameCount, const char** &variants) = 0;
+
+	/**
+	\brief This method globally enabled or disables the screen-space culling LOD feature for EffectPackageActors
+	EffectPackageActors can be culled based on whether or not they are on screen.  For this to work the application
+	must provide a valid projection matrix, in addition to a current view matrix, into the SDK.
+	The projection matrix in some engines define Z positive as being in front of the screen and others Z negative.
+
+	\param [in] state : Whether to enable or disable the screen culling feature
+	\param [in] znegative : Whether or not Z is positive or negative when a point projected into screen-space is in front or behind the camera.
+	*/
+	virtual void setEnableScreenCulling(bool state, bool znegative) = 0;
+
+	/**
+	\brief Resets the emitter pool; causing all cached emitters to be released.
+	*/
+	virtual void resetEmitterPool() = 0;
+
+	/**
+	\brief Sets the state to determine whether or not the particles module is going to use the emitter pool.
+	The emitter pool is an optimization which prevents the effect system from constantly creating and the immediately releasing a great deal of APEX related
+	assets and resources.  Take for example the case of a short lived particle effect.  Without an emitter pool, triggering this effect would cause a number of
+	assets and rendering resources to be allocated sufficient to render and simulate this effect.  But, in just a very short time, the effect lifespan is over and
+	all of those assets and rendering resources are deleted.  Then the same effect gets fired again causing the assets and render resources to be immediately re-allocated
+	yet once again.  With the emitter pool enabled, the original emitter is not actually released when it times out.  Therefore the render resources and associated assets
+	stay resident in memory.  When the same effect gets triggered again, it simply reuses the previously allocated emitter from the emitter pool.
+	*/
+	virtual void setUseEmitterPool(bool state) = 0;
+
+	/**
+	\brief Returns the current state of the emitter pool status.
+	*/
+	virtual bool getUseEmitterPool() const = 0;
+
+	/**
+	\brief Used by the ParticleEffectTool to initialize the default database values for the editor
+	*/
+	virtual void initializeDefaultDatabases() = 0;
+
+protected:
+	virtual ~ModuleParticles() {}
+};
+
+#if !defined(_USRDLL)
+/**
+* If this module is distributed as a static library, the user must call this
+* function before calling ApexSDK::createModule("Particles")
+*/
+void instantiateModuleParticles();
+#endif
+
+
+PX_POP_PACK
+
+}
+} // end namespace nvidia
+
+#endif // MODULE_PARTICLES_H
diff --git a/APEX_1.4/include/particles/ParticlesPreview.h b/APEX_1.4/include/particles/ParticlesPreview.h
new file mode 100644
index 00000000..a3e60d70
--- /dev/null
+++ b/APEX_1.4/include/particles/ParticlesPreview.h
@@ -0,0 +1,92 @@
+/*
+ * 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_PREVIEW_H
+#define PARTICLES_PREVIEW_H
+
+#include "Apex.h"
+#include "AssetPreview.h"
+
+namespace nvidia
+{
+namespace apex
+{
+
+PX_PUSH_PACK_DEFAULT
+
+class RenderDebugInterface;
+
+namespace APEX_PARTICLES
+{
+/**
+	\def PARTICLES_DRAW_NOTHING
+	Draw no items.
+*/
+static const uint32_t PARTICLES_DRAW_NOTHING = (0x00);
+/**
+	\def PARTICLES_DRAW_ICON
+	Draw the icon.
+*/
+static const uint32_t PARTICLES_DRAW_ICON = (0x01);
+/**
+	\def PARTICLES_DRAW_BOUNDARIES
+	Draw the Particles include shapes.
+*/
+static const uint32_t PARTICLES_DRAW_BOUNDARIES = (0x2);
+/**
+	\def PARTICLES_DRAW_WITH_CYLINDERS
+	Draw the dynamicsystem field boundaries.
+*/
+static const uint32_t PARTICLES_DRAW_WITH_CYLINDERS = (0x4);
+/**
+	\def PARTICLES_DRAW_FULL_DETAIL
+	Draw all of the preview rendering items.
+*/
+static const uint32_t PARTICLES_DRAW_FULL_DETAIL = (PARTICLES_DRAW_ICON + PARTICLES_DRAW_BOUNDARIES);
+/**
+	\def PARTICLES_DRAW_FULL_DETAIL_BOLD
+	Draw all of the preview rendering items using cylinders instead of lines to make the text and icon look BOLD.
+*/
+static const uint32_t PARTICLES_DRAW_FULL_DETAIL_BOLD = (PARTICLES_DRAW_FULL_DETAIL + PARTICLES_DRAW_WITH_CYLINDERS);
+}
+
+/**
+\brief APEX asset preview wind asset.
+*/
+class ParticlesPreview : public AssetPreview
+{
+public:
+	/**
+	Set the scale of the icon.
+	The unscaled icon has is 1.0x1.0 game units.
+	By default the scale of the icon is 1.0. (unscaled)
+	*/
+	virtual void	setIconScale(float scale) = 0;
+	/**
+	Set the detail level of the preview rendering by selecting which features to enable.
+	Any, all, or none of the following masks may be added together to select what should be drawn.
+	The defines for the individual items are PARTICLES_DRAW_NOTHING, PARTICLES_DRAW_ICON, PARTICLES_DRAW_BOUNDARIES,
+	PARTICLES_DRAW_WITH_CYLINDERS.
+	All items may be drawn using the macro PARTICLES_DRAW_FULL_DETAIL and PARTICLES_DRAW_FULL_DETAIL_BOLD.
+	*/
+	virtual void	setDetailLevel(uint32_t detail) = 0;
+
+protected:
+	ParticlesPreview() {};
+};
+
+
+PX_POP_PACK
+
+}
+} // end namespace nvidia
+
+#endif // PARTICLES_PREVIEW_H