Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 1154 insertions, 0 deletions

diff --git a/APEX_1.4/module/iofx/include/ModifierImpl.h b/APEX_1.4/module/iofx/include/ModifierImpl.h
new file mode 100644
index 00000000..3eb671c9
--- /dev/null
+++ b/APEX_1.4/module/iofx/include/ModifierImpl.h
@@ -0,0 +1,1154 @@
+/*
+ * 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 __MODIFIER_IMPL_H__
+#define __MODIFIER_IMPL_H__
+
+#include "Modifier.h"
+#include "CurveImpl.h"
+#include "PsUserAllocated.h"
+
+#include "RotationModifierParams.h"
+#include "SimpleScaleModifierParams.h"
+#include "RandomScaleModifierParams.h"
+#include "ScaleByMassModifierParams.h"
+#include "ColorVsLifeModifierParams.h"
+#include "ScaleVsLifeModifierParams.h"
+#include "ScaleVsDensityModifierParams.h"
+#include "ScaleVsCameraDistanceModifierParams.h"
+#include "ColorVsDensityModifierParams.h"
+#include "SubtextureVsLifeModifierParams.h"
+#include "OrientAlongVelocityModifierParams.h"
+#include "ScaleAlongVelocityModifierParams.h"
+#include "RandomSubtextureModifierParams.h"
+#include "RandomRotationModifierParams.h"
+#include "ViewDirectionSortingModifierParams.h"
+#include "RotationRateModifierParams.h"
+#include "RotationRateVsLifeModifierParams.h"
+#include "OrientScaleAlongScreenVelocityModifierParams.h"
+#include "ColorVsVelocityModifierParams.h"
+
+#include "ParamArray.h"
+
+#include "PsArray.h"
+
+namespace nvidia
+{
+namespace apex
+{
+class InplaceStorage;
+class InplaceHandleBase;
+struct RandState;
+}
+namespace iofx
+{
+
+/**
+	Directions for adding a new APEX modifier type (an official modifier, not a user modifier).
+
+	1) In Modifier.h, add a value to the end of ModifierTypeEnum, matching the naming convention of others.
+	2) In Modifier.h, add a new subclass of ModifierT, specialized on your type.
+		- e.g. class MyNewModifier : public ModifierT<NxMyNewModifier> { };
+	3) MyNewModifier should include pure virtual getters (by value), and setters. Do not promise to return
+	   by const-reference.
+    4) In ModifierImpl.h (this file), add a subcless of your public class and ApexAllocateable
+		- e.g. class MyNewModifier : public MyNewModifier, public UserAllocated { };
+	5) The ModifierImpl.h class should provide concrete implementations of all of the functions.
+		- Feel free to do the getters and setters inline in ModifierImpl.h
+	6) In ModifierImpl.cpp, provide the implementations for the serailization functions and 'updateParticles.'
+*/
+
+// Ignore this warning temporarily. It's reset to default level at the bottom of the file.
+// We'll fix this soon, just not "right this second"
+#pragma warning( disable: 4100 )
+
+class IofxModifierHelper
+{
+public:
+
+	// assumes the mParams class contains a "controlPoints" member
+	static void setCurve(const nvidia::apex::Curve* f,
+	                       NvParameterized::Interface* mParams,
+	                       ParamDynamicArrayStruct* controlPoints)
+	{
+		uint32_t cpSize;
+		f->getControlPoints(cpSize);
+
+		NvParameterized::Handle h(*mParams);
+		mParams->getParameterHandle("controlPoints", h);
+		h.resizeArray((int32_t)cpSize);
+
+		ParamArray<ScaleVsCameraDistanceModifierParamsNS::vec2_Type>
+		cpArray(mParams, "controlPoints", controlPoints);
+
+		for (uint32_t i = 0; i < cpSize; i++)
+		{
+			cpArray[i].x = f->getControlPoints(cpSize)[i].x;
+			cpArray[i].y = f->getControlPoints(cpSize)[i].y;
+		}
+	}
+};
+
+
+class ModifierParamsMapperCPU
+{
+public:
+	virtual void beginParams(void* params, size_t size, size_t align, uint32_t randomCount) = 0;
+	virtual void endParams() = 0;
+
+	virtual void mapValue(size_t offset, int32_t value) = 0;
+	void mapValue(size_t offset, uint32_t value)
+	{
+		mapValue(offset, static_cast<int32_t>(value));
+	}
+
+	virtual void mapValue(size_t offset, float value) = 0;
+	void mapValue(size_t offset, const PxVec3& value)
+	{
+		mapValue(offset + offsetof(PxVec3, x), value.x);
+		mapValue(offset + offsetof(PxVec3, y), value.y);
+		mapValue(offset + offsetof(PxVec3, z), value.z);
+	}
+
+	virtual void mapCurve(size_t offset, const nvidia::apex::Curve* curve) = 0;
+};
+
+#if APEX_CUDA_SUPPORT
+
+class ModifierParamsMapperGPU
+{
+public:
+	virtual InplaceStorage& getStorage() = 0;
+
+	virtual void onParams(InplaceHandleBase handle, uint32_t randomCount) = 0;
+};
+#endif
+
+struct MeshInput;
+struct MeshPublicState;
+struct MeshPrivateState;
+struct SpriteInput;
+struct SpritePublicState;
+struct SpritePrivateState;
+struct ModifierCommonParams;
+
+class ModifierImpl
+{
+public:
+	static const ModifierImpl* castFrom(const Modifier*);
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const
+	{
+		PX_ASSERT(!"unimpl");
+	}
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& /*mapper*/) const
+	{
+		PX_ASSERT(!"unimpl");
+	}
+
+
+	typedef void (*updateSpriteFunc)(const void* params, const SpriteInput& input, SpritePublicState& pubState, SpritePrivateState& privState, const ModifierCommonParams& common, RandState& randState);
+	typedef void (*updateMeshFunc)(const void* params, const MeshInput& input, MeshPublicState& pubState, MeshPrivateState& privState, const ModifierCommonParams& common, RandState& randState);
+
+	virtual updateSpriteFunc getUpdateSpriteFunc(ModifierStage /*stage*/) const
+	{
+		PX_ASSERT(!"unimpl");
+		return 0;
+	}
+	virtual updateMeshFunc getUpdateMeshFunc(ModifierStage /*stage*/) const
+	{
+		PX_ASSERT(!"unimpl");
+		return 0;
+	}
+};
+
+// ------------------------------------------------------------------------------------------------
+class RotationModifierImpl : public RotationModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	RotationModifierImpl(RotationModifierParams* params);
+
+	virtual ApexMeshParticleRollType::Enum getRollType() const
+	{
+		return mRollType;
+	}
+	virtual void setRollType(ApexMeshParticleRollType::Enum rollType);
+	virtual float getMaxSettleRate() const
+	{
+		return mParams->maxSettleRatePerSec;
+	}
+	virtual void setMaxSettleRate(float settleRate)
+	{
+		mParams->maxSettleRatePerSec = settleRate;
+	}
+	virtual float getMaxRotationRate() const
+	{
+		return mParams->maxRotationRatePerSec;
+	}
+	virtual void setMaxRotationRate(float rotationRate)
+	{
+		mParams->maxRotationRatePerSec = rotationRate;
+	}
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.mapValue(offsetof(Params, rollType), uint32_t(mRollType));
+		mapper.mapValue(offsetof(Params, rollAxis), mRollAxis);
+		mapper.mapValue(offsetof(Params, rollSign), mRollSign);
+
+		mapper.mapValue(offsetof(Params, maxSettleRatePerSec), mParams->maxSettleRatePerSec);
+		mapper.mapValue(offsetof(Params, maxRotationRatePerSec), mParams->maxRotationRatePerSec);
+
+		mapper.mapValue(offsetof(Params, inAirRotationMultiplier), mParams->inAirRotationMultiplier);
+		mapper.mapValue(offsetof(Params, collisionRotationMultiplier), mParams->collisionRotationMultiplier);
+
+		mapper.mapValue(offsetof(Params, includeVerticalDirection), uint32_t(mParams->includeVerticalDirection));
+
+		mapper.endParams();
+	}
+
+	virtual updateMeshFunc getUpdateMeshFunc(ModifierStage stage) const;
+
+private:
+	RotationModifierParams* mParams;
+	ApexMeshParticleRollType::Enum mRollType;
+	int32_t mRollAxis;
+	float mRollSign;
+	float mLastUpdateTime;
+};
+
+// ------------------------------------------------------------------------------------------------
+class SimpleScaleModifierImpl : public SimpleScaleModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	SimpleScaleModifierImpl(SimpleScaleModifierParams* params);
+
+	virtual uint32_t getModifierSpriteSemantics()
+	{
+		return (uint32_t)(1 << IofxRenderSemantic::SCALE);
+	}
+
+	virtual PxVec3 getScaleFactor() const
+	{
+		return mParams->scaleFactor;
+	}
+	virtual void setScaleFactor(const PxVec3& s)
+	{
+		mParams->scaleFactor = s;
+	}
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.mapValue(offsetof(Params, scaleFactor), mParams->scaleFactor);
+
+		mapper.endParams();
+	}
+
+	virtual updateSpriteFunc getUpdateSpriteFunc(ModifierStage stage) const;
+	virtual updateMeshFunc getUpdateMeshFunc(ModifierStage stage) const;
+
+private:
+	SimpleScaleModifierParams* mParams;
+
+};
+
+// ------------------------------------------------------------------------------------------------
+class ScaleByMassModifierImpl : public ScaleByMassModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	ScaleByMassModifierImpl(ScaleByMassModifierParams* params);
+
+	virtual uint32_t getModifierSpriteSemantics()
+	{
+		return (uint32_t)(1 << IofxRenderSemantic::SCALE);
+	}
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.endParams();
+	}
+
+	virtual updateSpriteFunc getUpdateSpriteFunc(ModifierStage stage) const;
+	virtual updateMeshFunc getUpdateMeshFunc(ModifierStage stage) const;
+
+private:
+	ScaleByMassModifierParams* mParams;
+
+};
+
+// ------------------------------------------------------------------------------------------------
+class RandomScaleModifierImpl : public RandomScaleModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	RandomScaleModifierImpl(RandomScaleModifierParams* params);
+
+	virtual uint32_t getModifierSpriteSemantics()
+	{
+		return (uint32_t)(1 << IofxRenderSemantic::SCALE);
+	}
+
+	virtual Range<float> getScaleFactor() const
+	{
+		Range<float> s;
+		s.minimum = mParams->minScaleFactor;
+		s.maximum = mParams->maxScaleFactor;
+		return s;
+	}
+
+	virtual void setScaleFactor(const Range<float>& s)
+	{
+		mParams->minScaleFactor = s.minimum;
+		mParams->maxScaleFactor = s.maximum;
+	}
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.mapValue(offsetof(Params, scaleFactorMin), mParams->minScaleFactor);
+		mapper.mapValue(offsetof(Params, scaleFactorMax), mParams->maxScaleFactor);
+
+		mapper.endParams();
+	}
+
+	virtual updateSpriteFunc getUpdateSpriteFunc(ModifierStage stage) const;
+	virtual updateMeshFunc getUpdateMeshFunc(ModifierStage stage) const;
+
+private:
+	RandomScaleModifierParams* mParams;
+};
+
+// ------------------------------------------------------------------------------------------------
+class ColorVsLifeModifierImpl : public ColorVsLifeModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	ColorVsLifeModifierImpl(ColorVsLifeModifierParams* params);
+
+	// Methods from Modifier
+	virtual uint32_t getModifierSpriteSemantics()
+	{
+		return (uint32_t)(1 << IofxRenderSemantic::COLOR);
+	}
+	virtual uint32_t getModifierMeshSemantics()
+	{
+		return (uint32_t)(1 << IofxRenderSemantic::COLOR);
+	}
+
+	// Access to expected data members
+	virtual ColorChannel getColorChannel() const
+	{
+		return mColorChannel;
+	}
+	virtual void setColorChannel(ColorChannel colorChannel);
+
+	virtual const nvidia::apex::Curve* getFunction() const
+	{
+		return static_cast<const nvidia::apex::Curve*>(&mCurveFunction);
+	}
+	virtual void setFunction(const nvidia::apex::Curve* f)
+	{
+		const CurveImpl* curve = static_cast<const CurveImpl*>(f);
+		mCurveFunction = *curve;
+
+		IofxModifierHelper::setCurve(f,
+		                               mParams,
+		                               (ParamDynamicArrayStruct*)&mParams->controlPoints);
+	}
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.mapValue(offsetof(Params, channel), uint32_t(mColorChannel));
+		mapper.mapCurve(offsetof(Params, curve), static_cast<const CurveImpl*>(&mCurveFunction));
+
+		mapper.endParams();
+	}
+
+	virtual updateSpriteFunc getUpdateSpriteFunc(ModifierStage stage) const;
+	virtual updateMeshFunc getUpdateMeshFunc(ModifierStage stage) const;
+
+private:
+	ColorVsLifeModifierParams* mParams;
+	ColorChannel mColorChannel;
+	CurveImpl mCurveFunction;
+};
+
+// ------------------------------------------------------------------------------------------------
+class ColorVsDensityModifierImpl : public ColorVsDensityModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	ColorVsDensityModifierImpl(ColorVsDensityModifierParams* params);
+
+	// Methods from Modifier
+	virtual uint32_t getModifierSpriteSemantics()
+	{
+		return (uint32_t)(1 << IofxRenderSemantic::COLOR);
+	}
+	virtual uint32_t getModifierMeshSemantics()
+	{
+		return (uint32_t)(1 << IofxRenderSemantic::COLOR);
+	}
+
+	// Access to expected data members
+	virtual ColorChannel getColorChannel() const
+	{
+		return mColorChannel;
+	}
+	virtual void setColorChannel(ColorChannel colorChannel);
+
+	virtual const nvidia::apex::Curve* getFunction() const
+	{
+		return static_cast<const nvidia::apex::Curve*>(&mCurveFunction);
+	}
+	virtual void setFunction(const nvidia::apex::Curve* f)
+	{
+		const CurveImpl* curve = static_cast<const CurveImpl*>(f);
+		mCurveFunction = *curve;
+
+		IofxModifierHelper::setCurve(f,
+		                               mParams,
+		                               (ParamDynamicArrayStruct*)&mParams->controlPoints);
+	}
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.mapValue(offsetof(Params, channel), uint32_t(mColorChannel));
+		mapper.mapCurve(offsetof(Params, curve), static_cast<const CurveImpl*>(&mCurveFunction));
+
+		mapper.endParams();
+	}
+
+	virtual updateSpriteFunc getUpdateSpriteFunc(ModifierStage stage) const;
+	virtual updateMeshFunc getUpdateMeshFunc(ModifierStage stage) const;
+
+private:
+	ColorVsDensityModifierParams* mParams;
+	ColorChannel mColorChannel;
+	CurveImpl mCurveFunction;
+};
+
+// ------------------------------------------------------------------------------------------------
+class ColorVsVelocityModifierImpl : public ColorVsVelocityModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	ColorVsVelocityModifierImpl(ColorVsVelocityModifierParams* params);
+
+	// Methods from Modifier
+	virtual uint32_t getModifierSpriteSemantics()
+	{
+		return (uint32_t)(1 << IofxRenderSemantic::COLOR);
+	}
+	virtual uint32_t getModifierMeshSemantics()
+	{
+		return (uint32_t)(1 << IofxRenderSemantic::COLOR);
+	}
+
+	// Access to expected data members
+	virtual ColorChannel getColorChannel() const
+	{
+		return mColorChannel;
+	}
+	virtual void setColorChannel(ColorChannel colorChannel);
+
+	virtual const nvidia::apex::Curve* getFunction() const
+	{
+		return static_cast<const nvidia::apex::Curve*>(&mCurveFunction);
+	}
+	virtual void setFunction(const nvidia::apex::Curve* f)
+	{
+		const CurveImpl* curve = static_cast<const CurveImpl*>(f);
+		mCurveFunction = *curve;
+
+		IofxModifierHelper::setCurve(f,
+		                               mParams,
+		                               (ParamDynamicArrayStruct*)&mParams->controlPoints);
+	}
+
+	virtual float getVelocity0() const
+	{
+		return mParams->velocity0;
+	}
+	virtual void setVelocity0(float value)
+	{
+		mParams->velocity0 = value;
+	}
+
+	virtual float getVelocity1() const
+	{
+		return mParams->velocity1;
+	}
+	virtual void setVelocity1(float value)
+	{
+		mParams->velocity1 = value;
+	}
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.mapValue(offsetof(Params, velocity0), mParams->velocity0);
+		mapper.mapValue(offsetof(Params, velocity1), mParams->velocity1);
+		mapper.mapValue(offsetof(Params, channel), uint32_t(mColorChannel));
+		mapper.mapCurve(offsetof(Params, curve), static_cast<const CurveImpl*>(&mCurveFunction));
+
+		mapper.endParams();
+	}
+
+	virtual updateSpriteFunc getUpdateSpriteFunc(ModifierStage stage) const;
+	virtual updateMeshFunc getUpdateMeshFunc(ModifierStage stage) const;
+
+private:
+	ColorVsVelocityModifierParams* mParams;
+	ColorChannel mColorChannel;
+	CurveImpl mCurveFunction;
+};
+
+// ------------------------------------------------------------------------------------------------
+class SubtextureVsLifeModifierImpl : public SubtextureVsLifeModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	SubtextureVsLifeModifierImpl(SubtextureVsLifeModifierParams* params);
+	// Methods from Modifier
+	virtual uint32_t getModifierSpriteSemantics()
+	{
+		return (uint32_t)(1 << IofxRenderSemantic::SUBTEXTURE);
+	}
+
+	// Access to expected data members
+	virtual const nvidia::apex::Curve* getFunction() const
+	{
+		return static_cast<const nvidia::apex::Curve*>(&mCurveFunction);
+	}
+	virtual void setFunction(const nvidia::apex::Curve* f)
+	{
+		const CurveImpl* curve = static_cast<const CurveImpl*>(f);
+		mCurveFunction = *curve;
+
+		IofxModifierHelper::setCurve(f,
+		                               mParams,
+		                               (ParamDynamicArrayStruct*)&mParams->controlPoints);
+	}
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.mapCurve(offsetof(Params, curve), static_cast<const CurveImpl*>(&mCurveFunction));
+
+		mapper.endParams();
+	}
+
+	virtual updateSpriteFunc getUpdateSpriteFunc(ModifierStage stage) const;
+
+private:
+	SubtextureVsLifeModifierParams* mParams;
+	CurveImpl mCurveFunction;
+};
+
+// ------------------------------------------------------------------------------------------------
+class OrientAlongVelocityModifierImpl : public OrientAlongVelocityModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	OrientAlongVelocityModifierImpl(OrientAlongVelocityModifierParams* params);
+
+	// Methods from Modifier
+
+	// Access to expected data members
+	virtual PxVec3 getModelForward() const
+	{
+		return mParams->modelForward;
+	}
+	virtual void setModelForward(const PxVec3& s)
+	{
+		mParams->modelForward = s;
+	}
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.mapValue(offsetof(Params, modelForward), mParams->modelForward);
+
+		mapper.endParams();
+	}
+
+	virtual updateMeshFunc getUpdateMeshFunc(ModifierStage stage) const;
+
+private:
+	OrientAlongVelocityModifierParams* mParams;
+};
+
+// ------------------------------------------------------------------------------------------------
+class ScaleAlongVelocityModifierImpl : public ScaleAlongVelocityModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	ScaleAlongVelocityModifierImpl(ScaleAlongVelocityModifierParams* params);
+
+	// Methods from Modifier
+
+	// Access to expected data members
+	virtual float getScaleFactor() const
+	{
+		return mParams->scaleFactor;
+	}
+	virtual void setScaleFactor(const float& s)
+	{
+		mParams->scaleFactor = s;
+	}
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.mapValue(offsetof(Params, scaleFactor), mParams->scaleFactor);
+
+		mapper.endParams();
+	}
+
+	virtual updateMeshFunc getUpdateMeshFunc(ModifierStage stage) const;
+
+private:
+	ScaleAlongVelocityModifierParams* mParams;
+};
+
+// ------------------------------------------------------------------------------------------------
+class RandomSubtextureModifierImpl : public RandomSubtextureModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	RandomSubtextureModifierImpl(RandomSubtextureModifierParams* params);
+
+	// Methods from Modifier
+	virtual uint32_t getModifierSpriteSemantics()
+	{
+		return (uint32_t)(1 << IofxRenderSemantic::SUBTEXTURE);
+	}
+
+	// Access to expected data members
+	virtual Range<float> getSubtextureRange() const
+	{
+		Range<float> s;
+		s.minimum = mParams->minSubtexture;
+		s.maximum = mParams->maxSubtexture;
+		return s;
+	}
+
+	virtual void setSubtextureRange(const Range<float>& s)
+	{
+		mParams->minSubtexture = s.minimum;
+		mParams->maxSubtexture = s.maximum;
+	}
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.mapValue(offsetof(Params, subtextureRangeMin), mParams->minSubtexture);
+		mapper.mapValue(offsetof(Params, subtextureRangeMax), mParams->maxSubtexture);
+
+		mapper.endParams();
+	}
+
+	virtual updateSpriteFunc getUpdateSpriteFunc(ModifierStage stage) const;
+
+private:
+	RandomSubtextureModifierParams* mParams;
+};
+
+// ------------------------------------------------------------------------------------------------
+class RandomRotationModifierImpl : public RandomRotationModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	RandomRotationModifierImpl(RandomRotationModifierParams* params);
+
+	// Methods from Modifier
+	virtual uint32_t getModifierSpriteSemantics()
+	{
+		return (uint32_t)(1 << IofxRenderSemantic::ORIENTATION);
+	}
+
+	// Access to expected data members
+	virtual Range<float> getRotationRange() const
+	{
+		Range<float> s;
+		s.minimum = mParams->minRotation;
+		s.maximum = mParams->maxRotation;
+		return s;
+	}
+
+	virtual void setRotationRange(const Range<float>& s)
+	{
+		mParams->minRotation = s.minimum;
+		mParams->maxRotation = s.maximum;
+	}
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.mapValue(offsetof(Params, rotationRangeMin), mParams->minRotation);
+		mapper.mapValue(offsetof(Params, rotationRangeMax), mParams->maxRotation);
+
+		mapper.endParams();
+	}
+
+	virtual updateSpriteFunc getUpdateSpriteFunc(ModifierStage stage) const;
+
+private:
+	RandomRotationModifierParams* mParams;
+};
+
+// ------------------------------------------------------------------------------------------------
+class ScaleVsLifeModifierImpl : public ScaleVsLifeModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	ScaleVsLifeModifierImpl(ScaleVsLifeModifierParams* params);
+
+	// Methods from Modifier
+	virtual uint32_t getModifierSpriteSemantics()
+	{
+		return (uint32_t)(1 << IofxRenderSemantic::SCALE);
+	}
+
+	// Access to expected data members
+	virtual ScaleAxis getScaleAxis() const
+	{
+		return mScaleAxis;
+	}
+	virtual void setScaleAxis(ScaleAxis a);
+	virtual const nvidia::apex::Curve* getFunction() const
+	{
+		return static_cast<const nvidia::apex::Curve*>(&mCurveFunction);
+	}
+	virtual void setFunction(const nvidia::apex::Curve* f)
+	{
+		const CurveImpl* curve = static_cast<const CurveImpl*>(f);
+		mCurveFunction = *curve;
+
+		IofxModifierHelper::setCurve(f,
+		                               mParams,
+		                               (ParamDynamicArrayStruct*)&mParams->controlPoints);
+	}
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.mapValue(offsetof(Params, axis), uint32_t(mScaleAxis));
+		mapper.mapCurve(offsetof(Params, curve), static_cast<const CurveImpl*>(&mCurveFunction));
+
+		mapper.endParams();
+	}
+
+	virtual updateSpriteFunc getUpdateSpriteFunc(ModifierStage stage) const;
+	virtual updateMeshFunc getUpdateMeshFunc(ModifierStage stage) const;
+
+private:
+	ScaleVsLifeModifierParams* mParams;
+	ScaleAxis mScaleAxis;
+	CurveImpl mCurveFunction;
+};
+
+// ------------------------------------------------------------------------------------------------
+class ScaleVsDensityModifierImpl : public ScaleVsDensityModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	ScaleVsDensityModifierImpl(ScaleVsDensityModifierParams* params);
+
+	// Methods from Modifier
+	virtual uint32_t getModifierSpriteSemantics()
+	{
+		return (uint32_t)(1 << IofxRenderSemantic::SCALE);
+	}
+
+	// Access to expected data members
+	virtual ScaleAxis getScaleAxis() const
+	{
+		return mScaleAxis;
+	}
+	virtual void setScaleAxis(ScaleAxis a);
+	virtual const nvidia::apex::Curve* getFunction() const
+	{
+		return static_cast<const nvidia::apex::Curve*>(&mCurveFunction);
+	}
+	virtual void setFunction(const nvidia::apex::Curve* f)
+	{
+		const CurveImpl* curve = static_cast<const CurveImpl*>(f);
+		mCurveFunction = *curve;
+
+		IofxModifierHelper::setCurve(f,
+		                               mParams,
+		                               (ParamDynamicArrayStruct*)&mParams->controlPoints);
+	}
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.mapValue(offsetof(Params, axis), uint32_t(mScaleAxis));
+		mapper.mapCurve(offsetof(Params, curve), static_cast<const CurveImpl*>(&mCurveFunction));
+
+		mapper.endParams();
+	}
+
+	virtual updateSpriteFunc getUpdateSpriteFunc(ModifierStage stage) const;
+	virtual updateMeshFunc getUpdateMeshFunc(ModifierStage stage) const;
+
+private:
+	ScaleVsDensityModifierParams* mParams;
+	ScaleAxis mScaleAxis;
+	CurveImpl mCurveFunction;
+};
+
+// ------------------------------------------------------------------------------------------------
+class ScaleVsCameraDistanceModifierImpl : public ScaleVsCameraDistanceModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	ScaleVsCameraDistanceModifierImpl(ScaleVsCameraDistanceModifierParams* params);
+
+	// Methods from Modifier
+
+	// Access to expected data members
+	virtual ScaleAxis getScaleAxis() const
+	{
+		return mScaleAxis;
+	}
+	virtual void setScaleAxis(ScaleAxis a);
+	virtual const nvidia::apex::Curve* getFunction() const
+	{
+		return static_cast<const nvidia::apex::Curve*>(&mCurveFunction);
+	}
+	virtual void setFunction(const nvidia::apex::Curve* f)
+	{
+		const CurveImpl* curve = static_cast<const CurveImpl*>(f);
+		mCurveFunction = *curve;
+
+		IofxModifierHelper::setCurve(f,
+		                               mParams,
+		                               (ParamDynamicArrayStruct*)&mParams->controlPoints);
+	}
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.mapValue(offsetof(Params, axis), uint32_t(mScaleAxis));
+		mapper.mapCurve(offsetof(Params, curve), static_cast<const CurveImpl*>(&mCurveFunction));
+
+		mapper.endParams();
+	}
+
+	virtual updateSpriteFunc getUpdateSpriteFunc(ModifierStage stage) const;
+	virtual updateMeshFunc getUpdateMeshFunc(ModifierStage stage) const;
+
+private:
+	ScaleVsCameraDistanceModifierParams* mParams;
+	ScaleAxis mScaleAxis;
+	CurveImpl mCurveFunction;
+};
+
+/**
+	NvParameterized::Factory for modifiers. TODO: This should be a class that you instantiate, which you can then register objects with,
+	and that you then pass to the Asset class for deserialization.
+*/
+Modifier* CreateModifier(ModifierTypeEnum modifierType, NvParameterized::Interface* objParam, NvParameterized::Handle& h);
+
+// ------------------------------------------------------------------------------------------------
+class ViewDirectionSortingModifierImpl : public ViewDirectionSortingModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	ViewDirectionSortingModifierImpl(ViewDirectionSortingModifierParams* params);
+
+	// Methods from Modifier
+	virtual uint32_t getModifierSpriteSemantics()
+	{
+		return (uint32_t)0;
+	}
+
+	// Access to expected data members
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.endParams();
+	}
+
+	virtual updateSpriteFunc getUpdateSpriteFunc(ModifierStage stage) const;
+
+private:
+	ViewDirectionSortingModifierParams* mParams;
+};
+
+// ------------------------------------------------------------------------------------------------
+class RotationRateModifierImpl : public RotationRateModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	RotationRateModifierImpl(RotationRateModifierParams* params);
+	// Methods from Modifier
+	virtual uint32_t getModifierSpriteSemantics()
+	{
+		return (uint32_t)(1 << IofxRenderSemantic::ORIENTATION);
+	}
+
+	// Access to expected data members
+	virtual float getRotationRate() const
+	{
+		return mParams->rotationRate;
+	}
+	virtual void setRotationRate(const float& r)
+	{
+		mParams->rotationRate = r;
+	}
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.mapValue(offsetof(Params, rotationRate), mParams->rotationRate);
+
+		mapper.endParams();
+	}
+
+	virtual updateSpriteFunc getUpdateSpriteFunc(ModifierStage stage) const;
+
+private:
+	RotationRateModifierParams* mParams;
+};
+
+// ------------------------------------------------------------------------------------------------
+class RotationRateVsLifeModifierImpl : public RotationRateVsLifeModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	RotationRateVsLifeModifierImpl(RotationRateVsLifeModifierParams* params);
+	// Methods from Modifier
+	virtual uint32_t getModifierSpriteSemantics()
+	{
+		return (uint32_t)(1 << IofxRenderSemantic::ORIENTATION);
+	}
+
+	// Access to expected data members
+	virtual const nvidia::apex::Curve* getFunction() const
+	{
+		return static_cast<const nvidia::apex::Curve*>(&mCurveFunction);
+	}
+	virtual void setFunction(const nvidia::apex::Curve* f)
+	{
+		const CurveImpl* curve = static_cast<const CurveImpl*>(f);
+		mCurveFunction = *curve;
+
+		IofxModifierHelper::setCurve(f,
+		                               mParams,
+		                               (ParamDynamicArrayStruct*)&mParams->controlPoints);
+	}
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.mapCurve(offsetof(Params, curve), static_cast<const CurveImpl*>(&mCurveFunction));
+
+		mapper.endParams();
+	}
+
+	virtual updateSpriteFunc getUpdateSpriteFunc(ModifierStage stage) const;
+
+private:
+	RotationRateVsLifeModifierParams* mParams;
+	CurveImpl mCurveFunction;
+};
+
+// ------------------------------------------------------------------------------------------------
+class OrientScaleAlongScreenVelocityModifierImpl : public OrientScaleAlongScreenVelocityModifier, public ModifierImpl, public UserAllocated
+{
+public:
+	OrientScaleAlongScreenVelocityModifierImpl(OrientScaleAlongScreenVelocityModifierParams* params);
+	// Methods from Modifier
+	virtual uint32_t getModifierSpriteSemantics()
+	{
+		return (uint32_t)((1 << IofxRenderSemantic::ORIENTATION) | (1 << IofxRenderSemantic::SCALE));
+	}
+
+	// Access to expected data members
+	virtual float getScalePerVelocity() const
+	{
+		return mParams->scalePerVelocity;
+	}
+	virtual void setScalePerVelocity(const float& s)
+	{
+		mParams->scalePerVelocity = s;
+	}
+
+	virtual float getScaleChangeLimit() const
+	{
+		return mParams->scaleChangeLimit;
+	}
+	virtual void setScaleChangeLimit(const float& s)
+	{
+		mParams->scaleChangeLimit = s;
+	}
+
+	virtual float getScaleChangeDelay() const
+	{
+		return mParams->scaleChangeDelay;
+	}
+	virtual void setScaleChangeDelay(const float& s)
+	{
+		mParams->scaleChangeDelay = s;
+	}
+
+#if APEX_CUDA_SUPPORT
+	virtual void mapParamsGPU(ModifierParamsMapperGPU& mapper) const;
+#endif
+	virtual void mapParamsCPU(ModifierParamsMapperCPU& mapper) const;
+
+	template <class Mapper, typename Params>
+	void mapParams(Mapper& mapper, Params* params) const
+	{
+		mapper.beginParams(params, sizeof(Params), __alignof(Params), Params::RANDOM_COUNT);
+
+		mapper.mapValue(offsetof(Params, scalePerVelocity), mParams->scalePerVelocity);
+		mapper.mapValue(offsetof(Params, scaleChangeLimit), mParams->scaleChangeLimit);
+		mapper.mapValue(offsetof(Params, scaleChangeDelay), mParams->scaleChangeDelay);
+
+		mapper.endParams();
+	}
+
+	virtual updateSpriteFunc getUpdateSpriteFunc(ModifierStage stage) const;
+
+private:
+	OrientScaleAlongScreenVelocityModifierParams* mParams;
+};
+
+#pragma warning( default: 4100 )
+
+}
+} // namespace nvidia
+
+#endif /* __MODIFIER_IMPL_H__ */