CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plParticleSystem/plParticleEffect.h

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#ifndef plParticleEffect_inc
#define plParticleEffect_inc

#include "../pnKeyedObject/hsKeyedObject.h"
#include "hsMatrix44.h"

class plEffectTargetInfo;
class plConvexVolume;
class hsResMgr;
class plSceneObject;

class plParticleEffect : public hsKeyedObject
{
public:
	CLASSNAME_REGISTER( plParticleEffect );
	GETINTERFACE_ANY( plParticleEffect, hsKeyedObject );

	// Order is:
	//  PrepareEffect is called with a given target (including valid
	//		ParticleContext).
	//  ApplyEffect is called some once for each particle (maybe zero times). 
	//		It can return true to kill a particle. 
	//		Target and Context passed in with Prepare will be
	//		guaranteed to remain valid until,
	//  EndEffect marks no more particles will be processed with the above
	//		context (invalidating anything cached).
	// Defaults for Prepare and End are no-ops.
	virtual void PrepareEffect(const plEffectTargetInfo& target) {}
	virtual hsBool ApplyEffect(const plEffectTargetInfo& target, Int32 i) = 0;
	virtual void EndEffect(const plEffectTargetInfo& target) {}
};

class plParticleCollisionEffect : public plParticleEffect
{
public:
	plParticleCollisionEffect();
	~plParticleCollisionEffect();

	CLASSNAME_REGISTER( plParticleCollisionEffect );
	GETINTERFACE_ANY( plParticleCollisionEffect, plParticleEffect );

	virtual void PrepareEffect(const plEffectTargetInfo& target);

	virtual void Read(hsStream *s, hsResMgr *mgr);
	virtual void Write(hsStream *s, hsResMgr *mgr);
	virtual hsBool MsgReceive(plMessage *msg);

protected:
	plSceneObject *fSceneObj;
	plConvexVolume *fBounds;
};

// Default particle blocker. Doesn't affect particle's velocity,
// so it'll keep "beat"ing on the deflector until the velocity
// dotted with the deflector normal slides it off an edge.
class plParticleCollisionEffectBeat : public plParticleCollisionEffect
{
public:
	plParticleCollisionEffectBeat();

	CLASSNAME_REGISTER( plParticleCollisionEffectBeat );
	GETINTERFACE_ANY( plParticleCollisionEffectBeat, plParticleCollisionEffect );

	virtual hsBool ApplyEffect(const plEffectTargetInfo& target, Int32 i);
};

// This particle blocker just kills any particles that hit it.
class plParticleCollisionEffectDie : public plParticleCollisionEffect
{
public:
	plParticleCollisionEffectDie();

	CLASSNAME_REGISTER( plParticleCollisionEffectDie );
	GETINTERFACE_ANY( plParticleCollisionEffectDie, plParticleCollisionEffect );

	virtual hsBool ApplyEffect(const plEffectTargetInfo& target, Int32 i);
};

class plParticleCollisionEffectBounce : public plParticleCollisionEffect
{
protected:
	hsScalar	fBounce;
	hsScalar	fFriction;
public:
	plParticleCollisionEffectBounce();

	CLASSNAME_REGISTER( plParticleCollisionEffectBounce );
	GETINTERFACE_ANY( plParticleCollisionEffectBounce, plParticleCollisionEffect );

	virtual hsBool ApplyEffect(const plEffectTargetInfo& target, Int32 i);

	virtual void Read(hsStream *s, hsResMgr *mgr);
	virtual void Write(hsStream *s, hsResMgr *mgr);

	void SetBounce(hsScalar b) { fBounce = b; }
	hsScalar GetBounce() const { return fBounce; }

	void SetFriction(hsScalar f) { fFriction = f; }
	hsScalar GetFriction() const { return fFriction; }
};

class plParticleFadeVolumeEffect : public plParticleEffect
{
protected:
	// Some cached properties. These will be the same for all
	// particles between matching PrepareEffect and EndEffect calls.
	hsPoint3	fMax;
	hsPoint3	fMin;
	hsPoint3	fNorm;

public:
	plParticleFadeVolumeEffect();
	~plParticleFadeVolumeEffect();

	CLASSNAME_REGISTER( plParticleFadeVolumeEffect );
	GETINTERFACE_ANY( plParticleFadeVolumeEffect, plParticleEffect );

	virtual void PrepareEffect(const plEffectTargetInfo& target);
	virtual hsBool ApplyEffect(const plEffectTargetInfo& target, Int32 i);

	virtual void Read(hsStream *s, hsResMgr *mgr);
	virtual void Write(hsStream *s, hsResMgr *mgr);
	//virtual hsBool MsgReceive(plMessage *msg);

	hsScalar fLength;
	hsBool fIgnoreZ;
};

class plParticleWindEffect : public plParticleEffect
{
protected:
	// The properties that define the wind. These might/should be animatable.
	hsScalar	fStrength;
	hsScalar	fConstancy;
	hsScalar	fSwirl;
	hsBool		fHorizontal;
	hsVector3	fRefDir;

	// Some cached properties. These will be the same for all
	// particles between matching PrepareEffect and EndEffect calls.
	// These define the current state of the wind.
	hsVector3	fWindVec;
	hsVector3	fRandDir;
	hsVector3	fDir;
	double		fLastDirSecs;
public:

	plParticleWindEffect();
	~plParticleWindEffect();

	CLASSNAME_REGISTER( plParticleWindEffect );
	GETINTERFACE_ANY( plParticleWindEffect, plParticleEffect );

	virtual void PrepareEffect(const plEffectTargetInfo& target);
	virtual hsBool ApplyEffect(const plEffectTargetInfo& target, Int32 i) = 0;

	virtual void Read(hsStream *s, hsResMgr *mgr);
	virtual void Write(hsStream *s, hsResMgr *mgr);

	void				SetStrength(hsScalar v) { fStrength = v; }
	hsScalar			GetStrength() const { return fStrength; }

	void				SetConstancy(hsScalar c) { fConstancy = c; }
	hsScalar			GetConstancy() const { return fConstancy; }

	void				SetSwirl(hsScalar s) { fSwirl = s; }
	hsScalar			GetSwirl() const { return fSwirl; }

	void				SetHorizontal(hsBool on) { fHorizontal = on; }
	hsBool				GetHorizontal() const { return fHorizontal; }

	void				SetRefDirection(const hsVector3& v);
	const hsVector3&	GetRefDirection() const { return fRefDir; }
};

class plParticleLocalWind : public plParticleWindEffect
{
protected:
	hsVector3	fScale;
	hsScalar	fSpeed;

	hsVector3	fPhase;
	hsVector3	fInvScale;
	double		fLastPhaseSecs;
	
public:
	plParticleLocalWind();
	~plParticleLocalWind();

	CLASSNAME_REGISTER( plParticleLocalWind );
	GETINTERFACE_ANY( plParticleLocalWind, plParticleWindEffect );

	virtual void PrepareEffect(const plEffectTargetInfo& target);
	virtual hsBool ApplyEffect(const plEffectTargetInfo& target, Int32 i);

	void				SetScale(const hsVector3& v) { fScale = v; }
	const hsVector3&	GetScale() const { return fScale; }

	void				SetSpeed(hsScalar v) { fSpeed = v; }
	hsScalar			GetSpeed() const { return fSpeed; }

	virtual void Read(hsStream *s, hsResMgr *mgr);
	virtual void Write(hsStream *s, hsResMgr *mgr);

};

class plParticleUniformWind : public plParticleWindEffect
{
protected:

	hsScalar	fFreqMin;
	hsScalar	fFreqMax;
	hsScalar	fFreqCurr;
	hsScalar	fFreqRate;
	double		fCurrPhase;

	double		fLastFreqSecs;

	hsScalar	fCurrentStrength;
public:
	plParticleUniformWind();
	~plParticleUniformWind();

	CLASSNAME_REGISTER( plParticleUniformWind );
	GETINTERFACE_ANY( plParticleUniformWind, plParticleWindEffect );

	virtual void PrepareEffect(const plEffectTargetInfo& target);
	virtual hsBool ApplyEffect(const plEffectTargetInfo& target, Int32 i);

	void		SetFrequencyRange(hsScalar minSecsPerCycle, hsScalar maxSecsPerCycle);
	void		SetFrequencyRate(hsScalar secsPerCycle);

	virtual void Read(hsStream *s, hsResMgr *mgr);
	virtual void Write(hsStream *s, hsResMgr *mgr);

};

class plParticleInfluenceInfo
{
public:
	hsVector3 fAvgVel;
	hsVector3 fRepDir;
};

class plParticleFlockEffect : public plParticleEffect
{
//protected:
protected:
	hsPoint3 fTargetOffset;		// Worldspace offset from our target to get the true goal
	hsPoint3 fDissenterTarget;	// Where to particles go when they get scared and leave us?
	hsScalar fInfAvgRadSq;		// Square of the radius of influence for average velocity matching.
	hsScalar fInfRepRadSq;		// Same, for repelling from neighbors.
	hsScalar fAvgVelStr;		// How strongly are we influenced by average dir?
	hsScalar fRepDirStr;		// Same for repelling
	hsScalar fGoalOrbitStr;		// Same for the goal (when we're within the desired distance)
	hsScalar fGoalChaseStr;		// Same for the goal (when we're too far away, and chasing it)
	hsScalar fGoalDistSq;
	hsScalar fFullChaseDistSq;
	hsScalar fMaxOrbitSpeed;
	hsScalar fMaxChaseSpeed;

	UInt16 fMaxParticles;
	hsScalar *fDistSq;			// Table of distances from particle to particle
	plParticleInfluenceInfo *fInfluences; 

	void IUpdateDistances(const plEffectTargetInfo &target);
	void IUpdateInfluences(const plEffectTargetInfo &target);

public:
	plParticleFlockEffect();
	~plParticleFlockEffect();

	CLASSNAME_REGISTER( plParticleFlockEffect );
	GETINTERFACE_ANY( plParticleFlockEffect, plParticleEffect );

	virtual void PrepareEffect(const plEffectTargetInfo& target);
	virtual hsBool ApplyEffect(const plEffectTargetInfo& target, Int32 i);	

	void SetTargetOffset(const hsPoint3 &offset) { fTargetOffset = offset; }
	void SetDissenterTarget(const hsPoint3 &target) { fDissenterTarget = target; }
	void SetInfluenceAvgRadius(hsScalar val) { fInfAvgRadSq = val * val; }
	void SetInfluenceRepelRadius(hsScalar val) { fInfRepRadSq = val * val; }
	void SetGoalRadius(hsScalar val) { fGoalDistSq = val * val; }
	void SetFullChaseRadius(hsScalar val) { fFullChaseDistSq = val * val; }
	void SetConformStr(hsScalar val) { fAvgVelStr = val; }
	void SetRepelStr(hsScalar val) { fRepDirStr = val; }
	void SetGoalOrbitStr(hsScalar val) { fGoalOrbitStr = val; }
	void SetGoalChaseStr(hsScalar val) { fGoalChaseStr = val; }
	void SetMaxOrbitSpeed(hsScalar val) { fMaxOrbitSpeed = val; }
	void SetMaxChaseSpeed(hsScalar val) { fMaxChaseSpeed = val; }
	void SetMaxParticles(UInt16 num);

	virtual void Read(hsStream *s, hsResMgr *mgr);
	virtual void Write(hsStream *s, hsResMgr *mgr);
	virtual hsBool MsgReceive(plMessage *msg);	
};	

class plParticleFollowSystemEffect : public plParticleEffect
{
public:
	CLASSNAME_REGISTER( plParticleFollowSystemEffect );
	GETINTERFACE_ANY( plParticleFollowSystemEffect, plParticleEffect );
	
	plParticleFollowSystemEffect();

	virtual void PrepareEffect(const plEffectTargetInfo& target);
	virtual hsBool ApplyEffect(const plEffectTargetInfo& target, Int32 i);
	virtual void EndEffect(const plEffectTargetInfo& target);
	
protected:
	hsMatrix44 fOldW2L;
	hsBool fEvalThisFrame;
};

#endif