CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Tools/MaxComponent/plAnimComponent.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 plAnimComponent_inc
#define plAnimComponent_inc

#include <map>
#include "plComponent.h"
#include "plComponentReg.h"
#include "../pnKeyedObject/plKey.h"
#include "hsTemplates.h"
#include "plAnimObjInterface.h"
#include "plNoteTrackDlgComp.h"

#define ANIM_COMP_CID Class_ID(0x32e77ab, 0x28a80383)
#define ANIM_GROUP_COMP_CID Class_ID(0x341a57fc, 0x4cda6c64)
#define ANIM_COMPRESS_COMP_CID Class_ID(0x116d3175, 0x4e465807)

class plComponentBase;
class plMaxNode;
class plSimpleTMModifier;
class plLightModifier;
class plAGMasterMod;
class plAGAnim;
class plMsgForwarder;
class plController;
class plAGApplicator;

class plAnimComponentBase : public plComponent, public plAnimObjInterface
{
protected:
	std::map<plMaxNode*, plAGMasterMod*> fMods;
	std::map<plMaxNode*, plLightModifier*> fLightMods;
	bool fNeedReset;

public:
	plAnimComponentBase();
	void DeleteThis() { delete this; }

	hsBool SetupProperties(plMaxNode *node, plErrorMsg *pErrMsg);
	hsBool PreConvert(plMaxNode *node, plErrorMsg *pErrMsg);
	hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg);
	hsBool DeInit(plMaxNode *node, plErrorMsg *pErrMsg);

	virtual plKey GetModKey(plMaxNode *node)=0;
	const char *GetAnimName();
	static IsAnimComponent(plComponentBase *comp);

	std::map<plMaxNode*, plAGAnim*> fAnims;

	// Static function for setting up scalar controllers
	static void	SetupCtl( plAGAnim *anim, plController *ctl, plAGApplicator *app, plMaxNode *node );
	
	// Static function to grab the animation key given the INode pointing to either a) an anim component or b) a material stealth node
	static bool	GetAnimKey( plMaxNode *node, hsTArray<plKey> &outKeys );

	// Static function to grab the animObjInterface for a given INode, regardless of type
	static plAnimObjInterface	*GetAnimInterface( INode *node );

	// plAnimObjInterface functions
	virtual void	PickTargetNode( IParamBlock2 *destPB, ParamID destParamID, ParamID typeID );
	virtual hsBool	IsNodeRestricted( void ) { return true; }
	virtual const char	*GetIfaceSegmentName( hsBool allowNil );

protected:
	hsBool IAddTMToAnim(plMaxNode *node, plAGAnim *anim, plErrorMsg *pErrMsg);
	hsBool IAddLightToAnim(plMaxNode *node, plAGAnim *anim, plErrorMsg *pErrMsg);
	hsBool IConvertNodeSegmentBranch(plMaxNode *node, plAGAnim *anim, plErrorMsg *pErrMsg);
	hsBool IMakePersistent(plMaxNode *node, plAGAnim *anim, plErrorMsg *pErrMsg);
};

class plAnimComponent : public plAnimComponentBase
{
public:
	plAnimComponent();
	plKey GetModKey(plMaxNode *node);
	virtual hsBool	GetKeyList( INode *restrictedNode, hsTArray<plKey> &outKeys );
};

class plAnimGroupedComponent : public plAnimComponentBase
{
protected:
	plMsgForwarder *fForward;

public:
	plAnimGroupedComponent();

	hsBool PreConvert(plMaxNode *node, plErrorMsg *pErrMsg);

	plKey GetModKey(plMaxNode *node);

	virtual hsBool	IsNodeRestricted( void ) { return false; }
	virtual hsBool	GetKeyList( INode *restrictedNode, hsTArray<plKey> &outKeys );
};

//// Dialog Proc For Anim Selection /////////////////////////////////////////////////////////////
//	Derive from this guy to handle selection of an animation. Also, you can pass a pointer in
//	to another dialog proc to chain procs together (this proc will execute before the chained
//	one).

class plPlasmaAnimSelectDlgProc : public ParamMap2UserDlgProc
{
protected:
	ParamID			fParamID;
	int				fDlgItem;

	bool			fUseNode;
	ParamID			fNodeParamID;
	ParamID			fTypeParamID;
	int				fNodeDlgItem;

	TCHAR			fTitle[ 128 ];

	ParamMap2UserDlgProc	*fChain;

	void	IUpdateNodeBtn( HWND hWnd, IParamBlock2 *pb );

public:

	int		GetHandledDlgItem( void ) const { return fDlgItem; }

	// No node restriction version
	plPlasmaAnimSelectDlgProc( ParamID paramID, int dlgItem, TCHAR *promptTitle, ParamMap2UserDlgProc *chainedDlgProc = nil );

	// Node restricted version
	plPlasmaAnimSelectDlgProc( ParamID paramID, int dlgItem, ParamID nodeParamID, ParamID typeParamID, int nodeDlgItem, TCHAR *promptTitle, ParamMap2UserDlgProc *chainedDlgProc = nil );

	virtual void	SetThing( ReferenceTarget *m );
	virtual void	Update( TimeValue t, Interval &valid, IParamMap2 *map );
	virtual BOOL	DlgProc( TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam );

	void DeleteThis();
};

class plAnimComponentProc : public ParamMap2UserDlgProc
{
protected:
	plComponentNoteTrackDlg fNoteTrackDlg;
	IParamBlock2 *fPB;
	
	void EnableGlobal(HWND hWnd, hsBool enable);
	
public:
	static void FillAgeGlobalComboBox(HWND box, char *varName);
	static void SetBoxToAgeGlobal(HWND box, char *varName);

	virtual BOOL DlgProc(TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
	virtual void Update(TimeValue t, Interval &valid, IParamMap2 *map);	
	void DeleteThis();
};	

class plAnimCompressComp : public plComponent
{
public:
	plAnimCompressComp();
	void DeleteThis() { delete this; }

	virtual hsBool SetupProperties(plMaxNode *node, plErrorMsg *pErrMsg);
	//virtual hsBool PreConvert(plMaxNode *node, plErrorMsg *pErrMsg);
	virtual hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg);

	enum
	{
		kCompressionNone,
		kCompressionLow,
		kCompressionHigh,
	};

	enum
	{
		kAnimCompressLevel,
		kAnimCompressThreshold,
	};
};

#endif // plAnimComponent_inc