Leviathan/Client/Game/engine/Renderer/KSeqForm.h

// KSeqForm.h: interface for the KSeqForm class.
//
//////////////////////////////////////////////////////////////////////
#pragma once

#include "KRenderObject.h"
#include "KSortVector.h"

class KSeqForm : public KSeqObject
{
public:
	KSeqForm();
	virtual ~KSeqForm();

	virtual void Clear();
	virtual void Initialize( DWORD dwCurTime = -1 );
	virtual void ReSet();

	enum
	{
		SEQTYPE_NORMAL,
		SEQTYPE_LOOP,
		SEQTYPE_LASTPAGE,
		SEQTYPE_REVERSE,
		SEQTYPE_REVERSE_LOOP,
	};
	bool AddAnimation( const char *name, const char *filename, bool bNowLoading = false, int nReqType = 0xfffff );

	virtual bool PlayAnimation( DWORD dwCurTime, const char *name, int nAniType = SEQTYPE_NORMAL, float fPlayRate = 4.8f );
	virtual bool PlayOverride( DWORD dwCurTime, const char *name, float fPlayRate = 4.8f );
	virtual void StopAnimation();

	virtual void SetParentTransform( const K3DMatrix *pMatParent, const K3DMatrix *pMatAttach = NULL, BOOL bRotationLock = FALSE );

	/// 스피드트리만 쓰고 있음
	virtual void SetLodLevel( float fValue /*0.f~1.f*/ ) {}

	void TryPlayAnimation();

	enum
	{
		SEQPOS_BEGIN,
		SEQPOS_END,
	};
	void SetAnimationPos(int nPosFlag);
	void ChangeAnimationType(int nAniType);	

	void SetPosition( const K3DVector &pos );
	void SetPosition( float x, float y, float z = .0f );
	const K3DVector &GetPosition()
	{
		return *((K3DVector*)&m_matTransform.m30);
	}

	void SetViewVector( const K3DVector &view );
	void SetRoll( float rad );

	void RotateX( float rad );
	void RotateY( float rad );
	void RotateZ( float rad );

	virtual void SetTransform( const K3DMatrix &mat );

	virtual const K3DMatrix &GetTransform()
	{
		return m_matTransform;
	}

	virtual const K3DMatrix &GetResultTransform()
	{
		return m_matResult;
	}


	virtual void ClipTest( const K3DVector* pFrustum);

	KSeqObject *GetAnimation( const char *name, int nReqType = 0xfffff );
	bool RemoveAnimation( const char *name );

	KSeqObject *GetCurrentAnimation()
	{
		return m_pCurSeq;
	}
	const char *GetCurrentAnimationName()
	{
		return m_strCurSeq.c_str();
	}
	bool IsPlaying()
	{
		return m_bIsPlaying;
	}

	void SetTimeRate( float fTimeRate )
	{
		m_fRate = fTimeRate;
	}

	enum
	{
		SEQINFO_NOP,
		SEQINFO_PLAYING,
		SEQINFO_STOPPED,
		SEQINFO_LOOPWRAP,
	};
	virtual int Process( DWORD dwTime );
	int GetLoopCount()			{ return m_nLoopCount; }
	void ResetLoopCount()		{ m_nLoopCount = 0;	}

	virtual void *Perform( KID id, KArg& msg );

	virtual void SetColor( DWORD c1, DWORD c2 = 0, DWORD c3 = 0, DWORD c4 = 0, short nMode = 0 );
	virtual KSeqObject* Clone();

	virtual void Render( KViewportObject *viewport, DWORD flag = RENDEREFX_NONE, const K3DMatrix * pAttachMat = NULL );
	virtual void realizeTime();

	DWORD GetStartTime() { return m_nStartTime; }
	void SetStartTime(DWORD dwTime) { m_nStartTime = dwTime; }
	virtual DWORD GetAniTime() { return static_cast<DWORD>( m_dwAniTime / 4.8f ); }
	virtual K3DBoundRotCube* GetBoundCube( const char * pName = NULL );

	int	GetAniType() { return m_nAniType; }

	/// 맵 엔진에서, Load가 끝났나, 안 끝났나 확인 하는 기능.
	virtual bool IsLoadCompleted() const { return (NULL != m_pCurSeq); }

	/// Tool 에서 사용
	void GetKeyList( std::vector< const char * > &keylist );
	virtual void SetAniTime( DWORD dwTime );

	bool GetAnimationFromSeqObjList( const char *name );

	const char*	GetSeqObjName();

#ifndef _RAC
	/**	Tool 에서만 사용.
		화일로 존재하지 않는 KSeqObject 를 다루기 위해서 사용되고 있음. */
	void AddSeqObjectTemp( const char *name, KSeqObject *obj )
	{ AddSeqObject( name, obj ); };
#endif

protected:
	void AddSeqObject( const char *name, KSeqObject *obj );
	void UpdateColors();
	virtual void buildBoundCube();
	void clearPend();
	bool isPendActivate() { return m_bPendActivate; }

	bool CheckPendingSeq() { return ( m_pPendSeq != NULL ); }
protected:
	bool								m_bValidBoundCube;
	K3DBoundRotCube						m_BoundCube;

	short								m_nColorizedMode;
	DWORD								m_dwColors[4];
	int									m_nAniType;
	bool								m_bIsPlaying;
	DWORD								m_dwCurTime;
	DWORD								m_nStartTime;
	DWORD								m_nLength;
	float								m_fRate;
	std::string							m_strCurSeq;
	KSeqObject*							m_pCurSeq;
	K3DMatrix							m_matTransform;
	K3DMatrix							m_matResult;
	K3DMatrix							m_matWorld;
	int									m_nLoopCount;
	DWORD								m_dwAniTime;
	int									m_nAniPartIndex;
// be overrided animation
	bool								m_bPendActivate;
	int									m_nPendAniType;
	DWORD								m_nPendStartTime;
	DWORD								m_nPendLength;
	float								m_fPendRate;
	std::string							m_strPendSeq;
	KSeqObject*							m_pPendSeq;

	bool								m_bTryPlayAnimation; //
	std::string							m_strTryAnimation;
	DWORD								m_dwTryTime;
	int									m_nTryAniType;
	float								m_fTryRate;

	bool								m_bUseBlend;	///< Ani Blend를 지원하기 위함. Blend 가 필요 없는 것들도 있다.

	enum
	{
		SEQ_NEEDLOADING,
		SEQ_FAILED,
		SEQ_SUCCESS,
	};
	struct SEQOBJ
	{
		SEQOBJ()
		{
			nFlag = SEQ_NEEDLOADING;
			pSeq = NULL;
		}
		~SEQOBJ()
		{
			if ( pSeq ) delete pSeq;
		}
		int					nFlag;
		KSeqObject*			pSeq;
		std::string			strName;
		std::string			strFileName;
	};

	struct lessOfSEQOBJPtr
	{
		bool operator() ( const SEQOBJ* a, const SEQOBJ* b )
		{
			return _stricmp( a->strName.c_str(), b->strName.c_str() ) < 0;
		}
	};

	typedef KSortVector<SEQOBJ*, lessOfSEQOBJPtr>	SeqObjList;
	SeqObjList m_vSeqObj;
};