CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plDrawable/plDynaDecalMgr.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 plDynaDecalMgr_inc
#define plDynaDecalMgr_inc

#include "../pnNetCommon/plSynchedObject.h"
#include "hsTemplates.h"
#include "hsGeometry3.h"
#include "hsMatrix44.h"
#include "hsStlUtils.h"


class plParticleSystem;

class plPrintShape;
class plDynaDecalEnableMsg;
class plDynaDecal;
class plDrawableSpans;
class plGBufferGroup;
class plIcicle;
class hsGMaterial;
class plBitmap;
class plMipmap;
class plSceneObject;
class plArmatureMod;

class hsStream;
class hsResMgr;
class plMessage;

class plCutter;
class plCutoutPoly;
class plFlatGridMesh;

class plDrawVisList;
class plRenderLevel;

class plAccessSpan;
class plAuxSpan;
class plDecalVtxFormat;

class plPipeline;

// plDynaDecalInfo - information we store specific to what we've
// done about a specific avatar part or scene object.
class plDynaDecalInfo
{
public:
	enum
	{
		kNone			= 0x0,
		kImmersed		= 0x1,
		kActive			= 0x2
	};

	plKey		fKey;

	double		fLastTime;
	hsPoint3	fLastPos;
	double		fWetTime;
	hsScalar	fWetLength;
	UInt32		fFlags;

	plDynaDecalInfo& Init(const plKey& key);
};

typedef std::map< UInt32, plDynaDecalInfo, std::less<UInt32> > plDynaDecalMap;

// plDynaDecalMgr
// Primary responsibilities:
//	Allocation of adequate buffer space in plGBufferGroup
//	Setup of decal materials
//	Allocation of auxSpans
//	Receive lists of polys, translate into drawable tris
//	Create DynaDecals and destroy them when they expire.
//	Assign vertex and index subsets to DynaDecals
//	Call Update on DynaDecals
class plDynaDecalMgr : public plSynchedObject
{
public:
	enum DynaRefType
	{
		kRefMatPreShade,
		kRefMatRTShade,
		kRefTarget,
		kRefAvatar,
		kRefPartyObject,
		kRefParticles, 
		kRefNextAvailable	= 10
	};
protected:
	static hsBool				fDisableAccumulate;
	static hsBool				fDisableUpdate;

	plDynaDecalMap				fDecalMap;

	hsTArray<plDynaDecal*>		fDecals;

	hsTArray<plGBufferGroup*>	fGroups;

	plCutter*					fCutter;

	hsTArray<plAuxSpan*>		fAuxSpans;

	hsGMaterial*				fMatPreShade;
	hsGMaterial*				fMatRTShade;

	hsTArray<plSceneObject*>	fTargets;

	hsTArray<plSceneObject*>	fPartyObjects;
	hsTArray<plParticleSystem*>	fParticles;

	hsScalar					fPartyTime;

	UInt16						fMaxNumVerts;
	UInt16						fMaxNumIdx;

	UInt32						fWaitOnEnable;
	
	hsScalar					fWetLength;
	hsScalar					fRampEnd;
	hsScalar					fDecayStart;
	hsScalar					fLifeSpan;
	hsScalar					fIntensity;

	hsScalar					fGridSizeU;
	hsScalar					fGridSizeV;

	hsVector3					fScale;

	// some temp calculated stuff
	hsScalar					fInitAtten; 
	// These 4 are in normalized units [0..1], not feet.
	hsScalar					fMinDepth;
	hsScalar					fMinDepthRange;
	hsScalar					fMaxDepth;
	hsScalar					fMaxDepthRange;

	hsTArray<UInt32>			fPartIDs;
	hsTArray<plKey>				fNotifies;

	const plPrintShape*	IGetPrintShape(const plKey& objKey) const;
	const plPrintShape*	IGetPrintShape(plArmatureMod* avMod, UInt32 id) const;

	virtual hsBool		IHandleEnableMsg(const plDynaDecalEnableMsg* enaMsg);
	void				INotifyActive(plDynaDecalInfo& info, const plKey& armKey, UInt32 id) const;
	void				INotifyInactive(plDynaDecalInfo& info, const plKey& armKey, UInt32 id) const;
	hsBool				IWetParts(const plDynaDecalEnableMsg* enaMsg);
	hsBool				IWetPart(UInt32 id, const plDynaDecalEnableMsg* enaMsg);
	void				IWetInfo(plDynaDecalInfo& info, const plDynaDecalEnableMsg* enaMsg) const;
	hsScalar			IHowWet(plDynaDecalInfo& info, double t) const;
	plDynaDecalInfo&	IGetDecalInfo(UInt32 id, const plKey& key);
	void				IRemoveDecalInfo(UInt32 id);
	void				IRemoveDecalInfos(const plKey& key);

	hsGMaterial*		ISetAuxMaterial(plAuxSpan* aux, hsGMaterial* mat, hsBool rtLit);
	void				IAllocAuxSpan(plAuxSpan* aux, UInt32 maxNumVerts, UInt32 maxNumIdx);
	plAuxSpan*			IGetAuxSpan(plDrawableSpans* targ, int iSpan, hsGMaterial* mat, UInt16 numVerts, UInt16 numIdx);
	hsBool				IMakeAuxRefs(plPipeline* pipe);

	UInt16*				IGetBaseIdxPtr(const plAuxSpan* auxSpan) const;
	plDecalVtxFormat*	IGetBaseVtxPtr(const plAuxSpan* auxSpan) const;

	virtual int			INewDecal() = 0;
	plDynaDecal*		IInitDecal(plAuxSpan* aux, double t, UInt16 numVerts, UInt16 numIdx);
	void				IKillDecal(int i);
	void				IUpdateDecals(double t);

	void				ICountIncoming(hsTArray<plCutoutPoly>& src, UInt16& numVerts, UInt16& numIdx) const;
	hsBool				IConvertPolysColor(plAuxSpan* auxSpan, plDynaDecal* decal, hsTArray<plCutoutPoly>& src);
	hsBool				IConvertPolysAlpha(plAuxSpan* auxSpan, plDynaDecal* decal, hsTArray<plCutoutPoly>& src);
	hsBool				IConvertPolysVS(plAuxSpan* auxSpan, plDynaDecal* decal, hsTArray<plCutoutPoly>& src);
	hsBool				IConvertPolys(plAuxSpan* auxSpan, plDynaDecal* decal, hsTArray<plCutoutPoly>& src);
	hsBool				IProcessPolys(plDrawableSpans* targ, int iSpan, double t, hsTArray<plCutoutPoly>& src);
	hsBool				IHitTestPolys(hsTArray<plCutoutPoly>& src) const;

	hsBool				IProcessGrid(plDrawableSpans* targ, int iSpan, hsGMaterial* mat, double t, const plFlatGridMesh& grid);
	hsBool				IConvertFlatGrid(plAuxSpan* auxSpan, plDynaDecal* decal, const plFlatGridMesh& grid) const;
	hsBool				ICutoutGrid(plDrawableSpans* drawable, int iSpan, hsGMaterial* mat, double secs);
	hsBool				IHitTestFlatGrid(const plFlatGridMesh& grid) const;

	hsBool				ICutoutList(hsTArray<plDrawVisList>& drawVis, double secs);
	hsBool				ICutoutObject(plSceneObject* so, double secs);
	hsBool				ICutoutTargets(double secs);

	void				ISetDepthFalloff(); // Sets from current cutter settings.

	virtual void		ICutoutCallback(const hsTArray<plCutoutPoly>& cutouts, hsBool hasWaterHeight=false, hsScalar waterHeight=0.f);

	hsGMaterial*		IConvertToEnvMap(hsGMaterial* mat, plBitmap* envMap);

	virtual void		SetKey(plKey k);

	hsVector3			IReflectDir(hsVector3 dir) const;
	hsMatrix44			IL2WFromHit(hsPoint3 pos, hsVector3 dir) const;
	hsVector3			IRandomUp(hsVector3 dir) const;
	void				IGetParticles();

public:

	plDynaDecalMgr();
	virtual ~plDynaDecalMgr();

	CLASSNAME_REGISTER( plDynaDecalMgr );
	GETINTERFACE_ANY( plDynaDecalMgr, plSynchedObject );

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

	virtual hsBool MsgReceive(plMessage* msg);

	// This is public, because you need to call it after creating
	// a DynaDecalMgr on the fly. It's normally called on Read().
	void	InitAuxSpans();

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

	void SetWaitOnEnable(hsBool on) { fWaitOnEnable = on; }
	hsBool GetWaitOnEnable() const { return fWaitOnEnable; }

	void SetWetLength(hsScalar f) { fWetLength = f; }
	void SetRampEnd(hsScalar f) { fRampEnd = f; }
	void SetDecayStart(hsScalar f) { fDecayStart = f; }
	void SetLifeSpan(hsScalar f) { fLifeSpan = f; }
	void SetIntensity(hsScalar f) { fIntensity = f; }
	hsScalar GetWetLength() const { return fWetLength; }
	hsScalar GetRampEnd() const { return fRampEnd; }
	hsScalar GetDecayStart() const { return fDecayStart; }
	hsScalar GetLifeSpan() const { return fLifeSpan; }
	hsScalar GetIntensity() const { return fIntensity; }

	void		SetPartyTime(hsScalar secs) { fPartyTime = secs; } // Duration of particle spewage
	hsScalar	GetPartyTime() const { return fPartyTime; }

	void ConvertToEnvMap(plBitmap* envMap);
	const plMipmap* GetMipmap() const;

	void AddNotify(const plKey& k) { fNotifies.Append(k); }
	UInt32 GetNumNotifies() const { return fNotifies.GetCount(); }
	const plKey& GetNotify(int i) const { return fNotifies[i]; }

	static void SetDisableAccumulate(hsBool on) { fDisableAccumulate = on; }
	static void ToggleDisableAccumulate() { fDisableAccumulate = !fDisableAccumulate; }
	static hsBool GetDisableAccumulate() { return fDisableAccumulate; }

	static void SetDisableUpdate(hsBool on) { fDisableUpdate = on; }
	static void ToggleDisableUpdate() { fDisableUpdate = !fDisableUpdate; }
	static hsBool GetDisableUpdate() { return fDisableUpdate; }
};

#endif // plDynaDecalMgr_inc