#include "stdafx.h"
#include ".\kseqloadingscreen.h"
#include "KResourceManager.h"
#include "KViewport.h"
#include <math.h>


int Randomize(int nMin, int nMax)
{
  if(nMin == nMax) return nMin;
  return ((rand() % (abs(nMax - nMin) + 1)) + nMin);
}

float Randomize(float fMin, float fMax)
{
  if(fMin == fMax) return fMin;
  float fRandom = (float) rand() / (float) RAND_MAX;
  return ((fRandom * (float) fabsf(fMax - fMin)) + fMin);
}

// KSeqLoadingScreen

//KSeqLoadingScreen::KSeqLoadingScreen(void) : m_pTexture(NULL), m_Tiles(NULL), m_pRenderDevice(NULL), m_numTilesInARow(0), m_numTilesInAColumn(0)
KSeqLoadingScreen::KSeqLoadingScreen() : m_pTexture(NULL), m_Tiles(NULL), m_numTilesInARow(0), m_numTilesInAColumn(0)
{
}

KSeqLoadingScreen::~KSeqLoadingScreen()
{
	//SAFE_RELEASE(m_pTexture);
	Destroy();
	//KTextureManager::GetManager()->RemoveTexture(m_pTexture);
	//SAFE_DELETE_ARRAY(m_Tiles);
}

void KSeqLoadingScreen::Destroy()
{
	KTextureManager::GetManager()->RemoveTexture(m_pTexture);
	m_pTexture = NULL;

	SAFE_DELETE_ARRAY(m_Tiles);

	m_numTilesInARow = 0;
	m_numTilesInAColumn = 0;
}

bool KSeqLoadingScreen::LoadTexture(const char* pszTexFile)
{
	//SAFE_RELEASE(m_pTexture);
	KTextureManager::GetManager()->RemoveTexture(m_pTexture);

	NX3LoadPack loadpack;
	K3DTexture* pTexture = KTextureManager::GetManager()->GetTexture( pszTexFile, &loadpack, true, KTextureManager::GetManager()->GetMipMapBiasLevel() );
	if(!pTexture)
	{
		_oprint( "Can't load this texture file : %s\n", "LoadTexture()" );
		return false;
	}

	for(int i = 0; i < m_numTilesInAColumn * m_numTilesInARow; i++)
	{
		m_Tiles[i].SetTexture(pTexture);
	}

	m_pTexture = pTexture;

	return true;
}

void KSeqLoadingScreen::SetTexture(K3DTexture* pTexture)
{
	m_pTexture = pTexture;

	for(int i = 0; i < m_numTilesInAColumn * m_numTilesInARow; i++)
	{
		m_Tiles[i].SetTexture(pTexture);
	}
}

void KSeqLoadingScreen::Render( KViewportObject *viewport, DWORD flag, const K3DMatrix * pAttachMat)
{
	//if(!m_pRenderDevice || !m_pTexture) return;
	if(!m_pTexture) return;

	for(int i = 0; i < m_numTilesInAColumn; i++)
	{
		for(int j= 0; j < m_numTilesInARow; j++)
		{
			//m_Tiles[i * m_numTilesInARow + j].Render(viewport, m_pRenderDevice);
			viewport->Register(&m_Tiles[i * m_numTilesInARow + j]);
		}
	}
}

int KSeqLoadingScreen::Process( DWORD dwTime )
{
	if(!m_Tiles) return 0;

	return 1;
}

void KSeqLoadingScreen::StartAnimation(DWORD dwTime)
{
	// do nothing
}

void KSeqLoadingScreen::SetupTiles(KTilePrimitive::STileVertex min, KTilePrimitive::STileVertex max, int numTilesInARow, int numTilesInAColumn)
//void KSeqLoadingScreen::SetupTiles(STileVertex min, STileVertex max, int numTilesInARow, int numTilesInAColumn)
{
	if(m_Tiles) SAFE_DELETE_ARRAY(m_Tiles);

	m_numTilesInARow = (numTilesInARow > 0) ? numTilesInARow : 1;
	m_numTilesInAColumn = (numTilesInAColumn > 0) ? numTilesInAColumn : 1;

	m_Tiles = new KTilePrimitive[numTilesInARow * numTilesInAColumn];
	if(!m_Tiles) return;
    
	float incX, incY, incZ, incW, incU, incV, incR, incG, incB, incA;

	incX = (max.x - min.x) / numTilesInARow;
	incY = (max.y - min.y) / numTilesInAColumn;
	incZ = (max.z - min.z) / numTilesInARow;
	//incY = (max.y - min.y) / numTilesInARow;
	//incZ = (max.z - min.z) / numTilesInAColumn;
	incW = (max.w - min.w) / numTilesInARow;
	incU = (max.u - min.u) / numTilesInARow;
	incV = (max.v - min.v) / numTilesInAColumn;
	incR = (float) (max.color.r - min.color.r) / numTilesInARow;
	incG = (float) (max.color.g - min.color.g) / numTilesInARow;
	incB = (float) (max.color.b - min.color.b) / numTilesInARow;
	incA = (float) (max.color.a - min.color.a) / numTilesInARow;
    
	float startX, startY, startZ, startW, startU, startV;
	BYTE startR, startG, startB, startA;

	startX = min.x;
	startY = min.y;
	startZ = min.z;
	startW = min.w;
	startU = min.u;
	startV = min.v;
	startR = min.color.r;
	startG = min.color.g;
	startB = min.color.b;
	startA = min.color.a;

	for(int i = 0; i < numTilesInAColumn; i++)
	{
		for(int j = 0; j < numTilesInARow; j++)
		{
			KTilePrimitive::STileVertex minForThisTile, maxForThisTile;

			minForThisTile.x = incX * j + startX;
			minForThisTile.y = incY * i + startY;
			minForThisTile.z = incZ * j + startZ;
			//minForThisTile.y = incY * j + startY;
			//minForThisTile.z = incZ * i + startZ;
			minForThisTile.w = incW * j + startW;
			minForThisTile.u = incU * j + startU;
			minForThisTile.v = incV * i + startV;
			minForThisTile.color.r = (BYTE) (incR * (float) j) + startR;
			minForThisTile.color.g = (BYTE) (incG * (float) j) + startG;
			minForThisTile.color.b = (BYTE) (incB * (float) j) + startB;
			minForThisTile.color.a = (BYTE) (incA * (float) j) + startA;
	
			maxForThisTile.x = incX * (j + 1) + startX;
			maxForThisTile.y = incY * (i + 1) + startY;
			maxForThisTile.z = incZ * (j + 1) + startZ;
			//maxForThisTile.y = incY * (j + 1) + startY;
			//maxForThisTile.z = incZ * (i + 1) + startZ;
			maxForThisTile.w = incW * (j + 1) + startW;
			maxForThisTile.u = incU * (j + 1) + startU;
			maxForThisTile.v = incV * (i + 1) + startV;
			maxForThisTile.color.r = (BYTE) (incR * (float) (j + 1)) + startR;
			maxForThisTile.color.g = (BYTE) (incG * (float) (j + 1)) + startG;
			maxForThisTile.color.b = (BYTE) (incB * (float) (j + 1)) + startB;
			maxForThisTile.color.a = (BYTE) (incA * (float) (j + 1)) + startA;

            m_Tiles[i * numTilesInARow + j].SetupVerts(minForThisTile, maxForThisTile);
		}
	}
}

void KSeqLoadingScreen::ResetTiles(KTilePrimitive::STileVertex min, KTilePrimitive::STileVertex max)
{
	if(m_numTilesInARow == 0 || m_numTilesInAColumn == 0) return;

	float incX, incY, incZ, incW, incU, incV, incR, incG, incB, incA;

	incX = (max.x - min.x) / m_numTilesInARow;
	incY = (max.y - min.y) / m_numTilesInAColumn;
	incZ = (max.z - min.z) / m_numTilesInARow;
	incW = (max.w - min.w) / m_numTilesInARow;
	incU = (max.u - min.u) / m_numTilesInARow;
	incV = (max.v - min.v) / m_numTilesInAColumn;
	incR = (float) (max.color.r - min.color.r) / m_numTilesInARow;
	incG = (float) (max.color.g - min.color.g) / m_numTilesInARow;
	incB = (float) (max.color.b - min.color.b) / m_numTilesInARow;
	incA = (float) (max.color.a - min.color.a) / m_numTilesInARow;

	float startX, startY, startZ, startW, startU, startV;
	BYTE startR, startG, startB, startA;

	startX = min.x;
	startY = min.y;
	startZ = min.z;
	startW = min.w;
	startU = min.u;
	startV = min.v;
	startR = min.color.r;
	startG = min.color.g;
	startB = min.color.b;
	startA = min.color.a;

	for(int i = 0; i < m_numTilesInAColumn; i++)
	{
		for(int j = 0; j < m_numTilesInARow; j++)
		{
			KTilePrimitive::STileVertex minForThisTile, maxForThisTile;

			minForThisTile.x = incX * j + startX;
			minForThisTile.y = incY * i + startY;
			minForThisTile.z = incZ * j + startZ;
			minForThisTile.w = incW * j + startW;
			minForThisTile.u = incU * j + startU;
			minForThisTile.v = incV * i + startV;
			minForThisTile.color.r = (BYTE) (incR * (float) j) + startR;
			minForThisTile.color.g = (BYTE) (incG * (float) j) + startG;
			minForThisTile.color.b = (BYTE) (incB * (float) j) + startB;
			minForThisTile.color.a = (BYTE) (incA * (float) j) + startA;
	
			maxForThisTile.x = incX * (j + 1) + startX;
			maxForThisTile.y = incY * (i + 1) + startY;
			maxForThisTile.z = incZ * (j + 1) + startZ;
			maxForThisTile.w = incW * (j + 1) + startW;
			maxForThisTile.u = incU * (j + 1) + startU;
			maxForThisTile.v = incV * (i + 1) + startV;
			maxForThisTile.color.r = (BYTE) (incR * (float) (j + 1)) + startR;
			maxForThisTile.color.g = (BYTE) (incG * (float) (j + 1)) + startG;
			maxForThisTile.color.b = (BYTE) (incB * (float) (j + 1)) + startB;
			maxForThisTile.color.a = (BYTE) (incA * (float) (j + 1)) + startA;

            m_Tiles[i * m_numTilesInARow + j].SetupVerts(minForThisTile, maxForThisTile);
		}
	}
}


// KSeqScreenTransition

KSeqScreenTransition::KSeqScreenTransition()
{
	KSeqLoadingScreen::KSeqLoadingScreen();
	
	m_dwStartTime = 0;
	m_dwLife = 1000;
}

KSeqScreenTransition::~KSeqScreenTransition()
{
	Destroy();
}

void KSeqScreenTransition::Destroy()
{
	KSeqLoadingScreen::Destroy();

	m_dwStartTime = 0;
	m_dwLife = 1000;
}
/*
int KSeqScreenTransition::Process( DWORD dwTime )
{
	if(!m_Tiles) return 0;
	//int nRet = KSeqLoadingScreen::Process(dwTime);
	//if(!nRet) return 0;

	if(m_dwStartTime == 0) return 0;

	DWORD dwElapsedTime = (dwTime - m_dwStartTime);
	float fAniTime = (float) dwElapsedTime / (float) m_dwLife;
	if(fAniTime >= 1.0f)
	{
		Destroy();
		return 0;
	}

	return 1;
}
*/
void KSeqScreenTransition::StartAnimation(DWORD dwTime)
{
	m_dwStartTime = dwTime;
}
/*
void KSeqScreenTransition::SetupTiles(KTilePrimitive::STileVertex min, KTilePrimitive::STileVertex max, int numTilesInARow, int numTilesInAColumn)
{
	KSeqLoadingScreen::SetupTiles(min, max, numTilesInARow, numTilesInAColumn);
}
*/

// KSeqDissolveScreen

//KSeqDissolveScreen::KSeqDissolveScreen() : m_pTexture(NULL), m_Tiles(NULL), m_numTilesInARow(0), m_numTilesInAColumn(0), m_dwStartTime(0), m_dwElapsedTime(0)
KSeqDissolveScreen::KSeqDissolveScreen()
{
	KSeqScreenTransition::KSeqScreenTransition();
	
	//m_dwStartTime = 0;
	//m_dwElapsedTime = 0;
	//m_dwLife = 1000;
}

KSeqDissolveScreen::~KSeqDissolveScreen()
{
	//SAFE_RELEASE(m_pTexture);
	//KTextureManager::GetManager()->RemoveTexture(m_pTexture);
	//SAFE_DELETE_ARRAY(m_Tiles);
/*	
	KSeqLoadingScreen::~KSeqLoadingScreen();
	
	m_dwStartTime = 0;
	//m_dwElapsedTime = 0;
	m_dwLife = 1000;
	*/
	Destroy();
}

void KSeqDissolveScreen::Destroy()
{
	/*KTextureManager::GetManager()->RemoveTexture(m_pTexture);
	m_pTexture = NULL;

	SAFE_DELETE_ARRAY(m_Tiles);

	m_numTilesInARow = 0;
	m_numTilesInAColumn = 0;
*/
	KSeqScreenTransition::Destroy();

	//m_dwStartTime = 0;
	//m_dwLife = 1000;
}

int KSeqDissolveScreen::Process( DWORD dwTime )
{
	if(!m_Tiles) return 0;
	if(m_dwStartTime == 0) return 0;

	//m_dwElapsedTime += (dwTime - m_dwStartTime);
	DWORD dwElapsedTime = (dwTime - m_dwStartTime);
	//float fAniTime = (float) m_dwElapsedTime / (float) m_dwLife;
	float fAniTime = (float) dwElapsedTime / (float) m_dwLife;
	if(fAniTime >= 1.0f)
	{
		Destroy();
		return 0;
	}

	//int nRet = KSeqScreenTransition::Process(dwTime);
	//if(!nRet) return 0;

	for(int i = 0; i < m_numTilesInARow * m_numTilesInAColumn; i++)
	{
		for(int j= 0; j < 4; j++)
		{
            m_Tiles[i].m_Verts[j].color.a = 255 - (BYTE) ((float) 255 * fAniTime);
		}
	}

	return 1;
}
/*
void KSeqDissolveScreen::StartAnimation(DWORD dwTime)
{
	m_dwStartTime = dwTime;
	//m_dwElapsedTime = 0;
}
*/
void KSeqDissolveScreen::SetupTiles(KTilePrimitive::STileVertex min, KTilePrimitive::STileVertex max, int numTilesInARow, int numTilesInAColumn)
{
	//KSeqScreenTransition::SetupTiles(min, max, 1, 1);	// 한개의 타일만 허용
	KSeqLoadingScreen::SetupTiles(min, max, 1, 1);	// 한개의 타일만 허용
}
/*
void KSeqDissolveScreen::ResetTiles(KTilePrimitive::STileVertex min, KTilePrimitive::STileVertex max)
{
	ScreenTransition::ResetTiles(min, max);
}
*/


// KSeqWipeScreen


//KSeqWipeScreen::KSeqWipeScreen() : m_pTexture(NULL), m_Tiles(NULL), m_numTilesInARow(0), m_numTilesInAColumn(0), m_dwStartTime(0), m_dwElapsedTime(0)
KSeqWipeScreen::KSeqWipeScreen()
{
	KSeqScreenTransition::KSeqScreenTransition();
	
	//m_dwStartTime = 0;
	//m_dwElapsedTime = 0;
	//m_dwLife = 1000;
}

KSeqWipeScreen::~KSeqWipeScreen()
{
	//SAFE_RELEASE(m_pTexture);
	//KTextureManager::GetManager()->RemoveTexture(m_pTexture);
	//SAFE_DELETE_ARRAY(m_Tiles);
/*	
	KSeqScreenTransition::~KSeqScreenTransition();

	m_dwStartTime = 0;
	//m_dwElapsedTime = 0;
	m_dwLife = 1000;
	*/
	Destroy();
}

void KSeqWipeScreen::Destroy()
{	
	KSeqScreenTransition::Destroy();

	//m_dwStartTime = 0;
	//m_dwLife = 1000;
}

int KSeqWipeScreen::Process( DWORD dwTime )
{
	if(!m_Tiles) return 0;
	if(m_dwStartTime == 0) return 0;

	DWORD dwElapsedTime = (dwTime - m_dwStartTime);
	float fAniTime = (float) dwElapsedTime / (float) m_dwLife;
	if(fAniTime >= 1.0f)
	{
		Destroy();
		return 0;
	}

//	int nRet = KSeqScreenTransition::Process(dwTime);
//	if(!nRet) return 0;

	//static float fMinX = m_Tiles[0].m_Verts[0].x;
	//static float fMaxX = m_Tiles[0].m_Verts[1].x;
	for(int i = 0; i < m_numTilesInARow * m_numTilesInAColumn; i++)
	{
		//for(int j= 0; j < 4; j++)
		{
            //m_Tiles[i].m_Verts[j].color.a = 255 - (BYTE) ((float) 255 * fAniTime);
			float fMinX = m_Tiles[i].m_Min.x;
			float fMaxX = m_Tiles[i].m_Max.x;

			m_Tiles[i].m_Verts[0].x = fMinX + (fMaxX - fMinX) * fAniTime;
			m_Tiles[i].m_Verts[1].x = fMaxX + (fMaxX - fMinX) * fAniTime;
			m_Tiles[i].m_Verts[2].x = fMaxX + (fMaxX - fMinX) * fAniTime;
			m_Tiles[i].m_Verts[3].x = fMinX + (fMaxX - fMinX) * fAniTime;
		}
	}

	return 1;
}
/*
void KSeqWipeScreen::StartAnimation(DWORD dwTime)
{
	m_dwStartTime = dwTime;
	//m_dwElapsedTime = 0;
}
*/
void KSeqWipeScreen::SetupTiles(KTilePrimitive::STileVertex min, KTilePrimitive::STileVertex max, int numTilesInARow, int numTilesInAColumn)
{
	//KSeqScreenTransition::SetupTiles(min, max, 1, 1);	// 1개의 타일만 허용
	KSeqLoadingScreen::SetupTiles(min, max, 1, 1);	// 1개의 타일만 허용
}
/*
void KSeqWipeScreen::ResetTiles(KTilePrimitive::STileVertex min, KTilePrimitive::STileVertex max)
{
	KSeqScreenTransition::ResetTiles(min, max);
}
*/


// KSeqBlindScreen

KSeqBlindScreen::KSeqBlindScreen()
{
	KSeqScreenTransition::KSeqScreenTransition();
	
	//m_dwStartTime = 0;
	//m_dwLife = 1000;
}

KSeqBlindScreen::~KSeqBlindScreen()
{
/*	KSeqScreenTransition::~KSeqScreenTransition();

	m_dwStartTime = 0;
	m_dwLife = 1000;
	*/
	Destroy();
}

void KSeqBlindScreen::Destroy()
{	
	KSeqScreenTransition::Destroy();

	//m_dwStartTime = 0;
	//m_dwLife = 1000;
}

int KSeqBlindScreen::Process( DWORD dwTime )
{
	if(!m_Tiles) return 0;
	if(m_dwStartTime == 0) return 0;

	DWORD dwElapsedTime = (dwTime - m_dwStartTime);
	float fAniTime = (float) dwElapsedTime / (float) m_dwLife;
	if(fAniTime >= 1.0f)
	{
		Destroy();
		return 0;
	}

//	int nRet = KSeqScreenTransition::Process(dwTime);
//	if(!nRet) return 0;

	for(int i = 0; i < m_numTilesInARow * m_numTilesInAColumn; i++)
	{
		//for(int j= 0; j < 4; j++)
		{
            //m_Tiles[i].m_Verts[j].color.a = 255 - (BYTE) ((float) 255 * fAniTime);
			float fMinX = m_Tiles[i].m_Min.x;
			float fMaxX = m_Tiles[i].m_Max.x;

			m_Tiles[i].m_Verts[0].x = fMinX + (fMaxX - fMinX) * fAniTime * 0.5f;
			m_Tiles[i].m_Verts[1].x = fMaxX - (fMaxX - fMinX) * fAniTime * 0.5f;
			m_Tiles[i].m_Verts[2].x = fMaxX - (fMaxX - fMinX) * fAniTime * 0.5f;
			m_Tiles[i].m_Verts[3].x = fMinX + (fMaxX - fMinX) * fAniTime * 0.5f;
		}
	}

	return 1;
}
/*
void KSeqBlindScreen::StartAnimation(DWORD dwTime)
{
	m_dwStartTime = dwTime;
}
*/
void KSeqBlindScreen::SetupTiles(KTilePrimitive::STileVertex min, KTilePrimitive::STileVertex max, int numTilesInARow, int numTilesInAColumn)
{
	numTilesInAColumn = 1;

	//KSeqScreenTransition::SetupTiles(min, max, numTilesInARow, numTilesInAColumn);
	KSeqLoadingScreen::SetupTiles(min, max, numTilesInARow, numTilesInAColumn);
}
/*
void KSeqBlindScreen::ResetTiles(KTilePrimitive::STileVertex min, KTilePrimitive::STileVertex max)
{
	KSeqScreenTransition::ResetTiles(min, max);
}
*/


// KSeqMeltScreen


KSeqMeltScreen::KSeqMeltScreen()
{
	KSeqScreenTransition::KSeqScreenTransition();
	
	//m_dwStartTime = 0;
	m_dwLife = 2000;
	m_fDropSpeeds = NULL;
}

KSeqMeltScreen::~KSeqMeltScreen()
{
	/*KSeqScreenTransition::~KSeqScreenTransition();

	m_dwStartTime = 0;
	m_dwLife = 2000;
	SAFE_DELETE_ARRAY(m_fDropSpeeds);
	*/
	Destroy();
}

void KSeqMeltScreen::Destroy()
{	
	KSeqScreenTransition::Destroy();

	//m_dwStartTime = 0;
	m_dwLife = 2000;
	SAFE_DELETE_ARRAY(m_fDropSpeeds);
}

int KSeqMeltScreen::Process( DWORD dwTime )
{
	if(!m_Tiles) return 0;
	if(m_dwStartTime == 0) return 0;

	DWORD dwElapsedTime = (dwTime - m_dwStartTime);
	float fAniTime = (float) dwElapsedTime / (float) m_dwLife;
	if(fAniTime >= 1.0f)
	{
		Destroy();
		return 0;
	}

//	int nRet = KSeqScreenTransition::Process(dwTime);
//	if(!nRet) return 0;

	for(int i = 0; i < m_numTilesInARow * m_numTilesInAColumn; i++)
	{
		//for(int j= 0; j < 4; j++)
		{
            float fMinY = m_Tiles[i].m_Min.y;
			float fMaxY = m_Tiles[i].m_Max.y;

			m_Tiles[i].m_Verts[0].y = fMinY + (fMaxY - fMinY) * fAniTime * m_fDropSpeeds[i];
			m_Tiles[i].m_Verts[1].y = fMinY + (fMaxY - fMinY) * fAniTime * m_fDropSpeeds[i + 1];
			m_Tiles[i].m_Verts[2].y = fMaxY + (fMaxY - fMinY) * fAniTime * m_fDropSpeeds[i + 1];
			m_Tiles[i].m_Verts[3].y = fMaxY + (fMaxY - fMinY) * fAniTime * m_fDropSpeeds[i];
		}
	}

	return 1;
}
/*
void KSeqMeltScreen::StartAnimation(DWORD dwTime)
{
	m_dwStartTime = dwTime;
}
*/
void KSeqMeltScreen::SetupTiles(KTilePrimitive::STileVertex min, KTilePrimitive::STileVertex max, int numTilesInARow, int numTilesInAColumn)
{
	numTilesInAColumn = 1;

	//KSeqScreenTransition::SetupTiles(min, max, numTilesInARow, numTilesInAColumn);
	KSeqLoadingScreen::SetupTiles(min, max, numTilesInARow, numTilesInAColumn);

	m_fDropSpeeds = new float[numTilesInARow + 1];
	if(!m_fDropSpeeds) return;

	srand(GetTickCount());

	for(int i = 0; i < numTilesInARow + 1; i++)
	{
		int n = rand() % (numTilesInARow + 2);
        //m_fDropSpeeds[i] = (float) (n + numTilesInARow) / ((float) numTilesInARow * 2.0f);
		m_fDropSpeeds[i] = (float) (n + numTilesInARow + 1) / (float) (numTilesInARow + 1);
	}
}


// KSeqShrinkScreen


KSeqShrinkScreen::KSeqShrinkScreen()
{
	KSeqScreenTransition::KSeqScreenTransition();
	
	//m_dwStartTime = 0;
	//m_dwLife = 1000;
//	m_fDropSpeeds = NULL;
}

KSeqShrinkScreen::~KSeqShrinkScreen()
{
	/*KSeqScreenTransition::~KSeqScreenTransition();

	m_dwStartTime = 0;
	m_dwLife = 2000;
	SAFE_DELETE_ARRAY(m_fDropSpeeds);
	*/
	Destroy();
}

void KSeqShrinkScreen::Destroy()
{	
	KSeqScreenTransition::Destroy();

	//m_dwStartTime = 0;
	//m_dwLife = 1000;
//	SAFE_DELETE_ARRAY(m_fDropSpeeds);
}

int KSeqShrinkScreen::Process( DWORD dwTime )
{
	if(!m_Tiles) return 0;
	if(m_dwStartTime == 0) return 0;

	DWORD dwElapsedTime = (dwTime - m_dwStartTime);
	float fAniTime = (float) dwElapsedTime / (float) m_dwLife;
	if(fAniTime >= 1.0f)
	{
		Destroy();
		return 0;
	}

//	int nRet = KSeqScreenTransition::Process(dwTime);
//	if(!nRet) return 0;

	for(int i = 0; i < m_numTilesInARow * m_numTilesInAColumn; i++)
	{
		//for(int j= 0; j < 4; j++)
		{
			float fMinX = m_Tiles[i].m_Min.x;
			float fMaxX = m_Tiles[i].m_Max.x;
            float fMinY = m_Tiles[i].m_Min.y;
			float fMaxY = m_Tiles[i].m_Max.y;

			m_Tiles[i].m_Verts[0].x = fMinX + (fMaxX - fMinX) * fAniTime * 0.5f;
			m_Tiles[i].m_Verts[0].y = fMinY + (fMaxY - fMinY) * fAniTime * 0.5f;
			m_Tiles[i].m_Verts[1].x = fMaxX - (fMaxX - fMinX) * fAniTime * 0.5f;
			m_Tiles[i].m_Verts[1].y = fMinY + (fMaxY - fMinY) * fAniTime * 0.5f;
			m_Tiles[i].m_Verts[2].x = fMaxX - (fMaxX - fMinX) * fAniTime * 0.5f;
			m_Tiles[i].m_Verts[2].y = fMaxY - (fMaxY - fMinY) * fAniTime * 0.5f;
			m_Tiles[i].m_Verts[3].x = fMinX + (fMaxX - fMinX) * fAniTime * 0.5f;
			m_Tiles[i].m_Verts[3].y = fMaxY - (fMaxY - fMinY) * fAniTime * 0.5f;
		}
	}

	return 1;
}
/*
void KSeqShrinkScreen::StartAnimation(DWORD dwTime)
{
	m_dwStartTime = dwTime;
}
*/
void KSeqShrinkScreen::SetupTiles(KTilePrimitive::STileVertex min, KTilePrimitive::STileVertex max, int numTilesInARow, int numTilesInAColumn)
{
//	numTilesInAColumn = 1;

	//KSeqScreenTransition::SetupTiles(min, max, numTilesInARow, numTilesInAColumn);
	KSeqLoadingScreen::SetupTiles(min, max, numTilesInARow, numTilesInAColumn);
/*
	m_fDropSpeeds = new float[numTilesInARow];
	if(!m_fDropSpeeds) return;

	srand(GetTickCount());

	for(int i = 0; i < numTilesInARow; i++)
	{
		int n = rand() % (numTilesInARow + 1);
        //m_fDropSpeeds[i] = (float) (n + numTilesInARow) / ((float) numTilesInARow * 2.0f);
		m_fDropSpeeds[i] = (float) (n + numTilesInARow) / (float) numTilesInARow;
	}
	*/
}


// KSeqSpinAndShrinkScreen


KSeqSpinAndShrinkScreen::KSeqSpinAndShrinkScreen()
{
	KSeqScreenTransition::KSeqScreenTransition();
	
	//m_dwStartTime = 0;
	//m_dwLife = 1000;
	//m_fDropSpeeds = NULL;
	m_fSpinSpeed = 10.0f;
}

KSeqSpinAndShrinkScreen::~KSeqSpinAndShrinkScreen()
{
	/*KSeqScreenTransition::~KSeqScreenTransition();

	m_dwStartTime = 0;
	m_dwLife = 2000;
	SAFE_DELETE_ARRAY(m_fDropSpeeds);
	*/
	Destroy();
}

void KSeqSpinAndShrinkScreen::Destroy()
{	
	KSeqScreenTransition::Destroy();

	//m_dwStartTime = 0;
	//m_dwLife = 1000;
	//SAFE_DELETE_ARRAY(m_fDropSpeeds);
	m_fSpinSpeed = 10.0f;
}

int KSeqSpinAndShrinkScreen::Process( DWORD dwTime )
{
	if(!m_Tiles) return 0;
	if(m_dwStartTime == 0) return 0;

	DWORD dwElapsedTime = (dwTime - m_dwStartTime);
	float fAniTime = (float) dwElapsedTime / (float) m_dwLife;
	if(fAniTime >= 1.0f)
	{
		Destroy();
		return 0;
	}

//	int nRet = KSeqScreenTransition::Process(dwTime);
//	if(!nRet) return 0;

	float fMinX, fMinY, fMaxX, fMaxY;
	float fOriginX, fOriginY;
	float fOldX, fOldY;
	float fNewX, fNewY;
	float fSpinAngle = m_fSpinSpeed * fAniTime;

	for(int i = 0; i < m_numTilesInARow * m_numTilesInAColumn; i++)
	{
		//for(int j= 0; j < 4; j++)
		{
            fMinX = m_Tiles[i].m_Min.x;
			fMaxX = m_Tiles[i].m_Max.x;
            fMinY = m_Tiles[i].m_Min.y;
			fMaxY = m_Tiles[i].m_Max.y;

			fOriginX = (fMinX + fMaxX) * 0.5f;
			fOriginY = (fMinY + fMaxY) * 0.5f;
			
			//m_Tiles[i].m_Verts[0].x = fMinX + (fMaxX - fMinX) * fAniTime * 0.5f;
			//m_Tiles[i].m_Verts[0].y = fMinY + (fMaxY - fMinY) * fAniTime * 0.5f;
			fOldX = fMinX + (fMaxX - fMinX) * fAniTime * 0.5f - fOriginX;
			fOldY = fMinY + (fMaxY - fMinY) * fAniTime * 0.5f - fOriginY;
			fNewX = fOldX * cosf(fSpinAngle) - fOldY * sinf(fSpinAngle);
			fNewY = fOldX * sinf(fSpinAngle) + fOldY * cosf(fSpinAngle);
			m_Tiles[i].m_Verts[0].x = fNewX + fOriginX;
			m_Tiles[i].m_Verts[0].y = fNewY + fOriginY;

			//m_Tiles[i].m_Verts[1].x = fMaxX - (fMaxX - fMinX) * fAniTime * 0.5f;
			//m_Tiles[i].m_Verts[1].y = fMinY + (fMaxY - fMinY) * fAniTime * 0.5f;
			fOldX = fMaxX - (fMaxX - fMinX) * fAniTime * 0.5f - fOriginX;
			fOldY = fMinY + (fMaxY - fMinY) * fAniTime * 0.5f - fOriginY;
			fNewX = fOldX * cosf(fSpinAngle) - fOldY * sinf(fSpinAngle);
			fNewY = fOldX * sinf(fSpinAngle) + fOldY * cosf(fSpinAngle);
			m_Tiles[i].m_Verts[1].x = fNewX + fOriginX;
			m_Tiles[i].m_Verts[1].y = fNewY + fOriginY;

			//m_Tiles[i].m_Verts[2].x = fMaxX - (fMaxX - fMinX) * fAniTime * 0.5f;
			//m_Tiles[i].m_Verts[2].y = fMaxY - (fMaxY - fMinY) * fAniTime * 0.5f;
			fOldX = fMaxX - (fMaxX - fMinX) * fAniTime * 0.5f - fOriginX;
			fOldY = fMaxY - (fMaxY - fMinY) * fAniTime * 0.5f - fOriginY;
			fNewX = fOldX * cosf(fSpinAngle) - fOldY * sinf(fSpinAngle);
			fNewY = fOldX * sinf(fSpinAngle) + fOldY * cosf(fSpinAngle);
			m_Tiles[i].m_Verts[2].x = fNewX + fOriginX;
			m_Tiles[i].m_Verts[2].y = fNewY + fOriginY;

			//m_Tiles[i].m_Verts[3].x = fMinX + (fMaxX - fMinX) * fAniTime * 0.5f;
			//m_Tiles[i].m_Verts[3].y = fMaxY - (fMaxY - fMinY) * fAniTime * 0.5f;
			fOldX = fMinX + (fMaxX - fMinX) * fAniTime * 0.5f - fOriginX;
			fOldY = fMaxY - (fMaxY - fMinY) * fAniTime * 0.5f - fOriginY;
			fNewX = fOldX * cosf(fSpinAngle) - fOldY * sinf(fSpinAngle);
			fNewY = fOldX * sinf(fSpinAngle) + fOldY * cosf(fSpinAngle);
			m_Tiles[i].m_Verts[3].x = fNewX + fOriginX;
			m_Tiles[i].m_Verts[3].y = fNewY + fOriginY;
		}
	}

	return 1;
}
/*
void KSeqSpinAndShrinkScreen::StartAnimation(DWORD dwTime)
{
	m_dwStartTime = dwTime;
}
*/
void KSeqSpinAndShrinkScreen::SetupTiles(KTilePrimitive::STileVertex min, KTilePrimitive::STileVertex max, int numTilesInARow, int numTilesInAColumn)
{
	//numTilesInAColumn = 1;

	//KSeqScreenTransition::SetupTiles(min, max, numTilesInARow, numTilesInAColumn);
	KSeqLoadingScreen::SetupTiles(min, max, numTilesInARow, numTilesInAColumn);
/*
	m_fDropSpeeds = new float[numTilesInARow];
	if(!m_fDropSpeeds) return;

	srand(GetTickCount());

	for(int i = 0; i < numTilesInARow; i++)
	{
		int n = rand() % (numTilesInARow + 1);
        //m_fDropSpeeds[i] = (float) (n + numTilesInARow) / ((float) numTilesInARow * 2.0f);
		m_fDropSpeeds[i] = (float) (n + numTilesInARow) / (float) numTilesInARow;
	}*/
}


// KSeqWarpDissolveScreen

KSeqWarpDissolveScreen::KSeqWarpDissolveScreen()
{
	KSeqScreenTransition::KSeqScreenTransition();

	m_dwLife = 3000;
	m_fWarpCoefficient = 0.2f;
	m_fDeltaUs = NULL;
	m_fDeltaVs = NULL;
	m_fJiggles = NULL;
}

KSeqWarpDissolveScreen::~KSeqWarpDissolveScreen()
{
	Destroy();
}

void KSeqWarpDissolveScreen::Destroy()
{	
	KSeqScreenTransition::Destroy();

	m_dwLife = 3000;
	m_fWarpCoefficient = 0.2f;

	SAFE_DELETE_ARRAY(m_fDeltaUs);
	SAFE_DELETE_ARRAY(m_fDeltaVs);
	SAFE_DELETE_ARRAY(m_fJiggles);
}

int KSeqWarpDissolveScreen::Process( DWORD dwTime )
{
	if(!m_Tiles) return 0;
	if(m_dwStartTime == 0) return 0;

	DWORD dwElapsedTime = (dwTime - m_dwStartTime);
	float fAniTime = (float) dwElapsedTime / (float) m_dwLife;
	if(fAniTime >= 1.0f)
	{
		Destroy();
		return 0;
	}

	float fWarpX = m_fWarpCoefficient / (float) m_numTilesInARow;
	float fWarpY = m_fWarpCoefficient / (float) m_numTilesInAColumn;
	//float fDeltaU, fDeltaV;

	srand(GetTickCount());

	for(int i = 0; i < (m_numTilesInARow + 1) * (m_numTilesInAColumn + 1); i++)
	{
		m_fDeltaUs[i] = Randomize(-fWarpX, fWarpX);
		m_fDeltaVs[i] = Randomize(-fWarpY, fWarpY);
		m_fJiggles[i] = Randomize(1.0f, 1.0f + m_fWarpCoefficient);
	}

	float fNewAlpha;

	for(int i = 0; i < m_numTilesInAColumn; i++)
	{
		for(int j = 0; j < m_numTilesInARow; j++)
		{
			m_Tiles[i * m_numTilesInARow + j].m_Verts[0].u += m_fDeltaUs[i * m_numTilesInARow + j];
			m_Tiles[i * m_numTilesInARow + j].m_Verts[0].v += m_fDeltaVs[i * m_numTilesInARow + j];
			//if(m_Tiles[i * m_numTilesInARow + j].m_Verts[0].u < 0.0f) m_Tiles[i * m_numTilesInARow + j].m_Verts[0].u = 0.0f;
			//if(m_Tiles[i * m_numTilesInARow + j].m_Verts[0].v < 0.0f) m_Tiles[i * m_numTilesInARow + j].m_Verts[0].v = 0.0f;
			//if(m_Tiles[i * m_numTilesInARow + j].m_Verts[0].u > 1.0f) m_Tiles[i * m_numTilesInARow + j].m_Verts[0].u = 1.0f;
			//if(m_Tiles[i * m_numTilesInARow + j].m_Verts[0].v > 1.0f) m_Tiles[i * m_numTilesInARow + j].m_Verts[0].v = 1.0f;
			fNewAlpha = 1.0f - m_fJiggles[i * m_numTilesInARow + j] * fAniTime;
			if(fNewAlpha < 0.0f) fNewAlpha = 0.0f;
			m_Tiles[i * m_numTilesInARow + j].m_Verts[0].color.a = (BYTE) ((float) 255 * fNewAlpha);

			m_Tiles[i * m_numTilesInARow + j].m_Verts[1].u += m_fDeltaUs[i * m_numTilesInARow + j + 1];
			m_Tiles[i * m_numTilesInARow + j].m_Verts[1].v += m_fDeltaVs[i * m_numTilesInARow + j + 1];
			//if(m_Tiles[i * m_numTilesInARow + j].m_Verts[1].u < 0.0f) m_Tiles[i * m_numTilesInARow + j].m_Verts[1].u = 0.0f;
			//if(m_Tiles[i * m_numTilesInARow + j].m_Verts[1].v < 0.0f) m_Tiles[i * m_numTilesInARow + j].m_Verts[1].v = 0.0f;
			//if(m_Tiles[i * m_numTilesInARow + j].m_Verts[1].u > 1.0f) m_Tiles[i * m_numTilesInARow + j].m_Verts[1].u = 1.0f;
			//if(m_Tiles[i * m_numTilesInARow + j].m_Verts[1].v > 1.0f) m_Tiles[i * m_numTilesInARow + j].m_Verts[1].v = 1.0f;
			fNewAlpha = 1.0f - m_fJiggles[i * m_numTilesInARow + j + 1] * fAniTime;
			if(fNewAlpha < 0.0f) fNewAlpha = 0.0f;
			m_Tiles[i * m_numTilesInARow + j].m_Verts[1].color.a = (BYTE) ((float) 255 * fNewAlpha);

			m_Tiles[i * m_numTilesInARow + j].m_Verts[2].u += m_fDeltaUs[(i + 1) * m_numTilesInARow + j + 1];
			m_Tiles[i * m_numTilesInARow + j].m_Verts[2].v += m_fDeltaVs[(i + 1) * m_numTilesInARow + j + 1];
			//if(m_Tiles[i * m_numTilesInARow + j].m_Verts[2].u < 0.0f) m_Tiles[i * m_numTilesInARow + j].m_Verts[2].u = 0.0f;
			//if(m_Tiles[i * m_numTilesInARow + j].m_Verts[2].v < 0.0f) m_Tiles[i * m_numTilesInARow + j].m_Verts[2].v = 0.0f;
			//if(m_Tiles[i * m_numTilesInARow + j].m_Verts[2].u > 1.0f) m_Tiles[i * m_numTilesInARow + j].m_Verts[2].u = 1.0f;
			//if(m_Tiles[i * m_numTilesInARow + j].m_Verts[2].v > 1.0f) m_Tiles[i * m_numTilesInARow + j].m_Verts[2].v = 1.0f;
			fNewAlpha = 1.0f - m_fJiggles[(i + 1) * m_numTilesInARow + j + 1] * fAniTime;
			if(fNewAlpha < 0.0f) fNewAlpha = 0.0f;
			m_Tiles[i * m_numTilesInARow + j].m_Verts[2].color.a = (BYTE) ((float) 255 * fNewAlpha);

			m_Tiles[i * m_numTilesInARow + j].m_Verts[3].u += m_fDeltaUs[(i + 1) * m_numTilesInARow + j];
			m_Tiles[i * m_numTilesInARow + j].m_Verts[3].v += m_fDeltaVs[(i + 1) * m_numTilesInARow + j];
			//if(m_Tiles[i * m_numTilesInARow + j].m_Verts[3].u < 0.0f) m_Tiles[i * m_numTilesInARow + j].m_Verts[3].u = 0.0f;
			//if(m_Tiles[i * m_numTilesInARow + j].m_Verts[3].v < 0.0f) m_Tiles[i * m_numTilesInARow + j].m_Verts[3].v = 0.0f;
			//if(m_Tiles[i * m_numTilesInARow + j].m_Verts[3].u > 1.0f) m_Tiles[i * m_numTilesInARow + j].m_Verts[3].u = 1.0f;
			//if(m_Tiles[i * m_numTilesInARow + j].m_Verts[3].v > 1.0f) m_Tiles[i * m_numTilesInARow + j].m_Verts[3].v = 1.0f;
			fNewAlpha = 1.0f - m_fJiggles[(i + 1) * m_numTilesInARow + j] * fAniTime;
			if(fNewAlpha < 0.0f) fNewAlpha = 0.0f;
			m_Tiles[i * m_numTilesInARow + j].m_Verts[3].color.a = (BYTE) ((float) 255 * fNewAlpha);
		}
	}

	return 1;
}

void KSeqWarpDissolveScreen::SetupTiles(KTilePrimitive::STileVertex min, KTilePrimitive::STileVertex max, int numTilesInARow, int numTilesInAColumn)
{
	m_fDeltaUs = new float[(numTilesInARow + 1) * (numTilesInAColumn + 1)];
	m_fDeltaVs = new float[(numTilesInARow + 1) * (numTilesInAColumn + 1)];
	m_fJiggles = new float[(numTilesInARow + 1) * (numTilesInAColumn + 1)];
	if(!m_fDeltaUs || !m_fDeltaVs || !m_fJiggles) return;

	KSeqLoadingScreen::SetupTiles(min, max, numTilesInARow, numTilesInAColumn);
}


// KSeqTileTransition

KSeqTileTransition::KSeqTileTransition()
{
	KSeqScreenTransition::KSeqScreenTransition();

	m_Priorities = NULL;
	m_numPriorities = 0;
}

KSeqTileTransition::~KSeqTileTransition()
{
	Destroy();
}

void KSeqTileTransition::Destroy()
{
	KSeqScreenTransition::Destroy();

	SAFE_DELETE_ARRAY(m_Priorities);
	m_numPriorities = 0;
}


// KSeqTileConcentric

KSeqTileConcentric::KSeqTileConcentric()
{
	KSeqTileTransition::KSeqTileTransition();
}

KSeqTileConcentric::~KSeqTileConcentric()
{
	Destroy();
}
/*
int KSeqTileConcentric::Process(DWORD dwTime)
{
	return 1;
}
*/
void KSeqTileConcentric::SetupTiles(KTilePrimitive::STileVertex min, KTilePrimitive::STileVertex max, int numTilesInARow, int numTilesInAColumn)
{
	if(numTilesInARow != numTilesInAColumn)
	{
		(numTilesInARow > numTilesInAColumn) ? (numTilesInAColumn = numTilesInARow) : (numTilesInARow = numTilesInAColumn);	// 둘 중 큰 값으로 통일
	}

	if(numTilesInARow % 2 == 0)
	{
		++numTilesInARow;
		numTilesInAColumn = numTilesInARow;
	}

	KSeqLoadingScreen::SetupTiles(min, max, numTilesInARow, numTilesInAColumn);

	m_numPriorities = numTilesInARow / 2 + 1;
	m_Priorities = new int[numTilesInARow * numTilesInAColumn];

	int center = m_numPriorities - 1;
	int distX, distY;

	for(int i = 0; i < numTilesInAColumn; i++)
	{
		for(int j = 0; j < numTilesInARow; j++)
		{
			distX = abs(j - center);
			distY = abs(i - center);
			int thisPriority = ((distX > distY) ? distX : distY);	// priority 는 0 부터 시작

			m_Priorities[i * numTilesInARow + j] = thisPriority;
		}
	}
}


// KSeqTileWipe

KSeqTileWipe::KSeqTileWipe()
{
	KSeqTileTransition::KSeqTileTransition();
}

KSeqTileWipe::~KSeqTileWipe()
{
	Destroy();
}

void KSeqTileWipe::SetupTiles(KTilePrimitive::STileVertex min, KTilePrimitive::STileVertex max, int numTilesInARow, int numTilesInAColumn)
{
/*	if(numTilesInARow != numTilesInAColumn)
	{
		(numTilesInARow > numTilesInAColumn) ? (numTilesInAColumn = numTilesInARow) : (numTilesInARow = numTilesInAColumn);	// 둘 중 큰 값으로 통일
	}

	if(numTilesInARow % 2 == 0)
	{
		++numTilesInARow;
		numTilesInAColumn = numTilesInARow;
	}
*/
	KSeqLoadingScreen::SetupTiles(min, max, numTilesInARow, numTilesInAColumn);

	m_numPriorities = numTilesInARow;
	m_Priorities = new int[numTilesInARow * numTilesInAColumn];	// 타일 수만큼 할당 (m_numPriorities 만큼이 아님)

	for(int i = 0; i < numTilesInAColumn; i++)
	{
		for(int j = 0; j < numTilesInARow; j++)
		{
			int thisPriority = j;	// priority 는 0 부터 시작

			m_Priorities[i * numTilesInARow + j] = thisPriority;
		}
	}
}

// KSeqSpinShrinkTileConcentric

KSeqSpinShrinkTileConcentric::KSeqSpinShrinkTileConcentric()
{
	KSeqTileConcentric::KSeqTileTransition();
	m_fSpinSpeed = 10.0f;
	m_dwLife = 2000;
}

KSeqSpinShrinkTileConcentric::~KSeqSpinShrinkTileConcentric()
{
	Destroy();
}

void KSeqSpinShrinkTileConcentric::Destroy()
{
	KSeqTileConcentric::Destroy();
	m_fSpinSpeed = 10.0f;
	m_dwLife = 2000;
}

int KSeqSpinShrinkTileConcentric::Process(DWORD dwTime)
{
	if(!m_Tiles) return 0;
	if(m_dwStartTime == 0) return 0;
	if(m_numPriorities <= 0) return 0;

	DWORD dwElapsedTime = (dwTime - m_dwStartTime);
	float fAniTime = (float) dwElapsedTime / (float) m_dwLife;
	if(fAniTime >= 1.0f)
	{
		Destroy();
		return 0;
	}

	float fMinX, fMinY, fMaxX, fMaxY;
	float fOriginX, fOriginY;
	float fOldX, fOldY;
	float fNewX, fNewY;
	float fSpinAngle = m_fSpinSpeed * fAniTime;
	float fLifeForOneTile = 1.0f / (float) m_numPriorities;
	float fStartTimeForThisTile;
	float fAniTimeForThisTile;

	for(int i = 0; i < m_numTilesInARow * m_numTilesInAColumn; i++)
	{
		fStartTimeForThisTile = fLifeForOneTile * (float) m_Priorities[i];		// priority가 0부터 시작이니 맞는 코드
		if((fAniTime < fStartTimeForThisTile) || (fAniTime > fStartTimeForThisTile + fLifeForOneTile)) continue;

		fAniTimeForThisTile = (fAniTime - fStartTimeForThisTile) / fLifeForOneTile;

        fMinX = m_Tiles[i].m_Min.x;
		fMaxX = m_Tiles[i].m_Max.x;
        fMinY = m_Tiles[i].m_Min.y;
		fMaxY = m_Tiles[i].m_Max.y;

		fOriginX = (fMinX + fMaxX) * 0.5f;
		fOriginY = (fMinY + fMaxY) * 0.5f;
		
		fOldX = fMinX + (fMaxX - fMinX) * fAniTimeForThisTile * 0.5f - fOriginX;
		fOldY = fMinY + (fMaxY - fMinY) * fAniTimeForThisTile * 0.5f - fOriginY;
		fNewX = fOldX * cosf(fSpinAngle) - fOldY * sinf(fSpinAngle);
		fNewY = fOldX * sinf(fSpinAngle) + fOldY * cosf(fSpinAngle);
		m_Tiles[i].m_Verts[0].x = fNewX + fOriginX;
		m_Tiles[i].m_Verts[0].y = fNewY + fOriginY;

		fOldX = fMaxX - (fMaxX - fMinX) * fAniTimeForThisTile * 0.5f - fOriginX;
		fOldY = fMinY + (fMaxY - fMinY) * fAniTimeForThisTile * 0.5f - fOriginY;
		fNewX = fOldX * cosf(fSpinAngle) - fOldY * sinf(fSpinAngle);
		fNewY = fOldX * sinf(fSpinAngle) + fOldY * cosf(fSpinAngle);
		m_Tiles[i].m_Verts[1].x = fNewX + fOriginX;
		m_Tiles[i].m_Verts[1].y = fNewY + fOriginY;

		fOldX = fMaxX - (fMaxX - fMinX) * fAniTimeForThisTile * 0.5f - fOriginX;
		fOldY = fMaxY - (fMaxY - fMinY) * fAniTimeForThisTile * 0.5f - fOriginY;
		fNewX = fOldX * cosf(fSpinAngle) - fOldY * sinf(fSpinAngle);
		fNewY = fOldX * sinf(fSpinAngle) + fOldY * cosf(fSpinAngle);
		m_Tiles[i].m_Verts[2].x = fNewX + fOriginX;
		m_Tiles[i].m_Verts[2].y = fNewY + fOriginY;

		fOldX = fMinX + (fMaxX - fMinX) * fAniTimeForThisTile * 0.5f - fOriginX;
		fOldY = fMaxY - (fMaxY - fMinY) * fAniTimeForThisTile * 0.5f - fOriginY;
		fNewX = fOldX * cosf(fSpinAngle) - fOldY * sinf(fSpinAngle);
		fNewY = fOldX * sinf(fSpinAngle) + fOldY * cosf(fSpinAngle);
		m_Tiles[i].m_Verts[3].x = fNewX + fOriginX;
		m_Tiles[i].m_Verts[3].y = fNewY + fOriginY;
	}

	return 1;
}

void KSeqSpinShrinkTileConcentric::SetupTiles(KTilePrimitive::STileVertex min, KTilePrimitive::STileVertex max, int numTilesInARow, int numTilesInAColumn)
{
	KSeqTileConcentric::SetupTiles(min, max, numTilesInARow, numTilesInAColumn);
}


// KSeqSpinShrinkTileWipe

KSeqSpinShrinkTileWipe::KSeqSpinShrinkTileWipe()
{
	KSeqTileWipe::KSeqTileTransition();
	m_fSpinSpeed = 10.0f;
	m_dwLife = 2000;
}

KSeqSpinShrinkTileWipe::~KSeqSpinShrinkTileWipe()
{
	Destroy();
}

void KSeqSpinShrinkTileWipe::Destroy()
{
	KSeqTileWipe::Destroy();
	m_fSpinSpeed = 10.0f;
	m_dwLife = 2000;
}

int KSeqSpinShrinkTileWipe::Process(DWORD dwTime)
{
	if(!m_Tiles) return 0;
	if(m_dwStartTime == 0) return 0;
	if(m_numPriorities <= 0) return 0;

	DWORD dwElapsedTime = (dwTime - m_dwStartTime);
	float fAniTime = (float) dwElapsedTime / (float) m_dwLife;
	if(fAniTime >= 1.0f)
	{
		Destroy();
		return 0;
	}

	float fMinX, fMinY, fMaxX, fMaxY;
	float fOriginX, fOriginY;
	float fOldX, fOldY;
	float fNewX, fNewY;
	float fSpinAngle = m_fSpinSpeed * fAniTime;
	float fLifeForOneTile = 1.0f / (float) m_numPriorities;
	float fStartTimeForThisTile;
	float fAniTimeForThisTile;

	for(int i = 0; i < m_numTilesInARow * m_numTilesInAColumn; i++)
	{
		fStartTimeForThisTile = fLifeForOneTile * (float) m_Priorities[i];		// priority가 0부터 시작이니 맞는 코드
		if((fAniTime < fStartTimeForThisTile) || (fAniTime > fStartTimeForThisTile + fLifeForOneTile)) continue;

		fAniTimeForThisTile = (fAniTime - fStartTimeForThisTile) / fLifeForOneTile;

        fMinX = m_Tiles[i].m_Min.x;
		fMaxX = m_Tiles[i].m_Max.x;
        fMinY = m_Tiles[i].m_Min.y;
		fMaxY = m_Tiles[i].m_Max.y;

		fOriginX = (fMinX + fMaxX) * 0.5f;
		fOriginY = (fMinY + fMaxY) * 0.5f;
		
		fOldX = fMinX + (fMaxX - fMinX) * fAniTimeForThisTile * 0.5f - fOriginX;
		fOldY = fMinY + (fMaxY - fMinY) * fAniTimeForThisTile * 0.5f - fOriginY;
		fNewX = fOldX * cosf(fSpinAngle) - fOldY * sinf(fSpinAngle);
		fNewY = fOldX * sinf(fSpinAngle) + fOldY * cosf(fSpinAngle);
		m_Tiles[i].m_Verts[0].x = fNewX + fOriginX;
		m_Tiles[i].m_Verts[0].y = fNewY + fOriginY;

		fOldX = fMaxX - (fMaxX - fMinX) * fAniTimeForThisTile * 0.5f - fOriginX;
		fOldY = fMinY + (fMaxY - fMinY) * fAniTimeForThisTile * 0.5f - fOriginY;
		fNewX = fOldX * cosf(fSpinAngle) - fOldY * sinf(fSpinAngle);
		fNewY = fOldX * sinf(fSpinAngle) + fOldY * cosf(fSpinAngle);
		m_Tiles[i].m_Verts[1].x = fNewX + fOriginX;
		m_Tiles[i].m_Verts[1].y = fNewY + fOriginY;

		fOldX = fMaxX - (fMaxX - fMinX) * fAniTimeForThisTile * 0.5f - fOriginX;
		fOldY = fMaxY - (fMaxY - fMinY) * fAniTimeForThisTile * 0.5f - fOriginY;
		fNewX = fOldX * cosf(fSpinAngle) - fOldY * sinf(fSpinAngle);
		fNewY = fOldX * sinf(fSpinAngle) + fOldY * cosf(fSpinAngle);
		m_Tiles[i].m_Verts[2].x = fNewX + fOriginX;
		m_Tiles[i].m_Verts[2].y = fNewY + fOriginY;

		fOldX = fMinX + (fMaxX - fMinX) * fAniTimeForThisTile * 0.5f - fOriginX;
		fOldY = fMaxY - (fMaxY - fMinY) * fAniTimeForThisTile * 0.5f - fOriginY;
		fNewX = fOldX * cosf(fSpinAngle) - fOldY * sinf(fSpinAngle);
		fNewY = fOldX * sinf(fSpinAngle) + fOldY * cosf(fSpinAngle);
		m_Tiles[i].m_Verts[3].x = fNewX + fOriginX;
		m_Tiles[i].m_Verts[3].y = fNewY + fOriginY;
	}

	return 1;
}

void KSeqSpinShrinkTileWipe::SetupTiles(KTilePrimitive::STileVertex min, KTilePrimitive::STileVertex max, int numTilesInARow, int numTilesInAColumn)
{
	KSeqTileWipe::SetupTiles(min, max, numTilesInARow, numTilesInAColumn);
}