#pragma once
#include <kfile/KFiler.h>
#include "K3DTypes.h"
#include "KRenderDevice.h"
#include "KResource.h"
//#include "kSound.h"
#include "K3DBound.h"
#include <kfile/TRFMapper.h>

struct NX3LoadPack;
class KNX3MtlChannel;
class KNX3Mtl;
class KNX3MtlElement;	
/**
KNX3MtelElement description.
- This class has a texuture and material information.
- Each object is referenced by KNX3MeshElement using MtlID
*/
class KNX3MtlElement
{
public:
	KNX3MtlElement();
	~KNX3MtlElement();
	
	/// Delete material and texture release.
	void	Clear();

	/// Load from filer object.
	BOOL	Load( KTemplateDataObject * pObject, const NX3LoadPack * ploadpack );
	
	bool LoadTRF( trf::MTemplatePtr pObject, const NX3LoadPack* pLoadPack );

	/// Get the Material ID which indicates relation between KNX3MtlElement and KNX3MeshElement.
	DWORD	GetMtlID() { return m_dwMtlID; }
	
	K3DMaterial * GetMaterial()             { return m_pMaterial;  }
	int			  GetBlendMode()            { return m_nBlendmode; }

	K3DTexture  * GetTexture();           
	K3DTexture  * GetBumpTexture();       
	K3DTexture  * GetIlluminTexture();    
	K3DTexture  * GetSpecularTexture();   
	K3DTexture  * GetSpecularColorTexture();
	
private:
	K3DTexture* _GetTexture(LPCSTR name);

private:
	int					m_nBlendmode;               ///< 피직 모드
	K3DMaterial*		m_pMaterial;                ///< 메트리얼

	std::string			m_sTextureName;
	const NX3LoadPack*	m_pLoadPack;

	K3DTextureSPtr			m_spTexture;                 ///< 텍스쳐 디퓨즈 맵
	K3DTextureSPtr			m_spTexture_Bump;            ///< 텍스쳐 범프 맵
	K3DTextureSPtr			m_spTexture_Illumin;         ///< 텍스쳐 셀프 일루민 맵
	K3DTextureSPtr			m_spTexture_Specular;        ///< 텍스쳐 스페큘러 맵
	K3DTextureSPtr			m_spTexture_SpecularColorMap;///< 텍스쳐 스페큘러 칼라 맵

	DWORD				m_dwMtlID;                  ///< 메트리얼 ID
};

/**
KNX3MtlChannel description
- This class has the list of KNX3Mtl pointer object.
- It is related to KNX3MeshChannel. 
*/
class KNX3MtlChannel
{
public:
	KNX3MtlChannel(K3DRenderDevice * pGraphics);
	~KNX3MtlChannel();
	
	/// Get KNX3Mtl from ID.
	KNX3Mtl	* GetMtl(int nID);
	/// Delete all mtl list.
	void	  Clear();
	BOOL	  Load(KTemplateDataObject * pObject, const NX3LoadPack * pLoadPack);

	bool LoadTRF( trf::MTemplatePtr pObject, const NX3LoadPack* pLoadPack );

private:
	K3DRenderDevice*			m_pGraphics;
	std::vector<KNX3Mtl *>		m_vtMtlList;     ///< 메트리얼 리스트
};

/**
- This class has the list of KNX3MtlElement pointer object.
- It is related to KNX3Mesh. (When load the KNX3Mesh, it is necessary) 
*/
class KNX3Mtl
{
public:
	KNX3Mtl(K3DRenderDevice * pGraphics);
	~KNX3Mtl();
	
	/// Delete all KNX3MtlElement.
	void Clear();
	BOOL Load(KTemplateDataObject * pObject, const NX3LoadPack * pLoadPack );
	
	bool LoadTRF( trf::MTemplatePtr pObject, const NX3LoadPack* pLoadPack );

	/// Get the MtlID from first item of list. (If list size is 0, return value is -1)
	int	 GetMtlID()
	{
		if(m_vtMtlElement.size() > 0)
		{
			KNX3MtlElement * pElement = m_vtMtlElement.at(0);
			return pElement->GetMtlID();
		}
		
		return -1;
	}
	
	/// Get KNX3MtlElement from SubID which is index of list.
	KNX3MtlElement * GetMtlElement(unsigned int nSubID)
	{
		if(nSubID >= m_vtMtlElement.size() || nSubID < 0)
		{
			return NULL;
		}
		
		return m_vtMtlElement.at(nSubID);
	}
	
private:
	K3DRenderDevice*				m_pGraphics;
	std::vector<KNX3MtlElement*>	m_vtMtlElement;	///< 메트리얼 구성 요소 리스트
};

struct KNX3MeshTM 
{
	char  szName[64];
	float baseTM[16];
};

//작업중..
//BERSERK
#pragma pack(push, 1)
typedef struct tagKNXgeneric_key_t
{
	unsigned long msec;

	union {
		struct {  /* linear position */
			float pos[3];
		} lin_pos;

		struct { /* linear rotation */
			float quat[4];
		} lin_rot;
	};
} KNXgeneric_key_t;
#pragma pack(pop)

class KNX3Bone
{
public:
	KNX3Bone()
	{
		memset( szName, 0, sizeof(szName) );
		m_nParentIndex = -1;
		memset( m_BaseTM, 0, sizeof(m_BaseTM) );
		m_dwFlag = 0; //Key flag

		m_dwPosCount = 0;
		m_pPosKey = NULL;

		m_dwRotCount = 0;
		m_pRotKey = NULL;

		m_dwChildCount = 0;
		m_pChildList = NULL;
	}
	~KNX3Bone()
	{
		Clear();
	}

	void Clear()
	{
		SAFE_DELETE_ARRAY( m_pPosKey );
		SAFE_DELETE_ARRAY( m_pRotKey );
		SAFE_DELETE_ARRAY( m_pChildList );	
	}

	BOOL Load( KTemplateDataObject * pObject );

	bool LoadTRF( trf::MTemplatePtr pObject );

	int     GetParentIndex() { return m_nParentIndex; }
	float * GetBaseTM()      { return m_BaseTM; }
	DWORD	GetFlag()	     { return m_dwFlag; }
	DWORD   GetPosCount()    { return m_dwPosCount; }
	DWORD   GetRotCount()    { return m_dwRotCount; }
	DWORD   GetChildCount()  { return m_dwChildCount; }

	KNXgeneric_key_t*   GetPosKey()    { return m_pPosKey; }
	KNXgeneric_key_t*   GetRotKey()    { return m_pRotKey; }
	int *				GetChildList() { return m_pChildList; }

	char * GetName() { return szName; }

protected:
	char            szName[64];    ///< 본 이름
	int				m_nParentIndex;///< 부모 인덱스
	float			m_BaseTM[16];  ///< 기본 TM
	DWORD			m_dwFlag;      ///< Key flag

	DWORD			m_dwPosCount; ///< 위치 수
	KNXgeneric_key_t* m_pPosKey;  ///< 위치 키 데이타 배열

	DWORD			m_dwRotCount; ///< 회전 수
	KNXgeneric_key_t* m_pRotKey;  ///< 회전 키 데이타 배열

	DWORD			m_dwChildCount; ///< 자식 수
	int	 *			m_pChildList;   ///< 자식 리스트
};

class KNX3BoneChannel
{
public:
	KNX3BoneChannel(K3DRenderDevice * pGraphics):m_pGraphics(pGraphics),m_spBoneRes(NULL) {};
	~KNX3BoneChannel(){ Clear(); }

	void Clear();

	/// Load from filer.
	BOOL Load( KTemplateDataObject * pObject, const char * szName, DWORD dwVersion );

	bool LoadTRF( trf::MTemplatePtr pObject, const char* szName, DWORD dwVersion );

	K3DBoneResource * GetBoneRes() { return m_spBoneRes; }

protected:
	K3DRenderDevice*		  m_pGraphics;

	DWORD m_dwChannelFlag;     ///< ???
	DWORD m_dwChannelTimeSpan; ///< 채널 시간 길이
	DWORD m_dwChannelFrameRate;///< 프레임 률
	char  m_szChannelName[128];///< 채널 이름

	K3DBoneResourceSPtr m_spBoneRes; 
};

class KNX3Mesh;

class KNX3MeshElement;
class KNX3AniElement;
class KNX3VisiElement;
class KNX3FX;
//class KNX3Sound;

class KNX3MeshFrame;

typedef std::vector<KNX3MeshElement *>	MeshVector;
typedef std::vector<KNX3FX *>			FXVector;
typedef std::vector<KNX3MeshFrame *>	MeshFrameVector;


class KNX3MeshChannel
{
public:
	enum LOAD_TYPE
	{
		LT_OLD_MESH = 0,
		LT_NEW_MESH,
	};

public:
	KNX3MeshChannel(K3DRenderDevice * pGraphics, KNX3MtlChannel * pMtlChannel);
	~KNX3MeshChannel();

	/// Delete all KNX3Mesh.
	void Clear();

	/// Load from filer.
	BOOL Load( const NX3LoadPack * pLoadPack, KTemplateDataObject * pObject, int loadType );

	bool LoadTRF( const NX3LoadPack * pLoadPack, trf::MTemplatePtr pObject, int loadType );

	/// Get list of KNX3Mesh. (which is vector)
	std::vector<KNX3Mesh *>	& GetMeshList()
	{
		return m_vtMeshList;
	}

	std::vector<KNX3MeshTM *> & GetMeshTMList()
	{
		return m_vtMeshTM;
	}

private:
	K3DRenderDevice*		m_pGraphics;
	KNX3MtlChannel*			m_pMtlChannel; ///< 메트리얼 채널
	std::vector<KNX3Mesh *>	m_vtMeshList;  ///< 메쉬 리스트

	std::vector<KNX3MeshTM *> m_vtMeshTM;  ///< 메쉬 TM
};

/**
KNX3Mesh description.
- This class has the list of KNX3MeshElement pointer object, matrix animation, visibility information, fx note.
- When load this mesh, get the appropriate KNX3Mtl from input KNX3MtlChannel by MtlID.
- The list of Child KNX3Mesh are connected whth this mesh.
*/
class KNX3Mesh
{

public:
	KNX3Mesh(K3DRenderDevice * pGraphics);
	~KNX3Mesh();

	/// Delete all resource.
	void	Clear();	

	/// Load from Filer. 
	BOOL	Load( const NX3LoadPack * pLoadPack, KTemplateDataObject * pObject, KNX3MtlChannel * pMtlChannel, int loadType);

	bool LoadTRF( const NX3LoadPack * pLoadPack, trf::MTemplatePtr pObject, KNX3MtlChannel * pMtlChannel, int loadType );

	/// Get MeshElements vector.
	MeshVector& GetMeshElements()						{ return m_vtMeshElement; }

	/// Get Fx-Note Vectors.
	FXVector& GetFXVector()								{ return m_vtFX; }

	/// Get Matrix Animation information.
	K3DResMeshMatrixAnimation*		GetMatrixAniRes()	{ return m_spAniElement; }
	
	/// Get Visibility information.
	K3DResMeshVisibilityAnimation*	GetVisibilityRes()	{ return m_spVisiElement; }
	/// Get UVAni information.
	K3DResMeshUVAnimation*			GetUVAniRes()		{ return m_spUVAniElement; }
	const char *GetMeshName()							{ return m_sMeshName.c_str(); }

	/// Exist of FX-Note vector.
	bool	IsFX()										{ return m_bIsFX;	}
	/// Event Box
	bool	IsEventBox()								{ return m_bIsEventBox; }
	bool	IsEventPoint()								{ return m_bIsEventPoint; }

	/// Get child mesh vector.
	std::vector<KNX3Mesh *> & GetChild()				{ return m_vtChildMesh;	}
private:
	void loadUVAni( KNX3FX *pFX );
	void loadAniAndVisiBlockOldType(KTemplateDataObject* pObject);
	void loadAniAndVisiBlockNewType(KTemplateDataObject* pObject);
	void loadAniAndVisiBlockOldType(trf::MTemplatePtr pObject);
	void loadAniAndVisiBlockNewType(trf::MTemplatePtr pObject);
private:

	bool							m_bIsEventBox;   ///< 이벤트 박스?
	bool							m_bIsEventPoint; ///< 이벤트 포인트?
	bool							m_bIsFX;         ///< FX ?
	std::string						m_sMeshName;     ///< 메쉬 이름
	
	DWORD							m_dwMaterialID;  ///< 메트리얼 ID
	DWORD							m_dwChannelID;   ///< 채널 ID
		
	MeshVector							m_vtMeshElement; ///< MeshElement List
	K3DResMeshMatrixAnimationSPtr		m_spAniElement;   ///< MeshMatrixAnimation
	K3DResMeshVisibilityAnimationSPtr	m_spVisiElement;  ///< MeshVisibilityAnimation
	K3DResMeshUVAnimationSPtr			m_spUVAniElement; ///< MeshUVAnimation
	FXVector							m_vtFX;
	
	std::vector<KNX3Mesh *>			m_vtChildMesh;   ///< 자식 메쉬
	
	KNX3Mtl*						m_pMtl;          ///< 메트리얼
	K3DRenderDevice*				m_pGraphics;  
};

class KNX3MeshElement
{
public:
	KNX3MeshElement(K3DRenderDevice * pGraphics);
	~KNX3MeshElement();
	
	/// Delete all resources.
	void Clear();

	/// Load from filer.
	BOOL Load(const NX3LoadPack * pLoadPack, const char *meshname, KTemplateDataObject * pObject, KNX3Mtl * pMtl);
	
	bool LoadTRF( const NX3LoadPack * pLoadPack, const char *meshname, trf::MTemplatePtr pObject, KNX3Mtl * pMtl );
	
	/// Get created index buffer.
	K3DIndexBuffer* GetIndexBuffer()		{ return m_spIndices; 	}	

	/// 충돌, 높낮이 용
	K3DUnsignedShortRes*	GetIndexArray()	{ return m_spIdxarry;   }

	int GetPrimitiveCount()					{ return m_dwNumIndexBuffer/3; }
	int GetSimultaneousFrameCount()			{ return m_nSimultaneousFrameCount; }

	/// Get number of mesh frame. (ordinarily 1)
	int GetFrameCount()						{ return static_cast<int>(m_vtMeshFrame.size()); }
	/// Get MeshFrame by index.
	KNX3MeshFrame* GetFrame( int index )	{ return m_vtMeshFrame.at(index); }
	
	/// Get associated texture. (caution : reference count is added)
	K3DTexture* GetTexture() 				{	return m_spTexture;				 }
	K3DTexture* GetBumpTexture()			{	return m_spTexture_Bump;			 }
	K3DTexture* GetIlluminTexture()			{	return m_spTexture_Illumin;		 }
	K3DTexture* GetSpecularTexture()		{	return m_spTexture_Specular;		 }
	K3DTexture* GetSpecularColorTexture()	{	return m_spTexture_SpecularColor; }

	DWORD GetLightMapIndex()				{ return m_lightMapIndex; }
	void  SetLightMapIndex( DWORD index )	{ m_lightMapIndex = index; }

	/// Get associated material. 
	K3DMaterial* GetMaterial() 
	{
		return m_pMaterial;
	}
	int			GetBlendMode()
	{
		return m_nBlendMode;
	}
	bool IsEventBox()
	{
		return m_bIsEventBox;
	}
	bool IsEventPoint()
	{
		return m_bIsEventPoint;
	}
	const K3DBoundRotCube &GetEventCube()
	{
		return m_bEventCube;
	}
	const K3DBoundSphere &GetBoundSphere()
	{
		return m_bSphere;
	}
	K3DBoundRotCube &GetWritableEventCube()
	{
		return m_bEventCube;
	}
	K3DBoundSphere &GetWritableBoundSphere()
	{
		return m_bSphere;
	}

private:

	// Reference
	bool					m_bIsEventBox;             ///< 이벤트 박스?
	bool					m_bIsEventPoint;           ///<  이벤트 포인트?
	K3DBoundRotCube			m_bEventCube;              ///< 이벤트 큐브
	K3DBoundSphere			m_bSphere;                 ///< 스피어
	K3DRenderDevice*		m_pGraphics; 
	K3DTextureSPtr			m_spTexture;                ///< 텍스쳐 디퓨즈
	K3DTextureSPtr			m_spTexture_Bump;			///< 텍스쳐 범프
	K3DTextureSPtr			m_spTexture_Illumin;        ///< 텍스쳐 셀프 일루민
	K3DTextureSPtr			m_spTexture_Specular;       ///< 텍스쳐 스페큘러
	K3DTextureSPtr			m_spTexture_SpecularColor;  ///< 텍스쳐 스페큘러 칼라맵

	K3DMaterial*			m_pMaterial;               ///< 메트리얼
	int						m_nBlendMode;              ///< 블랜드 모드
	BOOL					m_bDeletK3DMaterial;       ///< ??
	DWORD					m_dwFormat;                ///< 버텍스 포맷
	DWORD					m_dwStride;                ///< 버텍스 간격
	DWORD					m_dwNumVertex;             ///< 버텍스 수
	
	int						m_nSimultaneousFrameCount; ///< 동시에 존재 하는 프레임 수
	DWORD					m_dwNumIndexBuffer;        ///< 인덱스 버퍼 수
	K3DIndexBufferSPtr		m_spIndices;                ///<  Index Buffer

	K3DUnsignedShortResSPtr	m_spIdxarry;			   ///< 충돌 정보 관련 버텍스 인덱스

	DWORD					m_lightMapIndex;

	MeshFrameVector			m_vtMeshFrame;             ///< MeshFrame 리스트
};

//Weight 작업중..
class KNX3WeightElement
{
public:
	KNX3WeightElement();
	~KNX3WeightElement();

	BOOL Load(KTemplateDataObject * pObject);

	bool LoadTRF( trf::MTemplatePtr pObject );

	DWORD GetWeightSize()     { return m_dwWeightSize;  }
	float * GetVertexIndex()  { return m_pVertexIndex;  }
	float * GetVertexWeight() { return m_pVertexWeight; }
	char  * GetBoneName()     { return m_szBoneName;   	}

	K3DVector * GetOffSetVector() { return m_pOffsetVector;	}

private:
	char    m_szBoneName[64];
	DWORD   m_dwWeightSize;  ///< 가중치 수
	float * m_pVertexIndex;  ///< 버텍스 인덱스
	float * m_pVertexWeight; ///< 버텍스 가중치
	DWORD   m_dwOffsetVectorSize; ///< Offset Vector 수
	K3DVector * m_pOffsetVector; ///< Offset Vector
};

class KNX3MeshFrame
{
public:
	KNX3MeshFrame( K3DRenderDevice *pGraphics );
	~KNX3MeshFrame();

	void Clear();
	BOOL Load(const NX3LoadPack * pLoadPack, const char *meshname, int idxcount, const WORD *_idxlist, KTemplateDataObject * pObject, 
		DWORD & dwFormat, DWORD & dwStride, DWORD & dwNumVertex, KTemplateDataObject* pFirstObject = NULL);
	
	bool LoadTRF(const NX3LoadPack * pLoadPack, const char *meshname, int idxcount, const WORD *_idxlist, trf::MTemplatePtr pObject, 
		DWORD & dwFormat, DWORD & dwStride, DWORD & dwNumVertex, trf::MTemplatePtr pFirstObject = NULL);
	
	K3DVertexBuffer* GetVertexBuffer() 
	{
		return m_spVertexBuffer;
	}

	K3DVertexRes* GetVertexArray() 
	{
		return m_spVtxArray;
	}

	DWORD GetFrameTime()
	{
		return m_dwFrameTime;
	}
	bool IsEventBox()
	{
		return m_bIsEventBox;
	}
	bool IsEventPoint()
	{
		return m_bIsEventPoint;
	}
	const K3DBoundSphere &GetSphere()
	{
		return m_bSphere;
	}
	const K3DBoundRotCube &GetCube()
	{
		return m_bCube;
	}

	int GetBoneSize() { return m_dwBoneSize;  }
	std::vector< KNX3WeightElement * > & GetWeightList()   { return m_vWeightList; }

	int GetSimultaneousFrameCount()	{ return m_nMeshSimultaneousFrameCount; }

	K3DMatrix * GetNodeTM() { return &m_NodeTM; }

	void AddUseBoneIndex( int nIndex );
	int GetUseBoneIndexCount() { return (int)m_vUseBoneList.size(); }
	int * GetUseBoneList() { return &m_vUseBoneList[0]; }

private:
	int GetNewBoneIndex( int nBoneIndex );

	void _MakeVertexBuffer(DWORD numVertex, DWORD format, DWORD stride, KTemplateDataArrayObject* pWeightArray, const NX3LoadPack * pLoadPack, 
		KSimpleDataArrayObject* pVertexArray,KSimpleDataArrayObject* pNormalArray, KSimpleDataArrayObject* pColorArray,KSimpleDataArrayObject* pTexelArray,
		int indexCount, const WORD* pIndexArray);

	void _MakeWeightInfo(KTemplateDataArrayObject* pWeightArray, K3DBLENDEDBUMPVERTEX* pBlendVtxArray, DWORD numVertex);

	void _MakeVertexBuffer(DWORD numVertex, DWORD format, DWORD stride, trf::MTemplateArrayPtr pWeightArray, const NX3LoadPack * pLoadPack, 
		trf::MArrayPtr pVertexArray, trf::MArrayPtr pNormalArray, trf::MArrayPtr pColorArray, trf::MArrayPtr pTexelArray,
		int indexCount, const WORD* pIndexArray);

	void _MakeWeightInfo( trf::MTemplateArrayPtr pWeightArray, K3DBLENDEDBUMPVERTEX* pBlendVtxArray, DWORD numVertex);

private:
	bool				m_bIsEventBox;       ///< 이벤트 박스?
	bool				m_bIsEventPoint;     ///< 이벤트 포인트 ?
	K3DRenderDevice*	m_pGraphics;   

	DWORD				m_dwFrameTime;       ///< 프레임 시간	
	K3DVertexBufferSPtr	m_spVertexBuffer;     ///< 버텍스 버퍼


	K3DBoundRotCube		m_bCube;             ///< 큐브
	K3DBoundSphere		m_bSphere;           ///< 스피어

	K3DVertexResSPtr	m_spVtxArray;          ///< 충돌 정보 관련 버텍스
	
	bool				m_bIsBlended;		///< 쉐이더용 셋팅

	//Weight
	DWORD							   m_dwBoneSize;  ///<뼈수 만큼.
	std::vector< KNX3WeightElement * > m_vWeightList; ///<뼈수 만큼.
	
	int					m_nMeshSimultaneousFrameCount;	///< 동시에 찍을 수 있는 갯수

	//UseBoneIndex
	std::vector< int > m_vUseBoneList; ///< 사용하는 뼈 인덱스

	K3DMatrix			m_NodeTM;      ///< TM
};

class KNX3FXElement
{
public:
	KNX3FXElement();
	~KNX3FXElement();

	BOOL Load(KTemplateDataObject * pObject);

	bool LoadTRF( trf::MTemplatePtr pObject );

	DWORD GetFrameTime() 
	{
		return m_dwFrameTime;	
	}
	const char *GetNote()
	{
		return m_sNote.c_str();
	}
	bool IsFX()
	{
		return m_bIsFX;
	}
	const char *GetValue( const char *fname );
	int GetNumValue( const char *key, int nDef );
	float GetFloatValue( const char *key, float fDef );
	K3DVector GetVectorValue( const char *key, const K3DVector &vecDef );
	K3DVector Get2DVectorValue( const char *key, const K3DVector &vecDef );
	void GetVariNumValue( const char *key, int *base_num, int *vari_num );
	
private:
	void parse();
	void getKeyValue( std::string &value, int &pos );
	bool getKey( std::string &key, int &pos );
	struct DATA
	{
		std::string key;
		std::string value;
	};
	std::vector<DATA>	m_vecData;     ///< FX Data ??
	bool				m_bIsFX;       ///< FX?
	DWORD				m_dwFrameTime; ///< 프레임 시간
	std::string			m_sNote;       ///< Note 이름 ??
}; 

class KNX3FX
{
public:
	KNX3FX()
	{
		m_bIsFX = false;
		m_vtFXElement.clear();
	}

	~KNX3FX()
	{
		m_vtFXElement.clear();
	}

	BOOL Load(KTemplateDataObject * pObject);

	bool LoadTRF( trf::MTemplatePtr pObject );

	bool			IsFX()
	{
		return m_bIsFX;
	}
	KNX3FXElement * GetFXElement(DWORD dwFrmaeTime);
	KNX3FXElement * GetFxElementByIndeX(int iIndex);
	DWORD			GetFXElementSize();

private:
	bool						m_bIsFX;       ///< FX ?
	std::vector<KNX3FXElement>	m_vtFXElement; ///< FX Element 구성 요소
};

class KNX3CameraChannel
{
public:
	KNX3CameraChannel(K3DRenderDevice * pGraphics)
	{
		m_pGraphics = pGraphics;
	}
	~KNX3CameraChannel()
	{
	}

	BOOL Load(KTemplateDataObject * pObject);

	bool LoadTRF( trf::MTemplatePtr pObject );

	K3DResCamera*	GetCameraRes()				{ return m_spCameraRes; }
private:
	K3DRenderDevice*	m_pGraphics;
	K3DResCameraSPtr	m_spCameraRes;   ///< 카메라 리소스
};

class KNX3Light
{
public:
	KNX3Light(K3DRenderDevice * pGraphics)
	{
		m_pGraphics = pGraphics;
	}
	~KNX3Light()
	{
	}
	K3DResLight* GetLightRes()	{ return m_spLightRes; }
	BOOL Load(KTemplateDataObject * pObject);

	bool LoadTRF( trf::MTemplatePtr pObject );

private:
	K3DResLightSPtr		m_spLightRes; ///< 라이트 리소스
	K3DRenderDevice*	m_pGraphics;
};

class KNX3LightChannel
{
public:
	KNX3LightChannel(K3DRenderDevice * pGraphics)
	{
		m_pGraphics = pGraphics;
		m_vtLightList.clear();
	}
	~KNX3LightChannel()
	{
		Clear();
	}
	
	void Clear();
	BOOL Load(KTemplateDataObject * pObject);

	bool LoadTRF( trf::MTemplatePtr pObject );

	BOOL Render(DWORD dwFrameTime);

	int GetLightCount()					{ return static_cast<int>(m_vtLightList.size()); }
	KNX3Light* GetLight( int index )	{ return m_vtLightList[index]; }
private:
	K3DRenderDevice * m_pGraphics;
	std::vector<KNX3Light *> m_vtLightList; ///< 라이트 리스트
	
};


class KNX3ChannelControl
{
public:
	KNX3ChannelControl()
	{
		m_pMtlChannel = NULL; m_pMeshChannel = NULL; m_pLightChannel = NULL; m_pCameraChannel = NULL; //m_pSoundChannel = NULL;
		m_pBoneChannel = NULL; 
#ifdef  _KPATH_EFFECT
		m_pPfxChannel = NULL;
#endif
		m_dwVersion = ( 1 << 16 ) | 0;
	}
	~KNX3ChannelControl()
	{
		Clear();
	}
	
	void Clear();
	KNX3MtlChannel* GetMtlChannel()
	{
		return m_pMtlChannel;
	}
	KNX3MeshChannel* GetMeshChannel()
	{
		return m_pMeshChannel;
	}
	KNX3CameraChannel* GetCameraChannel()
	{
		return m_pCameraChannel;
	}
	KNX3LightChannel* GetLightChannel()
	{
		return m_pLightChannel;
	}

	KNX3BoneChannel * GetBoneChannel()
	{
		return m_pBoneChannel;
	}

	DWORD GetVersion()
	{
		return m_dwVersion;
	}

	const char* GetPropertyString()
	{
		return m_strProperty.c_str();
	}

	BOOL Load( const NX3LoadPack * pLoadPack, K3DRenderDevice * pGraphics, /*KSoundDevice  * pSound ,*/ KFiler * pFiler, const char * pFileName );

	bool LoadTRF( const NX3LoadPack * pLoadPack, K3DRenderDevice * pGraphics, /*KSoundDevice  * pSound ,*/ trf::MDictPtr pRoot, const char * pFileName );

private:
	KNX3MtlChannel		* m_pMtlChannel;     ///< 메트리얼 채널
	KNX3MeshChannel		* m_pMeshChannel;    ///< Mesh 채널
	KNX3LightChannel	* m_pLightChannel;   ///< 빛 채널
	KNX3CameraChannel	* m_pCameraChannel;	 ///< 카메라 채널
	//작업중..
	KNX3BoneChannel	    * m_pBoneChannel;    ///< 본 채널
	DWORD				m_dwVersion;
	std::string			m_strProperty;
};