#ifndef __KVIEWPORT__
#define __KVIEWPORT__

#include "K3DTypes.h"
#include <toolkit/khash.h>
#include "KResource.h"
#include "KResourceDX.h"
#include "KCustomVector.h"
#include "KSortVector.h"
#include "k3dcamera.h"
#include "kprimitive.h"
#include "KPrimitiveTile.h"
#include <list>

struct K3DLight;
class K3DPrimitive;
class KSpritePrimitive;
class KBillboardPrimitive;
class KWireUtilPrimitive;
class K3DRenderDevice;
class K3DCamera;

#ifdef _RAC
	#define MESH_POOL_COUNT		(1024)
	#define AFTER_SPRITE_MESH_POOL_COUNT (128)
#else	
	#define MESH_POOL_COUNT		(7168)
	#define AFTER_SPRITE_MESH_POOL_COUNT (256)
#endif

class KViewportObject
{
public:
	enum {
		VIEWPORT_GAME   = 1,
		VIEWPORT_SHADOW = 2,
		VIEWPORT_DUSK   = 4,
		VIEWPORT_WATER  = 8,
// { [sonador] 
#ifdef _KUI_INVALIDATION
		VIEWPORT_GUI	= 16, 
#endif
// }
		VIEWPORT_USER0  = 32,
		VIEWPORT_USER1  = 64,
		VIEWPORT_USER2  = 128,
		VIEWPORT_MAPTOOL= 256,  ///< 맵 툴용
		VIEWPORT_VIEWER = 512,  ///< 뷰어 용
	};

	enum 
	{	
		SHADOW_DEFAULT = 0, ///< 안 그린다.
		SHADOW_RENDER,      ///< 프로젝션 쉐도우
		SHADOW_MAP_RENDER,  ///< 쉐도우 맵
	};

	KViewportObject( DWORD attr, bool bClearColorBuffer, bool bClearDepthBuffer );
	virtual ~KViewportObject();

	DWORD GetAttributes()							{ return m_dwAttributes; }

	virtual void SetRenderFlag( int nFlag ) {};

	virtual void Initilaize( K3DRenderDevice *dev, const KViewportStruct &viewarea, float nearClip, float farClip );

	KViewportStruct * GetViewportStruct() { return &m_viewport; }
	virtual void SetViewArea( const KRect &viewarea );

	virtual float GetVertexAspect()			const { return (float)m_viewwidth/m_viewheight; }
	float GetFarClip()						const { return m_fFarClip; }
	float GetNearClip()						const { return m_fNearClip; }
	const K3DMatrix* GetInverseViewMatrix() const 
	{ 
		return &m_matInvView;
	}

	int GetFSAA()								  { return m_nFSAA; }
	void SetFSAA( int size )					  { m_nFSAA = size; }
	float GetMipBias()							  { return m_fMipBias; }
	void SetMipBias( float fBias )				  { m_fMipBias = fBias; }
	void SetMipRange( float fRange)				  { m_fMipRange = fRange; }
	float GetMipRange()							  { return m_fMipRange; }
	void SetMipMode( bool mode )				  { m_bMipMode = mode; }
	bool IsMipMode()							  { return m_bMipMode; }

	void SetClipRange( float nearclip, float farclip )
	{
		m_fNearClip = nearclip;
		m_fFarClip = farclip;
	}

	void SetSceneAmbient( const KColor &color )	{ m_colSceneAmbient = color; }
	void SetFillColor( const KColor &color )	{ m_colFill = color; }
	void SetFillMode( bool bColorBuf, bool bDepthBuf )	{ m_bClearColorBuf = bColorBuf; m_bClearDepthBuf = bDepthBuf; }

	void SetSkyColor( K3DColor start, K3DColor mid, K3DColor end )
	{
		m_SkyColorStart = start;
		m_SkyColorMid	= mid;
		m_SkyColorEnd   = end;
	}

	void SetSkyColorHeight( float fMinHeight, float fMaxHeight, float fMidPercent = 0.5f )
	{
		m_fSkyMinHeight = fMinHeight;
		m_fSkyMaxHeight = fMaxHeight;
		m_fSKyMidPercent = fMidPercent;
	}

	void SetFogMode(DWORD fogmode, KColor fogcolor, float p1, float p2, float p3, float p4)
	{
		m_fogMode = fogmode;
		m_fogColor = fogcolor;
		m_fogFactor1 = p1;
		m_fogFactor2 = p2;
		m_fogFactor3 = p3;
		m_fogFactor4 = p4;
	}
	void GetFogMode(DWORD &fogmode, KColor &fogcolor, float &p1, float &p2, float &p3, float &p4) const
	{
		fogmode = m_fogMode;
		fogcolor = m_fogColor;
		p1 = m_fogFactor1;
		p2 = m_fogFactor2;
		p3 = m_fogFactor3;
		p4 = m_fogFactor4;
	}
	void GetFogFactor( float &p1, float &p2, float &p3, float &p4) const
	{
		p1 = m_fogFactor1;
		p2 = m_fogFactor2;
		p3 = m_fogFactor3;
		p4 = m_fogFactor4;
	}
	/*void SetViewTransform( const K3DVector &campos, const K3DVector &tarpos, const K3DMatrix &view, const K3DMatrix &projection )
	{	m_matView = view; m_matProjection = projection; m_vCamPos = campos; K3DMatrixInverse( &m_matInvView, NULL, &m_matView ); 
		m_vTarPos = tarpos; 
		K3DMatrixIdentity( m_matBlendShader );
		K3DMatrixMultiply(&m_matBlendShader, &m_matView, &m_matProjection);
		K3DMatrixTranspose( &m_matBlendShader, &m_matBlendShader );
	}*/

	int	GetViewportX()			{ return m_viewx; }
	int GetViewportY()			{ return m_viewy; }
	int GetViewportWidth()		{ return m_viewwidth; }
	int GetViewportHeight()		{ return m_viewheight; }
	
	const K3DVector& GetCameraPos()			{ return m_vCamPos; }
	const K3DVector& GetCameraTargetPos()	{ return m_vTarPos; }
	float GetCameraFOV()					{ return m_ViewCamera.GetFOV(); }
	//const K3DCamera* GetCamera()			{ return &m_ViewCamera; }

	const K3DMatrix	* GetProjMatrix() { return &m_matProjection; }
	const K3DMatrix	* GetViewMatrix() { return &m_matView; }
	const K3DMatrix * GetBlendMatrix(){ return &m_matBlendShader; } //Speed Tree

	virtual void SetCamera( const K3DCamera *cam );
	K3DVector* GetFrustum();
	void GetCameraSegmentView(float o_scrX, float o_scrY, K3DVector &nearPt, K3DVector &farPt);
	void GetCameraFrustum(float left, float top, float right, float bottom, K3DVector *cube);
	void SetClipOffsetRatio( float fRatio );
	float GetClipOffsetRatio();
	void PickScreenPoint(const K3DVector &pos, int &x, int &y);

	virtual void AddLight( const K3DLight *lit );
	virtual void Register( KSpritePrimitive *spr, bool isFront = false );
	virtual void Register( KBillboardPrimitive *pBillboard );
	virtual void Register( K3DPrimitive *pr, DWORD flag );
	virtual void Register(KTilePrimitive* tpr);
	virtual void RegisterWire( KWireUtilPrimitive *wpr );

	virtual void Render( K3DRenderTarget *pRT, DWORD flag = 0, bool bClearRegister = true );
	virtual void Render( bool bClearRegister = true, bool bSetRenderTarget = true );
	virtual void ClearRegisteredList();

	virtual const K3DLight * GetLight( int nIndex = 0 );

	KViewportObject* GetChildViewportObj() const { return m_pChildViewportObj; }
	KViewportObject* SetChildViewportObj( KViewportObject* pChild )
	{
		KViewportObject* pOldChild = m_pChildViewportObj;
		m_pChildViewportObj = pChild;

		return pOldChild;
	}

	virtual void OcclusionCulling() { };

	void SetUseWater( bool bUseWater );
	void SetUseSpecular( int  nUseSpecular );
	void SetUseViewPort( bool bUseViewPort );
	void SetRenderWater( bool bRenderWater );

	int  GetUseSpecular()   { return m_nUseSpecular; }
	bool GetUseViewPort()	{ return m_bUseViewPort; }
	bool GetUseWater()		{ return m_bUseWater;    }
	bool IsRenderWater()	{ return m_bRenderWater; }

	void SetRenderBumpMapMode( bool bRender )	{ m_bRenderBumpMap = bRender; }
	bool GetRenderBumpMapMode() { return m_bRenderBumpMap; }

	void SetTerrainSpecularFactor( float fFactor ) { m_fTerrainSpecularFactor = fFactor; }
	float GetTerrainSpecularFactor() { return m_fTerrainSpecularFactor; }

	void SetSkinAmbientFactor( float fFactor ) { m_fSkinAmbientFactor = fFactor; }
	float GetSkinAmbientFactor() { return m_fSkinAmbientFactor; }

	void SetSkinDiffuseFactor( float fFactor ) { m_fSkinDiffuseFactor = fFactor; }
	float GetSkinDiffuseFactor() { return m_fSkinDiffuseFactor; }

	void SetSkinSpecularFactor( float fFactor ) { m_fSkinSpecularFactor = fFactor; }
	float GetSkinSpecularFactor() { return m_fSkinSpecularFactor; }

	virtual void SetHQWaterHeight( float fHeight ){};

	void SetWaterHeight( bool bExistence, float fHeight = -3.0000000e+038f );
	void SetInsideWater( bool bInside );

	//void SetLocalCoordMode(bool bLocalCoord) { m_bLocalCoord = bLocalCoord; }
	//bool IsLocalCoordMode() { return m_bLocalCoord; }

	float DoesExistWaterHeight() { return m_bExistenceWaterHeight; }
	float GetWaterHeight() { return m_fWaterHeight; }

	void  BackUpViewCamera()				{ m_BackUpViewCamera = m_ViewCamera; }
	const K3DCamera* GetBackUpViewCamera()	{ return &m_BackUpViewCamera ; }
	void  RestoreBackUpViewCamera()			{ SetCamera( &m_BackUpViewCamera ); }
	
	bool  IsLocalCoord() { return m_bLocalCoord; }

	/// 2D -> 3D
	void Get2DVto3DV( const K3DVector & v2D, K3DVector & v3D );
	/// 3D -> 2D
	void Get3DVto2DV( const K3DVector & v3D, K3DVector & v2D );

	void SetSpeedTreeTransparent( bool bMode ) { m_bSpeedTreeTransMode = bMode; }
	bool IsSpeedTreeTransparent()              { return m_bSpeedTreeTransMode; }

	const int GetUsedMeshEXPoolCount()		   {  return m_nUsedMeshEXPool; }

#ifdef _KUI_INVALIDATION
	// { [sonador] 
	virtual void RearrangeSpriteOffset( const K3DVector& vOffset );	
	// }
#endif
	// z,x 로 조절하는 spec_factor 과 spec_color
	int	m_nSpecularFactor;
	int	m_nSpecularColor;

protected:
	HRESULT TestCooperativeLevel();

	void renderDefault();
	void updateLight();
	void drawSprite( KSpritePrimitive** prSpriteList, int nSpriteCount );
	void sortCenter( K3DPrimitive** prList, int nPrCount );
	void sortDepth( K3DPrimitive** prList, int nPrCount );
	void sortDepth( KBillboardPrimitive** prList, int nPrCount );
protected:
	DWORD					m_dwAttributes;

	bool					m_bMipMode;
	bool					m_bClearColorBuf;
	bool					m_bClearDepthBuf;
	int						m_viewx;
	int						m_viewy;
	int						m_viewwidth;
	int						m_viewheight;
	float					m_fVertexAspect;
	float					m_fNearClip, m_fFarClip;
	KColor					m_colFill;
	KColor					m_colSceneAmbient;

	K3DCamera				m_ViewCamera;
	K3DCamera				m_BackUpViewCamera;
	K3DVector				m_pFrustum[8];

	K3DMatrix				m_matView;
	K3DMatrix				m_matProjection;
	K3DVector				m_vCamPos;
	K3DVector				m_vTarPos;
	K3DMatrix				m_matInvView;
	K3DMatrix				m_matBlendShader;
	
	K3DVector				m_vCameraCorrection;	///< 위치 보정을 통해 오차를 최소화 한다.

	float					m_fMipBias;
	float					m_fMipRange;
	int						m_nFSAA;
	DWORD					m_fogMode;
	KColor					m_fogColor;
	float					m_fogFactor1;
	float					m_fogFactor2;
	float					m_fogFactor3;
	float					m_fogFactor4;

	KViewportObject*		m_pChildViewportObj;

	K3DColor				m_SkyColorStart;
	K3DColor				m_SkyColorMid;
	K3DColor				m_SkyColorEnd;
	float					m_fSkyMaxHeight;	///< 하늘 칼라 시작 점
	float					m_fSkyMinHeight;	///< 하늘 칼라 끝   점
	float					m_fSKyMidPercent;	///< 하늘 중점 비율

	//Specular
	bool					m_bUseWater;
	int						m_nUseSpecular;
	bool					m_bUseViewPort;

	bool					m_bRenderWater;

	bool					m_bRenderBumpMap;

	float					m_fTerrainSpecularFactor;

	float					m_fSkinAmbientFactor;
	float					m_fSkinDiffuseFactor;
	float					m_fSkinSpecularFactor;

	K3DRenderDevice*		m_dev;
	KViewportStruct			m_viewport;

	// light
	KCustomVector<const K3DLight*>			m_pLightList;

	// 환경
	KCustomVector<K3DPrimitive*>			m_prListSky;
	KCustomVector<K3DPrimitive*>			m_prListLensFlare;
	KCustomVector<K3DPrimitive*>			m_prListCloud;
	KCustomVector<K3DPrimitive*>			m_prListWeather;		///<  [sonador][2007.03.19] custom vector of weather primitives
	KCustomVector<K3DPrimitive*>			m_prListLightning;		///<  [sonador][2007.04.25] custom vector of lightning primitives

	// 지형
	KCustomVector<K3DPrimitive*>			m_prListTerrain;
	KCustomVector<K3DPrimitive*>			m_prListTerrainShadow;

	//Speed Tree - 알파 블렌드를 사용하지 않음
	KCustomVector<K3DPrimitive*>			m_prListBranch;
	KCustomVector<K3DPrimitive*>			m_prListFrond;
	KCustomVector<K3DPrimitive*>			m_prListLeaf;
	KCustomVector<K3DPrimitive*>			m_prListTreeBillboard;

	KCustomVector<K3DPrimitive*>			m_prListSpeedGrass;

	//KCustomVector<K3DPrimitive*>			m_prListPathEffect;
	KCustomVector<K3DPrimitive*>			m_prListQuad;
	KCustomVector<K3DPrimitive*>			m_prListLine;
	KCustomVector<K3DPrimitive*>			m_prListPolyLine;

	struct RENDER_MESHEX
	{
		RENDER_MESHEX() { primitive = NULL; }
		void Set( K3DPrimitive* p, DWORD f, int l, bool bump, bool spec, bool vsmode, bool lightmap, float depth, int pass = 0 )
		{
			primitive = p;
			render_flag = f;
			nLitIndex = l;
			bUseBump = bump;
			bUseSpecular = spec;
			bUseVSMode = vsmode;
			bUseLightmap = lightmap;
			fDepth = depth;
			nPass = pass;
			dwPriority = ( ( WORD ) p->GetBlendMode() << 16 ) | ( ( WORD ) pass );
			bForcePriority = ( p->GetBlendMode() == K3DMaterial::MBM_ADDITIVE || p->GetBlendMode() == K3DMaterial::MBM_ADDTIVE_BILLBOARD );
		}

		float GetHashNumber() const							{ return fDepth; }

		// basic render object
		K3DPrimitive*	primitive;
		DWORD			render_flag;

		// state
		bool			bUseBump;		///< bump map을 사용하는 경우
		bool			bUseSpecular;	///< specular map을 사용하는 경우(일반 specular와 다름)
		bool			bUseVSMode;
		bool			bUseLightmap;	
		float			fDepth;
		int				nLitIndex;
		int				nPass;
		DWORD			dwPriority;
		bool			bForcePriority;

		//K3DMatrix		matRoot;	// root(world positioning) matrix
		//K3DMatrix		matLocal;	// local to world matrix

		bool operator==	(const RENDER_MESHEX* rhs) const { return (this->GetHashNumber() == rhs->GetHashNumber()); }
		bool operator!=	(const RENDER_MESHEX* rhs) const { return (this->GetHashNumber() != rhs->GetHashNumber()); }
		bool operator>	(const RENDER_MESHEX* rhs) const { return (this->GetHashNumber() >  rhs->GetHashNumber()); }
		bool operator>=	(const RENDER_MESHEX* rhs) const { return (this->GetHashNumber() >= rhs->GetHashNumber()); }
		bool operator<	(const RENDER_MESHEX* rhs) const { return (this->GetHashNumber() <  rhs->GetHashNumber()); }
		bool operator<=	(const RENDER_MESHEX* rhs) const { return (this->GetHashNumber() <= rhs->GetHashNumber()); }
		float operator-	(const RENDER_MESHEX* rhs) const { return (this->GetHashNumber() -  rhs->GetHashNumber()); }

		bool operator==	(const RENDER_MESHEX& rhs) const { return (this->GetHashNumber() == rhs.GetHashNumber()); }
		bool operator!=	(const RENDER_MESHEX& rhs) const { return (this->GetHashNumber() != rhs.GetHashNumber()); }
		bool operator>	(const RENDER_MESHEX& rhs) const { return (this->GetHashNumber() >  rhs.GetHashNumber()); }
		bool operator>=	(const RENDER_MESHEX& rhs) const { return (this->GetHashNumber() >= rhs.GetHashNumber()); }
		bool operator<	(const RENDER_MESHEX& rhs) const { return (this->GetHashNumber() <  rhs.GetHashNumber()); }
		bool operator<=	(const RENDER_MESHEX& rhs) const { return (this->GetHashNumber() <= rhs.GetHashNumber()); }
		float operator-	(const RENDER_MESHEX& rhs) const { return (this->GetHashNumber() -  rhs.GetHashNumber()); }
	};

	struct PRIMITIVE_CONTAINER
	{
//		PRIMITIVE_CONTAINER(const RENDER_MESHEX *p)		{ pr = p; }
		bool operator==(const PRIMITIVE_CONTAINER& p) const	{ return (pr->GetHashNumber() == p.pr->GetHashNumber()); }
		bool operator!=(const PRIMITIVE_CONTAINER& p) const	{ return (pr->GetHashNumber() != p.pr->GetHashNumber()); }
		bool operator>(const PRIMITIVE_CONTAINER& p) const	{ return (pr->GetHashNumber() > p.pr->GetHashNumber()); }
		bool operator>=(const PRIMITIVE_CONTAINER& p) const	{ return (pr->GetHashNumber() >= p.pr->GetHashNumber()); }
		bool operator<(const PRIMITIVE_CONTAINER& p) const	{ return (pr->GetHashNumber() < p.pr->GetHashNumber()); }
		bool operator<=(const PRIMITIVE_CONTAINER& p) const	{ return (pr->GetHashNumber() <= p.pr->GetHashNumber()); }
		float operator-(const PRIMITIVE_CONTAINER& p) const { return (pr->GetHashNumber() - p.pr->GetHashNumber()); }

		bool IsValid()		{ return pr != NULL; }
		void SetRenderMesh(const RENDER_MESHEX *p) { pr = p; }

		const RENDER_MESHEX *pr;
	};

	typedef	KCustomVector<RENDER_MESHEX>	vec_rendermesh;

//	RENDER_MESHEX						m_pAfterSpriteMeshEXPool[AFTER_SPRITE_MESH_POOL_COUNT];
	int									m_nAfterSpriteUsedMeshEXPool;
	float								m_fAfterSpriteDepth;
	
	bool AllocAfterSpriteNewMeshEX( RENDER_MESHEX & container, K3DPrimitive* p, DWORD f, int l, bool bump, bool spec, bool vsmode, bool lightmap, float depth, int pass = 0 )
	{
#ifdef _RELEASE
		if( m_nAfterSpriteUsedMeshEXPool >= AFTER_SPRITE_MESH_POOL_COUNT ) 
			return false;
#else
		if( m_nAfterSpriteUsedMeshEXPool >= AFTER_SPRITE_MESH_POOL_COUNT ) 
		{
			if( m_fDepth < depth ) 
				return false;
		}
#endif

		if( m_fDepth < depth ) m_fDepth = depth;

//		RENDER_MESHEX* alloc = &m_pAfterSpriteMeshEXPool[ m_nAfterSpriteUsedMeshEXPool ];
		++m_nAfterSpriteUsedMeshEXPool;
		container.Set( p, f, l, bump, spec, vsmode,lightmap, depth, pass );

		return true;
	}

	// 메쉬 pool
//	RENDER_MESHEX						m_pMeshEXPool[MESH_POOL_COUNT];
	int									m_nUsedMeshEXPool;
	float								m_fDepth;

	bool AllocNewMeshEX( RENDER_MESHEX & container, K3DPrimitive* p, DWORD f, int l, bool bump, bool spec, bool vsmode, bool lightmap, float depth, int pass = 0, bool forceRender = false )
	{
		// sonador 7.0.14	카메라 위치에 따른 물효과 컬링 문제 수정
		// soandor 1.6.2	프랍 렌더링시 정렬 문제 해결
//		if( !forceRender )
//		{
//#ifdef _RELEASE
//			//1024개 제한 설정
//			if( m_nUsedMeshEXPool >= MESH_POOL_COUNT )
//				return false;
//#else
//			if( m_nUsedMeshEXPool >= MESH_POOL_COUNT )
//			{
//				if( m_fDepth < depth ) 
//					return false;
//			}
//#endif
//			++m_nUsedMeshEXPool;
//		}

		++m_nUsedMeshEXPool;
		if( m_fDepth < depth ) m_fDepth = depth;

//		RENDER_MESHEX* alloc = &m_pMeshEXPool[ m_nUsedMeshEXPool ];		
		container.Set( p, f, l, bump, spec, vsmode,lightmap, depth, pass );

		return true;
	}

	/// 메쉬(건물, 프랍)
	vec_rendermesh							m_prMesh;
	vec_rendermesh							m_prTransMesh;
//	KSortVector<PRIMITIVE_CONTAINER>		m_prAdditiveMesh;

	vec_rendermesh							m_prAfterSpriteMesh;
	vec_rendermesh							m_prAfterSpriteTransMesh;
	vec_rendermesh							m_prSelectMesh;

	// sprite & billboard
	KCustomVector<KBillboardPrimitive*>		m_prBliiboardList;
	KCustomVector<KBillboardPrimitive*>		m_prAdditiveBliiboardList;

	KCustomVector<KSpritePrimitive*>		m_prFrontSpriteList;
	KCustomVector<KSpritePrimitive*>		m_prFrontAdditiveSpriteList;
	KCustomVector<KSpritePrimitive*>		m_prSpriteList;
	KCustomVector<KSpritePrimitive*>		m_prAdditiveSpriteList;

	KCustomVector<KTilePrimitive*>			m_prTileList;

	std::list<KWireUtilPrimitive*>			m_wprList;

//	bool									m_bLocalCoord;

	float									m_fClipOffsetRatio;

	bool									m_bLocalCoord;
	bool									m_bSpeedTreeTransMode;

	/// 수위(물 높이)
	float									m_fWaterHeight;
	bool									m_bInsideWater;
	bool									m_bExistenceWaterHeight;
};

#endif