#include "stdafx.h"
#include "KResource.h"
#include "KResourceDX.h"
#include "KResourceManager.h"
#include "KRenderDefine.h"
#include "KDeviceManager.h"

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// KResource Implement
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

KResource::KResource() 
: m_nRef(0), m_dwLoadedTime(0), m_nTextureMode(0)		
{
	
}
KResource::~KResource()		
{
	//if( m_type == RESTYPE_TEXTURE )
	//{
	//	_oprint( "TEXTURE : Delete\n" );
	//}
}

int KResource::GetResourceType() const	
{ 
	return m_type; 
}

int KResource::GetState() const
{ 
	return m_state; 
}
bool KResource::Discard()			
{ 
	bool bRet = m_nRef ? false : true;
	if( !( bRet && m_strName.empty()) )	// Fraun removal of outputs when name is fucking empty (few thousands of them, really)
	{
		_oprint("Warning! Resource Ref of [ %s ] is not Zero but %d when discarded\n", m_strName.c_str(), m_nRef);
	}
	delete this;
	return bRet;
}

int KResource::AddRef()					
{ 
	return InterlockedIncrement( (volatile LONG *)&m_nRef ); //m_nRef++;
}
int KResource::GetRefCount() const
{ 
	return m_nRef; 
}
void KResource::Release()			
{ 
	assert(m_nRef && "사용 하지 않은 리소스를 삭제 한다.!!!" ); 
	InterlockedDecrement( (volatile LONG *)&m_nRef ); ////m_nRef--;
	assert(m_nRef >= 0); 

	if ( m_nRef == 0 ) 
		Recycle();
}

void KResource::Recycle()		// 재사용
{
	delete this;  
}

void KResource::SetName(const char *name)	
{ 
	m_strName = name;	
}
LPCSTR KResource::GetName()	const		
{ 
	return m_strName.c_str(); 
}

void KResource::SetVersion( DWORD dwVersion )
{
	m_dwVersion = dwVersion;
}

DWORD KResource::GetVersion()
{
	return m_dwVersion;
}


//static KRESOURCEID g_texID = 0;

////////////////////////////////////////////////////////////////////////
//
K3DTexture::K3DTexture()
{ 
	m_nQuality = 0; 
	m_size.cx  = m_size.cy = 0; 
	m_type     = RESTYPE_TEXTURE; 
	m_format   = K3DFMT_UNKNOWN; 
	m_pSurface = NULL; 
	m_nLevels  = 1; 
	m_bManagedByTexManager = false;
	m_flags = 0;
	m_ColorizedMode = 0;

//	SetID( g_texID++ );
//	_oprint( "K3DTexture::K3DTexture:(%08X):(%08d)\n", this, GetID() );
}

K3DTexture::~K3DTexture()
{
//	_oprint( "K3DTexture::Destroy:(%08X):(%08d)\n", this, GetID() );
}

bool K3DTexture::IsValid() const
{
	return false;
}

void K3DTexture::Release()
{
	assert( m_nRef && "0이 들어 온다." );

	if ( m_nRef <= 1 )
	{
		// IsValid Check 일부러 뺐음 (안그러면 RenderTarget 실패시 Memory Leak 가능성)
		//_oprint( "K3DTexture::Release:(%08X)\n", this );

		if( m_bManagedByTexManager)
			KTextureManager::GetManager()->RemoveTexture( this );
		
		K3DRenderDevice* pDev = KDeviceManager::GetDeviceManager()->GetRenderDevice();

		if(pDev)
			pDev->RemoveTexture( this );
	}
	KResource::Release();
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// K3DResVertexAnimation Implement
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

K3DResVertexAnimation::Key::Key()
{
	time = 0;

}
bool K3DResVertexAnimation::Key::operator<( const Key &target ) const
{
	return time < target.time;
}

K3DResVertexAnimation::K3DResVertexAnimation()
{
	m_bUseAnimation  = false;
	m_bTransparent   = false;
	m_type           = RESTYPE_VERTEXANIMATION;
}

K3DResVertexAnimation::~K3DResVertexAnimation()
{
}
const KInterval &K3DResVertexAnimation::GetInterval()
{
	return m_keys.GetInterval();
}
void K3DResVertexAnimation::SetKeyCount( int count )
{
	if ( count > 1 )
	{
		m_bUseAnimation = true;
		m_keys.SetKeyCount( count );
	}
	else m_bUseAnimation = false;
}
void K3DResVertexAnimation::SetKey( int index, Key *key, int count)
{
	if ( m_bUseAnimation )
	{
		m_keys.SetKey( index, key, count );
	}
	else
	{
		m_akey = key[0];
	}
}

int    K3DResVertexAnimation::GetKeyCount()
{
	return m_keys.GetKeyCount();
}

K3DResVertexAnimation::Key& K3DResVertexAnimation::GetKey( int nIndex )
{
	return m_keys.GetKey( nIndex );
}

void K3DResVertexAnimation::SetWholeKey( Key *key, int count )
{
	if ( count > 1 )
	{
		m_bUseAnimation = true;
		m_keys.SetWholeKey( key, count );
	}
	else
	{
		m_bUseAnimation = false;
		m_akey = key[0];
	}
}
void K3DResVertexAnimation::GetData( int time, Key*& key1, Key*& key2 )
{
	if ( m_bUseAnimation == false )
	{
		key1 = &m_akey;
		key2 = NULL;
	}
else
	{
		m_keys.GetData( time, key1, key2 );
	}
}

void K3DResVertexAnimation::SetIndexArray(  K3DUnsignedShortRes * pUS )
{
	m_spUS = pUS;
}

void K3DResVertexAnimation::SetIndexBuffer( K3DIndexBuffer *pIB )
{
	m_spIB = pIB;
}
bool K3DResVertexAnimation::IsTransparent()
{
	return m_bTransparent;
}
void K3DResVertexAnimation::SetMaterial( K3DMaterial *mat )
{
	if( mat )
		memcpy( &m_Mtl, mat, sizeof(m_Mtl) );
}
void K3DResVertexAnimation::SetBlendMode( int blendmode )
{
	m_nBlendMode = blendmode;
	if ( blendmode == K3DMaterial::MBM_ADDITIVE )
		m_bTransparent = true;
}

void K3DResVertexAnimation::SetTexturePack( TEXPACK * pTexPack )
{
	if( pTexPack->spTexture == NULL)
		return;

	m_TexPack = *pTexPack;
	m_TexPack.nTextureMode = m_TexPack.spTexture->m_nTextureMode;

	K3DFORMAT fmt = m_TexPack.spTexture->GetFormat();
	m_bTransparent = false;
	switch( fmt )
	{
	case K3DFMT_A8R8G8B8:
	case K3DFMT_A4R4G4B4:
	case K3DFMT_A8R3G3B2:
	case K3DFMT_A2B10G10R10:
	case K3DFMT_DXT3:
	case K3DFMT_DXT5:
		m_bTransparent = true;
		break;
	default:
		if ( m_nBlendMode != K3DMaterial::MBM_DEFAULT )
			m_bTransparent = true;
		break;
	}
}


K3DMaterial *K3DResVertexAnimation::GetMaterial()
{
	return &m_Mtl;
}
int K3DResVertexAnimation::GetBlendMode()
{
	return m_nBlendMode;
}
TEXPACK* K3DResVertexAnimation::GetTexturePack()
{
	if(m_TexPack.spTexture != NULL)
	{
		K3DFORMAT fmt = m_TexPack.spTexture->GetFormat();
		m_bTransparent = false;
		m_TexPack.nTextureMode = m_TexPack.spTexture->m_nTextureMode;
		switch( fmt )
		{
		case K3DFMT_A8R8G8B8:
		case K3DFMT_A4R4G4B4:
		case K3DFMT_A8R3G3B2:
		case K3DFMT_A2B10G10R10:
		case K3DFMT_DXT3:
		case K3DFMT_DXT5:
			m_bTransparent = true;
			break;
		default:
			if ( m_nBlendMode != K3DMaterial::MBM_DEFAULT )
				m_bTransparent = true;
			break;
		}
	}

	return &m_TexPack;
}

K3DUnsignedShortRes* K3DResVertexAnimation::GetIndexArray()
{
	return m_spUS;
}

K3DIndexBuffer* K3DResVertexAnimation::GetIndexBuffer()
{
	return m_spIB;
}
bool K3DResVertexAnimation::Reload()
{
	return true;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// K3DBoneResource ImplementK3DBoneResource
K3DBone::K3DBone()
{
	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;
	m_pChild = NULL;

	m_pParent = NULL;

	m_nIndex = -1;

	K3DMatrixIdentity( m_BaseMat  );
	K3DMatrixIdentity( m_CacheMat );

	memset( m_szBoneName, 0, sizeof(m_szBoneName) );

	//보간 관련
	m_CacheAniData.pos		= K3DVector(0,0,0);			//보간 전달용
	m_CacheAniData.quat		= K3DQuaternion(0,0,0,1);	//보간 전달용
}

K3DBone::~K3DBone()
{
	SAFE_DELETE_ARRAY( m_pPosKey );
	SAFE_DELETE_ARRAY( m_pRotKey );
	SAFE_DELETE_ARRAY( m_pChildList );
	SAFE_DELETE_ARRAY( m_pChild );
}

//Key로 변환 시키자~
Kgeneric_key_t * K3DBone::GetPosKey( DWORD mSec, K3DVector &pos )
{
	if( m_dwPosCount <= 0 ) return NULL;

	Kgeneric_key_t *key1 = NULL;
	Kgeneric_key_t *key2 = NULL;

	//와 보간두 되겠다~.
	m_PosKey.GetData( (int)mSec, key1, key2 );
	if( key1 && key2 )
	{
		K3DVector v1 = K3DVector(key1->lin_pos.pos);
		K3DVector v2 = K3DVector(key2->lin_pos.pos);

		float t = 0;
		if( key1->time != 0 )
			t = (mSec % key1->time) / (float)(key2->time - key1->time);

		K3DVector dir = v2 - v1;
		dir = dir * t;
		pos = v1 + dir;

		return key1;
	}

	if( key1 )
	{
		pos = K3DVector(key1->lin_pos.pos);
		return key1;
	}

	return NULL;
}

Kgeneric_key_t * K3DBone::GetRotKey( DWORD mSec, K3DQuaternion &quat )
{
	if( m_dwRotCount <= 0 ) return NULL;

	Kgeneric_key_t *key1 = NULL;
	Kgeneric_key_t *key2 = NULL;

	//와 보간두 되겠다~.
	m_RotKey.GetData( (int)mSec, key1, key2 );
	if( key1 && key2 )
	{
		K3DQuaternion q1 = K3DQuaternion(key1->lin_rot.quat);
		K3DQuaternion q2 = K3DQuaternion(key2->lin_rot.quat);

		float t = 0;
		if( key1->time != 0 )
			t = (float)(mSec % key1->time) / (float)(key2->time - key1->time);

		K3DQuaternionSlerp(quat, q1, q2, t );
		return key1;
	}

	if( key1 )
	{
		quat = K3DQuaternion(key1->lin_rot.quat);
		return key1;
	}

	return NULL;
}

void K3DBone::Interpolate(DWORD mSec, K3DVector &pos, K3DQuaternion &quat)
{
	// Linear interpolate position
	Kgeneric_key_t *posKeyStart = GetPosKey(mSec, pos);
	Kgeneric_key_t *rotKeyStart = GetRotKey(mSec, quat);
}

void K3DBone::CalcTM(DWORD mSec, DWORD mSecLimit, BONE_ANI_DATA *pAniData/*=NULL*/, float fWeight/*=0.f*/)
{
	K3DVector pos      = K3DVector(0,0,0);
	K3DQuaternion quat = K3DQuaternion(0,0,0,1);

	Interpolate( mSec, pos, quat );
	
	if( pAniData )
	{
		//Pos
		K3DVector dir = pos - pAniData[GetIndex()].pos;
		dir = dir * fWeight;
		pos = pAniData[GetIndex()].pos + dir;
	
		//Quaternion
		K3DQuaternionSlerp(quat, pAniData[GetIndex()].quat, quat, fWeight );
	}

	m_CacheAniData.pos  = pos;  
	m_CacheAniData.quat = quat; 

	K3DMatrixIdentity( m_CacheMat );
	K3DMatrixRotationQuaternion( m_CacheMat, quat );
	m_CacheMat._41 = pos.x;
	m_CacheMat._42 = pos.y;
	m_CacheMat._43 = pos.z;

	//if(mSec >= mSecLimit)
	//{
	//	GetPosKey(mSec, pos );
	//	GetRotKey(mSec, quat);
	//}
	//else
	//	Interpolate( mSec, pos, quat );

	//K3DQuaternion ang;
	//float scale, tw;
	//tw = (float)acos(quat.w) * 2.f;
	//scale = (float)sin(tw * 0.5);
	//ang.x = quat.x / scale;
	//ang.y = quat.y / scale;
	//ang.z = quat.z / scale;
	//ang.w = (tw * 180.f) / (float)K3D_PI;

	//D3DXMATRIX mat1, mat2, mOut;
	//D3DXMatrixIdentity( &mat1 );
	//D3DXMatrixIdentity( &mat2 );
	//D3DXMatrixIdentity( &mOut );

	//////최적화 할 수 있게 바꿔야 할 부분..
	//D3DXMatrixTranslation( &mat1, pos.x, pos.y, pos.z);

	//D3DXVECTOR3 vector = D3DXVECTOR3(ang.x, ang.y, ang.z );

	//float angRadian = ang.w*K3D_PI/180; //anf[_W_]는 Degree 값.

	//D3DXMatrixRotationAxis( &mat2, &vector, angRadian );

	//mOut = mat2;

	//mOut._41 = mat1._41;
	//mOut._42 = mat1._42;
	//mOut._43 = mat1._43;
	//mOut._44 = mat1._44;

	//m_cacheTM[0] = mOut._11;
	//m_cacheTM[1] = mOut._12;
	//m_cacheTM[2] = mOut._13;
	//m_cacheTM[3] = mOut._14;

	//m_cacheTM[4] = mOut._21;
	//m_cacheTM[5] = mOut._22;
	//m_cacheTM[6] = mOut._23;
	//m_cacheTM[7] = mOut._24;

	//m_cacheTM[8]  = mOut._31;
	//m_cacheTM[9]  = mOut._32;
	//m_cacheTM[10] = mOut._33;
	//m_cacheTM[11] = mOut._34;

	//m_cacheTM[12] = mOut._41;
	//m_cacheTM[13] = mOut._42;
	//m_cacheTM[14] = mOut._43;
	//m_cacheTM[15] = mOut._44;

	//캐쉬 Matrix 갱신
	//m_CacheMat = K3DMatrix(m_cacheTM);

	for(int i = 0; i < GetChildCount(); i++)
	{
//		_oprint( "ChildName : %s\n", m_pChild[i]->GetName() );
		m_pChild[i]->CalcTM(mSec, mSecLimit, pAniData, fWeight);
	}
}

K3DBoneResource::K3DBoneResource()
{
	m_type         = RESTYPE_BONE;
	m_nBoneCount   = 0;
	m_pBoneList    = NULL;

	m_pParent      = NULL;
	m_nChildCount  = 0;
	m_ppChild      = NULL;

	m_dwTimeSpan   = 0;
	m_pBoneBaseTM  = NULL;
}

K3DBoneResource::~K3DBoneResource()
{
	if( m_pBoneList )
	{
		for( int i(0); m_nBoneCount>i; i++ )
		{
			delete m_pBoneList[i];
		}
		delete [] m_pBoneList;
	}
	if( m_ppChild )
		delete [] m_ppChild;

	SAFE_DELETE_ARRAY(m_pBoneBaseTM );
}

const KInterval & K3DBoneResource::GetInterval()
{
	return m_Interval;
}

bool K3DBoneResource::Reload()
{
	//작업중..
	return true;
}	
void K3DBoneResource::AddBone(int nIndex, K3DBone * pBone)
{
	if( m_nBoneCount == 0 || m_nBoneCount <= nIndex ) return;

//#ifndef _RELEASE
//	_oprint( "Bone Name[%d] : %s\n", nIndex, pBone->GetName() );
//#endif

	pBone->SetIndex(nIndex);
	m_pBoneList[nIndex] = pBone;

	std::string strPureBoneName;
	GetPureBoneName(strPureBoneName, pBone->GetName() );
	pBone->SetName( strPureBoneName.c_str() );
}

void K3DBoneResource::SetBone( int nBoneCount )
{
	assert( m_nBoneCount == 0 );
	m_nBoneCount = nBoneCount;
	m_pBoneList = new K3DBone*[m_nBoneCount];
//	m_pBoneBaseTM = new K3DMatrix[m_nBoneCount];
}

void K3DBoneResource::SetChildCount( int nChildCount )
{
	m_nChildCount = nChildCount;
	if( m_nChildCount > 0 )
	{
		m_ppChild = new K3DBone*[m_nChildCount];

		int idx(0);
		for(int i(0); i < m_nBoneCount; i++)
		{
			K3DBone *pBone = m_pBoneList[i];
			if(pBone->GetParentBone() == NULL)
			{
				m_ppChild[idx] = pBone;
				idx++;
			}
		}
	}
}

float K3DBoneResource::GetHeadZ()
{
	int nIndex;
	K3DBone * pHead = GetBone( "Head", nIndex );
	if(pHead)
	{
		return pHead->GetCacheTM()->_43;
	}
	
	return 0.f;
}

void K3DBoneResource::GetHandLeft( K3DVector & pos )
{
	int nIndex;
	K3DBone * pHandLeft = GetBone( "HandL", nIndex );
	if(pHandLeft)
	{
		pos.x = pHandLeft->GetCacheTM()->_41;
		pos.y = pHandLeft->GetCacheTM()->_42;
		pos.z = pHandLeft->GetCacheTM()->_43;
	}
}

void K3DBoneResource::GetHandRight( K3DVector & pos )
{
	int nIndex;
	K3DBone * pHandRight = GetBone( "HandR", nIndex );
	if(pHandRight)
	{
		pos.x = pHandRight->GetCacheTM()->_41;
		pos.y = pHandRight->GetCacheTM()->_42;
		pos.z = pHandRight->GetCacheTM()->_43;
	}
}

void K3DBoneResource::CalcBoneTransforms( DWORD dwTime, K3DMatrix *pMatList, BONE_ANI_DATA *pAniData, BONE_ANI_DATA *pPrevAniData/*=NULL*/, float fWeight/*=1.f*/ )
{
//	if( GetAsyncKeyState(VK_CONTROL) < 0 )
//		_oprint( "CalcBoneTransforms : %d\n", dwTime );

	for(int i(0); GetChildCount()>i; i++ )
	{
//		_oprint( "ChildName : %s\n", m_ppChild[i]->GetName() );
		m_ppChild[i]->CalcTM( dwTime, GetTimeSpan(), pPrevAniData, fWeight );
	}

	//계산이 완료 되면, CacheTM을 얻어 온다.
	for(int i(0); GetBoneCount()>i; i++ )
	{
//		_oprint( "BoneName : %s\n", GetBone(i)->GetName() );
		pMatList[i] = *GetBone(i)->GetCacheTM();
		pAniData[i] = *GetBone(i)->GetCacheAniData();
	}
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// K3DMeshResource Implement
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

K3DMeshResource::K3DMeshResource()
{
	m_spVBArray = NULL;
	m_nVBCount = 0;
	m_type = RESTYPE_MESH;

	m_nWeightCount = 0;
	m_ppWeight = NULL;

	m_nNodeCount = 0;
	m_pNodeTM = NULL;

	m_nMeshTMCount = 0;
	m_pMeshTM = NULL;
	m_pMeshTM_Array = NULL;
}
K3DMeshResource::~K3DMeshResource()
{
	if ( m_spVBArray != NULL )
	{
		delete[] m_spVBArray;
	}

	if ( m_ppWeight != NULL )
	{
		for ( int i=0 ; i<m_nWeightCount ; ++i )
		{
			SAFE_DELETE_ARRAY(m_ppWeight[i]);
		}
		delete[] m_ppWeight;
	}

	SAFE_DELETE_ARRAY( m_pNodeTM );
	SAFE_DELETE_ARRAY( m_pMeshTM );
	SAFE_DELETE_ARRAY( m_pMeshTM_Array );
}
const KInterval &K3DMeshResource::GetInterval()
{
	return m_Interval;
}

int K3DMeshResource::GetWeightResCount()
{
	return m_nWeightCount;
}

K3DWeight* K3DMeshResource::GetWeightRes(int nIndex)
{
	if( m_ppWeight[0] == NULL ) return NULL;

	if( m_nWeightCount <= 0 && nIndex > m_nWeightCount ) return NULL;

	return m_ppWeight[nIndex];
}

K3DWeight** K3DMeshResource::GetWeightResList()
{
	if( m_nWeightCount <= 0 ) return NULL;

	return m_ppWeight;
}

K3DMatrix * K3DMeshResource::GetNodeTM( int nIndex )
{
	if( m_nNodeCount <= 0 && nIndex > m_nNodeCount ) return NULL;

	return &m_pNodeTM[nIndex];
}

void K3DMeshResource::SetNodeTM( K3DMatrix * pMatrix, int count )
{
	assert( m_pNodeTM == NULL );
	if( count <= 0) return;

	m_nNodeCount = count;

	m_pNodeTM = new K3DMatrix[count];

	for( int i(0); count>i; i++ )
	{
		memcpy( &m_pNodeTM[i], &pMatrix[i], sizeof(m_pNodeTM[i]) );
	}
}

void K3DMeshResource::SetMeshTM( K3DMeshTM * pMeshTM, int count )
{	
	assert( m_pMeshTM == NULL );
	if( count <= 0) return;

	m_nMeshTMCount = count;

	m_pMeshTM = new K3DMeshTM[count];
	m_pMeshTM_Array = new K3DMatrix[count];

	for( int i(0); count>i; i++ )
	{
		memcpy( &m_pMeshTM[i], &pMeshTM[i], sizeof(m_pMeshTM[i]) );
		memcpy( &m_pMeshTM_Array[i], &pMeshTM[i].mTM, sizeof(m_pMeshTM_Array[i]) );
	}
}

void K3DMeshResource::SetWeightResource( K3DWeight **ppWeight, int count )
{
	assert( m_ppWeight == NULL );
	if( count <= 0) return;
	if( ppWeight[0] == NULL ) return;

	m_nWeightCount = count;
	m_ppWeight = new K3DWeight*[count];
	for( int i=0; i<count; ++i )
	{
		m_ppWeight[i] = ppWeight[i];
	}
}

void K3DMeshResource::SetVBResource( K3DResVertexAnimation **vbres, int count )
{
	assert( m_spVBArray == NULL );
	m_nVBCount = count;
	m_spVBArray = new K3DResVertexAnimationSPtr[count];
	for ( int i=0 ; i<count ; ++i )
	{
		m_spVBArray[i] = vbres[i];
		m_Interval.Expand( vbres[i]->GetInterval() );
	}
}
int K3DMeshResource::GetResCount()
{
	return m_nVBCount;
}
K3DResVertexAnimation* K3DMeshResource::GetRes( int index )
{
	return m_spVBArray[index];
}
K3DResVertexAnimationSPtr* K3DMeshResource::GetResList()
{
	return m_spVBArray;
}
void K3DMeshResource::SetBound( const K3DBoundRotCube &cube, const K3DBoundSphere &sphere )
{
	m_boundCube = cube;
	m_boundSphere = sphere;
}
const K3DBoundRotCube &K3DMeshResource::GetBoundCube()
{
	return m_boundCube;
}
const K3DBoundSphere &K3DMeshResource::GetBoundSphere()
{
	return m_boundSphere;
}
bool K3DMeshResource::Reload()
{
	return true;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// K3DResMeshMatrixAnimation Implement
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
K3DResMeshMatrixAnimation::K3DResMeshMatrixAnimation()
{
	m_type = RESTYPE_MESHMATRIX;
}
K3DResMeshMatrixAnimation::~K3DResMeshMatrixAnimation()	
{
}
bool K3DResMeshMatrixAnimation::Key::operator<( const Key &target ) const
{
	return time < target.time;
}
const KInterval &K3DResMeshMatrixAnimation::GetInterval()
{
	return m_keys.GetInterval();
}
void K3DResMeshMatrixAnimation::SetKeyCount( int count )
{
	m_keys.SetKeyCount( count );
}
void K3DResMeshMatrixAnimation::SetKey( int index, Key *key, int count)
{
	m_keys.SetKey( index, key, count );
}
void K3DResMeshMatrixAnimation::SetWholeKey( Key *key, int count )
{
	m_keys.SetWholeKey( key, count );
}

void K3DResMeshMatrixAnimation::GetLerpMatrix(int time, K3DMatrix* pMat)
{
	Key *key1 = NULL, *key2 = NULL;
	m_keys.GetData( time, key1, key2 );

	if ( key2 != NULL )
	{
		int ctime = time - key1->time;
		float ratio = (float)ctime / float(key2->time - key1->time);
		K3DMatrix resmat;
		K3DMatrixLerp( resmat, key1->mat, key2->mat, ratio );
		*pMat = resmat;
	}
	else
	{
		*pMat = key1->mat;
	}
}


bool K3DResMeshMatrixAnimation::Reload()
{
	return true;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// K3DResMeshUVAnimation Implement
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

K3DResMeshUVAnimation::K3DResMeshUVAnimation()
{
	m_type = RESTYPE_MESHUV;
	m_nMode = 0;
}

K3DResMeshUVAnimation::~K3DResMeshUVAnimation()	
{
}

bool K3DResMeshUVAnimation::Key::operator<( const Key &target ) const
{
	return time < target.time;
}
const KInterval &K3DResMeshUVAnimation::GetInterval()
{
	return m_keys.GetInterval();
}
void K3DResMeshUVAnimation::SetKeyCount( int count )
{
	m_keys.SetKeyCount( count );
}

void K3DResMeshUVAnimation::SetKey( int index, Key *key, int count)
{
	m_keys.SetKey( index, key, count );
}

void K3DResMeshUVAnimation::SetWholeKey( Key *key, int count )
{
	m_keys.SetWholeKey( key, count );
}

void K3DResMeshUVAnimation::SetMode( int nMode )
{
	m_nMode = nMode;
}

int K3DResMeshUVAnimation::GetMode()
{
	return m_nMode;
}

void K3DResMeshUVAnimation::SetUvAnimation( bool bUseUvAni, int nMaxFrame, int nLoopFrame )
{
	m_bUseUvAni = bUseUvAni;
	m_nUvMaxFrame = nMaxFrame;
	m_nUvLoopFrame = nLoopFrame;
}

void K3DResMeshUVAnimation::GetLerpMatrix(int time, K3DMatrix* pMat)
{
	if( m_bUseUvAni )
	{
		int nMaxFrame = m_nUvMaxFrame;
		assert( nMaxFrame );

		float fUVRatio = 1.0f / sqrtf( ( float ) nMaxFrame );
		int nLoopFrame = m_nUvLoopFrame;
		if( nLoopFrame == 0 )
			nLoopFrame = m_keys.GetInterval().GetLength();
		int nAniCount = int(( nMaxFrame / ( float ) nLoopFrame ) * time );
		if ( nAniCount >= nMaxFrame )
			nAniCount %= nMaxFrame;

		int width = ( int ) ( 1.0f / fUVRatio );
		int txtpos = nAniCount % nMaxFrame;

		int px = txtpos % width;
		int py = txtpos / width;

		float l, t;
		l = fUVRatio * px;
		t = fUVRatio * py;

		K3DMatrixIdentity( *pMat );
		pMat->_31 = l;
		pMat->_32 = t;
		pMat->_41 = 1.0f;
	}
	else
	{
		Key *key1 = NULL, *key2 = NULL;
		m_keys.GetData( time, key1, key2 );

		if ( key2 != NULL )
		{
			int ctime = time - key1->time;
			float ratio = (float)ctime / float(key2->time - key1->time);
			K3DMatrix resmat;
			K3DMatrixLerp( resmat, key1->mat, key2->mat, ratio );
			*pMat = resmat;
		}
		else
		{
			*pMat = key1->mat;
		}
	}
}

bool K3DResMeshUVAnimation::Reload()
{
	return true;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// K3DResMeshVisibilityAnimation Implement
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
K3DResMeshVisibilityAnimation::K3DResMeshVisibilityAnimation()
{
	m_type = RESTYPE_MESHVISIBILITY;
}
K3DResMeshVisibilityAnimation::~K3DResMeshVisibilityAnimation()	
{
}
bool K3DResMeshVisibilityAnimation::Key::operator<( const Key &target ) const
{
	return time < target.time;
}
const KInterval& K3DResMeshVisibilityAnimation::GetInterval()
{
	return m_keys.GetInterval();
}
void K3DResMeshVisibilityAnimation::SetKeyCount( int count )
{
	m_keys.SetKeyCount( count );
}
void K3DResMeshVisibilityAnimation::SetKey( int index, Key *key, int count)
{
	m_keys.SetKey( index, key, count );
}
void K3DResMeshVisibilityAnimation::SetWholeKey( Key *key, int count )
{
	m_keys.SetWholeKey( key, count );
}

void K3DResMeshVisibilityAnimation::GetVisibility(int time, float* pVisi)
{
	Key *key1 = NULL, *key2 = NULL;
	m_keys.GetData( time, key1, key2 );

	if ( key2 != NULL )
	{
		int ctime = time - key1->time;
		float ratio = (float)ctime / float(key2->time - key1->time);
		*pVisi = key1->val + ((key2->val - key1->val) * ratio);
	}
	else
	{
		*pVisi = key1->val;
	}
}

bool K3DResMeshVisibilityAnimation::Reload()
{
	return true;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// K3DResEventPoint Implement
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
K3DResEventPoint::K3DResEventPoint()
{
	m_type = RESTYPE_EVENTPOINT;
}
K3DResEventPoint::~K3DResEventPoint()
{
}
const KInterval& K3DResEventPoint::GetInterval()
{
	return m_Interval;
}
void K3DResEventPoint::SetRes( K3DResMeshMatrixAnimation *matres )
{
	m_spResMat = matres;

	if(m_spResMat != NULL)
	{
		m_Interval = m_spResMat->GetInterval();
	}
}

void K3DResEventPoint::GetData( int time, K3DMatrix *point )
{
	if(m_spResMat != NULL)
	{
		m_spResMat->GetLerpMatrix(time, point);
	}
}
bool K3DResEventPoint::Reload()
{
	return true;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// K3DResEventBox Implement
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

K3DResEventBox::K3DResEventBox()
{
	m_type = RESTYPE_EVENTBOX;
}
K3DResEventBox::~K3DResEventBox()
{
}
const KInterval&K3DResEventBox::GetInterval()
{
	return m_Interval;
}
void K3DResEventBox::SetRes( const K3DBoundRotCube &cube, K3DResMeshMatrixAnimation *matres )
{
	m_Cube = cube;

	assert( m_spResMat == NULL);
	m_spResMat = matres;

	if(m_spResMat != NULL)
	{
		m_Interval = m_spResMat->GetInterval();
	}
}
void K3DResEventBox::GetData( int time, K3DBoundRotCube *cube )
{
	if(m_spResMat != NULL)
	{
		static K3DMatrix resmat;
		m_spResMat->GetLerpMatrix(time, &resmat);
		m_Cube.SetTransform(resmat);
	}

	*cube = m_Cube;
}
bool K3DResEventBox::Reload()
{
	return true;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// K3DResCamera Implement
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

K3DResCamera::K3DResCamera()
{
	m_type = RESTYPE_CAMERA;
}
K3DResCamera::~K3DResCamera()	
{
}
bool K3DResCamera::Key::operator<( const Key &target ) const
{
	return time < target.time;
}
const KInterval& K3DResCamera::GetInterval()
{
	return m_keys.GetInterval();
}
void K3DResCamera::SetKeyCount( int count )
{
	m_keys.SetKeyCount( count );
}
void K3DResCamera::SetKey( int index, Key *key, int count  )
{
	m_keys.SetKey( index, key, count );
}
void K3DResCamera::SetWholeKey( Key *key, int count )
{
	m_keys.SetWholeKey( key, count );
}

void K3DResCamera::GetData( int time, Key*& key1, Key*& key2 )
{
	m_keys.GetData( time, key1, key2 );
}
bool K3DResCamera::Reload()
{
	return true;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// K3DResLight Implement
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
K3DResLight::K3DResLight()
{
	m_type = RESTYPE_LIGHT;
}
K3DResLight::~K3DResLight()	
{
}
bool K3DResLight::Key::operator<( const Key &target ) const
{
	return time < target.time;
}
const KInterval& K3DResLight::GetInterval()
{
	return m_keys.GetInterval();
}
void K3DResLight::SetKeyCount( int count )
{
	m_keys.SetKeyCount( count );
}
void K3DResLight::SetKey( int index, Key *key, int count)
{
	m_keys.SetKey( index, key, count );
}
void K3DResLight::SetWholeKey( Key *key, int count )
{
	m_keys.SetWholeKey( key, count );
}

void K3DResLight::GetData( int time, Key*& key1, Key*& key2 )
{
	m_keys.GetData( time, key1, key2 );
}
bool K3DResLight::Reload()
{
	return true;
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// KResSprite Implement
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

KResSprite::KResSprite()
{
	m_type = RESTYPE_SPRITE;
	m_ptOffset.x = m_ptOffset.y = 0;
	m_fSizeX = m_fSizeY = .0f;
	m_fTop = 0.f;
	m_fLeft = 0.f;
	m_fRight = 1.f;
	m_fBottom = 1.f;
	m_fVisibility = 1.0f;
	m_bMirrorH = m_bMirrorV = false;
	m_bUseAdditive = false;
	m_bCWRotation = m_bCCWRotation	 = false;
	K3DMatrixIdentity(m_matTransform);
}
KResSprite::~KResSprite()
{
	//_LEAK_SUN
	m_sNote.clear();
	m_vtBoundBox.clear();
}
void KResSprite::SetTexture( K3DTexture *pTex, const KRect *srcrect )
{
	m_spTexture = pTex;

	if(m_spTexture == NULL)
		return;

	if ( srcrect )
	{
		m_rectSrc = *srcrect;
		m_fSizeX = (float)m_rectSrc.right - m_rectSrc.left;
		m_fSizeY = (float)m_rectSrc.bottom - m_rectSrc.top;

		KSize texsize;
		texsize.width = m_spTexture->GetWidth();
		texsize.height = m_spTexture->GetHeight();

		m_fLeft		= (float)m_rectSrc.left / texsize.width;
		m_fRight	= (float)m_rectSrc.right / texsize.width;
		m_fTop		= (float)m_rectSrc.top / texsize.height;
		m_fBottom	= (float)m_rectSrc.bottom / texsize.height;
	}
	else
	{
		KSize texsize;
		texsize.width = m_spTexture->GetWidth();
		texsize.height = m_spTexture->GetHeight();

		m_fSizeX = static_cast<float>(texsize.width);
		m_fSizeY = static_cast<float>(texsize.height);

		m_rectSrc = KRect( 0, 0, texsize.width, texsize.height );
		m_fLeft = m_fTop = .0f;
		m_fRight = m_fBottom = 1.0f;
	}
}
void KResSprite::AddNote( const char *note )
{
	m_sNote.push_back( note );
}
int KResSprite::GetNoteCount()
{
	return static_cast<int>(m_sNote.size());
}
LPCSTR KResSprite::GetNote( int index )
{
	return m_sNote[index].c_str();
}
void KResSprite::SetMirror( bool h, bool v )
{
	m_bMirrorH = h; m_bMirrorV = v;
}
void KResSprite::SetCWRotation(bool r)
{
	m_bCWRotation = r;
}
void KResSprite::SetCCWRotation(bool r)
{
	m_bCCWRotation = r;
}
bool KResSprite::IsCWRotate()
{
	return m_bCWRotation;
}
bool KResSprite::IsCCWRotate()
{
	return m_bCCWRotation;
}
void KResSprite::SetAdditiveRenderMode( bool useAdditive )
{
	m_bUseAdditive = useAdditive;
}
bool KResSprite::IsAdditiveRenderMode()
{
	return m_bUseAdditive;
}
bool KResSprite::IsMirrorHori()
{
	return m_bMirrorH;
}
bool KResSprite::IsMirrorVert()
{
	return m_bMirrorV;
}
void KResSprite::SetOffset( const K3DPoint &offset )
{
	m_ptOffset = offset;
}
void KResSprite::GetSourceUVRect( float &left, float &top, float &right, float &bottom )
{
	left = m_fLeft; top = m_fTop; right = m_fRight; bottom = m_fBottom;
}
float KResSprite::GetSizeX()
{
	return m_fSizeX;
}
float KResSprite::GetSizeY()
{
	return m_fSizeY;
}
void KResSprite::SetSize( float cx, float cy )
{
	m_fSizeX = cx;
	m_fSizeY = cy;
}

K3DTexture* KResSprite::GetTexture()
{
	return m_spTexture;
}
const KRect& KResSprite::GetSourceRect()
{
	return m_rectSrc;
}
const K3DPoint& KResSprite::GetOffset()
{
	return m_ptOffset;
}
bool KResSprite::Reload()
{
	return true;
}
void KResSprite::SetTransform( const K3DMatrix &mat )
{
	m_matTransform = mat;
}
const K3DMatrix& KResSprite::GetTransform()
{
	return m_matTransform;
}
void KResSprite::SetVisibility( float vis )
{
	m_fVisibility = vis;
}
float KResSprite::GetVisibility()
{
	return m_fVisibility;
}

int KResSprite::GetBoundBoxSize() 
{
	return static_cast<int>(m_vtBoundBox.size());
}

KResSprite::KSpriteBoundBox & KResSprite::GetBoundBox(int nIndex)
{
	if(nIndex < 0 || nIndex >= (int)m_vtBoundBox.size() )
	{
		{ assert(false && "Error on Index"); }
	}

	return m_vtBoundBox.at(nIndex);
}

void KResSprite::PushBoundBox(KResSprite::KSpriteBoundBox & cBoundBox)
{
	m_vtBoundBox.push_back(cBoundBox);
}
KResSprite::KSpriteBoundBox::KSpriteBoundBox() 
{
}
KResSprite::KSpriteBoundBox::KSpriteBoundBox(LPCSTR lpszName, KRect & rcArea)
{
	m_sBoxName = lpszName;
	m_rcArea = rcArea;
}
KResSprite::KSpriteBoundBox::KSpriteBoundBox(const KSpriteBoundBox & rhs) 
{
	_Copy(rhs);
}

KResSprite::KSpriteBoundBox & KResSprite::KSpriteBoundBox::operator=(const KSpriteBoundBox & rhs)
{
	_Copy(rhs);
	return *this;
}
bool KResSprite::KSpriteBoundBox::operator<(KSpriteBoundBox & rhs) const
{
	return this->m_sBoxName < rhs.m_sBoxName;
}
KRect KResSprite::KSpriteBoundBox::GetRect() 
{ 
	return m_rcArea; 
}
void KResSprite::KSpriteBoundBox::_Copy(const KSpriteBoundBox & rhs)
{
	m_sBoxName = rhs.m_sBoxName;
	m_rcArea = rhs.m_rcArea;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// KResSpriteAnimation Implement
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
KResSpriteAnimation::KResSpriteAnimation()
{
	m_type    = RESTYPE_SPRITEANIMATION;
	m_bIsLoad = false;
	m_bEncrypt = false; 
	m_bUseColorKey = false;
	m_ColorKey = KColor( 0,0,0 );
}
KResSpriteAnimation::~KResSpriteAnimation()	
{
	//_LEAK_SUN
	ClearFrame();
	m_vtTrack.clear();
}

KResSpriteAnimation::Key::Key()
{
	time = 0;
}

bool KResSpriteAnimation::Key::operator<( const Key &target ) const
{
	return time < target.time;
}
const KInterval& KResSpriteAnimation::GetInterval()
{
	return m_keys.GetInterval();
}
void KResSpriteAnimation::SetKeyCount( int count )
{
	m_keys.SetKeyCount( count );
}

void KResSpriteAnimation::SetKey( int index, Key *key, int count)
{
	m_keys.SetKey( index, key, count );
}

void KResSpriteAnimation::SetWholeKey( Key *key, int count )
{
	m_keys.SetWholeKey( key, count );
}

int KResSpriteAnimation::GetKeyCount()
{
	return m_keys.GetKeyCount();
}
void KResSpriteAnimation::GetData( int time, Key*& key1, Key*& key2 )
{
	m_keys.GetData( time, key1, key2 );
}
bool KResSpriteAnimation::Reload()
{
	return true;
}
int KResSpriteAnimation::GetIndexNumber(DWORD dwTime)
{
	return m_keys.GetIndexNumber(dwTime);
}

void KResSpriteAnimation::AddTrack(const Track & trackData)
{
	m_vtTrack.push_back(trackData);
}
DWORD KResSpriteAnimation::GetTrackSize()
{
	return static_cast<DWORD>(m_vtTrack.size());
}
KResSpriteAnimation::Track & KResSpriteAnimation::GetTrack(int nIndeX)
{
	return m_vtTrack.at(nIndeX);
}

KResSprite * KResSpriteAnimation::GetSpriteByFrame(int nFrame)
{
	if(nFrame < 0 || nFrame >= m_keys.GetKeyCount() )
		return NULL;

	return m_keys.GetKey(nFrame).spSprite;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// KResFXBillboard Implement
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
KResFXBillboard::KResFXBillboard()
{
	m_type		= RESTYPE_FXBILLBOARD;
}

KResFXBillboard::~KResFXBillboard()
{
}

void KResFXBillboard::SetTexture( K3DTexture *pTex)
{
	m_spTex = pTex;

}
void KResFXBillboard::SetVertices( K3DVertex *vtxs )
{
	memcpy( m_vtxBillBoard, vtxs, sizeof(m_vtxBillBoard) );
}
const K3DVertex* KResFXBillboard::GetVertices()
{
	return m_vtxBillBoard;
}
void KResFXBillboard::SetRes( K3DResMeshMatrixAnimation *pResMat, K3DResMeshVisibilityAnimation *pResVis)
{
	assert(m_spResMat == NULL && m_spResVis == NULL);

	m_spResMat = pResMat;

	if(m_spResMat != NULL)
	{
		m_interval = m_spResMat->GetInterval();
	}

	m_spResVis = pResVis;
}
const KInterval &KResFXBillboard::GetInterval()
{
	return m_interval;
}
K3DTexture *KResFXBillboard::GetTexture()
{
	return m_spTex;
}
void KResFXBillboard::GetData( int time, float *vis, K3DMatrix *mat )
{
	if(m_spResMat != NULL)
	{
		m_spResMat->GetLerpMatrix(time, mat);
	}

	if(m_spResVis != NULL)
	{
		m_spResVis->GetVisibility(time, vis);
	}
	else
	{
		*vis = 1.0f;
	}
}
bool KResFXBillboard::Reload()
{
	return true;
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// KResFXParticle Implement
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

KResFXParticle::KResFXParticle()
{
	m_type = RESTYPE_FXPARTICLE;
}

KResFXParticle::~KResFXParticle()
{
}

void KResFXParticle::SetTexture( K3DTexture *pTex )
{
	m_spTex = pTex;
}

void KResFXParticle::SetRes( K3DResMeshMatrixAnimation *pResMat, K3DResMeshVisibilityAnimation *pResVis)
{
	assert(m_spResVis == NULL && m_spResMat == NULL);

	m_spResMat = pResMat;
	
	if(m_spResMat != NULL)
	{
		m_interval = m_spResMat->GetInterval();
	}
	
	m_spResVis = pResVis;

}

const KInterval& KResFXParticle::GetInterval()
{
	return m_interval;
}

K3DTexture* KResFXParticle::GetTexture()
{ 
	return m_spTex; 
}

void KResFXParticle::SetVertices( K3DVertex *vtxs )				
{ 
	memcpy( m_vtxBillBoard, vtxs, sizeof(m_vtxBillBoard) );	
}

const K3DVertex* KResFXParticle::GetVertices()			
{ 
	return m_vtxBillBoard; 
}

void KResFXParticle::CalcNormal( K3DVertex* vtxs )
{
	K3DVector v1( vtxs[ 1 ] - vtxs[ 0 ] );
	K3DVector v2( vtxs[ 2 ] - vtxs[ 0 ] );

	K3DVectorCross( m_vecNormal, v1, v2 );
	m_vecNormal.Normalize();
}

const K3DVector& KResFXParticle::GetNormal()
{
	return m_vecNormal;
}

void KResFXParticle::GetData( int time, float *vis, K3DMatrix *mat )
{
	if ( m_spResMat != NULL)
	{
		m_spResMat->GetLerpMatrix(time, mat);
	}

	if ( m_spResVis != NULL)
	{
		m_spResVis->GetVisibility(time, vis);
	}
	else
	{
		*vis = 1.0f;
	}

}

bool KResFXParticle::Reload()
{
	return true;
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// KResFXAfterImage Implement
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

KResFXAfterImage::KResFXAfterImage()
{
	m_type = RESTYPE_FXAFTERIMAGE;
}
KResFXAfterImage::~KResFXAfterImage()
{
}
void KResFXAfterImage::SetTexture( K3DTexture *pTex )
{
	m_spTex = pTex;
}
void KResFXAfterImage::SetVertices( K3DVertex *vtxs )
{
	memcpy( m_vtxAfterImage, vtxs, sizeof(m_vtxAfterImage) );
}
const K3DVertex *KResFXAfterImage::GetVertices()
{
	return m_vtxAfterImage;
}

void KResFXAfterImage::SetRes( K3DResMeshMatrixAnimation *pMatRes, K3DResMeshVisibilityAnimation *pVisRes)
{
	assert(m_spResMat == NULL && m_spResVis == NULL);

	m_spResMat = pMatRes;

	if ( m_spResMat != NULL )
	{
		m_interval = m_spResMat->GetInterval();
	}

	m_spResVis = pVisRes;
}
const KInterval &KResFXAfterImage::GetInterval()
{
	return m_interval;
}
K3DTexture *KResFXAfterImage::GetTexture()
{
	return m_spTex;
}

void KResFXAfterImage::GetData( int time, K3DSPRITEVERTEX& vtx0, K3DSPRITEVERTEX& vtx1, const K3DMatrix& matParent, float& vis )
{
	static K3DMatrix mat;
	
	if ( m_spResMat != NULL)
	{
		m_spResMat->GetLerpMatrix(time, &mat);
	}

	if ( m_spResVis != NULL)
	{
		m_spResVis->GetVisibility(time, &vis);
	}
	else
	{
		vis = 1.0f;
	}
	
	K3DVectorTransform(vtx0.pos, m_vtxAfterImage[0], mat );
	K3DVectorTransform(vtx1.pos, m_vtxAfterImage[2], mat );
	vtx0.diffuse = KColor(255,255,255,unsigned char( 255 * vis ));
	vtx1.diffuse = KColor(255,255,255,unsigned char( 255 * vis ));	
}

bool KResFXAfterImage::Reload()
{
	return true;
}