#pragma once

#include "KObject.h"
#include "KPrimitiveMesh.h"
#include "KPrimitiveFXParticle.h"
#include "K3DBound.h"
#include "krenderobject.h"

class KViewportObject;
class K3DRenderDeviceDX;
//class K3DFrustum;

class K3DMeshResource;
class K3DResMeshMatrixAnimation;
class K3DResMeshVisibilityAnimation;

/** Mesh Render Off
	"SETRENDER_FLAG" */
class KMsgSET_RENDERFLAG : public KArg
{
public:
	KMsgSET_RENDERFLAG() : pName(NULL), bRenderFlag(FALSE) {}
	
	const char * pName;
	BOOL		 bRenderFlag;
};

/** Mesh 이름 얻기
	"GETMESH_NAME" */
class KMsgGET_MESHNAME : public KArg
{
public:
	KMsgGET_MESHNAME() {}

	std::vector<const char *> vNameList;
};

/// "GETMESH_INFO"
class KMsgGET_MESHINFO : public KArg
{
public:
	KMsgGET_MESHINFO() {}

	struct MESH_INFO
	{
		const char*		szMeshName;
		std::vector< const char* >	vTextureList;
	};

	std::vector< MESH_INFO > vMeshList;
};

/// "CHANGE_MESH_TEXTURE"
class KMsgCHANGE_MESH_TEXTURE : public KArg
{
public:
	KMsgCHANGE_MESH_TEXTURE() { bForceChange = false; }

	bool bForceChange;							// on이면 그냥 vTextureList[0]에 저장된 이름으로 모든 텍스쳐를 밀어버림-_- 아이템 텍스쳐 교환을 위해 억지로 삽입.
	const char*	szMeshName;
	std::vector< const char* > vTextureList;
};

struct MESHVERTEXBUFFERSTRUCT
{
	MESHVERTEXBUFFERSTRUCT() : pVBs(NULL), nVBCount(0) { K3DMatrixIdentity( matLocal ); }
	~MESHVERTEXBUFFERSTRUCT() { SAFE_DELETE(pVBs); }

	K3DVertexBuffer** pVBs;
	int nVBCount;

	K3DMatrix matLocal;
};

/** 버텍스 버퍼 얻기
	"GETMESH_VERTEXBUFFERS" */
class KMsgGET_MESHVERTEXBUFFERS : public KArg
{
public:
	KMsgGET_MESHVERTEXBUFFERS() {}
	~KMsgGET_MESHVERTEXBUFFERS() { SAFE_DELETE_VECTOR(vVbStruct); }

	std::vector<MESHVERTEXBUFFERSTRUCT*> vVbStruct;	
};

struct MESHINDEXBUFFERSTRUCT
{
	MESHINDEXBUFFERSTRUCT() : pIBs(NULL), nIBCount(0) {}
	~MESHINDEXBUFFERSTRUCT() { SAFE_DELETE(pIBs); }

	K3DIndexBuffer** pIBs;
	int nIBCount;
};

/** 인덱스 버퍼 얻기
	"GETMESH_INDEXBUFFERS" */
class KMsgGET_MESHINDEXBUFFERS : public KArg
{
public:
    KMsgGET_MESHINDEXBUFFERS() {}
	~KMsgGET_MESHINDEXBUFFERS() { SAFE_DELETE_VECTOR(vIbStruct); }

	std::vector<MESHINDEXBUFFERSTRUCT*> vIbStruct;
};

/** 폴리곤 수 얻기
	"GETMESH_POLYCOUNT" */
class KMsgGET_MESHPOLYCOUNT : public KArg
{
public:
	KMsgGET_MESHPOLYCOUNT() : nPolyCount(0) {}

	int nPolyCount;
};

/** 폴리곤의 삼각형 얻기
	"GETMESH_TRI" */
class KMsgGET_GETMESH_TRI : public KArg
{
public:
	KMsgGET_GETMESH_TRI() 
	{
		K3DMatrixIdentity( mat );
		pListTriangles = NULL;
	}

	K3DMatrix mat;
	std::vector< K3DVector > * pListTriangles;
};

/** 텍스쳐 이름 얻기
	"GETMESH_TEXNAME" */
class KMsgGET_MESHTEXNAME : public KArg
{
public:
	KMsgGET_MESHTEXNAME() {}

	std::vector<const char *> vNameList;
};

/** Ani Info
	"GETMESH_ANIINFO" */
class KMsgGET_MESHANI_INFO : public KArg
{
public:
	KMsgGET_MESHANI_INFO() : nStart(-1), nEnd(-1) {}

	std::string strFindName;

	int	nStart;
	int	nEnd;
};

class KBoneSeqObject;

/** Deform Mesh
	"SETDEFORM_BONE" */
class KMsgSET_DEFORM : public KArg
{
public:
	KMsgSET_DEFORM( int _nBoneCount, K3DMatrix *_pMatBoneList ) : nBoneCount(_nBoneCount), pMatBoneList(_pMatBoneList) {}
	int nBoneCount;
	K3DMatrix * pMatBoneList;
	
	KBoneSeqObject * pBoneSeq;
};

/// "REQ_BOUNDBOXEX"
class KMsgREQ_BOUNDBOXEX : public KArg
{
public:
	KMsgREQ_BOUNDBOXEX() : m_isValid(false), pSearchName(NULL) {}

	bool IsValid()
	{
		return m_isValid;
	}
	void AddBound( K3DBoundRotCube *cube )
	{
		m_isValid = true;
		m_cubeBound.AddCube( *cube );
	}
	const K3DBoundRotCube &GetCube()
	{
		return m_cubeBound;
	}
	const char * pSearchName;

protected:
	bool			m_isValid;
	K3DBoundRotCube m_cubeBound;
};

/** Request Clip Bound Box
	"REQ_BOUNDBOX" */
class KMsgREQ_BOUNDBOX : public KArg
{
public:
	KMsgREQ_BOUNDBOX() 
	{
		m_isValid = false;
	}
	bool IsValid()
	{
		return m_isValid;
	}
	void AddBound( K3DBoundRotCube *cube )
	{
		if ( m_isValid == false )
		{
			m_cubeBound = *cube;
			m_isValid = true;
		}
		else
			m_cubeBound.AddCube( *cube );
	}
	const K3DBoundRotCube &GetCube()
	{
		return m_cubeBound;
	}
protected:
	bool			m_isValid;
	K3DBoundRotCube m_cubeBound;
};

/** Request Clip Bound Sphere
	"REQ_BOUNDSPHERE" */
class KMsgREQ_BOUNDSPHERE : public KArg
{
public:
	KMsgREQ_BOUNDSPHERE() 
	{
		m_isValid = false;
	}
	bool IsValid()
	{
		return m_isValid;
	}
	void AddBound( K3DBoundSphere *sphere )
	{
		m_isValid = true;
		m_sphereBound.AddSphere( *sphere );
	}
	const K3DBoundSphere &GetSphere()
	{
		return m_sphereBound;
	}
protected:
	bool			m_isValid;
	K3DBoundSphere m_sphereBound;
};

/// "SET_LIGHT_MAP"
class KMsgSET_LIGHTMAP : public KArg
{
public:
	KMsgSET_LIGHTMAP(LPCSTR texName,size_t segmentIdx, size_t propIdx)
	{
		m_sPrefixTexName = texName;
		m_segmentIdx = segmentIdx;
		m_propIdx = propIdx;
	}
	size_t	GetSegmentIdx()	const { return m_segmentIdx; }
	size_t	GetPropIdx() const { return m_propIdx; }
	LPCSTR	GetPrefixTexName() const { return m_sPrefixTexName.c_str(); }
private:
	std::string	m_sPrefixTexName;
	size_t m_segmentIdx;
	size_t m_propIdx;
};

/// "GET_SEQOBJECT"
class KMsgGET_SEQOBJECT : public KArg
{
public:
	KMsgGET_SEQOBJECT( const char * seqName )
	{
		pName = seqName;
		pSeqObject = NULL;
	}

	const char * pName;
	KSeqObject * pSeqObject;
};

class KMsgGET_MORPHMESH : public KArg
{
public:
	KMsgGET_MORPHMESH()
	{
		bIsValid	  =false;
		numFrames     =0;
		loopWindowSize=0;
		markFrame     =0;

		animationDelay=0;

		startColor0=startColor1=0xffffffff;
		markColor0=markColor1  =0x80808080;
		endColor0=endColor1    =0x00000000;

		startSizeOffset=0.f;
		markSizeOffset =0.f;
		endSizeOffset  =0.f;
	}
	bool bIsValid;
	int numFrames;						
	int loopWindowSize;					
	int animationDelay;					

	int markFrame;						

	DWORD startColor0, startColor1;		
	DWORD markColor0, markColor1;		
	DWORD endColor0, endColor1;			
	float startSizeOffset;				
	float markSizeOffset;				
	float endSizeOffset;		

	std::string strTexture;
};

class KMsgSET_FIXTEXTURE : public KArg
{
public:
	KMsgSET_FIXTEXTURE()
	{
		bUseFix  = false;
		bForceTransparent = false;
		pTexture = NULL;
	}
	bool		bUseFix;
	bool		bForceTransparent;
	K3DTexture *pTexture;
};

class KMsgSET_WINKTEXTURE : public KArg
{
public:
	KMsgSET_WINKTEXTURE() : bUseWink(false), nWinkTime(0), pTexture(NULL) {}
	
	bool		bUseWink;
	short		nWinkTime;
	K3DTexture *pTexture;
};

class KMsgSET_COLORIZE : public KArg
{
public:
	KMsgSET_COLORIZE()
	{
		color[0] = 0;
		color[1] = 0; 
		color[2] = 0;
		color[3] = 0;
		nMode = 0;
	}
	DWORD	color[4];
	short	nMode;
};

class KMsgSET_USE_TEXALPHA : public KArg
{
public:
	KMsgSET_USE_TEXALPHA()
	{
		bIsUseTexAlpha = true;
	}
	bool	bIsUseTexAlpha;
};

class KMsgSET_UV_MODIFY : public KArg
{
public:
	KMsgSET_UV_MODIFY()
	{
		nW = 0;
		nH = 0;
		nTargetW = 0;
		nTargetH = 0;
	}
	int nW, nH;
	int nTargetW, nTargetH;
};

class KMsgSET_MORPHMESH : public KArg
{
public:

	enum
	{
		FLAG_FRAME  = 1 << 0, 
		FLAG_LOOP   = 1 << 1, 
		FLAG_DELAY  = 1 << 2, 
		FLAG_MARK   = 1 << 3,
		FLAG_SC0    = 1 << 4, 
		FLAG_SC1    = 1 << 5, 
		FLAG_MC0    = 1 << 6, 
		FLAG_MC1    = 1 << 7, 
		FLAG_EC0    = 1 << 8, 
		FLAG_EC1    = 1 << 9, 
		FLAG_SSIZE  = 1 << 10, 
		FLAG_MSIZE  = 1 << 11, 
		FLAG_ESIZE  = 1 << 12, 
		FLAG_TEXTURE = 1 << 13, 
		FLAG_ADDITIVE = 1 << 14, 
	};

	KMsgSET_MORPHMESH()
	{
		bShow         =false;
		nSetFlag      =0;

		numFrames     =0;
		loopWindowSize=0;
		markFrame     =0;

		animationDelay=0;

		startColor0=startColor1=0xffffffff;
		markColor0=markColor1  =0x80808080;
		endColor0=endColor1    =0x00000000;

		startSizeOffset=0.f;
		markSizeOffset =0.f;
		endSizeOffset  =0.f;
		additive = 0;
	}
	bool bShow;
	int nSetFlag;

	int numFrames;						
	int loopWindowSize;					
	int animationDelay;					

	int markFrame;						

	DWORD startColor0, startColor1;		
	DWORD markColor0, markColor1;		
	DWORD endColor0, endColor1;			
	float startSizeOffset;				
	float markSizeOffset;				
	float endSizeOffset;		
	int  additive;

	std::string strTexture;
};

/** 텍스쳐 이름 얻기
	"GETMESH_TEXNAME" */
class KMsgGET_MATRIX : public KArg
{
public:
	KMsgGET_MATRIX() : matLocal( NULL )
					 , matRoot( NULL )
					 , bSuc( false )
	{}

	K3DMatrix* matLocal;
	K3DMatrix* matRoot;
	bool	   bSuc;
};

/// sonador 4.1.2	아바타 머리카락 알바 버그 재수정(ALPHABLENDTWOPASS)
class KMsgSET_BLENDMODE : public KArg
{
public:
	KMsgSET_BLENDMODE() : blendMode( K3DMaterial::MBM_DEFAULT )
	{
	}
	int blendMode;
};

//mte
class KMsgSET_MTETEX : public KArg
{
public:
	KMsgSET_MTETEX() : pTexture(NULL) {}
	K3DTexture* pTexture;
};

DECL_SPTR(K3DMeshResource)
DECL_SPTR(K3DResMeshMatrixAnimation)
DECL_SPTR(K3DResMeshVisibilityAnimation)
DECL_SPTR(K3DResMeshUVAnimation)

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

	void SetMeshRes( K3DMeshResource *mesh );
	void SetMatrixRes( K3DResMeshMatrixAnimation *res );
	void SetVisibilityRes( K3DResMeshVisibilityAnimation *res );
	void SetUVAniRes( K3DResMeshUVAnimation *res );

	virtual void SetAlterMaterial( K3DMaterial *pMtl );
	
	virtual void SetColor( DWORD c1, DWORD c2 = 0, DWORD c3 = 0, DWORD c4 = 0, short nMode = 0 );

	virtual void ClipTest( const K3DVector* pFrustrum);

	virtual void Render( KViewportObject *viewport, DWORD flag = RENDEREFX_NONE, const K3DMatrix * pAttachMat = NULL );
	virtual KSeqObject* Clone();
	virtual void realizeTime();
	virtual void *Perform( KID id, KArg& msg );

	K3DBoundRotCube * GetCube();
	K3DBoundSphere* GetSphere();

	KMeshPrimitive* getMeshPrimitive(int nIndex);

	static void	SetToggleVisbleCube() { m_sVisbleCube = !m_sVisbleCube; }

	void	CalcMatrix();

	//mte
	void SetMTETexture( K3DTexture* pTex );
protected:
	bool _defRender( int i, K3DResVertexAnimation *va, DWORD flag, float vis );
	void _defSetTransform( DWORD flag );
	void _makeBoundCube( KBoneSeqObject * pBoneSeq );
	void updateColors();
	void setBone( int nCount, K3DMatrix *pMatList );
	void realizeTransform();
	
	/// 강화
	void _morphInit();
	void _morphClear();
	void _morphMeshMake();
	void _morphDefaultSet();
	void _oldmorphClear();

	/// 무기 효과
	void _effectMeshMake();

protected:
	DWORD					m_dwColors[4];
	short					m_nColorizedMode;
	int						m_nRenderState;
	K3DMatrix				m_matLocal;
	K3DMatrix				m_matRoot;
	K3DMatrix				m_matResult;

	K3DMatrix				m_matUV;
	float					m_fVisResult;
	bool					m_bForceTransparent;

	K3DBoundSphere				m_boundSphere;
	K3DBoundRotCube				m_boundCube;

	K3DBoundOcclusion			m_boundOcclusion;

	K3DMaterial*						m_pAlterMtl;
	K3DMeshResourceSPtr					m_spResMesh;
	K3DResMeshMatrixAnimationSPtr		m_spResMatrix;
	K3DResMeshVisibilityAnimationSPtr	m_spResVis;
	K3DResMeshUVAnimationSPtr			m_spResUV;

	int								m_nPrMeshCount;
	KMeshPrimitive*					m_pPrMesh;
	KWireUtilPrimitive				m_prCenterWire;

	std::vector<K3DResVertexAnimation::Key *> m_vCacheKeyList;
	
	int						m_nBoneMatCount;
	K3DMatrix*				m_pBoneMatList;
	
	static	bool			m_sVisbleCube;
	bool					m_bIsMakeBoundCube;

	bool					m_bUseTextureAlpha;
	// sonador 1.8.10	아바타 텍스쳐 그룹 적용(페이스 컷 포함)
	bool					m_bUseDefaultTexture;	///< K3DResVertexAnimation의 TexPack을 사용하는가?

	//무기 강화
	// Parameters
	int numFrames;						///< 전체 애니메이션 프레임 수. 대충 16~32
	int loopWindowSize;					///< 반복될 애니메이션 간의 간격. 대충 4~8
	int animationDelay;					///< 프레임 애니메이션 속도 (애니메이션 프레임 간의 시간간격)

	int markFrame;						///< markFrame : 중간의 어떤 적절한 프레임. 애니메이션 경계를 주기 위해 사용

	DWORD startColor0, startColor1;		///< 0번 프레임의 컬러. 24bit ARGB
	DWORD markColor0, markColor1;		///< (markFrame)번 프레임의 컬러
	DWORD endColor0, endColor1;			///< (numFrames-1)번 프레임의 컬러
	float startSizeOffset;				///< 0번 프레임의 메쉬 확대 거리. 대충 +0.01정도?
	float markSizeOffset;				///< (markFrame)번 프레임의 메쉬 크기.
	float endSizeOffset;				///< (numFrames-1)번 프레임의 메쉬 크기. 대충 +0.6정도?

	int	  additive;                     ///< Additive On/Off

	std::string strFxTexture;

	// Variables
	DWORD previousTime;
	DWORD checkTime;
	int currentFrame;						///< 0 <= current < loopWindowSize

	std::vector< FxResizedPrimitive* > morph_primitivelist;
	int	m_nMorphPrimitiveCount;
	std::vector< FxResizedPrimitive* > clear_morph_primitivelist;

	bool		m_bUseWink;
	bool		m_bFlipWink;
	K3DTextureSPtr m_spWinkTexture;
	K3DTextureSPtr m_spBackUpDiffTexture;
};