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

#include "../pnModifier/plSingleModifier.h"
#include "plMorphArray.h"

class plDrawable;
class plDrawInterface;
class plSharedMesh;
class plMorphSequenceSDLMod;

class plMorphArrayWeights
{
public:
	hsTArray<hsScalar> fDeltaWeights;
};

class plSharedMeshInfo
{
public:
	enum
	{
		kInfoDirtyMesh = 0x1
	};

	plSharedMesh*		fMesh;
	hsTArray<Int32>		fCurrIdx;
	plDrawable*			fCurrDraw;
	hsTArray<plMorphArrayWeights> fArrayWeights;
	UInt8				fFlags;

	plSharedMeshInfo() : fMesh(nil), fCurrDraw(nil), fFlags(0) {}
};

// Keyed storage class for morph arrays/deltas
// supply your own weights.
class plMorphDataSet : public hsKeyedObject
{
public:
	hsTArray<plMorphArray>	fMorphs;

	CLASSNAME_REGISTER( plMorphDataSet );
	GETINTERFACE_ANY( plMorphDataSet, hsKeyedObject );
	
	virtual void Read(hsStream* s, hsResMgr* mgr);
	virtual void Write(hsStream* s, hsResMgr* mgr);		
};

// A place to hold incoming state while we're still waiting for the
// mesh and morph data to load.
class plMorphState
{
public:
	plKey fSharedMeshKey;
	hsTArray<plMorphArrayWeights> fArrayWeights;
};

class plMorphSequence : public plSingleModifier
{
	friend class plMorphSequenceSDLMod;
	
protected:
	enum
	{
		kDirty				= 0x1,
		kHaveSnap			= 0x2,
		kHaveShared			= 0x4,
		kDirtyIndices		= 0x8
	};
	UInt32						fMorphFlags;

	hsTArray<plMorphArray>		fMorphs;

	//Int32						fActiveMesh; // Doesn't appear to be used.
	hsTArray<plSharedMeshInfo>	fSharedMeshes;
	hsTArray<plMorphState>		fPendingStates;
	plMorphSequenceSDLMod*		fMorphSDLMod;
	Int8						fGlobalLayerRef;

	const plDrawInterface*		IGetDrawInterface() const;

	virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty) { return false; }

	void ISetHaveSnap(hsBool on) { if(on)fMorphFlags |= kHaveSnap; else fMorphFlags &= ~kHaveSnap; }
	void ISetDirty(hsBool on);

	hsBool		IResetShared(int iShare);
	void		IApplyShared(int iShare);
	hsBool		IFindIndices(int iShare);
	void		IReleaseIndices(int iShare);

	void		IRenormalize(hsTArray<plAccessSpan>& dst) const;

	void		IResetShared();
	void		IReleaseIndices(); // Puts everyone inactive
	void		IFindIndices(); // Refresh Indicies
	void		IApplyShared(); // Apply whatever morphs are active

	Int32		IFindPendingStateIndex(plKey meshKey) const; // Do we have pending state for this mesh?
	Int32		IFindSharedMeshIndex(plKey meshKey) const; // What's this mesh's index in our array?
	hsBool		IIsUsingDrawable(plDrawable *draw); // Are we actively looking at spans in this drawable?

	// Internal functions for maintaining that all meshes share the same global weight(s) (fGlobalLayerRef)
	void		ISetAllSharedToGlobal();
	void		ISetSingleSharedToGlobal(int idx);
		

public:
	plMorphSequence();
	virtual ~plMorphSequence();

	CLASSNAME_REGISTER( plMorphSequence );
	GETINTERFACE_ANY( plMorphSequence, plSingleModifier );

	virtual hsBool MsgReceive(plMessage* msg);

	virtual void AddTarget(plSceneObject* so);
	virtual void RemoveTarget(plSceneObject* so);
	virtual void Read(hsStream* s, hsResMgr* mgr);
	virtual void Write(hsStream* s, hsResMgr* mgr);	

	void Init();
	void Activate();
	void DeInit();
	void DeActivate();

	void Apply() const;
	void Reset(const plDrawInterface* di=nil) const;

	int GetNumLayers(plKey meshKey = nil) const; 
	void AddLayer(const plMorphArray& ma) { fMorphs.Append(ma); }

	int GetNumDeltas(int iLay, plKey meshKey = nil) const;
	hsScalar GetWeight(int iLay, int iDel, plKey meshKey = nil) const;
	void SetWeight(int iLay, int iDel, hsScalar w, plKey meshKey = nil);

	hsBool GetHaveSnap() const { return 0 != (fMorphFlags & kHaveSnap); }
	hsBool GetDirty() const { return 0 != (fMorphFlags & kDirty); }
	hsBool GetUseSharedMesh() const { return 0 != (fMorphFlags & kHaveShared); }

	void SetUseSharedMesh(hsBool on) { if(on)fMorphFlags |= kHaveShared; else fMorphFlags &= ~kHaveShared; }
	void AddSharedMesh(plSharedMesh* mesh);
	void RemoveSharedMesh(plSharedMesh* mesh);
	static void FindMorphMods(const plSceneObject *so, hsTArray<const plMorphSequence*> &mods);
	plMorphSequenceSDLMod *GetSDLMod() const { return fMorphSDLMod; }
};

#endif // plMorphSequence_inc