1317 lines
38 KiB
C++
1317 lines
38 KiB
C++
#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);
|
|
}
|