3759 lines
83 KiB
C++
3759 lines
83 KiB
C++
|
|
#include "stdafx.h"
|
|
#include "KRenderDevice.h"
|
|
#include "SGameCloud.h"
|
|
#include "SEnvPrimitive.h"
|
|
#include "K3DTypes.h"
|
|
#include "KSeqModel.h"
|
|
#include "K3DCamera.h"
|
|
#include "KResourceManager.h"
|
|
|
|
#include "KRenderObjectEtc.h"
|
|
|
|
#include <dump/XException.h>
|
|
|
|
#include <mmo/ArTime.h>
|
|
#include "TerrainPrimitive.h"
|
|
|
|
//#include "SDebug_Util.h"
|
|
|
|
#include "SGameWeather.h" // [sonador] to include 'lerp' function in namespace 'env_fx'
|
|
#include "SGameLightning.h"
|
|
#include <toolkit/XStringUtil.h>
|
|
#include <kfile/KFileManager.h>
|
|
//#include "SGameMilesSoundMgr.h"
|
|
|
|
#ifdef CLOUD_LUA
|
|
#include "SGameSystem.h"
|
|
#include "SGameAvatarEx.h"
|
|
#include "SGameWorld.h"
|
|
|
|
|
|
CCloudKindDB* g_pCloudKindDB = NULL;
|
|
CCloudThicknessDB* g_pCloudThicknesDB = NULL;
|
|
CCloudThicknessGapDB* g_pCloudThicknessGapDB = NULL;
|
|
CCloudSizeDB* g_pCloudSizeDB = NULL;
|
|
CCloudTxrGroupDB* g_pCloudTxrGroupDB = NULL;
|
|
CCloudDistributionDB* g_pCloudDistributionDB = NULL;
|
|
CCloudHeightRadomGapDB* g_pCloudHeightRadomGapDB = NULL;
|
|
CCloudLayerGapDB* g_pCloudCloudLayerGapDB = NULL;
|
|
CCloudMoveDirDB* g_pCloudCloudMoveDirDB = NULL;
|
|
CCloudPathDB* g_pCloudPathDB = NULL;
|
|
CCloudTypeInfoDB* g_pCloudTypeInfoDB = NULL;
|
|
CCloudLayerDB* g_pCloudLayerDB = NULL;
|
|
CCloudLayerSetDB* g_pCloudLayerSetDB = NULL;
|
|
|
|
float g_fMyPlayerHeight = 0.0f;
|
|
|
|
extern SGameSystem * g_pCurrentGameSystem;
|
|
int g_nFadeState = 0;
|
|
float g_fRateG = 1.0f;
|
|
float g_fRate = 1.0f;
|
|
float g_fRateScale= 1.0f;
|
|
float g_fTestX = 0.0f;
|
|
float g_fTestY = 0.0f;
|
|
float g_fTestZ = 0.0f;
|
|
float g_fTestG = 3.0f;
|
|
bool g_bUseWorldTM = false;
|
|
|
|
float g_fZ = 0.0f;
|
|
float g_fX = 0.0f;
|
|
float g_fY = 0.0f;
|
|
#endif
|
|
|
|
|
|
#ifdef SKYBOX_CLOUD
|
|
const int CLOUD_MAX = 190;
|
|
const float START_TIME = 6000.f;
|
|
const float END_TIME = 4000.f;
|
|
const float DEFAULT_HEIGHT = 500.0f;
|
|
// { [sonador]
|
|
const int THUNDER_CLOUD_MAX = 3;
|
|
const float DEFAULT_HEIGHT_THUNDER_CLOUD = 510.0f;
|
|
// }
|
|
float fRotSpeed[] =
|
|
{
|
|
0.2f,
|
|
// 0.2f,
|
|
// 0.3f,
|
|
// 0.4f,
|
|
// 0.5f,
|
|
};
|
|
|
|
bool SGameCloud::m_bProcessPause = false;
|
|
|
|
|
|
|
|
float SCloudEx::s_fFactor = 0.1f;
|
|
float SCloudEx::s_fLightningFactor = 1.0f;
|
|
DWORD SCloudEx::s_dwDuration = 250;
|
|
int SCloudEx::s_nFlashCount = 3;
|
|
K3DColor SCloudEx::s_sDestColor = K3DColor( 0xffdae7fe );
|
|
|
|
SCloudEx::SCloudEx()
|
|
{
|
|
InitVariable();
|
|
}
|
|
|
|
SCloudEx::SCloudEx(int nType, int nCount, int nDepth, int nZoneWidth, int nZoneHeight)
|
|
{
|
|
InitVariable();
|
|
}
|
|
|
|
SCloudEx::~SCloudEx()
|
|
{
|
|
Destroy();
|
|
}
|
|
|
|
void SCloudEx::InitVariable()
|
|
{
|
|
nWidth = 0;
|
|
nHeight = 0;
|
|
vPosition = K3DVector(0, 0, 0);
|
|
vStartPosition = K3DVector(0, 0, 0);
|
|
fVisibilityCap = 1;
|
|
fVisibility = 0;
|
|
color = 0x00000000;
|
|
bActive = false;
|
|
pVecCloud = 0;
|
|
dwStartTime = 0;
|
|
dwOldTime = 0;
|
|
fRotSpeed = 0.1f;
|
|
eStep = APPEAR;
|
|
}
|
|
|
|
void SCloudEx::Init( K3DRenderDevice *pDevice, K3DIndexBuffer * pIndexBuf )
|
|
{
|
|
m_pDevice = pDevice;
|
|
/*
|
|
DWORD dwFormat = 0;
|
|
m_pVB = m_pDevice->CreateVertexBufferUsePoolDefault( sizeof(K3DVERTEX_CLOUD), dwFormat, 4 * nDepth, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY );
|
|
if( m_pVB && m_pVB->IsValidVtx() )
|
|
{
|
|
K3DVERTEX_CLOUD* vtx = NULL;
|
|
int nVtxSize;
|
|
m_pVB->Lock( (void**)&vtx, nVtxSize, D3DLOCK_NOSYSLOCK | D3DLOCK_DISCARD );
|
|
assert(vtx && "m_pVB->Lock( (void**)&vtx, nVtxSize );");
|
|
|
|
if( vtx == NULL ) return;
|
|
|
|
for( int n=0; 4 * nDepth > n; )
|
|
{
|
|
int nRand = rand() % 150 + 255;
|
|
vtx[n].position = K3DVector( (float)-m_nWidth/2.f, (float)-m_nHeight/2.f, 0 );
|
|
vtx[n].color = m_CloudColor;
|
|
vtx[n].color.a = nRand;
|
|
vtx[n].normal = K3DVector( 0.f, 0.f, -1.f);
|
|
vtx[n].texcoord0.x = 0.f;
|
|
vtx[n].texcoord0.y = 0.f;
|
|
|
|
n++;
|
|
vtx[n].position = K3DVector( m_nWidth / 2.f, (float)-m_nHeight/2.f, 0 );
|
|
vtx[n].color = m_CloudColor;
|
|
vtx[n].color.a = nRand;
|
|
vtx[n].normal = K3DVector( 0.f, 0.f, -1.f);
|
|
vtx[n].texcoord0.x = 1.f;
|
|
vtx[n].texcoord0.y = 0.f;
|
|
|
|
n++;
|
|
vtx[n].position = K3DVector( (float)-m_nWidth/2.f, m_nHeight / 2.f, 0 );
|
|
vtx[n].color = m_CloudColor;
|
|
vtx[n].color.a = nRand;
|
|
vtx[n].normal = K3DVector( 0.f, 0.f, -1.f);
|
|
vtx[n].texcoord0.x = 0.0f;
|
|
vtx[n].texcoord0.y = 1.f;
|
|
|
|
n++;
|
|
vtx[n].position = K3DVector( m_nWidth / 2.f, m_nHeight / 2.f, 0 );
|
|
vtx[n].color = m_CloudColor;
|
|
vtx[n].color.a = nRand;
|
|
vtx[n].normal = K3DVector( 0.f, 0.f, -1.f);
|
|
vtx[n].texcoord0.x = 1.0f;
|
|
vtx[n].texcoord0.y = 1.f;
|
|
|
|
n++;
|
|
}
|
|
m_pVB->Unlock();
|
|
m_pVB->Backup();
|
|
|
|
m_spIB = NULL; // Index Buf
|
|
m_spTexture = NULL;
|
|
m_spAlphaTexture = NULL;
|
|
|
|
m_pMat = new K3DMaterial;
|
|
m_pMat->SetAmbient( K3DColor( 1.f, 1.f, 1.f, 1.f ) );
|
|
m_pMat->SetDiffuse( K3DColor( 1.f, 1.f, 1.f, 1.f ) );
|
|
m_pMat->SetSpecular( K3DColor( 0.f, 0.f, 0.f, 1.f ) );
|
|
m_pMat->SetSpecularPower( 1.0f );
|
|
|
|
m_pParentMat = NULL; // SkyBox 위치
|
|
K3DMatrixIdentity( m_LocalMat ); // 구름 위치
|
|
K3DMatrixIdentity( m_WorldMat );
|
|
|
|
m_pPrimitive = new SCloudPrimitive; // Render Object
|
|
m_pPrimitive->SetTransparent( true );
|
|
m_pPrimitive->SetTransform( &m_LocalMat, &m_WorldMat );
|
|
m_pPrimitive->SetVertexBuffer( m_pVB );
|
|
m_pPrimitive->SetMaterial( m_pMat );
|
|
|
|
this->initCloudObjects();
|
|
}
|
|
*/
|
|
}
|
|
|
|
void SCloudEx::Process( DWORD dwTime )
|
|
{
|
|
/* if( IsProcessPause() ) return;
|
|
|
|
if( m_pVB == NULL || !m_pVB->IsValidVtx() ) return;
|
|
|
|
m_dwTime = dwTime;
|
|
|
|
// [sonador] Lock / Unlock 을 짧은 시간에 수행하기 위해 update 를 분리하였음.
|
|
for( int it = 0; it < m_nCloudCount; ++it )
|
|
{
|
|
if( m_pCloud[ it ].IsActive() )
|
|
this->procesSCloudEx( it );
|
|
}
|
|
|
|
K3DVERTEX_CLOUD* vtx = NULL;
|
|
int nVtxSize;
|
|
int nPrimCnt = 0;
|
|
//D3DLOCK_NOOVERWRITE 옵션이 일부 그래픽 카드에서 문제 발생되어 수정됨.
|
|
#if defined( _DEBUG )
|
|
m_pVB->Lock( (void**)&vtx, nVtxSize, D3DLOCK_NOSYSLOCK | D3DLOCK_DISCARD );
|
|
#else
|
|
m_pVB->Lock( (void**)&vtx, nVtxSize, D3DLOCK_DISCARD );
|
|
#endif
|
|
assert(vtx && "m_pVB->Lock( (void**)&vtx, nVtxSize );");
|
|
|
|
if( vtx == NULL ) return;
|
|
|
|
for(int it = 0; it < m_nCloudCount; ++it)
|
|
{
|
|
if( m_pCloud[ it ].IsActive() )
|
|
{
|
|
this->updateVB( &vtx[ nPrimCnt * 4 ], m_pCloud[ it ] );
|
|
}
|
|
else
|
|
{
|
|
vtx[ nPrimCnt * 4 + 0 ].color.a = 0;
|
|
vtx[ nPrimCnt * 4 + 1 ].color.a = 0;
|
|
vtx[ nPrimCnt * 4 + 2 ].color.a = 0;
|
|
vtx[ nPrimCnt * 4 + 3 ].color.a = 0;
|
|
}
|
|
++nPrimCnt;
|
|
}
|
|
|
|
m_pVB->Unlock();
|
|
m_pPrimitive->SetVertexCnt( nPrimCnt * 4 );
|
|
*/
|
|
/*K3DMatrix mat;
|
|
K3DMatrixIdentity( mat );
|
|
//K3DMatrixRotationAxis( &mat, m_pVecCloud, (10.f*K3D_PI/180.f) );
|
|
K3DMatrixIdentity( m_LocalMat );
|
|
K3DMatrixSetPosVector( m_LocalMat, m_Pos );
|
|
K3DMatrixMultiply( &m_LocalMat, &mat, &m_LocalMat );
|
|
|
|
if( m_pParentMat )
|
|
K3DMatrixMultiply( &m_LocalMat, &m_LocalMat, m_pParentMat );*/
|
|
}
|
|
|
|
void SCloudEx::Render( KViewportObject *viewport )
|
|
{
|
|
if( m_pPrimitive && m_pPrimitive->GetVertexCnt() > 0 )
|
|
{
|
|
viewport->Register( m_pPrimitive, KRenderObject::RENDEREFX_CLOUD );
|
|
}
|
|
}
|
|
|
|
void SCloudEx::Create(int nType, int nCount, int nDepth, int nZoneWidth, int nZoneHeight)
|
|
{
|
|
if ( nType == 0 )
|
|
{
|
|
;
|
|
}
|
|
else if( nType == 0 )
|
|
{
|
|
|
|
}
|
|
else if( nType == 0 )
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
void SCloudEx::Destroy()
|
|
{
|
|
|
|
}
|
|
|
|
void SCloudEx::SetPosition( float x, float y, float z )
|
|
{
|
|
if( vStartPosition.x == 0.f &&
|
|
vStartPosition.y == 0.f &&
|
|
vStartPosition.z == 0.f )
|
|
vStartPosition = vPosition;
|
|
vPosition.Set( x, y, z );
|
|
}
|
|
|
|
void SCloudEx::SetColor( const K3DColor& _color )
|
|
{
|
|
color.r = (unsigned char)(_color.r * 255);
|
|
color.g = (unsigned char)(_color.g * 255);
|
|
color.b = (unsigned char)(_color.b * 255);
|
|
}
|
|
|
|
void SCloudEx::SetColor( const KColor& _color )
|
|
{
|
|
color.r = _color.r;
|
|
color.g = _color.g;
|
|
color.b = _color.b;
|
|
}
|
|
|
|
void SCloudEx::SetVisibility( float _visibility )
|
|
{
|
|
fVisibility = std::min( _visibility, fVisibilityCap );
|
|
fVisibility = std::max( 0.f, std::min( 1.0f, fVisibility ) );
|
|
color.a = (unsigned char)( 255 * fVisibility );
|
|
}
|
|
|
|
void SCloudEx::SetVisibilityCap( float _cap )
|
|
{
|
|
fVisibilityCap = _cap;
|
|
}
|
|
|
|
K3DVector SCloudEx::GetVertexPosition( EVtxPos _pos_type ) const
|
|
{
|
|
K3DVector vResult;
|
|
|
|
switch( _pos_type )
|
|
{
|
|
case UL:
|
|
vResult.Set( vPosition.x - nWidth / 2.f, vPosition.y - nHeight / 2.f, vPosition.z );
|
|
break;
|
|
case UR:
|
|
vResult.Set( vPosition.x + nWidth / 2.f, vPosition.y - nHeight / 2.f, vPosition.z );
|
|
break;
|
|
case BL:
|
|
vResult.Set( vPosition.x - nWidth / 2.f, vPosition.y + nHeight / 2.f, vPosition.z );
|
|
break;
|
|
case BR:
|
|
vResult.Set( vPosition.x + nWidth / 2.f, vPosition.y + nHeight / 2.f, vPosition.z );
|
|
break;
|
|
}
|
|
|
|
return vResult;
|
|
}
|
|
|
|
void SCloudEx::checkStartTime( DWORD dwTime_msec_ )
|
|
{
|
|
if( dwStartTime == 0 )
|
|
dwStartTime = dwTime_msec_;
|
|
}
|
|
|
|
void SCloudEx::ResetStartTime()
|
|
{
|
|
dwStartTime = 0;
|
|
}
|
|
|
|
void SCloudEx::resetPosition()
|
|
{
|
|
vPosition.x = (K3DVALUE)(-rand()%8000);
|
|
vPosition.y = (K3DVALUE)(-rand()%8000);
|
|
}
|
|
|
|
void SCloudEx::ChangeStep( EStep step )
|
|
{
|
|
eStep = step;
|
|
//dwStartTime = 0;
|
|
}
|
|
|
|
void SCloudEx::processByStep( DWORD elapsed_time , const KColor& _cloud_color )
|
|
{
|
|
//1)처음 나타나면, 0~1 서서히 나타난다.
|
|
//2)모두 보이면, 이동 시작
|
|
//3)이동이 끝나면 1~0 서서히 사라진다.
|
|
|
|
switch( eStep )
|
|
{
|
|
case APPEAR:
|
|
this->onAppear( elapsed_time );
|
|
break;
|
|
case DISAPPEAR:
|
|
this->onDisappear( elapsed_time );
|
|
break;
|
|
case MOVE:
|
|
this->onMove( elapsed_time );
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void SCloudEx::movePosition()
|
|
{
|
|
vPosition.x += fRotSpeed;
|
|
vPosition.y += fRotSpeed;
|
|
}
|
|
|
|
bool SCloudEx::IsOutOfBound() const
|
|
{
|
|
return ( vPosition.x > 1800.f || vPosition.y > 1800.f );
|
|
}
|
|
|
|
void SCloudEx::Update( DWORD _time, const KColor& _cloud_color )
|
|
{
|
|
this->checkStartTime( _time );
|
|
|
|
DWORD elapsed_time = _time - dwStartTime;
|
|
|
|
this->SetColor( _cloud_color );
|
|
this->SetVisibilityCap( (float)_cloud_color.a / 255 );
|
|
this->processByStep( elapsed_time, _cloud_color );
|
|
this->movePosition();
|
|
|
|
if( this->IsOutOfBound() && !this->IsStep( DISAPPEAR ) )
|
|
{
|
|
this->ChangeStep( DISAPPEAR );
|
|
this->ResetStartTime();
|
|
}
|
|
}
|
|
|
|
void SCloudEx::onAppear( DWORD elapsed_time )
|
|
{
|
|
if ( elapsed_time > START_TIME )
|
|
{
|
|
//종료
|
|
this->ChangeStep( MOVE );
|
|
this->ResetStartTime();
|
|
}
|
|
else
|
|
{
|
|
this->SetVisibility( (float)elapsed_time / START_TIME );
|
|
}
|
|
}
|
|
|
|
void SCloudEx::onDisappear( DWORD elapsed_time )
|
|
{
|
|
if( elapsed_time < END_TIME )
|
|
{
|
|
this->SetVisibility( 1.f - ( (float)elapsed_time / END_TIME ) );
|
|
}
|
|
else
|
|
{
|
|
//this->SetActivity( (rand() % 2) == 1 ); // 랜덤하게 활동여부를 설정하는 이유는?
|
|
this->resetPosition();
|
|
this->ResetStartTime();
|
|
this->ChangeStep( APPEAR );
|
|
}
|
|
}
|
|
|
|
void SCloudEx::onMove( DWORD elapsed_time )
|
|
{
|
|
this->SetVisibility( fVisibilityCap );
|
|
}
|
|
|
|
// =======================================================================
|
|
// SGameCloud
|
|
// =======================================================================
|
|
SGameCloud::SGameCloud( int cloud_count )
|
|
: m_dwTime ( 0 )
|
|
, m_nCloudCount ( cloud_count )
|
|
, m_CloudColor ( 255, 255, 255, 255 )
|
|
, m_pSoundMgr ( 0 )
|
|
, m_pDevice ( 0 )
|
|
{
|
|
}
|
|
|
|
SGameCloud::~SGameCloud()
|
|
{
|
|
SAFE_DELETE( m_pMat );
|
|
SAFE_DELETE_ARRAY( m_pCloud );
|
|
|
|
if( m_pVB )
|
|
m_pDevice->DelReloadVertexList( m_pVB );
|
|
}
|
|
|
|
void SGameCloud::Init( K3DRenderDevice *pDevice, K3DIndexBuffer * pIndexBuf )
|
|
{
|
|
m_pDevice = pDevice;
|
|
|
|
DWORD dwFormat = 0;
|
|
m_pVB = pDevice->CreateVertexBufferUsePoolDefault( sizeof(K3DVERTEX_CLOUD), dwFormat, 4*m_nCloudCount, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY ); //기본 사각형
|
|
if( m_pVB && m_pVB->IsValidVtx() )
|
|
{
|
|
// m_spVB = pDevice->CreateVertexBufferBlend( sizeof(K3DBLENDEDBUMPVERTEX), dwFormat, 4*m_nCloudCount ); //기본 사각형
|
|
|
|
this->initVB();
|
|
|
|
m_spIB = NULL; // Index Buf
|
|
m_spTexture = NULL;
|
|
m_spAlphaTexture = NULL;
|
|
|
|
m_pMat = new K3DMaterial;
|
|
m_pMat->SetAmbient( K3DColor( 1.f, 1.f, 1.f, 1.f ) );
|
|
m_pMat->SetDiffuse( K3DColor( 1.f, 1.f, 1.f, 1.f ) );
|
|
m_pMat->SetSpecular( K3DColor( 0.f, 0.f, 0.f, 1.f ) );
|
|
m_pMat->SetSpecularPower( 1.0f );
|
|
|
|
m_pParentMat = NULL; // SkyBox 위치
|
|
K3DMatrixIdentity( m_LocalMat ); // 구름 위치
|
|
K3DMatrixIdentity( m_WorldMat );
|
|
|
|
m_pPrimitive = new SCloudPrimitive; // Render Object
|
|
m_pPrimitive->SetTransparent( true );
|
|
m_pPrimitive->SetTransform( &m_LocalMat, &m_WorldMat );
|
|
m_pPrimitive->SetVertexBuffer( m_pVB );
|
|
m_pPrimitive->SetMaterial( m_pMat );
|
|
|
|
this->initCloudObjects();
|
|
}
|
|
}
|
|
|
|
void SGameCloud::Process( DWORD dwTime )
|
|
{
|
|
if( IsProcessPause() ) return;
|
|
|
|
if( m_pVB == NULL || !m_pVB->IsValidVtx() ) return;
|
|
|
|
m_dwTime = dwTime;
|
|
|
|
// [sonador] Lock / Unlock 을 짧은 시간에 수행하기 위해 update 를 분리하였음.
|
|
for( int it = 0; it < m_nCloudCount; ++it )
|
|
{
|
|
if( m_pCloud[ it ].IsActive() )
|
|
this->procesSCloudEx( it );
|
|
}
|
|
|
|
K3DVERTEX_CLOUD* vtx = NULL;
|
|
int nVtxSize;
|
|
int nPrimCnt = 0;
|
|
//D3DLOCK_NOOVERWRITE 옵션이 일부 그래픽 카드에서 문제 발생되어 수정됨.
|
|
#if defined( _DEBUG )
|
|
m_pVB->Lock( (void**)&vtx, nVtxSize, D3DLOCK_NOSYSLOCK | D3DLOCK_DISCARD );
|
|
#else
|
|
m_pVB->Lock( (void**)&vtx, nVtxSize, D3DLOCK_DISCARD );
|
|
#endif
|
|
assert(vtx && "m_pVB->Lock( (void**)&vtx, nVtxSize );");
|
|
|
|
if( vtx == NULL ) return;
|
|
|
|
for(int it = 0; it < m_nCloudCount; ++it)
|
|
{
|
|
if( m_pCloud[ it ].IsActive() )
|
|
{
|
|
this->updateVB( &vtx[ nPrimCnt * 4 ], m_pCloud[ it ] );
|
|
}
|
|
else
|
|
{
|
|
vtx[ nPrimCnt * 4 + 0 ].color.a = 0;
|
|
vtx[ nPrimCnt * 4 + 1 ].color.a = 0;
|
|
vtx[ nPrimCnt * 4 + 2 ].color.a = 0;
|
|
vtx[ nPrimCnt * 4 + 3 ].color.a = 0;
|
|
}
|
|
++nPrimCnt;
|
|
}
|
|
|
|
m_pVB->Unlock();
|
|
m_pPrimitive->SetVertexCnt( nPrimCnt * 4 );
|
|
/*K3DMatrix mat;
|
|
K3DMatrixIdentity( mat );
|
|
//K3DMatrixRotationAxis( &mat, m_pVecCloud, (10.f*K3D_PI/180.f) );
|
|
K3DMatrixIdentity( m_LocalMat );
|
|
K3DMatrixSetPosVector( m_LocalMat, m_Pos );
|
|
K3DMatrixMultiply( &m_LocalMat, &mat, &m_LocalMat );
|
|
|
|
if( m_pParentMat )
|
|
K3DMatrixMultiply( &m_LocalMat, &m_LocalMat, m_pParentMat );*/
|
|
}
|
|
|
|
void SGameCloud::Render( KViewportObject *viewport )
|
|
{
|
|
if( m_pPrimitive && m_pPrimitive->GetVertexCnt() > 0 )
|
|
{
|
|
viewport->Register( m_pPrimitive, KRenderObject::RENDEREFX_CLOUD );
|
|
}
|
|
}
|
|
|
|
void SGameCloud::SetHeight( int i, float fz )
|
|
{
|
|
if( i >=0 && i < m_nCloudCount )
|
|
{
|
|
m_pCloud[i].vPosition.z = fz;
|
|
}
|
|
else
|
|
{
|
|
assert( !"SGameCloud : refered wrong index" );
|
|
}
|
|
|
|
//if( m_pThunderCloud )
|
|
// m_pThunderCloud->SetHeight( i, fz );
|
|
}
|
|
|
|
void SGameCloud::SetPosition( int i, float fx, float fy, float fz )
|
|
{
|
|
if( i >=0 && i < m_nCloudCount )
|
|
{
|
|
m_pCloud[i].SetPosition( fx, fy, fz );
|
|
}
|
|
else
|
|
{
|
|
assert( !"SGameCloud : refered wrong index" );
|
|
}
|
|
|
|
//if( m_pThunderCloud )
|
|
// m_pThunderCloud->SetPosition( i, fz, fy, fz );
|
|
}
|
|
|
|
void SGameCloud::SetMaxVisibility( int i, float fVis )
|
|
{
|
|
if( i >=0 && i < m_nCloudCount )
|
|
{
|
|
m_pCloud[i].SetVisibilityCap( fVis );
|
|
}
|
|
else
|
|
{
|
|
assert( !"SGameCloud : refered wrong index" );
|
|
}
|
|
|
|
//if( m_pThunderCloud )
|
|
// m_pThunderCloud->SetMaxVisibility( i, fVis );
|
|
}
|
|
|
|
void SGameCloud::SetVisibility( int i, float fVis )
|
|
{
|
|
if( i >=0 && i < m_nCloudCount )
|
|
{
|
|
m_pCloud[i].SetVisibility( fVis );
|
|
}
|
|
else
|
|
{
|
|
assert( !"SGameCloud : refered wrong index" );
|
|
}
|
|
|
|
//if( m_pThunderCloud )
|
|
// m_pThunderCloud->SetVisibility( i, fVis );
|
|
}
|
|
|
|
void SGameCloud::SetCloudColor( int i, K3DColor & color )
|
|
{
|
|
if( i >=0 && i < m_nCloudCount )
|
|
{
|
|
m_pCloud[ i ].SetColor( color );
|
|
}
|
|
else
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
//if( m_pThunderCloud )
|
|
// m_pThunderCloud->SetCloudColor( i, color );
|
|
}
|
|
|
|
void SGameCloud::SetCloudColor( KColor & color )
|
|
{
|
|
m_CloudColor = color;
|
|
}
|
|
|
|
void SGameCloud::SetTransform( K3DMatrix* pParentMatrix )
|
|
{
|
|
SetParentMat( pParentMatrix );
|
|
m_pPrimitive->SetTransform( pParentMatrix, pParentMatrix );
|
|
}
|
|
|
|
SCloudEx* SGameCloud::GetFirstDeactiveCloud()
|
|
{
|
|
SCloudEx* pCloud = std::find_if(
|
|
&m_pCloud[ 0 ], &m_pCloud[ m_nCloudCount ], SFindFirstDeactiveCloud() );
|
|
|
|
if( pCloud != &m_pCloud[ m_nCloudCount ] )
|
|
return pCloud;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void SGameCloud::SetSoundManager( SGameMilesSoundMgr* pSoundMgr )
|
|
{
|
|
m_pSoundMgr = pSoundMgr;
|
|
}
|
|
|
|
void SGameCloud::initVB()
|
|
{
|
|
K3DVERTEX_CLOUD* vtx = NULL;
|
|
int nVtxSize;
|
|
m_pVB->Lock( (void**)&vtx, nVtxSize, D3DLOCK_NOSYSLOCK | D3DLOCK_DISCARD );
|
|
assert(vtx && "m_pVB->Lock( (void**)&vtx, nVtxSize );");
|
|
|
|
if( vtx == NULL ) return;
|
|
|
|
for( int n=0; 4 * m_nCloudCount > n; )
|
|
{
|
|
int nRand = rand() % 150 + 255;
|
|
vtx[n].position = K3DVector( (float)-m_nWidth/2.f, (float)-m_nHeight/2.f, 0 );
|
|
vtx[n].color = m_CloudColor;
|
|
vtx[n].color.a = nRand;
|
|
vtx[n].normal = K3DVector( 0.f, 0.f, -1.f);
|
|
vtx[n].texcoord0.x = 0.f;
|
|
vtx[n].texcoord0.y = 0.f;
|
|
//vtx[n].texcoord1.x = 0.f;
|
|
//vtx[n].texcoord1.y = 0.f;
|
|
n++;
|
|
vtx[n].position = K3DVector( m_nWidth / 2.f, (float)-m_nHeight/2.f, 0 );
|
|
vtx[n].color = m_CloudColor;
|
|
vtx[n].color.a = nRand;
|
|
vtx[n].normal = K3DVector( 0.f, 0.f, -1.f);
|
|
vtx[n].texcoord0.x = 1.f;
|
|
vtx[n].texcoord0.y = 0.f;
|
|
//vtx[n].texcoord1.x = 1.f;
|
|
//vtx[n].texcoord1.y = 0.f;
|
|
n++;
|
|
vtx[n].position = K3DVector( (float)-m_nWidth/2.f, m_nHeight / 2.f, 0 );
|
|
vtx[n].color = m_CloudColor;
|
|
vtx[n].color.a = nRand;
|
|
vtx[n].normal = K3DVector( 0.f, 0.f, -1.f);
|
|
vtx[n].texcoord0.x = 0.0f;
|
|
vtx[n].texcoord0.y = 1.f;
|
|
//vtx[n].texcoord1.x = 0.0f;
|
|
//vtx[n].texcoord1.y = 1.f;
|
|
n++;
|
|
vtx[n].position = K3DVector( m_nWidth / 2.f, m_nHeight / 2.f, 0 );
|
|
vtx[n].color = m_CloudColor;
|
|
vtx[n].color.a = nRand;
|
|
vtx[n].normal = K3DVector( 0.f, 0.f, -1.f);
|
|
vtx[n].texcoord0.x = 1.0f;
|
|
vtx[n].texcoord0.y = 1.f;
|
|
//vtx[n].texcoord1.x = 1.0f;
|
|
//vtx[n].texcoord1.y = 1.f;
|
|
n++;
|
|
}
|
|
m_pVB->Unlock();
|
|
m_pVB->Backup();
|
|
}
|
|
|
|
void SGameCloud::updateVB( K3DVERTEX_CLOUD* vtx, const SCloudEx& cloud )
|
|
{
|
|
vtx[ 0 ].position = cloud.GetVertexPosition( SCloudEx::UL );
|
|
vtx[ 1 ].position = cloud.GetVertexPosition( SCloudEx::UR );
|
|
vtx[ 2 ].position = cloud.GetVertexPosition( SCloudEx::BL );
|
|
vtx[ 3 ].position = cloud.GetVertexPosition( SCloudEx::BR );
|
|
|
|
for( short p = 0; p < 4; p++)
|
|
{
|
|
vtx[ p ].color = cloud.color;
|
|
vtx[ p ].normal = K3DVector( 0.f, 0.f, -1.f);
|
|
}
|
|
|
|
vtx[ 0 ].texcoord0.Set( 0, 0 );
|
|
vtx[ 1 ].texcoord0.Set( 1, 0 );
|
|
vtx[ 2 ].texcoord0.Set( 0, 1 );
|
|
vtx[ 3 ].texcoord0.Set( 1, 1 );
|
|
//vtx[ 0 ].texcoord1.Set( 0, 0 );
|
|
//vtx[ 1 ].texcoord1.Set( 1, 0 );
|
|
//vtx[ 2 ].texcoord1.Set( 0, 1 );
|
|
//vtx[ 3 ].texcoord1.Set( 1, 1 );
|
|
}
|
|
|
|
void SGameCloud::initCloudObjects()
|
|
{
|
|
m_pCloud = new SCloudEx[ m_nCloudCount ];
|
|
|
|
for(int i = 0; i < m_nCloudCount; ++i)
|
|
{
|
|
m_pCloud[i].nWidth = 1000+rand()/16000;//(float)(rand()/10000)+1400;
|
|
m_pCloud[i].nHeight = 1000+rand()/10000;//(float)(rand()/10000)+1400;
|
|
m_pCloud[i].dwStartTime = 0;
|
|
m_pCloud[i].dwOldTime = 0;
|
|
m_pCloud[i].fRotSpeed = fRotSpeed[0/*rand()%5*/];
|
|
m_pCloud[i].fVisibility = 0.8f;
|
|
m_pCloud[i].eStep = SCloudEx::MOVE;
|
|
}
|
|
}
|
|
|
|
void SGameCloud::procesSCloudEx( int nIndex )
|
|
{
|
|
assert( nIndex >= 0 && nIndex < m_nCloudCount && "wrong index" );
|
|
m_pCloud[ nIndex ].Update( m_dwTime, m_CloudColor );
|
|
}
|
|
|
|
void SGameCloud::_addSoundEvent( const K3DVector& addedPosition )
|
|
{
|
|
SSoundEvent* se = new SSoundEvent();
|
|
se->activeTime = m_dwTime
|
|
+ (DWORD)( addedPosition.Magnitude() );
|
|
se->activePos = addedPosition;
|
|
|
|
m_ctSoundEvents.push( se );
|
|
}
|
|
|
|
void SGameCloud::_procSoundEvent()
|
|
{
|
|
while( !m_ctSoundEvents.empty() )
|
|
{
|
|
SSoundEvent* se = 0;
|
|
se = m_ctSoundEvents.front();
|
|
if( se->activeTime >= m_dwTime )
|
|
{
|
|
//if( m_pSoundMgr )
|
|
//{
|
|
// m_pSoundMgr->PlaySound3D(
|
|
// SCloudEx::s_strSound.c_str(),
|
|
// se->activePos.x, se->activePos.y, se->activePos.z,
|
|
// 100, false, false, false );
|
|
//
|
|
//}
|
|
SAFE_DELETE( se );
|
|
m_ctSoundEvents.pop();
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void SGameCloud::CreateCloudByType( int type )
|
|
{
|
|
DestroyCloud();
|
|
|
|
if(type == 0)
|
|
{
|
|
int nCount = 15;
|
|
m_vcCloud.resize(nCount);
|
|
|
|
for(int x=0; x<nCount; x++)
|
|
{
|
|
SCloudEx* pCloud = new SCloudEx;
|
|
m_vcCloud[x] = pCloud;
|
|
}
|
|
}
|
|
}
|
|
|
|
void SGameCloud::DestroyCloud()
|
|
{
|
|
int nCount = m_vcCloud.size();
|
|
for(int x=0; x<nCount; x++)
|
|
{
|
|
SCloudEx* pCloud = m_vcCloud[x];
|
|
SAFE_DELETE( pCloud );
|
|
}
|
|
m_vcCloud.clear();
|
|
}
|
|
|
|
|
|
SGameThunderCloud::SGameThunderCloud( int cloud_count )
|
|
: SGameCloud ( cloud_count )
|
|
{
|
|
}
|
|
|
|
SGameThunderCloud::~SGameThunderCloud()
|
|
{
|
|
}
|
|
|
|
void SGameThunderCloud::initCloudObjects()
|
|
{
|
|
}
|
|
#else
|
|
|
|
const int CLOUD_MAX = 190;
|
|
const float START_TIME = 6000.f;
|
|
const float END_TIME = 4000.f;
|
|
const float DEFAULT_HEIGHT = 500.0f;
|
|
// { [sonador]
|
|
const int THUNDER_CLOUD_MAX = 3;
|
|
const float DEFAULT_HEIGHT_THUNDER_CLOUD = 510.0f;
|
|
|
|
float fRotSpeed[] =
|
|
{
|
|
0.2f,
|
|
// 0.2f,
|
|
// 0.3f,
|
|
// 0.4f,
|
|
// 0.5f,
|
|
};
|
|
|
|
bool SGameCloud::m_bProcessPause = false;
|
|
|
|
float SCloudObject::s_fFactor = 0.1f;
|
|
float SCloudObject::s_fLightningFactor = 1.0f;
|
|
DWORD SCloudObject::s_dwDuration = 250;
|
|
int SCloudObject::s_nFlashCount = 3;
|
|
K3DColor SCloudObject::s_sDestColor = K3DColor( 0xffdae7fe );
|
|
std::string SCloudObject::s_strSound = "";
|
|
float SCloudObject::s_fSoundSpeed = 0;
|
|
|
|
SCloudObject::SCloudObject()
|
|
: nWidth ( 0 )
|
|
, nHeight ( 0 )
|
|
, vPosition ( 0, 0, 0 )
|
|
, vStartPosition ( 0, 0, 0 )
|
|
, fVisibilityCap ( 1 )
|
|
, fVisibility ( 0 )
|
|
, color ( 0x00000000 )
|
|
, bActive ( false )
|
|
, pVecCloud ( 0 )
|
|
, dwStartTime ( 0 )
|
|
, dwOldTime ( 0 )
|
|
, fRotSpeed ( 0.1f )
|
|
, eStep ( APPEAR )
|
|
, dwThunderBegin ( 0 )
|
|
, bLightningEnable ( false )
|
|
{
|
|
}
|
|
|
|
void SCloudObject::SetPosition( float x, float y, float z )
|
|
{
|
|
if( vStartPosition.x == 0.f &&
|
|
vStartPosition.y == 0.f &&
|
|
vStartPosition.z == 0.f )
|
|
vStartPosition = vPosition;
|
|
vPosition.Set( x, y, z );
|
|
}
|
|
|
|
void SCloudObject::SetColor( const K3DColor& _color )
|
|
{
|
|
color.r = (unsigned char)(_color.r * 255);
|
|
color.g = (unsigned char)(_color.g * 255);
|
|
color.b = (unsigned char)(_color.b * 255);
|
|
}
|
|
|
|
void SCloudObject::SetColor( const KColor& _color )
|
|
{
|
|
color.r = _color.r;
|
|
color.g = _color.g;
|
|
color.b = _color.b;
|
|
}
|
|
|
|
void SCloudObject::SetVisibility( float _visibility )
|
|
{
|
|
fVisibility = std::min( _visibility, fVisibilityCap );
|
|
fVisibility = std::max( 0.f, std::min( 1.0f, fVisibility ) );
|
|
color.a = (unsigned char)( 255 * fVisibility );
|
|
}
|
|
|
|
void SCloudObject::SetVisibilityCap( float _cap )
|
|
{
|
|
fVisibilityCap = _cap;
|
|
}
|
|
|
|
K3DVector SCloudObject::GetVertexPosition( EVtxPos _pos_type ) const
|
|
{
|
|
K3DVector vResult;
|
|
|
|
switch( _pos_type )
|
|
{
|
|
case UL:
|
|
vResult.Set( vPosition.x - nWidth / 2.f, vPosition.y - nHeight / 2.f, vPosition.z );
|
|
break;
|
|
case UR:
|
|
vResult.Set( vPosition.x + nWidth / 2.f, vPosition.y - nHeight / 2.f, vPosition.z );
|
|
break;
|
|
case BL:
|
|
vResult.Set( vPosition.x - nWidth / 2.f, vPosition.y + nHeight / 2.f, vPosition.z );
|
|
break;
|
|
case BR:
|
|
vResult.Set( vPosition.x + nWidth / 2.f, vPosition.y + nHeight / 2.f, vPosition.z );
|
|
break;
|
|
}
|
|
|
|
return vResult;
|
|
}
|
|
|
|
void SCloudObject::checkStartTime( DWORD dwTime_msec_ )
|
|
{
|
|
if( dwStartTime == 0 )
|
|
dwStartTime = dwTime_msec_;
|
|
}
|
|
|
|
void SCloudObject::ResetStartTime()
|
|
{
|
|
dwStartTime = 0;
|
|
}
|
|
|
|
void SCloudObject::resetPosition()
|
|
{
|
|
vPosition.x = (K3DVALUE)(-rand()%8000);
|
|
vPosition.y = (K3DVALUE)(-rand()%8000);
|
|
}
|
|
|
|
void SCloudObject::ChangeStep( EStep step )
|
|
{
|
|
eStep = step;
|
|
//dwStartTime = 0;
|
|
}
|
|
|
|
void SCloudObject::processByStep( DWORD elapsed_time , const KColor& _cloud_color )
|
|
{
|
|
//1)처음 나타나면, 0~1 서서히 나타난다.
|
|
//2)모두 보이면, 이동 시작
|
|
//3)이동이 끝나면 1~0 서서히 사라진다.
|
|
|
|
switch( eStep )
|
|
{
|
|
case APPEAR:
|
|
this->onAppear( elapsed_time );
|
|
break;
|
|
case DISAPPEAR:
|
|
this->onDisappear( elapsed_time );
|
|
break;
|
|
case MOVE:
|
|
this->onMove( elapsed_time );
|
|
break;
|
|
case THUNDER:
|
|
this->onThunder( elapsed_time );
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void SCloudObject::movePosition()
|
|
{
|
|
vPosition.x += fRotSpeed;
|
|
vPosition.y += fRotSpeed;
|
|
}
|
|
|
|
bool SCloudObject::IsOutOfBound() const
|
|
{
|
|
return ( vPosition.x > 1800.f || vPosition.y > 1800.f );
|
|
}
|
|
|
|
void SCloudObject::Update( DWORD _time, const KColor& _cloud_color )
|
|
{
|
|
this->checkStartTime( _time );
|
|
|
|
DWORD elapsed_time = _time - dwStartTime;
|
|
|
|
this->SetColor( _cloud_color );
|
|
this->SetVisibilityCap( (float)_cloud_color.a / 255 );
|
|
this->processByStep( elapsed_time, _cloud_color );
|
|
this->movePosition();
|
|
|
|
if( this->IsOutOfBound() && !this->IsStep( DISAPPEAR ) )
|
|
{
|
|
this->ChangeStep( DISAPPEAR );
|
|
this->ResetStartTime();
|
|
}
|
|
}
|
|
|
|
void SCloudObject::onAppear( DWORD elapsed_time )
|
|
{
|
|
if ( elapsed_time > START_TIME )
|
|
{
|
|
//종료
|
|
this->ChangeStep( MOVE );
|
|
this->ResetStartTime();
|
|
}
|
|
else
|
|
{
|
|
this->SetVisibility( (float)elapsed_time / START_TIME );
|
|
}
|
|
}
|
|
|
|
void SCloudObject::onDisappear( DWORD elapsed_time )
|
|
{
|
|
if( elapsed_time < END_TIME )
|
|
{
|
|
this->SetVisibility( 1.f - ( (float)elapsed_time / END_TIME ) );
|
|
}
|
|
else
|
|
{
|
|
//this->SetActivity( (rand() % 2) == 1 ); // 랜덤하게 활동여부를 설정하는 이유는?
|
|
this->resetPosition();
|
|
this->ResetStartTime();
|
|
this->ChangeStep( APPEAR );
|
|
}
|
|
}
|
|
|
|
void SCloudObject::onMove( DWORD elapsed_time )
|
|
{
|
|
this->SetVisibility( fVisibilityCap );
|
|
}
|
|
|
|
void SCloudObject::onThunder( DWORD elapsed_time )
|
|
{
|
|
this->SetVisibility( fVisibilityCap );
|
|
|
|
if( elapsed_time <= s_dwDuration + dwThunderBegin )
|
|
{
|
|
float ftheta = K3D_PI * (float)( elapsed_time - dwThunderBegin )
|
|
* s_nFlashCount / (float)s_dwDuration;
|
|
float fwave = sinf( ftheta );
|
|
fwave = fabs( fwave );
|
|
|
|
color.a = (unsigned char)( fwave * 255.0f );
|
|
}
|
|
else
|
|
{
|
|
this->ChangeStep( MOVE );
|
|
}
|
|
}
|
|
|
|
|
|
SThunderCloudObject::SThunderCloudObject()
|
|
: SCloudObject()
|
|
{
|
|
}
|
|
|
|
SThunderCloudObject::~SThunderCloudObject()
|
|
{
|
|
}
|
|
|
|
void SThunderCloudObject::onAppear( DWORD elapsed_time )
|
|
{
|
|
this->SetActivity( false );
|
|
}
|
|
|
|
void SThunderCloudObject::onDisappear( DWORD elapsed_time )
|
|
{
|
|
this->SetActivity( false );
|
|
}
|
|
|
|
void SThunderCloudObject::onMove( DWORD elapsed_time )
|
|
{
|
|
this->SetActivity( false );
|
|
}
|
|
|
|
void SThunderCloudObject::onThunder( DWORD elapsed_time )
|
|
{
|
|
this->SetVisibility( fVisibilityCap );
|
|
|
|
if( elapsed_time <= s_dwDuration + dwThunderBegin )
|
|
{
|
|
float ftheta = K3D_PI * (float)( elapsed_time - dwThunderBegin )
|
|
* s_nFlashCount / (float)s_dwDuration;
|
|
float fwave = sinf( ftheta );
|
|
fwave = fabs( fwave );
|
|
|
|
color.a = (unsigned char)( fwave * 255.0f );
|
|
}
|
|
else
|
|
{
|
|
this->SetActivity( false );
|
|
}
|
|
}
|
|
|
|
SGameCloud::SGameCloud( int cloud_count )
|
|
: m_dwTime ( 0 )
|
|
, m_nCloudCount ( cloud_count )
|
|
, m_CloudColor ( 255, 255, 255, 255 )
|
|
, m_bEnableThunder ( false )
|
|
, m_pThunderCloud ( 0 )
|
|
, m_pLightning ( 0 )
|
|
, m_pSoundMgr ( 0 )
|
|
, m_pDevice ( 0 )
|
|
{
|
|
}
|
|
|
|
SGameCloud::~SGameCloud()
|
|
{
|
|
SAFE_DELETE( m_pMat );
|
|
SAFE_DELETE_ARRAY( m_pCloud );
|
|
|
|
if( m_pVB )
|
|
m_pDevice->DelReloadVertexList( m_pVB );
|
|
}
|
|
|
|
void SGameCloud::Init( K3DRenderDevice *pDevice, K3DIndexBuffer * pIndexBuf )
|
|
{
|
|
m_pDevice = pDevice;
|
|
|
|
DWORD dwFormat = 0;
|
|
m_pVB = pDevice->CreateVertexBufferUsePoolDefault( sizeof(K3DVERTEX_CLOUD), dwFormat, 4*m_nCloudCount, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY ); //기본 사각형
|
|
if( m_pVB && m_pVB->IsValidVtx() )
|
|
{
|
|
// m_spVB = pDevice->CreateVertexBufferBlend( sizeof(K3DBLENDEDBUMPVERTEX), dwFormat, 4*m_nCloudCount ); //기본 사각형
|
|
|
|
this->initVB();
|
|
|
|
m_spIB = NULL; // Index Buf
|
|
m_spTexture = NULL;
|
|
m_spAlphaTexture = NULL;
|
|
|
|
m_pMat = new K3DMaterial;
|
|
m_pMat->SetAmbient( K3DColor( 1.f, 1.f, 1.f, 1.f ) );
|
|
m_pMat->SetDiffuse( K3DColor( 1.f, 1.f, 1.f, 1.f ) );
|
|
m_pMat->SetSpecular( K3DColor( 0.f, 0.f, 0.f, 1.f ) );
|
|
m_pMat->SetSpecularPower( 1.0f );
|
|
|
|
m_pParentMat = NULL; // SkyBox 위치
|
|
K3DMatrixIdentity( m_LocalMat ); // 구름 위치
|
|
K3DMatrixIdentity( m_WorldMat );
|
|
|
|
m_pPrimitive = new SCloudPrimitive; // Render Object
|
|
m_pPrimitive->SetTransparent( true );
|
|
m_pPrimitive->SetTransform( &m_LocalMat, &m_WorldMat );
|
|
m_pPrimitive->SetVertexBuffer( m_pVB );
|
|
m_pPrimitive->SetMaterial( m_pMat );
|
|
|
|
this->initCloudObjects();
|
|
}
|
|
}
|
|
|
|
void SGameCloud::Process( DWORD dwTime )
|
|
{
|
|
if( IsProcessPause() ) return;
|
|
|
|
if( m_pVB == NULL || !m_pVB->IsValidVtx() ) return;
|
|
|
|
m_dwTime = dwTime;
|
|
|
|
// [sonador] Lock / Unlock 을 짧은 시간에 수행하기 위해 update 를 분리하였음.
|
|
for( int it = 0; it < m_nCloudCount; ++it )
|
|
{
|
|
if( m_pCloud[ it ].IsActive() )
|
|
this->processCloudObject( it );
|
|
}
|
|
|
|
K3DVERTEX_CLOUD* vtx = NULL;
|
|
int nVtxSize;
|
|
int nPrimCnt = 0;
|
|
//D3DLOCK_NOOVERWRITE 옵션이 일부 그래픽 카드에서 문제 발생되어 수정됨.
|
|
#if defined( _DEBUG )
|
|
m_pVB->Lock( (void**)&vtx, nVtxSize, D3DLOCK_NOSYSLOCK | D3DLOCK_DISCARD );
|
|
#else
|
|
m_pVB->Lock( (void**)&vtx, nVtxSize, D3DLOCK_DISCARD );
|
|
#endif
|
|
assert(vtx && "m_pVB->Lock( (void**)&vtx, nVtxSize );");
|
|
|
|
if( vtx == NULL ) return;
|
|
|
|
for(int it = 0; it < m_nCloudCount; ++it)
|
|
{
|
|
if( m_pCloud[ it ].IsActive() )
|
|
{
|
|
this->updateVB( &vtx[ nPrimCnt * 4 ], m_pCloud[ it ] );
|
|
}
|
|
else
|
|
{
|
|
vtx[ nPrimCnt * 4 + 0 ].color.a = 0;
|
|
vtx[ nPrimCnt * 4 + 1 ].color.a = 0;
|
|
vtx[ nPrimCnt * 4 + 2 ].color.a = 0;
|
|
vtx[ nPrimCnt * 4 + 3 ].color.a = 0;
|
|
}
|
|
++nPrimCnt;
|
|
}
|
|
|
|
m_pVB->Unlock();
|
|
m_pPrimitive->SetVertexCnt( nPrimCnt * 4 );
|
|
/*K3DMatrix mat;
|
|
K3DMatrixIdentity( mat );
|
|
//K3DMatrixRotationAxis( &mat, m_pVecCloud, (10.f*K3D_PI/180.f) );
|
|
K3DMatrixIdentity( m_LocalMat );
|
|
K3DMatrixSetPosVector( m_LocalMat, m_Pos );
|
|
K3DMatrixMultiply( &m_LocalMat, &mat, &m_LocalMat );
|
|
|
|
if( m_pParentMat )
|
|
K3DMatrixMultiply( &m_LocalMat, &m_LocalMat, m_pParentMat );*/
|
|
}
|
|
|
|
void SGameCloud::Render( KViewportObject *viewport )
|
|
{
|
|
if( m_pPrimitive && m_pPrimitive->GetVertexCnt() > 0 )
|
|
{
|
|
viewport->Register( m_pPrimitive, KRenderObject::RENDEREFX_CLOUD );
|
|
}
|
|
}
|
|
|
|
void SGameCloud::SetHeight( int i, float fz )
|
|
{
|
|
if( i >=0 && i < m_nCloudCount )
|
|
{
|
|
m_pCloud[i].vPosition.z = fz;
|
|
}
|
|
else
|
|
{
|
|
assert( !"SGameCloud : refered wrong index" );
|
|
}
|
|
|
|
//if( m_pThunderCloud )
|
|
// m_pThunderCloud->SetHeight( i, fz );
|
|
}
|
|
|
|
void SGameCloud::SetPosition( int i, float fx, float fy, float fz )
|
|
{
|
|
if( i >=0 && i < m_nCloudCount )
|
|
{
|
|
m_pCloud[i].SetPosition( fx, fy, fz );
|
|
}
|
|
else
|
|
{
|
|
assert( !"SGameCloud : refered wrong index" );
|
|
}
|
|
|
|
//if( m_pThunderCloud )
|
|
// m_pThunderCloud->SetPosition( i, fz, fy, fz );
|
|
}
|
|
|
|
void SGameCloud::SetMaxVisibility( int i, float fVis )
|
|
{
|
|
if( i >=0 && i < m_nCloudCount )
|
|
{
|
|
m_pCloud[i].SetVisibilityCap( fVis );
|
|
}
|
|
else
|
|
{
|
|
assert( !"SGameCloud : refered wrong index" );
|
|
}
|
|
|
|
//if( m_pThunderCloud )
|
|
// m_pThunderCloud->SetMaxVisibility( i, fVis );
|
|
}
|
|
|
|
void SGameCloud::SetVisibility( int i, float fVis )
|
|
{
|
|
if( i >=0 && i < m_nCloudCount )
|
|
{
|
|
m_pCloud[i].SetVisibility( fVis );
|
|
}
|
|
else
|
|
{
|
|
assert( !"SGameCloud : refered wrong index" );
|
|
}
|
|
|
|
//if( m_pThunderCloud )
|
|
// m_pThunderCloud->SetVisibility( i, fVis );
|
|
}
|
|
|
|
void SGameCloud::SetCloudColor( int i, K3DColor & color )
|
|
{
|
|
if( i >=0 && i < m_nCloudCount )
|
|
{
|
|
m_pCloud[ i ].SetColor( color );
|
|
}
|
|
else
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
//if( m_pThunderCloud )
|
|
// m_pThunderCloud->SetCloudColor( i, color );
|
|
}
|
|
|
|
void SGameCloud::SetCloudColor( KColor & color )
|
|
{
|
|
m_CloudColor = color;
|
|
|
|
if( m_pThunderCloud )
|
|
m_pThunderCloud->SetCloudColor( color );
|
|
}
|
|
|
|
void SGameCloud::SetEnableThunderFx( bool bEnable )
|
|
{
|
|
m_bEnableThunder = bEnable;
|
|
}
|
|
|
|
void SGameCloud::SetThunderCloud( SGameCloud* pThunderCloud )
|
|
{
|
|
m_pThunderCloud = pThunderCloud;
|
|
}
|
|
|
|
void SGameCloud::SetLightning( env_fx::SGameLightning* pLightning )
|
|
{
|
|
m_pLightning = pLightning;
|
|
}
|
|
|
|
void SGameCloud::SetTransform( K3DMatrix* pParentMatrix )
|
|
{
|
|
SetParentMat( pParentMatrix );
|
|
m_pPrimitive->SetTransform( pParentMatrix, pParentMatrix );
|
|
|
|
if( m_pThunderCloud )
|
|
m_pThunderCloud->SetTransform( pParentMatrix );
|
|
|
|
if( m_pLightning )
|
|
m_pLightning->SetParentMatrix( pParentMatrix );
|
|
}
|
|
|
|
SCloudObject* SGameCloud::GetFirstDeactiveCloud()
|
|
{
|
|
SCloudObject* pCloud = std::find_if(
|
|
&m_pCloud[ 0 ], &m_pCloud[ m_nCloudCount ], SFindFirstDeactiveCloud() );
|
|
|
|
if( pCloud != &m_pCloud[ m_nCloudCount ] )
|
|
return pCloud;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void SGameCloud::SetSoundManager( SGameMilesSoundMgr* pSoundMgr )
|
|
{
|
|
m_pSoundMgr = pSoundMgr;
|
|
}
|
|
|
|
void SGameCloud::initVB()
|
|
{
|
|
K3DVERTEX_CLOUD* vtx = NULL;
|
|
int nVtxSize;
|
|
m_pVB->Lock( (void**)&vtx, nVtxSize, D3DLOCK_NOSYSLOCK | D3DLOCK_DISCARD );
|
|
assert(vtx && "m_pVB->Lock( (void**)&vtx, nVtxSize );");
|
|
|
|
if( vtx == NULL ) return;
|
|
|
|
for( int n=0; 4 * m_nCloudCount > n; )
|
|
{
|
|
int nRand = rand() % 150 + 255;
|
|
vtx[n].position = K3DVector( (float)-m_nWidth/2.f, (float)-m_nHeight/2.f, 0 );
|
|
vtx[n].color = m_CloudColor;
|
|
vtx[n].color.a = nRand;
|
|
vtx[n].normal = K3DVector( 0.f, 0.f, -1.f);
|
|
vtx[n].texcoord0.x = 0.f;
|
|
vtx[n].texcoord0.y = 0.f;
|
|
//vtx[n].texcoord1.x = 0.f;
|
|
//vtx[n].texcoord1.y = 0.f;
|
|
n++;
|
|
vtx[n].position = K3DVector( m_nWidth / 2.f, (float)-m_nHeight/2.f, 0 );
|
|
vtx[n].color = m_CloudColor;
|
|
vtx[n].color.a = nRand;
|
|
vtx[n].normal = K3DVector( 0.f, 0.f, -1.f);
|
|
vtx[n].texcoord0.x = 1.f;
|
|
vtx[n].texcoord0.y = 0.f;
|
|
//vtx[n].texcoord1.x = 1.f;
|
|
//vtx[n].texcoord1.y = 0.f;
|
|
n++;
|
|
vtx[n].position = K3DVector( (float)-m_nWidth/2.f, m_nHeight / 2.f, 0 );
|
|
vtx[n].color = m_CloudColor;
|
|
vtx[n].color.a = nRand;
|
|
vtx[n].normal = K3DVector( 0.f, 0.f, -1.f);
|
|
vtx[n].texcoord0.x = 0.0f;
|
|
vtx[n].texcoord0.y = 1.f;
|
|
//vtx[n].texcoord1.x = 0.0f;
|
|
//vtx[n].texcoord1.y = 1.f;
|
|
n++;
|
|
vtx[n].position = K3DVector( m_nWidth / 2.f, m_nHeight / 2.f, 0 );
|
|
vtx[n].color = m_CloudColor;
|
|
vtx[n].color.a = nRand;
|
|
vtx[n].normal = K3DVector( 0.f, 0.f, -1.f);
|
|
vtx[n].texcoord0.x = 1.0f;
|
|
vtx[n].texcoord0.y = 1.f;
|
|
//vtx[n].texcoord1.x = 1.0f;
|
|
//vtx[n].texcoord1.y = 1.f;
|
|
n++;
|
|
}
|
|
m_pVB->Unlock();
|
|
m_pVB->Backup();
|
|
}
|
|
|
|
void SGameCloud::updateVB( K3DVERTEX_CLOUD* vtx, const SCloudObject& cloud )
|
|
{
|
|
vtx[ 0 ].position = cloud.GetVertexPosition( SCloudObject::UL );
|
|
vtx[ 1 ].position = cloud.GetVertexPosition( SCloudObject::UR );
|
|
vtx[ 2 ].position = cloud.GetVertexPosition( SCloudObject::BL );
|
|
vtx[ 3 ].position = cloud.GetVertexPosition( SCloudObject::BR );
|
|
|
|
for( short p = 0; p < 4; p++)
|
|
{
|
|
vtx[ p ].color = cloud.color;
|
|
vtx[ p ].normal = K3DVector( 0.f, 0.f, -1.f);
|
|
}
|
|
|
|
vtx[ 0 ].texcoord0.Set( 0, 0 );
|
|
vtx[ 1 ].texcoord0.Set( 1, 0 );
|
|
vtx[ 2 ].texcoord0.Set( 0, 1 );
|
|
vtx[ 3 ].texcoord0.Set( 1, 1 );
|
|
//vtx[ 0 ].texcoord1.Set( 0, 0 );
|
|
//vtx[ 1 ].texcoord1.Set( 1, 0 );
|
|
//vtx[ 2 ].texcoord1.Set( 0, 1 );
|
|
//vtx[ 3 ].texcoord1.Set( 1, 1 );
|
|
}
|
|
|
|
void SGameCloud::initCloudObjects()
|
|
{
|
|
m_pCloud = new SCloudObject[ m_nCloudCount ];
|
|
|
|
for(int i = 0; i < m_nCloudCount; ++i)
|
|
{
|
|
m_pCloud[i].nWidth = 1000+rand()/16000;//(float)(rand()/10000)+1400;
|
|
m_pCloud[i].nHeight = 1000+rand()/10000;//(float)(rand()/10000)+1400;
|
|
m_pCloud[i].dwStartTime = 0;
|
|
m_pCloud[i].dwOldTime = 0;
|
|
m_pCloud[i].fRotSpeed = fRotSpeed[0/*rand()%5*/];
|
|
m_pCloud[i].fVisibility = 0.8f;
|
|
m_pCloud[i].eStep = SCloudObject::MOVE;
|
|
}
|
|
}
|
|
|
|
void SGameCloud::processCloudObject( int nIndex )
|
|
{
|
|
assert( nIndex >= 0 && nIndex < m_nCloudCount && "wrong index" );
|
|
m_pCloud[ nIndex ].Update( m_dwTime, m_CloudColor );
|
|
|
|
if( m_bEnableThunder && m_pThunderCloud &&
|
|
m_pCloud[ nIndex ].IsStep( SCloudObject::MOVE ) &&
|
|
(float)( rand() % 100000 ) * 0.001f <= SCloudObject::s_fFactor )
|
|
{
|
|
SCloudObject* pCloud = m_pThunderCloud->GetFirstDeactiveCloud();
|
|
if( pCloud )
|
|
{
|
|
pCloud->SetActivity( true );
|
|
pCloud->ResetStartTime();
|
|
pCloud->vPosition = m_pCloud[ nIndex ].vPosition;
|
|
pCloud->vPosition.z = DEFAULT_HEIGHT_THUNDER_CLOUD;
|
|
pCloud->ChangeStep( SCloudObject::THUNDER );
|
|
pCloud->nWidth = m_pCloud[ nIndex ].nWidth;
|
|
pCloud->nHeight = m_pCloud[ nIndex ].nHeight;
|
|
}
|
|
|
|
// make lightning effect
|
|
if( m_pLightning )
|
|
{
|
|
float fRand = env_fx::util::GetRandomNumberInRange( 0.0f, 100.0f );
|
|
if( fRand <= SCloudObject::s_fLightningFactor )
|
|
{
|
|
//bLightningEnable = true;
|
|
m_pLightning->Emit( m_pCloud[ nIndex ].vPosition );
|
|
|
|
if( SCloudObject::s_strSound.size() > 0 )
|
|
_addSoundEvent( m_pCloud[ nIndex ].vPosition );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SGameCloud::_addSoundEvent( const K3DVector& addedPosition )
|
|
{
|
|
SSoundEvent* se = new SSoundEvent();
|
|
se->activeTime = m_dwTime
|
|
+ (DWORD)( SCloudObject::s_fSoundSpeed * addedPosition.Magnitude() );
|
|
se->activePos = addedPosition;
|
|
|
|
m_ctSoundEvents.push( se );
|
|
}
|
|
|
|
void SGameCloud::_procSoundEvent()
|
|
{
|
|
while( !m_ctSoundEvents.empty() )
|
|
{
|
|
SSoundEvent* se = 0;
|
|
se = m_ctSoundEvents.front();
|
|
if( se->activeTime >= m_dwTime )
|
|
{
|
|
//if( m_pSoundMgr )
|
|
//{
|
|
// m_pSoundMgr->PlaySound3D(
|
|
// SCloudObject::s_strSound.c_str(),
|
|
// se->activePos.x, se->activePos.y, se->activePos.z,
|
|
// 100, false, false, false );
|
|
//
|
|
//}
|
|
SAFE_DELETE( se );
|
|
m_ctSoundEvents.pop();
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
SGameThunderCloud::SGameThunderCloud( int cloud_count )
|
|
: SGameCloud ( cloud_count )
|
|
{
|
|
}
|
|
|
|
SGameThunderCloud::~SGameThunderCloud()
|
|
{
|
|
}
|
|
|
|
void SGameThunderCloud::initCloudObjects()
|
|
{
|
|
m_pCloud = new SThunderCloudObject[ m_nCloudCount ];
|
|
|
|
for(int i = 0; i < m_nCloudCount; ++i)
|
|
{
|
|
m_pCloud[i].nWidth = 1000+rand()/16000;//(float)(rand()/10000)+1400;
|
|
m_pCloud[i].nHeight = 1000+rand()/10000;//(float)(rand()/10000)+1400;
|
|
m_pCloud[i].dwStartTime = 0;
|
|
m_pCloud[i].dwOldTime = 0;
|
|
m_pCloud[i].fRotSpeed = fRotSpeed[0/*rand()%5*/];
|
|
m_pCloud[i].fVisibility = 0.8f;
|
|
m_pCloud[i].eStep = SCloudObject::MOVE;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef CLOUD_LUA
|
|
//---------------------------------------------------------------------------------------
|
|
// Kind
|
|
CCloudKindDB& GetCloudKindDB()
|
|
{
|
|
return *g_pCloudKindDB;
|
|
}
|
|
|
|
CCloudKindDB::CCloudKindDB()
|
|
{
|
|
|
|
}
|
|
|
|
CCloudKindDB::~CCloudKindDB()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
void CCloudKindDB::add(int id, SCloudKind* pKind)
|
|
{
|
|
if( pKind )
|
|
m_vcKind.push_back( pKind );
|
|
}
|
|
|
|
void CCloudKindDB::clear()
|
|
{
|
|
for(int i = 0; i < (int)m_vcKind.size(); ++i)
|
|
{
|
|
SCloudKind* p = m_vcKind[ i ];
|
|
SAFE_DELETE( p );
|
|
}
|
|
m_vcKind.clear();
|
|
}
|
|
|
|
void CCloudKindDB::size(int sz)
|
|
{
|
|
clear();
|
|
}
|
|
|
|
SCloudKind* CCloudKindDB::find(int id)
|
|
{
|
|
int k=0;
|
|
return m_vcKind[ id ];
|
|
}
|
|
|
|
float CCloudKindDB::calculateRate(int nKindID, int nGrade, int nMaxGrade)
|
|
{
|
|
// 9 : nTickness = ? : k
|
|
// ? = 9 x k / nTickness
|
|
// 9 : 33 = ? : 4
|
|
// ? = 9 * 4 / 33
|
|
double dbMock = 0.0f;
|
|
double nKindGapID = double( ( (float)nGrade * MAX_KIND_GRADE_F ) / (float)nMaxGrade );
|
|
float fNamujiRate = (float)modf(nKindGapID, &dbMock);
|
|
int nMock = (int)dbMock;
|
|
|
|
float fSZ0, fSZ1;
|
|
if ( nMock >= MAX_KIND_GRADE - 1 ) // 몫이 마지막이면
|
|
{
|
|
fSZ1 = (float)m_vcKind[ nKindID ]->v[ MAX_KIND_GRADE - 1 ] * RATE_CONVERT_100;
|
|
fSZ0 = (float)m_vcKind[ nKindID ]->v[ MAX_KIND_GRADE - 2 ] * RATE_CONVERT_100;
|
|
}
|
|
else if( nMock == 0 ) // 몫이 처음이면
|
|
{
|
|
fSZ1 = (float)m_vcKind[ nKindID ]->v[ 1 ] * RATE_CONVERT_100;
|
|
fSZ0 = (float)m_vcKind[ nKindID ]->v[ 0 ] * RATE_CONVERT_100;
|
|
}
|
|
else
|
|
{
|
|
fSZ1 = (float)m_vcKind[ nKindID ]->v[ nMock + 1 ] * RATE_CONVERT_100;
|
|
fSZ0 = (float)m_vcKind[ nKindID ]->v[ nMock ] * RATE_CONVERT_100;
|
|
}
|
|
|
|
float fRate = fSZ0 - ( (fSZ0 - fSZ1) * fNamujiRate );
|
|
if( fRate > 1.0f ) // 사실 이건 에러임!!
|
|
fRate = 1.0f;
|
|
|
|
return fRate;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// thickness
|
|
CCloudThicknessDB& GetCloudThicknessDB()
|
|
{
|
|
return *g_pCloudThicknesDB;
|
|
}
|
|
|
|
CCloudThicknessDB::CCloudThicknessDB()
|
|
{
|
|
|
|
}
|
|
|
|
CCloudThicknessDB::~CCloudThicknessDB()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
void CCloudThicknessDB::add(int id, int nThickness)
|
|
{
|
|
if( nThickness )
|
|
m_vcTickness.push_back( nThickness );
|
|
}
|
|
|
|
void CCloudThicknessDB::clear()
|
|
{
|
|
m_vcTickness.clear();
|
|
}
|
|
|
|
void CCloudThicknessDB::size(int sz)
|
|
{
|
|
clear();
|
|
}
|
|
|
|
int CCloudThicknessDB::find(int id)
|
|
{
|
|
return m_vcTickness[ id ];
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// thickness gap
|
|
CCloudThicknessGapDB& GetCloudThicknessGapDB()
|
|
{
|
|
return *g_pCloudThicknessGapDB;
|
|
}
|
|
|
|
CCloudThicknessGapDB::CCloudThicknessGapDB()
|
|
{
|
|
|
|
}
|
|
|
|
CCloudThicknessGapDB::~CCloudThicknessGapDB()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
void CCloudThicknessGapDB::add(int id, float fThickness)
|
|
{
|
|
if( fThickness > 0.0f )
|
|
m_vcTicknessGap.push_back( fThickness );
|
|
}
|
|
|
|
void CCloudThicknessGapDB::clear()
|
|
{
|
|
m_vcTicknessGap.clear();
|
|
}
|
|
|
|
void CCloudThicknessGapDB::size(int sz)
|
|
{
|
|
clear();
|
|
}
|
|
|
|
float CCloudThicknessGapDB::find(int id)
|
|
{
|
|
return m_vcTicknessGap[ id ];
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// Size
|
|
CCloudSizeDB& GetCloudSizeDB()
|
|
{
|
|
return *g_pCloudSizeDB;
|
|
}
|
|
|
|
CCloudSizeDB::CCloudSizeDB()
|
|
{
|
|
|
|
}
|
|
|
|
CCloudSizeDB::~CCloudSizeDB()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
void CCloudSizeDB::add(int id, SCloudSize* pSize)
|
|
{
|
|
int k=0;
|
|
if( pSize )
|
|
m_vcSize.push_back( pSize );
|
|
}
|
|
|
|
void CCloudSizeDB::clear()
|
|
{
|
|
for(int i = 0; i < (int)m_vcSize.size(); ++i)
|
|
{
|
|
SCloudSize* p = m_vcSize[ i ];
|
|
SAFE_DELETE( p );
|
|
}
|
|
m_vcSize.clear();
|
|
}
|
|
|
|
void CCloudSizeDB::size(int sz)
|
|
{
|
|
clear();
|
|
|
|
m_vcSize.resize(sz);
|
|
}
|
|
|
|
SCloudSize* CCloudSizeDB::find(int id)
|
|
{
|
|
int k=0;
|
|
return m_vcSize[ id ];
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// texture names
|
|
CCloudTxrNames::CCloudTxrNames()
|
|
{
|
|
|
|
}
|
|
|
|
CCloudTxrNames::~CCloudTxrNames()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
void CCloudTxrNames::add(int id, std::string* pStrTxrName)
|
|
{
|
|
if( pStrTxrName )
|
|
m_vcName.push_back( pStrTxrName );
|
|
}
|
|
|
|
void CCloudTxrNames::clear()
|
|
{
|
|
for(int i = 0; i < (int)m_vcName.size(); ++i)
|
|
{
|
|
std::string* p = m_vcName[ i ];
|
|
SAFE_DELETE( p );
|
|
}
|
|
m_vcName.clear();
|
|
}
|
|
|
|
void CCloudTxrNames::size(int sz)
|
|
{
|
|
clear();
|
|
}
|
|
|
|
std::string* CCloudTxrNames::find(int id)
|
|
{
|
|
if( id >= 0 && id < (int)m_vcName.size() )
|
|
return m_vcName[ id ];
|
|
return NULL;
|
|
}
|
|
|
|
// texture name group
|
|
CCloudTxrGroupDB& GetCloudTxrGroupDB()
|
|
{
|
|
return *g_pCloudTxrGroupDB;;
|
|
}
|
|
|
|
CCloudTxrGroupDB::CCloudTxrGroupDB()
|
|
{
|
|
|
|
}
|
|
|
|
CCloudTxrGroupDB::~CCloudTxrGroupDB()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
int CCloudTxrGroupDB::get_size(int brightness_type)
|
|
{
|
|
if ( brightness_type == NORMAL )
|
|
return (int)m_vcNormal.size();
|
|
else if( brightness_type == MIDDLE )
|
|
return (int)m_vcMiddle.size();
|
|
else if( brightness_type == DARK )
|
|
return (int)m_vcDark.size();
|
|
return 0;
|
|
}
|
|
|
|
void CCloudTxrGroupDB::add(int brightness_type, int id, CCloudTxrNames* pTxrNames)
|
|
{
|
|
int k=0;
|
|
if (brightness_type == NORMAL)
|
|
{
|
|
m_vcNormal.push_back( pTxrNames );
|
|
}
|
|
else if(brightness_type == MIDDLE)
|
|
{
|
|
m_vcMiddle.push_back( pTxrNames );
|
|
}
|
|
else if(brightness_type == DARK)
|
|
{
|
|
m_vcDark.push_back( pTxrNames );
|
|
}
|
|
}
|
|
|
|
void CCloudTxrGroupDB::clear(int brightness_type)
|
|
{
|
|
if (brightness_type == NORMAL)
|
|
{
|
|
for(int i = 0; i < (int)m_vcNormal.size(); ++i)
|
|
{
|
|
CCloudTxrNames* p = m_vcNormal[ i ];
|
|
SAFE_DELETE( p );
|
|
}
|
|
m_vcNormal.clear();
|
|
}
|
|
else if(brightness_type == MIDDLE)
|
|
{
|
|
for(int i = 0; i < (int)m_vcMiddle.size(); ++i)
|
|
{
|
|
CCloudTxrNames* p = m_vcMiddle[ i ];
|
|
SAFE_DELETE( p );
|
|
}
|
|
m_vcMiddle.clear();
|
|
}
|
|
else if(brightness_type == DARK)
|
|
{
|
|
for(int i = 0; i < (int)m_vcDark.size(); ++i)
|
|
{
|
|
CCloudTxrNames* p = m_vcDark[ i ];
|
|
SAFE_DELETE( p );
|
|
}
|
|
m_vcDark.clear();
|
|
}
|
|
else if(brightness_type == END)
|
|
{
|
|
clear( NORMAL );
|
|
clear( MIDDLE );
|
|
clear( DARK );
|
|
}
|
|
}
|
|
|
|
void CCloudTxrGroupDB::size(int brightness_type, int sz)
|
|
{
|
|
if (brightness_type == NORMAL)
|
|
{
|
|
clear( brightness_type );
|
|
}
|
|
else if(brightness_type == MIDDLE)
|
|
{
|
|
clear( brightness_type );
|
|
}
|
|
else if(brightness_type == DARK)
|
|
{
|
|
clear( brightness_type );
|
|
}
|
|
}
|
|
|
|
CCloudTxrNames* CCloudTxrGroupDB::find(int brightness_type, int id)
|
|
{
|
|
if (brightness_type == NORMAL)
|
|
{
|
|
if( id >= 0 && id < (int)m_vcNormal.size() )
|
|
return m_vcNormal[ id ];
|
|
}
|
|
else if(brightness_type == MIDDLE)
|
|
{
|
|
if( id >= 0 && id < (int)m_vcMiddle.size() )
|
|
return m_vcMiddle[ id ];
|
|
}
|
|
else if(brightness_type == DARK)
|
|
{
|
|
if( id >= 0 && id < (int)m_vcDark.size() )
|
|
return m_vcDark[ id ];
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
std::string* CCloudTxrGroupDB::find_str(int brightness_type, int id)
|
|
{
|
|
CCloudTxrNames* pCloudTxrName = GetCloudTxrGroupDB().find( brightness_type, id );
|
|
if( pCloudTxrName )
|
|
{
|
|
return pCloudTxrName->find( GetSafeTickCount() % (pCloudTxrName->get_size()) );
|
|
}
|
|
else
|
|
{
|
|
_oprint( "CCloudTxrNames : not find texturename" );
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// thickness
|
|
CCloudDistributionDB& GetCloudDistributionDB()
|
|
{
|
|
return *g_pCloudDistributionDB;
|
|
}
|
|
|
|
CCloudDistributionDB::CCloudDistributionDB()
|
|
{
|
|
|
|
}
|
|
|
|
CCloudDistributionDB::~CCloudDistributionDB()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
void CCloudDistributionDB::add(int id, int nDistribution)
|
|
{
|
|
if( nDistribution )
|
|
m_vcDistribution.push_back( nDistribution );
|
|
}
|
|
|
|
void CCloudDistributionDB::clear()
|
|
{
|
|
m_vcDistribution.clear();
|
|
}
|
|
|
|
void CCloudDistributionDB::size(int sz)
|
|
{
|
|
clear();
|
|
}
|
|
|
|
int CCloudDistributionDB::find(int id)
|
|
{
|
|
return m_vcDistribution[ id ];
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// distribution
|
|
CCloudHeightRadomGapDB& GetCloudHeightRadomGapDB()
|
|
{
|
|
return *g_pCloudHeightRadomGapDB;
|
|
}
|
|
|
|
CCloudHeightRadomGapDB::CCloudHeightRadomGapDB()
|
|
{
|
|
|
|
}
|
|
|
|
CCloudHeightRadomGapDB::~CCloudHeightRadomGapDB()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
void CCloudHeightRadomGapDB::add(int id, int nRadomGap)
|
|
{
|
|
m_vcRadomGap.push_back( nRadomGap );
|
|
}
|
|
|
|
void CCloudHeightRadomGapDB::clear()
|
|
{
|
|
m_vcRadomGap.clear();
|
|
}
|
|
|
|
void CCloudHeightRadomGapDB::size(int sz)
|
|
{
|
|
clear();
|
|
}
|
|
|
|
int CCloudHeightRadomGapDB::find(int id)
|
|
{
|
|
return m_vcRadomGap[ id ];
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// layer gap
|
|
CCloudLayerGapDB& GetCloudLayerGapDB()
|
|
{
|
|
return *g_pCloudCloudLayerGapDB;
|
|
}
|
|
|
|
CCloudLayerGapDB::CCloudLayerGapDB()
|
|
{
|
|
|
|
}
|
|
|
|
CCloudLayerGapDB::~CCloudLayerGapDB()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
void CCloudLayerGapDB::add(int id, int nLayerGap)
|
|
{
|
|
m_vcLayerGap.push_back( nLayerGap );
|
|
}
|
|
|
|
void CCloudLayerGapDB::clear()
|
|
{
|
|
m_vcLayerGap.clear();
|
|
}
|
|
|
|
void CCloudLayerGapDB::size(int sz)
|
|
{
|
|
clear();
|
|
}
|
|
|
|
int CCloudLayerGapDB::find(int id)
|
|
{
|
|
return m_vcLayerGap[ id ];
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// layer gap
|
|
CCloudMoveDirDB& GetCloudMoveDirDB()
|
|
{
|
|
return *g_pCloudCloudMoveDirDB;
|
|
}
|
|
|
|
CCloudMoveDirDB::CCloudMoveDirDB()
|
|
{
|
|
|
|
}
|
|
|
|
CCloudMoveDirDB::~CCloudMoveDirDB()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
void CCloudMoveDirDB::add(int id, int nMoveDir)
|
|
{
|
|
m_vcMoveDir.push_back( nMoveDir );
|
|
}
|
|
|
|
void CCloudMoveDirDB::clear()
|
|
{
|
|
m_vcMoveDir.clear();
|
|
}
|
|
|
|
void CCloudMoveDirDB::size(int sz)
|
|
{
|
|
clear();
|
|
}
|
|
|
|
int CCloudMoveDirDB::find(int id)
|
|
{
|
|
return m_vcMoveDir[ id ];
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// path
|
|
CCloudPathDB& GetCloudPathDB()
|
|
{
|
|
return *g_pCloudPathDB;
|
|
}
|
|
|
|
CCloudPathDB::CCloudPathDB()
|
|
{
|
|
|
|
}
|
|
|
|
CCloudPathDB::~CCloudPathDB()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
void CCloudPathDB::add(int id, SCloudPath* pPath)
|
|
{
|
|
if( pPath )
|
|
m_vcPath.push_back( pPath );
|
|
}
|
|
|
|
void CCloudPathDB::clear()
|
|
{
|
|
for(int i = 0; i < (int)m_vcPath.size(); ++i)
|
|
{
|
|
SCloudPath* p = m_vcPath[ i ];
|
|
SAFE_DELETE( p );
|
|
}
|
|
m_vcPath.clear();
|
|
}
|
|
|
|
void CCloudPathDB::size(int sz)
|
|
{
|
|
clear();
|
|
}
|
|
|
|
SCloudPath* CCloudPathDB::find(int id)
|
|
{
|
|
return m_vcPath[ id ];
|
|
}
|
|
|
|
float CCloudPathDB::calculateHeight(SCalculateHeightParam& sParam)
|
|
{
|
|
//-----------------------------------------------
|
|
// y
|
|
// ↑┌─────┐ N
|
|
// ││ → → → │ ↑
|
|
// ││ ← ← ← │ │
|
|
// ││ ↓ ↑ │ W ←─┼─→ E
|
|
// ││ ↓ ↑ │ │
|
|
// ││ │ ↓
|
|
// │└─────┘ S
|
|
// 0 ──────→x
|
|
//-----------------------------------------------
|
|
// max
|
|
// *
|
|
// * *
|
|
// * *
|
|
// * *
|
|
// start finish
|
|
//-----------------------------------------------
|
|
|
|
if( sParam.nPathType < 0 || sParam.nPathType >= (int)m_vcPath.size() )
|
|
return 0.0f;
|
|
|
|
int nLayerGap = 0;
|
|
if( sParam.nLayerGapType > 0 ) // 0번 타입은 기본 경로를 사용, 0번 타입보다 클때만 적용한다
|
|
nLayerGap = GetCloudLayerGapDB().find( sParam.nLayerGapType );
|
|
|
|
// x : (zonex / 2) = ? : max
|
|
// ? = max * x / (zonex / 2)
|
|
|
|
SCloudPath* pPath = m_vcPath[ sParam.nPathType ];
|
|
int max = pPath->max + nLayerGap;
|
|
float fMaxHeight = float(max);
|
|
float fHalfWidth = sParam.zoneX / 2.0f;
|
|
float fHalfHeight = sParam.zoneY / 2.0f;
|
|
float fResultHeight = 0.0f;
|
|
|
|
if (sParam.nDir == 0 || sParam.nDir == 1) // 동→ 서←
|
|
{
|
|
if( sParam.x < fHalfWidth )
|
|
{
|
|
fResultHeight = ( ( fMaxHeight * sParam.x ) / fHalfWidth );
|
|
|
|
if( sParam.y < fHalfHeight )
|
|
{
|
|
// fResultHeight : fHalfHeight = h : sParam.y
|
|
// h = sParam.y * fResultHeight / fHalfHeight;
|
|
float fH = fResultHeight * sParam.y / fHalfHeight;
|
|
fResultHeight = fH + pPath->start;
|
|
}
|
|
else
|
|
{
|
|
float ty = sParam.y - fHalfHeight;
|
|
float fH = fResultHeight * (fHalfHeight - ty) / fHalfHeight;
|
|
fResultHeight = fH + pPath->start;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
float tx = sParam.x - fHalfWidth;
|
|
fResultHeight = ( fMaxHeight - ( ( fMaxHeight * tx ) / fHalfWidth ) );
|
|
|
|
if( sParam.y < fHalfHeight )
|
|
{
|
|
float fH = fResultHeight * sParam.y / fHalfHeight;
|
|
fResultHeight = fH + pPath->start;
|
|
}
|
|
else
|
|
{
|
|
float ty = sParam.y - fHalfHeight;
|
|
float fH = fResultHeight * (fHalfHeight - ty) / fHalfHeight;
|
|
fResultHeight = fH + pPath->start;
|
|
}
|
|
}
|
|
}
|
|
else if(sParam.nDir == 2 || sParam.nDir == 3) // 남↓ 북↑
|
|
{
|
|
if( sParam.y < fHalfHeight )
|
|
{
|
|
fResultHeight = ( ( fMaxHeight * sParam.y ) / fHalfHeight );
|
|
|
|
if( sParam.x < fHalfWidth )
|
|
{
|
|
// fResultHeight : fHalfWidth = x : sParam.x
|
|
// x = sParam.x * fResultHeight / fHalfWidth;
|
|
float fW = fResultHeight * sParam.x / fHalfWidth;
|
|
fResultHeight = fW + pPath->start;
|
|
}
|
|
else
|
|
{
|
|
float tx = sParam.x - fHalfHeight;
|
|
float fW = fResultHeight * (fHalfWidth - tx) / fHalfWidth;
|
|
fResultHeight = fW + pPath->start;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
float ty = sParam.y - fHalfHeight;
|
|
fResultHeight = ( fMaxHeight - ( ( fMaxHeight * ty ) / fHalfHeight ) );
|
|
|
|
if( sParam.x < fHalfWidth )
|
|
{
|
|
float fW = fResultHeight * sParam.x / fHalfWidth;
|
|
fResultHeight = fW + pPath->start;
|
|
}
|
|
else
|
|
{
|
|
float tx = sParam.x - fHalfWidth;
|
|
float fW = fResultHeight * (fHalfWidth - tx) / fHalfWidth;
|
|
fResultHeight = fW + pPath->start;
|
|
}
|
|
}
|
|
}
|
|
return fResultHeight;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// cloud
|
|
CCloudTypeInfoDB& GetCloudTypeInfoDB()
|
|
{
|
|
return *g_pCloudTypeInfoDB;
|
|
}
|
|
|
|
CCloudTypeInfoDB::CCloudTypeInfoDB()
|
|
{
|
|
|
|
}
|
|
|
|
CCloudTypeInfoDB::~CCloudTypeInfoDB()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
void CCloudTypeInfoDB::add(int id, SCloudTypeInfo* pTypeInfo)
|
|
{
|
|
m_vcTypeInfo.push_back( pTypeInfo );
|
|
}
|
|
|
|
void CCloudTypeInfoDB::clear()
|
|
{
|
|
for(int i = 0; i < (int)m_vcTypeInfo.size(); ++i)
|
|
{
|
|
SCloudTypeInfo* p = m_vcTypeInfo[ i ];
|
|
SAFE_DELETE( p );
|
|
}
|
|
m_vcTypeInfo.clear();
|
|
}
|
|
|
|
void CCloudTypeInfoDB::size(int sz)
|
|
{
|
|
clear();
|
|
}
|
|
|
|
SCloudTypeInfo* CCloudTypeInfoDB::find(int id)
|
|
{
|
|
return m_vcTypeInfo[ id ];
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// appear layer
|
|
void SCloudLayer::add(int id, SCloudShowInfo* pLayer)
|
|
{
|
|
vcShowInfo.push_back( pLayer );
|
|
}
|
|
|
|
void SCloudLayer::clear()
|
|
{
|
|
for(int i = 0; i < (int)vcShowInfo.size(); ++i)
|
|
{
|
|
SCloudShowInfo* p = vcShowInfo[ i ];
|
|
SAFE_DELETE( p );
|
|
}
|
|
vcShowInfo.clear();
|
|
}
|
|
|
|
void SCloudLayer::size(int sz)
|
|
{
|
|
clear();
|
|
}
|
|
|
|
SCloudShowInfo* SCloudLayer::find(int id)
|
|
{
|
|
return vcShowInfo[ id ];
|
|
}
|
|
|
|
// appear layer
|
|
CCloudLayerDB* GetCloudLayerDB()
|
|
{
|
|
return g_pCloudLayerDB;
|
|
}
|
|
|
|
CCloudLayerDB::CCloudLayerDB()
|
|
{
|
|
int k=0;
|
|
}
|
|
|
|
CCloudLayerDB::~CCloudLayerDB()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
void CCloudLayerDB::add(int id, SCloudLayer* pLayer)
|
|
{
|
|
m_vcLayer.push_back( pLayer );
|
|
}
|
|
|
|
void CCloudLayerDB::clear()
|
|
{
|
|
for(int i = 0; i < (int)m_vcLayer.size(); ++i)
|
|
{
|
|
SCloudLayer* p = m_vcLayer[ i ];
|
|
SAFE_DELETE( p );
|
|
}
|
|
m_vcLayer.clear();
|
|
}
|
|
|
|
void CCloudLayerDB::size(int sz)
|
|
{
|
|
clear();
|
|
}
|
|
|
|
SCloudLayer* CCloudLayerDB::find(int id)
|
|
{
|
|
return m_vcLayer[ id ];
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// appear layer set
|
|
void SCloudLayerSet::add(int id, SCloudLayerInfo* pLayer)
|
|
{
|
|
vcLayerInfo.push_back( pLayer );
|
|
}
|
|
|
|
void SCloudLayerSet::clear()
|
|
{
|
|
for(int i = 0; i < (int)vcLayerInfo.size(); ++i)
|
|
{
|
|
SCloudLayerInfo* p = vcLayerInfo[ i ];
|
|
SAFE_DELETE( p );
|
|
}
|
|
vcLayerInfo.clear();
|
|
}
|
|
|
|
void SCloudLayerSet::size(int sz)
|
|
{
|
|
clear();
|
|
}
|
|
|
|
SCloudLayerInfo* SCloudLayerSet::find(int id)
|
|
{
|
|
return vcLayerInfo[ id ];
|
|
}
|
|
|
|
// appear layer
|
|
CCloudLayerSetDB* GetCloudLayerSetDB()
|
|
{
|
|
return g_pCloudLayerSetDB;
|
|
}
|
|
|
|
CCloudLayerSetDB::CCloudLayerSetDB()
|
|
{
|
|
|
|
}
|
|
|
|
CCloudLayerSetDB::~CCloudLayerSetDB()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
int CCloudLayerSetDB::get_size()
|
|
{
|
|
return (int)m_vcLayerSet.size();
|
|
}
|
|
|
|
void CCloudLayerSetDB::add(int id, SCloudLayerSet* pLayer)
|
|
{
|
|
m_vcLayerSet.push_back( pLayer );
|
|
}
|
|
|
|
void CCloudLayerSetDB::clear()
|
|
{
|
|
for(int i = 0; i < (int)m_vcLayerSet.size(); ++i)
|
|
{
|
|
SCloudLayerSet* p = m_vcLayerSet[ i ];
|
|
SAFE_DELETE( p );
|
|
}
|
|
m_vcLayerSet.clear();
|
|
}
|
|
|
|
void CCloudLayerSetDB::size(int sz)
|
|
{
|
|
clear();
|
|
|
|
// m_vcLayerSet.resize(sz);
|
|
}
|
|
|
|
SCloudLayerSet* CCloudLayerSetDB::find(int id)
|
|
{
|
|
return m_vcLayerSet[ id ];
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// SCloudVertexBufferPack
|
|
//---------------------------------------------------------------------------------------
|
|
void SCloudVertexBufferPack::add(K3DVERTEX_CLOUD* pVtx)
|
|
{
|
|
vcVB.push_back(pVtx);
|
|
}
|
|
|
|
void SCloudVertexBufferPack::add(int id, K3DVERTEX_CLOUD* pVtx)
|
|
{
|
|
vcVB.push_back(pVtx);
|
|
}
|
|
|
|
void SCloudVertexBufferPack::clear()
|
|
{
|
|
for(int i = 0; i < (int)vcVB.size(); ++i)
|
|
{
|
|
K3DVERTEX_CLOUD* p = vcVB[ i ];
|
|
SAFE_DELETE( p );
|
|
}
|
|
vcVB.clear();
|
|
}
|
|
|
|
K3DVERTEX_CLOUD* SCloudVertexBufferPack::find(int id)
|
|
{
|
|
if(id < 0 || id >= (int)vcVB.size())
|
|
return NULL;
|
|
return vcVB[ id ];
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// cloud unit
|
|
//---------------------------------------------------------------------------------------
|
|
CCloudUnit::CCloudUnit()
|
|
: SGameEnvCloud(), m_pDevice( 0 )
|
|
{
|
|
SetFadeState( FADE_NONE );
|
|
|
|
m_fMoveFrame = 0.0f;
|
|
m_fMovePosX = m_fMovePosY = m_fMovePosZ = 0.0f;
|
|
}
|
|
|
|
CCloudUnit::~CCloudUnit()
|
|
{
|
|
SAFE_DELETE(m_pPrimitive);
|
|
}
|
|
|
|
int CCloudUnit::make(SCloudCreateParam& pr)
|
|
{
|
|
m_fMoveFrame = 0.0f;
|
|
m_fMovePosX = m_vPos.x;
|
|
m_fMovePosY = m_vPos.y;
|
|
|
|
m_nDir = pr.nDir;
|
|
if ( m_nDir == 0 )
|
|
m_vDir = K3DVector(-1.0f, 0.0f, 0.0f);
|
|
else if( m_nDir == 1 )
|
|
m_vDir = K3DVector(1.0f, 0.0f, 0.0f);
|
|
else if( m_nDir == 2 )
|
|
m_vDir = K3DVector(0.0f, 1.0f, 0.0f);
|
|
else if( m_nDir == 3 )
|
|
m_vDir = K3DVector(0.0f, -1.0f, 0.0f);
|
|
|
|
int nCurrentTick = (int)GetSafeTickCount();
|
|
|
|
m_nType = pr.nType;
|
|
m_nLayerGap = pr.nLayerGapType;
|
|
m_nPath = pr.nPath;
|
|
|
|
SCloudTypeInfo* pTypeInfo = GetCloudTypeInfoDB().find( m_nType ); // 구름 타입정보를 구한다
|
|
if( pTypeInfo == NULL )
|
|
return 0;
|
|
|
|
m_nTypeSize = pTypeInfo->type_size; // 크기 타입
|
|
m_nTypeThickness = pTypeInfo->type_thickness; // 두께 타입
|
|
m_nTypeThicknessGap = pTypeInfo->type_thickness_gap; // 두께 간격 타입
|
|
m_nTypeTxrGroup[C_BRIGHT] = pTypeInfo->type_txr_normal; // 보통 덱스처 그룸 타입
|
|
m_nTypeTxrGroup[C_GRAY] = pTypeInfo->type_txr_middle; // 중간 밝기 텍스처 그룹 타입
|
|
m_nTypeTxrGroup[C_DARK] = pTypeInfo->type_txr_dark; // 어두운 텍스처 그룹 타입
|
|
m_fMoveSpeed = pTypeInfo->fMoveSpeed; // 이동 속도
|
|
|
|
m_nThickness = GetCloudThicknessDB().find( m_nTypeThickness ); // 구름 두께 구함
|
|
if( m_nThickness <= 0 )
|
|
return -1;
|
|
|
|
float fThicknessGap = GetCloudThicknessGapDB().find( m_nTypeThicknessGap ); // 구름 두께 간격 ( 구름 평면간의 간격 )
|
|
if( fThicknessGap < 0.0f )
|
|
return -2;
|
|
|
|
SCloudKind* pKind = GetCloudKindDB().find( m_nType ); // 구름모양의 종류 디비
|
|
if( pKind == NULL )
|
|
return -3;
|
|
|
|
SCloudSize* pSizeType = GetCloudSizeDB().find( m_nTypeSize ); // cloud size
|
|
if( pSizeType == NULL )
|
|
return -4;
|
|
|
|
float fSizeGap = pSizeType->e - pSizeType->s;
|
|
int nSGap = 3;
|
|
if( fSizeGap < 0.0f )
|
|
nSGap = 1;
|
|
|
|
float fCloudSize100 = (float)( (GetSafeTickCount() % nSGap) + pSizeType->s );
|
|
float fRealSizeW2 = fCloudSize100 / 2.0f;
|
|
|
|
// height
|
|
float fHeight = pr.fStandardHeight + ((float)m_nThickness * fThicknessGap);
|
|
|
|
GenerateCloudTexture( CCloudTxrGroupDB::NORMAL ); // 밝은 텍스처
|
|
GenerateCloudTexture( CCloudTxrGroupDB::MIDDLE ); // 중간 밝기 텍스처
|
|
GenerateCloudTexture( CCloudTxrGroupDB::DARK ); // 어두운 텍스처
|
|
|
|
|
|
int nHalfCount = m_nThickness / 2;
|
|
|
|
int j=0;
|
|
float fG = 1.0f / (float)nHalfCount;
|
|
|
|
for(int k=m_nThickness; k>0; k--)
|
|
{
|
|
float fRate = GetCloudKindDB().calculateRate(m_nType, k, m_nThickness); // 지정된 두께 비율에 따라 현재 단계의 비율을 구한다
|
|
|
|
float fCurrentCloudSize = fRate + fCloudSize100; // 구름 타입의 9단계 비율과 구름 두께의 비율이 조합된 현재 단계의 구름 크기
|
|
|
|
float fRealSizeW = (float)pSizeType->s + ( fSizeGap * fRate); // cloud size height
|
|
float fRealSizeW2 = fRealSizeW / 2.0f;
|
|
|
|
float fRealSizeH = (float)pSizeType->s + ( fSizeGap * fRate); // cloud size height
|
|
float fRealSizeH2 = fRealSizeH / 2.0f;
|
|
|
|
KColor cloudColor(pr.color[1], pr.color[2], pr.color[3], pr.color[0]);
|
|
|
|
int id = k * ONE_CLOUD_PLANE_VTX_COUNT; // 구름 한 평면당 버텍스 4
|
|
int nColorType = 0;
|
|
if ( k == 0 ) // 바닥은 어두운 텍스처
|
|
nColorType = C_DARK;
|
|
else if( k < nHalfCount ) // 중간까지는 중간 밝기 텍스처
|
|
nColorType = C_GRAY;
|
|
else if( k >= nHalfCount ) // 중간 이상은 가장 밝은 텍스처
|
|
{
|
|
nColorType = C_BRIGHT;
|
|
|
|
float rx = tan( fG * (float)(j) ) / 1.57079f;
|
|
|
|
cloudColor.a = BYTE( 255.0f * rx );
|
|
|
|
j++;
|
|
}
|
|
|
|
K3DVERTEX_CLOUD* pVtx = new K3DVERTEX_CLOUD[ ONE_CLOUD_PLANE_VTX_COUNT ];
|
|
pVtx[ 0 ].position = K3DVector( pr.fx - fRealSizeW2, pr.fy - fRealSizeH2, fHeight );
|
|
pVtx[ 0 ].color = cloudColor;
|
|
pVtx[ 0 ].normal = K3DVector( 0.0f, 0.0f, 1.0f );
|
|
pVtx[ 0 ].texcoord0.Set(0.0f, 0.0f);
|
|
pVtx[ 1 ].position = K3DVector( pr.fx + fRealSizeW2, pr.fy - fRealSizeH2, fHeight );
|
|
pVtx[ 1 ].color = cloudColor;
|
|
pVtx[ 1 ].normal = K3DVector( 0.0f, 0.0f, 1.0f );
|
|
pVtx[ 1 ].texcoord0.Set(1.0f, 0.0f);
|
|
pVtx[ 2 ].position = K3DVector( pr.fx - fRealSizeW2, pr.fy + fRealSizeH2, fHeight );
|
|
pVtx[ 2 ].color = cloudColor;
|
|
pVtx[ 2 ].normal = K3DVector( 0.0f, 0.0f, 1.0f );
|
|
pVtx[ 2 ].texcoord0.Set(0.0f, 1.0f);
|
|
pVtx[ 3 ].position = K3DVector( pr.fx + fRealSizeW2, pr.fy + fRealSizeH2, fHeight );
|
|
pVtx[ 3 ].color = cloudColor;
|
|
pVtx[ 3 ].normal = K3DVector( 0.0f, 0.0f, 1.0f );
|
|
pVtx[ 3 ].texcoord0.Set(1.0f, 1.0f);
|
|
|
|
m_VBPack[ nColorType ].add( &pVtx[ 0 ] );
|
|
m_VBPack[ nColorType ].add( &pVtx[ 1 ] );
|
|
m_VBPack[ nColorType ].add( &pVtx[ 2 ] );
|
|
m_VBPack[ nColorType ].add( &pVtx[ 3 ] );
|
|
|
|
fHeight -= fThicknessGap; // cloud height
|
|
}
|
|
|
|
GenerateCloudVertexBuffer();
|
|
|
|
return 1;
|
|
}
|
|
|
|
void CCloudUnit::GenerateCloudTexture(int nColorType)
|
|
{
|
|
if(nColorType < C_BRIGHT || nColorType >= C_MAX)
|
|
return ;
|
|
|
|
std::string* pStrTxrName = GetCloudTxrGroupDB().find_str( nColorType, m_nTypeTxrGroup[ nColorType ] );
|
|
if( pStrTxrName->size() <= 3 )
|
|
return ;
|
|
|
|
NX3LoadPack loadpack;
|
|
loadpack.Init();
|
|
|
|
K3DTexture* pTexture = KTextureManager::GetManager()->GetTexture( pStrTxrName->c_str(), &loadpack, true, KTextureManager::GetManager()->GetMipMapBiasLevel() );
|
|
if( pTexture == NULL )
|
|
return ;
|
|
|
|
m_pPrimitive->SetTexture( nColorType, pTexture ); // 텍스처 설정
|
|
}
|
|
|
|
void CCloudUnit::GenerateCloudVertexBuffer()
|
|
{
|
|
m_pPrimitive->ClearVertexBuffer();
|
|
|
|
for(int y=C_BRIGHT; y<C_MAX; y++)
|
|
{
|
|
int count = m_VBPack[ y ].get_size();
|
|
if( count <= 0 )
|
|
continue;
|
|
|
|
DWORD dwFormat = 0;
|
|
K3DVertexBuffer* pVB = m_pDevice->CreateVertexBufferUsePoolDefault(
|
|
sizeof(K3DVERTEX_CLOUD), dwFormat,
|
|
ONE_CLOUD_PLANE_VTX_COUNT * count,
|
|
D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY ); // 버텍스 버퍼 만듦
|
|
if( pVB == NULL )
|
|
assert(pVB && "Failed CreateVertexBufferUsePoolDefault");
|
|
|
|
// 버텍스 버퍼에 락걸고 내용을 채운다
|
|
int nVtxSize, nPrimCnt = 0;
|
|
K3DVERTEX_CLOUD* pVtx = NULL;
|
|
|
|
#if defined( _DEBUG ) // D3DLOCK_NOOVERWRITE 옵션이 일부 그래픽 카드에서 문제 발생되어 수정됨
|
|
pVB->Lock( (void**)&pVtx, nVtxSize, D3DLOCK_NOSYSLOCK | D3DLOCK_DISCARD );
|
|
#else
|
|
pVB->Lock( (void**)&pVtx, nVtxSize, D3DLOCK_DISCARD );
|
|
#endif
|
|
assert(vtx && "pVB->Lock( (void**)&vtx, nVtxSize );");
|
|
if( pVtx == NULL )
|
|
return;
|
|
|
|
int nPlaneCount = count / ONE_CLOUD_PLANE_VTX_COUNT;
|
|
|
|
for(int x=0; x<count; x++)
|
|
{
|
|
pVtx[ x ] = *m_VBPack[ y ].find( x );
|
|
}
|
|
|
|
nPrimCnt += count; // 4 : 평면당 버텍스 4개씩
|
|
|
|
pVB->Unlock();
|
|
m_pPrimitive->SetVertexCnt( y, nPrimCnt );
|
|
|
|
if( pVB )
|
|
m_pPrimitive->SetVertexBuffer( y, pVB ); // 렌더링 프리미티브에 버퍼 연결
|
|
|
|
|
|
// 인덱스 버퍼
|
|
int nInBCount = nPlaneCount * ONE_CLOUD_PLANE_INDEX_COUNT;
|
|
K3DIndexBuffer* pIB = m_pDevice->CreateIndexBuffer( nInBCount );
|
|
if( pIB == NULL )
|
|
assert(pIB && "Failed CreateIndexBuffer");
|
|
|
|
WORD *idxb;
|
|
int idxSize;
|
|
pIB->Lock((void **)&idxb, idxSize);
|
|
assert(idxb && "pIB->Lock((void **)&idxb, idxSize);");
|
|
|
|
int kid = 0;
|
|
for(int k = 0; k < nPlaneCount; k++, kid += ONE_CLOUD_PLANE_INDEX_COUNT)
|
|
{
|
|
idxb[ kid + 0 ] = k * ONE_CLOUD_PLANE_VTX_COUNT + 0;
|
|
idxb[ kid + 1 ] = k * ONE_CLOUD_PLANE_VTX_COUNT + 1;
|
|
idxb[ kid + 2 ] = k * ONE_CLOUD_PLANE_VTX_COUNT + 2;
|
|
idxb[ kid + 3 ] = k * ONE_CLOUD_PLANE_VTX_COUNT + 3;
|
|
idxb[ kid + 4 ] = k * ONE_CLOUD_PLANE_VTX_COUNT + 2;
|
|
idxb[ kid + 5 ] = k * ONE_CLOUD_PLANE_VTX_COUNT + 1;
|
|
}
|
|
pIB->Unlock();
|
|
|
|
if( pIB )
|
|
m_pPrimitive->SetIndexBuffer( y, pIB ); // 렌더링 프리미티브에 버퍼 연결
|
|
}
|
|
}
|
|
|
|
void CCloudUnit::UpdatePos( float fx, float fy, float fz )
|
|
{
|
|
int k=0;
|
|
}
|
|
|
|
void CCloudUnit::Init( K3DRenderDevice *pDevice, K3DIndexBuffer * pIndexBuf )
|
|
{
|
|
m_pDevice = pDevice;
|
|
|
|
m_pMtl = new K3DMaterial;
|
|
m_pMtl->SetAmbient( K3DColor( 1.f, 0.f, 0.f, 0.f ) );
|
|
m_pMtl->SetDiffuse( K3DColor( 1.f, 0.f, 0.f, 0.f ) );
|
|
m_pMtl->SetSpecular( K3DColor( 0.f, 0.f, 0.f, 0.f ) );
|
|
m_pMtl->SetSpecularPower( 1.0f );
|
|
|
|
m_pParentMat = NULL; // SkyBox 위치
|
|
K3DMatrixIdentity( m_LocalMat ); // 구름 위치
|
|
K3DMatrixIdentity( m_WorldMat );
|
|
|
|
m_pPrimitive->SetTransparent( true );
|
|
m_pPrimitive->SetTransform( &m_LocalMat, &m_WorldMat );
|
|
m_pPrimitive->SetMaterial( m_pMtl );
|
|
}
|
|
|
|
int CCloudUnit::ProcessSecond( DWORD dwTime )
|
|
{
|
|
DWORD dwFrameTick = dwTime - m_dwTickOld;
|
|
if( dwFrameTick < 0 )
|
|
return 0;
|
|
|
|
// 속도 = 움직인 거리 / 단위시간
|
|
// 거리 = 시간 * 속도
|
|
// 시간 = 거리 / 속도
|
|
float fGap = (float)dwFrameTick * (float)m_fMoveSpeed;
|
|
if ( m_nDir == 0 )
|
|
{
|
|
m_fMoveFrame += ( m_vDir.x * fGap );
|
|
m_fMovePosX = m_vPos.x + m_fMoveFrame;
|
|
if( m_fMovePosX < -ZONE_CLOUD_WIDTH_D2 )
|
|
{
|
|
m_fMoveFrame = ZONE_CLOUD_WIDTH_D2;
|
|
m_fMovePosX = ZONE_CLOUD_WIDTH_D2;
|
|
}
|
|
}
|
|
else if( m_nDir == 1 )
|
|
{
|
|
m_fMoveFrame += ( m_vDir.x * fGap );
|
|
m_fMovePosX = m_vPos.x + m_fMoveFrame;
|
|
if( m_fMovePosX > ZONE_CLOUD_WIDTH_D2 )
|
|
{
|
|
m_fMoveFrame = -ZONE_CLOUD_WIDTH_D2;
|
|
m_fMovePosX = -ZONE_CLOUD_WIDTH_D2;
|
|
}
|
|
}
|
|
else if( m_nDir == 2 )
|
|
{
|
|
m_fMoveFrame += ( m_vDir.y * fGap );
|
|
m_fMovePosY = m_vPos.y + m_fMoveFrame;
|
|
if( m_fMovePosY > ZONE_CLOUD_HEIGHT_D2 )
|
|
{
|
|
m_fMoveFrame = -ZONE_CLOUD_HEIGHT_D2;
|
|
m_fMovePosY = -ZONE_CLOUD_HEIGHT_D2;
|
|
}
|
|
}
|
|
else if( m_nDir == 3 )
|
|
{
|
|
m_fMoveFrame += ( m_vDir.y * fGap );
|
|
m_fMovePosY = m_vPos.y + m_fMoveFrame;
|
|
if( m_fMovePosY < -ZONE_CLOUD_HEIGHT_D2 )
|
|
{
|
|
m_fMoveFrame = ZONE_CLOUD_HEIGHT_D2;
|
|
m_fMovePosY = ZONE_CLOUD_HEIGHT_D2;
|
|
}
|
|
}
|
|
|
|
SCalculateHeightParam sParam;
|
|
sParam.nLayerGapType = m_nLayerGap;
|
|
sParam.nPathType = m_nPath;
|
|
sParam.nDir = m_nDir;
|
|
sParam.x = m_fMovePosX + ZONE_CLOUD_WIDTH_D2;
|
|
sParam.y = m_fMovePosY + ZONE_CLOUD_HEIGHT_D2;
|
|
sParam.zoneX = ZONE_CLOUD_WIDTH;
|
|
sParam.zoneY = ZONE_CLOUD_HEIGHT;
|
|
|
|
m_fMovePosZ = GetCloudPathDB().calculateHeight( sParam );
|
|
m_fMovePosZ -= g_fMyPlayerHeight;
|
|
|
|
m_dwTickOld = dwTime;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void CCloudUnit::SetFadeState( int nState )
|
|
{
|
|
m_sFadeState = nState;
|
|
|
|
if ( m_sFadeState == FADE_IN )
|
|
m_fAlpha = 0.0f;
|
|
else if( m_sFadeState == FADE_OUT )
|
|
m_fAlpha = 1.0f;
|
|
}
|
|
|
|
// 서서히 알파값 높아져 투명하게 변화시킴
|
|
int CCloudUnit::IncreaseAlpha( DWORD dwFrameTick )
|
|
{
|
|
m_fAlpha += (float)dwFrameTick / FADE_ALPHA_TIME;
|
|
|
|
float fCurAlpha = m_fAlpha;
|
|
float fCurAlpha2 = fCurAlpha;
|
|
if( fCurAlpha > 1.0f )
|
|
fCurAlpha = 1.0f;
|
|
|
|
UpdateAlpha( fCurAlpha );
|
|
|
|
return 1;
|
|
}
|
|
|
|
// 서서히 알파값 낮아져 불투명하게 변화시킴
|
|
int CCloudUnit::DecreaseAlpha( DWORD dwFrameTick )
|
|
{
|
|
m_fAlpha -= (float)dwFrameTick / FADE_ALPHA_TIME;
|
|
|
|
float fCurAlpha = m_fAlpha;
|
|
float fCurAlpha2 = fCurAlpha;
|
|
if( fCurAlpha < 0.0f )
|
|
fCurAlpha = 0.0f;
|
|
|
|
UpdateAlpha( fCurAlpha );
|
|
|
|
return 1;
|
|
}
|
|
|
|
void CCloudUnit::UpdateAlpha( float fAlpha )
|
|
{
|
|
for(int y=C_BRIGHT; y<C_MAX; y++)
|
|
{
|
|
int count = m_VBPack[ y ].get_size();
|
|
if( count <= 0 )
|
|
continue;
|
|
|
|
K3DVertexBuffer* pVB = m_pPrimitive->GetVertexBuffer( y );
|
|
if( pVB == NULL )
|
|
continue ;
|
|
|
|
// 버텍스 버퍼에 락걸고 내용을 채운다
|
|
int nVtxSize, nPrimCnt = 0;
|
|
K3DVERTEX_CLOUD* pVtx = NULL;
|
|
|
|
#if defined( _DEBUG ) // D3DLOCK_NOOVERWRITE 옵션이 일부 그래픽 카드에서 문제 발생되어 수정됨
|
|
pVB->Lock( (void**)&pVtx, nVtxSize, D3DLOCK_NOSYSLOCK | D3DLOCK_DISCARD );
|
|
#else
|
|
pVB->Lock( (void**)&pVtx, nVtxSize, D3DLOCK_DISCARD );
|
|
#endif
|
|
assert(vtx && "pVB->Lock( (void**)&vtx, nVtxSize );");
|
|
if( pVtx == NULL )
|
|
return;
|
|
|
|
for(int x=0; x<count; x++)
|
|
{
|
|
pVtx[ x ] = *m_VBPack[ y ].find( x );
|
|
pVtx[ x ].color.a = fAlpha;
|
|
}
|
|
pVB->Unlock();
|
|
}
|
|
}
|
|
|
|
void CCloudUnit::UpdateAlphaBrightLayer()
|
|
{
|
|
int y=C_BRIGHT;
|
|
{
|
|
int count = m_VBPack[ y ].get_size();
|
|
if( count <= 0 )
|
|
return ;
|
|
|
|
K3DVertexBuffer* pVB = m_pPrimitive->GetVertexBuffer( y );
|
|
if( pVB == NULL )
|
|
return ;
|
|
|
|
// 버텍스 버퍼에 락걸고 내용을 채운다
|
|
int nVtxSize, nPrimCnt = 0;
|
|
K3DVERTEX_CLOUD* pVtx = NULL;
|
|
|
|
#if defined( _DEBUG ) // D3DLOCK_NOOVERWRITE 옵션이 일부 그래픽 카드에서 문제 발생되어 수정됨
|
|
pVB->Lock( (void**)&pVtx, nVtxSize, D3DLOCK_NOSYSLOCK | D3DLOCK_DISCARD );
|
|
#else
|
|
pVB->Lock( (void**)&pVtx, nVtxSize, D3DLOCK_DISCARD );
|
|
#endif
|
|
assert(vtx && "pVB->Lock( (void**)&vtx, nVtxSize );");
|
|
if( pVtx == NULL )
|
|
return;
|
|
|
|
int nPlaneCount = count / ONE_CLOUD_PLANE_VTX_COUNT;
|
|
float fG = 1.0f / (float)nPlaneCount;
|
|
|
|
for(int x=0; x<count; x++)
|
|
{
|
|
pVtx[ x ] = *m_VBPack[ y ].find( x );
|
|
|
|
int j = x / 4;
|
|
float rx = tan( fG * (float)(j) ) / 1.57079f;
|
|
|
|
pVtx[ x ].color.a = BYTE( 255.0f * rx );
|
|
}
|
|
pVB->Unlock();
|
|
}
|
|
}
|
|
|
|
void CCloudUnit::Render( KViewportObject *viewport )
|
|
{
|
|
if( m_pPrimitive )
|
|
{
|
|
viewport->Register( m_pPrimitive, KRenderObject::RENDEREFX_CLOUD );
|
|
}
|
|
}
|
|
|
|
void CCloudUnit::SetHeight( int i, float fz )
|
|
{
|
|
}
|
|
|
|
void CCloudUnit::SetPosition( float fx, float fy, float fz )
|
|
{
|
|
m_vPos.x = fx;
|
|
m_vPos.y = fy;
|
|
m_vPos.z = fz;
|
|
}
|
|
|
|
K3DVector& CCloudUnit::GetPosition()
|
|
{
|
|
return m_vPos;
|
|
}
|
|
|
|
void CCloudUnit::UpdatePosition(float fx, float fy, float fz)
|
|
{
|
|
SGameWorld* pGameWorld = dynamicCast<SGameWorld*>(g_pCurrentGameSystem->GetGame());
|
|
|
|
float gfx = 0.0f;
|
|
float gfy = 0.0f;
|
|
float gfz = 0.0f;
|
|
SGameAvatarEx* pMyCharacter = g_pCurrentGameSystem->GetLocalPlayer();
|
|
if( pMyCharacter )
|
|
{
|
|
float out;
|
|
WORD wTile;
|
|
K3DVector vPos = pMyCharacter->GetCurPos();
|
|
pGameWorld->GetHeight( vPos.x, vPos.y, out, wTile );
|
|
gfz = pMyCharacter->GetCurPos().z;
|
|
gfz = out;
|
|
}
|
|
|
|
K3DMatrix* pMat = m_pPrimitive->GetTransform();
|
|
pMat->_41 = m_fMovePosX + g_fX + gfx;
|
|
pMat->_42 = m_fMovePosY + g_fY + gfy;
|
|
pMat->_43 = m_fMovePosZ + fz + g_fZ + gfz;
|
|
}
|
|
|
|
void CCloudUnit::SetTransform( K3DMatrix* pParentMatrix )
|
|
{
|
|
SetParentMat( pParentMatrix );
|
|
m_pPrimitive->SetTransform( pParentMatrix, pParentMatrix );
|
|
}
|
|
|
|
void CCloudUnit::initVB()
|
|
{
|
|
}
|
|
|
|
void CCloudUnit::initCloudObjects()
|
|
{
|
|
}
|
|
|
|
void CCloudUnit::ChangeCloudColor(int nR, int nG, int nB)
|
|
{
|
|
int count = m_VBPack[ C_BRIGHT ].get_size();
|
|
if( count <= 0 )
|
|
return ;
|
|
|
|
K3DVertexBuffer* pVB = m_pPrimitive->GetVertexBuffer( C_BRIGHT );
|
|
if( pVB == NULL )
|
|
return ;
|
|
|
|
// 버텍스 버퍼에 락걸고 내용을 채운다
|
|
int nVtxSize, nPrimCnt = 0;
|
|
K3DVERTEX_CLOUD* pVtx = NULL;
|
|
|
|
#if defined( _DEBUG ) // D3DLOCK_NOOVERWRITE 옵션이 일부 그래픽 카드에서 문제 발생되어 수정됨
|
|
pVB->Lock( (void**)&pVtx, nVtxSize, D3DLOCK_NOSYSLOCK | D3DLOCK_DISCARD );
|
|
#else
|
|
pVB->Lock( (void**)&pVtx, nVtxSize, D3DLOCK_DISCARD );
|
|
#endif
|
|
assert(vtx && "pVB->Lock( (void**)&vtx, nVtxSize );");
|
|
if( pVtx == NULL )
|
|
return;
|
|
|
|
int _r = nR; // - pVtx->color.r;
|
|
int _g = nG; // - pVtx->color.g;
|
|
int _b = nB; // - pVtx->color.b;
|
|
|
|
int j=0;
|
|
int nPlaneCount = count / ONE_CLOUD_PLANE_VTX_COUNT;
|
|
float fG = 1.0f / (float)nPlaneCount;
|
|
for(int k=nPlaneCount; k>0; k--, j++)
|
|
{
|
|
float rx = tan( fG * (float)j ) / 1.57079f;
|
|
|
|
int id = (k - 1) * ONE_CLOUD_PLANE_VTX_COUNT;
|
|
for(int z=0; z<ONE_CLOUD_PLANE_VTX_COUNT; z++)
|
|
{
|
|
K3DVERTEX_CLOUD* pV = m_VBPack[ C_BRIGHT ].find( id + z );
|
|
|
|
pV->color.r = _r;
|
|
pV->color.g = _g;
|
|
pV->color.b = _b;
|
|
}
|
|
}
|
|
pVB->Unlock();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// cloud uni manager
|
|
CCloudLayer::CCloudLayer()
|
|
{
|
|
}
|
|
|
|
CCloudLayer::~CCloudLayer()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
void CCloudLayer::add(int id, CCloudUnit* pCloud)
|
|
{
|
|
m_vcCloud.push_back( pCloud );
|
|
}
|
|
|
|
void CCloudLayer::clear()
|
|
{
|
|
int nCount = m_vcCloud.size();
|
|
for(int x=0; x<nCount; x++)
|
|
{
|
|
CCloudUnit* pCloud = m_vcCloud[x];
|
|
SAFE_DELETE( pCloud );
|
|
}
|
|
m_vcCloud.clear();
|
|
}
|
|
|
|
void CCloudLayer::size(int sz)
|
|
{
|
|
m_vcCloud.resize(sz);
|
|
}
|
|
|
|
CCloudUnit* CCloudLayer::find(int id)
|
|
{
|
|
return m_vcCloud[ id ];
|
|
}
|
|
|
|
int CCloudLayer::makeClouds(SCloudParam& sParam)
|
|
{
|
|
if( sParam.pCloudShowInfo == NULL )
|
|
return -1;
|
|
|
|
int nCurTick = GetSafeTickCount();
|
|
|
|
m_sParam.nTypeDistribution = sParam.nTypeDistribution;
|
|
m_sParam.nLayerGapType = sParam.nLayerGapType;
|
|
m_sParam.nTypeMoveDir = sParam.nTypeMoveDir;
|
|
m_sParam.nTypePathType = sParam.nTypePathType;
|
|
m_sParam.nTypeCloudHeightRandomGap = sParam.nTypeCloudHeightRandomGap;
|
|
|
|
float fLayerHeight = (float)GetCloudLayerGapDB().find( m_sParam.nLayerGapType );
|
|
|
|
// 분포도 값
|
|
int tDistribution = GetCloudDistributionDB().find( m_sParam.nTypeDistribution );
|
|
|
|
int tHeightRadomGap = GetCloudHeightRadomGapDB().find( m_sParam.nTypeCloudHeightRandomGap );
|
|
|
|
int sz = (int)sParam.pCloudShowInfo->vcShowInfo.size();
|
|
|
|
std::vector< int > vecCount;
|
|
std::vector< POINT > vecXY;
|
|
|
|
int nTotalCount = 0;
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
SCloudShowInfo* pShowInfo = sParam.pCloudShowInfo->find( x );
|
|
if( pShowInfo == NULL )
|
|
return -4;
|
|
|
|
// 구름의 개수
|
|
int nCloudCount = (tDistribution * pShowInfo->type_show_rate) / 100;
|
|
|
|
for(int z=0; z<nCloudCount; z++)
|
|
{
|
|
POINT pt;
|
|
pt.x = rand() % (int)ZONE_CLOUD_WIDTH;
|
|
pt.y = rand() % (int)ZONE_CLOUD_HEIGHT;
|
|
vecXY.push_back( pt );
|
|
}
|
|
|
|
vecCount.push_back(nCloudCount);
|
|
|
|
nTotalCount += nCloudCount;
|
|
}
|
|
|
|
int id = 0;
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
SCloudShowInfo* pShowInfo = sParam.pCloudShowInfo->find( x );
|
|
if( pShowInfo == NULL )
|
|
return -4;
|
|
|
|
for(int z=0; z<vecCount[ x ]; z++)
|
|
{
|
|
CCloudUnit* pCloud = new CCloudUnit;
|
|
pCloud->Init( m_pDevice );
|
|
pCloud->SetParent( this );
|
|
|
|
// cloud position
|
|
float fx = (float)vecXY[ id ].x;
|
|
float fy = (float)vecXY[ id ].y;
|
|
|
|
SCalculateHeightParam sHeightParam;
|
|
sHeightParam.nLayerGapType = m_sParam.nLayerGapType;
|
|
sHeightParam.nPathType = m_sParam.nTypePathType;
|
|
sHeightParam.nDir = m_sParam.nTypeMoveDir;
|
|
sHeightParam.x = fx;
|
|
sHeightParam.y = fy;
|
|
sHeightParam.zoneX = ZONE_CLOUD_WIDTH;
|
|
sHeightParam.zoneY = ZONE_CLOUD_HEIGHT;
|
|
|
|
float fHeight = GetCloudPathDB().calculateHeight( sHeightParam );
|
|
fx -= ZONE_CLOUD_WIDTH_D2;
|
|
fy -= ZONE_CLOUD_HEIGHT_D2;
|
|
|
|
pCloud->SetPosition(fx, fy, fHeight);
|
|
pCloud->SetID( id );
|
|
|
|
SCloudCreateParam pr;
|
|
pr.nType = pShowInfo->type_cloud;
|
|
pr.nLayerGapType = m_sParam.nLayerGapType;
|
|
pr.nPath = m_sParam.nTypePathType;
|
|
pr.fStandardHeight = 0.0f;
|
|
pr.nDir = m_sParam.nTypeMoveDir;
|
|
pr.fx = 0.0f;
|
|
pr.fy = 0.0f;
|
|
pr.color[0] = sParam.pCloudShowInfo->color[0];
|
|
pr.color[1] = sParam.pCloudShowInfo->color[1];
|
|
pr.color[2] = sParam.pCloudShowInfo->color[2];
|
|
pr.color[3] = sParam.pCloudShowInfo->color[3];
|
|
|
|
if( 0 == pCloud->make( pr ) )
|
|
return -4;
|
|
|
|
add( id, pCloud );
|
|
id += 1;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
int CCloudLayer::Process( DWORD dwTime )
|
|
{
|
|
int sz = (int)m_vcCloud.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
int nState = m_vcCloud[x]->ProcessSecond( dwTime );
|
|
if( nState == FADE_IN_COMPLETE || nState == FADE_OUT_COMPLETE )
|
|
return nState;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void CCloudLayer::Render( KViewportObject *viewport )
|
|
{
|
|
int sz = (int)m_vcCloud.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
m_vcCloud[x]->Render( viewport );
|
|
}
|
|
}
|
|
|
|
void CCloudLayer::SetPosition( float fx, float fy, float fz, int idCloud )
|
|
{
|
|
int sz = (int)m_vcCloud.size();
|
|
if( idCloud == -1 )
|
|
{
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
m_vcCloud[ x ]->SetPosition( fx, fy, fz );
|
|
}
|
|
return ;
|
|
}
|
|
|
|
if( idCloud < 0 || idCloud >= sz )
|
|
return ;
|
|
|
|
m_vcCloud[ idCloud ]->SetPosition( fx, fy, fz );
|
|
}
|
|
|
|
void CCloudLayer::UpdatePosition(float fx, float fy, float fz)
|
|
{
|
|
int sz = (int)m_vcCloud.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
m_vcCloud[ x ]->UpdatePosition(fx, fy, fz);
|
|
}
|
|
}
|
|
|
|
void CCloudLayer::FadeInOutCloud(int nFadeState)
|
|
{
|
|
int sz = (int)m_vcCloud.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
m_vcCloud[ x ]->SetFadeState( nFadeState );
|
|
}
|
|
}
|
|
|
|
void CCloudLayer::CompleteFadeIn()
|
|
{
|
|
m_pParent->CompleteFadeIn();
|
|
}
|
|
|
|
void CCloudLayer::CompleteFadeOut()
|
|
{
|
|
m_pParent->CompleteFadeOut();
|
|
}
|
|
|
|
void CCloudLayer::SetAlpha( float fAlpha )
|
|
{
|
|
int sz = (int)m_vcCloud.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
m_vcCloud[ x ]->SetAlpha( fAlpha );
|
|
}
|
|
}
|
|
|
|
void CCloudLayer::UpdateAlpha( float fAlpha )
|
|
{
|
|
int sz = (int)m_vcCloud.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
m_vcCloud[ x ]->UpdateAlpha( fAlpha );
|
|
}
|
|
}
|
|
|
|
void CCloudLayer::UpdateAlphaBrightLayer()
|
|
{
|
|
int sz = (int)m_vcCloud.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
m_vcCloud[ x ]->UpdateAlphaBrightLayer();
|
|
}
|
|
}
|
|
|
|
int CCloudLayer::DecreaseAlpha( DWORD dwFrameTick )
|
|
{
|
|
int sz = (int)m_vcCloud.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
m_vcCloud[ x ]->DecreaseAlpha( dwFrameTick );
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int CCloudLayer::IncreaseAlpha( DWORD dwFrameTick )
|
|
{
|
|
int sz = (int)m_vcCloud.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
m_vcCloud[ x ]->IncreaseAlpha( dwFrameTick );
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void CCloudLayer::ChangeCloudColor(int nR, int nG, int nB)
|
|
{
|
|
int sz = (int)m_vcCloud.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
m_vcCloud[ x ]->ChangeCloudColor(nR, nG, nB);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// cloud uni manager
|
|
CCloudLayerSet::CCloudLayerSet()
|
|
{
|
|
m_nRenderCloudID = -1;
|
|
}
|
|
|
|
CCloudLayerSet::~CCloudLayerSet()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
bool CCloudLayerSet::SetRenderCloudID( int id )
|
|
{
|
|
m_nRenderCloudID = id;
|
|
return true;
|
|
}
|
|
|
|
int CCloudLayerSet::get_size()
|
|
{
|
|
return (int)m_vcLayer.size();
|
|
}
|
|
|
|
void CCloudLayerSet::SetDevice(K3DRenderDevice* pDvc)
|
|
{
|
|
m_pDevice = pDvc;
|
|
}
|
|
|
|
void CCloudLayerSet::add(int id, CCloudLayer* pLayer)
|
|
{
|
|
m_vcLayer.push_back( pLayer );
|
|
}
|
|
|
|
void CCloudLayerSet::clear()
|
|
{
|
|
int nCount = m_vcLayer.size();
|
|
for(int x=0; x<nCount; x++)
|
|
{
|
|
CCloudLayer* pLayer = m_vcLayer[x];
|
|
SAFE_DELETE( pLayer );
|
|
}
|
|
m_vcLayer.clear();
|
|
}
|
|
|
|
void CCloudLayerSet::size(int sz)
|
|
{
|
|
int k=0;
|
|
m_vcLayer.resize(sz);
|
|
}
|
|
|
|
CCloudLayer* CCloudLayerSet::find(int id)
|
|
{
|
|
int k=0;
|
|
return m_vcLayer[ id ];
|
|
}
|
|
|
|
int CCloudLayerSet::makeLayer(int nLayerID, int nType, int nDir, int nPathType, int nLayerGapType)
|
|
{
|
|
if( nLayerID < 0 )
|
|
return -1;
|
|
if( nType < 0 || nDir < 0 || nPathType < 0 || nLayerGapType < 0 )
|
|
return -2;
|
|
|
|
// 구름 경로 디비 (높이)
|
|
SCloudPath* pPath = GetCloudPathDB().find( nPathType );
|
|
if( pPath == NULL )
|
|
return -3;
|
|
|
|
SCloudLayer* pCloudLayerDB = GetCloudLayerDB()->find( nType );
|
|
if( pCloudLayerDB == NULL )
|
|
return -3;
|
|
|
|
int sz = pCloudLayerDB->vcShowInfo.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
CCloudLayer* pLayer = new CCloudLayer;
|
|
pLayer->SetDevice( m_pDevice );
|
|
pLayer->SetParent( this );
|
|
|
|
SCloudParam sParam;
|
|
sParam.nTypeDistribution = pCloudLayerDB->type_distribution;
|
|
sParam.nTypeCloudHeightRandomGap = pCloudLayerDB->type_height_random_gap;
|
|
sParam.nTypePathType = nPathType;
|
|
sParam.nTypeMoveDir = nDir;
|
|
sParam.nLayerGapType = nLayerGapType;
|
|
sParam.pCloudShowInfo = pCloudLayerDB;
|
|
|
|
if( 0 == pLayer->makeClouds( sParam ) )
|
|
return -4;
|
|
|
|
add( x, pLayer );
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int CCloudLayerSet::Process( DWORD dwTime )
|
|
{
|
|
if( m_nRenderCloudID < 0 || m_nRenderCloudID >= m_vcLayer.size() )
|
|
return 0;
|
|
|
|
SGameWorld* pGameWorld = dynamicCast<SGameWorld*>(g_pCurrentGameSystem->GetGame());
|
|
SGameAvatarEx* pMyCharacter = g_pCurrentGameSystem->GetLocalPlayer();
|
|
if( pMyCharacter )
|
|
{
|
|
WORD wTile;
|
|
K3DVector vPos = pMyCharacter->GetCurPos();
|
|
pGameWorld->GetHeight( vPos.x, vPos.y, g_fMyPlayerHeight, wTile );
|
|
}
|
|
|
|
int sz = (int)m_vcLayer.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
int nState = m_vcLayer[x]->Process( dwTime );
|
|
if( nState == FADE_IN_COMPLETE || nState == FADE_OUT_COMPLETE )
|
|
return nState;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void CCloudLayerSet::Render( KViewportObject *viewport )
|
|
{
|
|
if( m_nRenderCloudID < 0 || m_nRenderCloudID >= m_vcLayer.size() )
|
|
return ;
|
|
|
|
int sz = (int)m_vcLayer.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
m_vcLayer[x]->Render( viewport );
|
|
}
|
|
}
|
|
|
|
void CCloudLayerSet::SetPosition( float fx, float fy, float fz )
|
|
{
|
|
if( m_nRenderCloudID < 0 || m_nRenderCloudID >= m_vcLayer.size() )
|
|
return ;
|
|
|
|
m_vcLayer[ m_nRenderCloudID ]->SetPosition( fx, fy, fz );
|
|
}
|
|
|
|
void CCloudLayerSet::UpdatePosition(float fx, float fy, float fz)
|
|
{
|
|
int nCount = m_vcLayer.size();
|
|
for(int x=0; x<nCount; x++)
|
|
{
|
|
CCloudLayer* pLayer = m_vcLayer[x];
|
|
pLayer->UpdatePosition(fx, fy, fz);
|
|
}
|
|
}
|
|
|
|
void CCloudLayerSet::FadeInOutCloud(int nFadeState)
|
|
{
|
|
int nCount = m_vcLayer.size();
|
|
for(int x=0; x<nCount; x++)
|
|
{
|
|
CCloudLayer* pLayer = m_vcLayer[x];
|
|
pLayer->FadeInOutCloud( nFadeState );
|
|
}
|
|
}
|
|
|
|
void CCloudLayerSet::CompleteFadeIn()
|
|
{
|
|
m_pParent->CompleteFadeIn();
|
|
}
|
|
|
|
void CCloudLayerSet::CompleteFadeOut()
|
|
{
|
|
m_pParent->CompleteFadeOut();
|
|
}
|
|
|
|
void CCloudLayerSet::SetAlpha( float fAlpha )
|
|
{
|
|
int sz = (int)m_vcLayer.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
m_vcLayer[ x ]->SetAlpha( fAlpha );
|
|
}
|
|
}
|
|
|
|
void CCloudLayerSet::UpdateAlpha( float fAlpha )
|
|
{
|
|
int sz = (int)m_vcLayer.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
m_vcLayer[ x ]->UpdateAlpha( fAlpha );
|
|
}
|
|
}
|
|
|
|
void CCloudLayerSet::UpdateAlphaBrightLayer()
|
|
{
|
|
int sz = (int)m_vcLayer.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
m_vcLayer[ x ]->UpdateAlphaBrightLayer();
|
|
}
|
|
}
|
|
|
|
int CCloudLayerSet::DecreaseAlpha( DWORD dwFrameTick )
|
|
{
|
|
int sz = (int)m_vcLayer.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
m_vcLayer[ x ]->DecreaseAlpha( dwFrameTick );
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int CCloudLayerSet::IncreaseAlpha( DWORD dwFrameTick )
|
|
{
|
|
int sz = (int)m_vcLayer.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
m_vcLayer[ x ]->IncreaseAlpha( dwFrameTick );
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void CCloudLayerSet::ChangeCloudColor(int nR, int nG, int nB)
|
|
{
|
|
int sz = (int)m_vcLayer.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
m_vcLayer[ x ]->ChangeCloudColor(nR, nG, nB);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
void CreateCloudDB()
|
|
{
|
|
g_pCloudKindDB = new CCloudKindDB;
|
|
g_pCloudThicknesDB = new CCloudThicknessDB;
|
|
g_pCloudThicknessGapDB = new CCloudThicknessGapDB;
|
|
g_pCloudSizeDB = new CCloudSizeDB;
|
|
g_pCloudTxrGroupDB = new CCloudTxrGroupDB;
|
|
g_pCloudDistributionDB = new CCloudDistributionDB;
|
|
g_pCloudHeightRadomGapDB = new CCloudHeightRadomGapDB;
|
|
g_pCloudCloudLayerGapDB = new CCloudLayerGapDB;
|
|
g_pCloudCloudMoveDirDB = new CCloudMoveDirDB;
|
|
g_pCloudPathDB = new CCloudPathDB;
|
|
g_pCloudTypeInfoDB = new CCloudTypeInfoDB;
|
|
g_pCloudLayerDB = new CCloudLayerDB;
|
|
g_pCloudLayerSetDB = new CCloudLayerSetDB;
|
|
}
|
|
|
|
void DestroyCloudDB()
|
|
{
|
|
SAFE_DELETE(g_pCloudKindDB);
|
|
SAFE_DELETE(g_pCloudThicknesDB);
|
|
SAFE_DELETE(g_pCloudThicknessGapDB);
|
|
SAFE_DELETE(g_pCloudSizeDB);
|
|
SAFE_DELETE(g_pCloudTxrGroupDB);
|
|
SAFE_DELETE(g_pCloudDistributionDB);
|
|
SAFE_DELETE(g_pCloudHeightRadomGapDB);
|
|
SAFE_DELETE(g_pCloudCloudLayerGapDB);
|
|
SAFE_DELETE(g_pCloudCloudMoveDirDB);
|
|
SAFE_DELETE(g_pCloudPathDB);
|
|
SAFE_DELETE(g_pCloudTypeInfoDB);
|
|
SAFE_DELETE(g_pCloudLayerDB);
|
|
SAFE_DELETE(g_pCloudLayerSetDB);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// cloud uni manager
|
|
CCloudMaker::CCloudMaker()
|
|
{
|
|
m_dwTickOld = 0;
|
|
m_bShow = false;
|
|
m_pCloud = new CCloudLayerSet;
|
|
m_pCloud->SetParent( this );
|
|
}
|
|
|
|
CCloudMaker::~CCloudMaker()
|
|
{
|
|
clearCloud();
|
|
SAFE_DELETE( m_pCloud );
|
|
}
|
|
|
|
void CCloudMaker::SetWillCloudID( int _id )
|
|
{
|
|
m_nWillCloudID = _id;
|
|
}
|
|
|
|
int CCloudMaker::GetRenderCloudID() const
|
|
{
|
|
if( m_pCloud )
|
|
return m_pCloud->GetRenderCloudID();
|
|
return -1;
|
|
}
|
|
|
|
void CCloudMaker::ClearRenderCloudID()
|
|
{
|
|
if( m_pCloud )
|
|
m_pCloud->SetRenderCloudID( -1 );
|
|
}
|
|
|
|
void CCloudMaker::SetDevice(K3DRenderDevice* pDvc)
|
|
{
|
|
m_pCloud->SetDevice(pDvc);
|
|
}
|
|
|
|
int CCloudMaker::makeCloud(int id)
|
|
{
|
|
if( id < 0 )
|
|
return 0;
|
|
if( m_pCloud->GetRenderCloudID() == id )
|
|
return 1;
|
|
if( id > GetCloudLayerSetDB()->get_size() )
|
|
return -1;
|
|
|
|
// current cloud id ( rendering )
|
|
if( false == m_pCloud->SetRenderCloudID( id ) )
|
|
return -2;
|
|
|
|
clearCloud();
|
|
|
|
SCloudLayerSet* pLayerSet = GetCloudLayerSetDB()->find( id ); // 아이디로 구름세트 구조체 얻는다
|
|
if( pLayerSet == NULL )
|
|
return -3;
|
|
|
|
int sz = (int)pLayerSet->vcLayerInfo.size();
|
|
for(int x=0; x<sz; x++)
|
|
{
|
|
SCloudLayerInfo* pLayerInfo = pLayerSet->find(x);
|
|
if( pLayerInfo == NULL )
|
|
return -4;
|
|
|
|
if( 0 == m_pCloud->makeLayer( x, pLayerInfo->type_layer, pLayerInfo->type_move_dir, pLayerInfo->type_path, pLayerInfo->type_layer_gap ) )
|
|
return -5;
|
|
}
|
|
m_bShow = true;
|
|
|
|
return 1;
|
|
}
|
|
|
|
void CCloudMaker::clearCloud()
|
|
{
|
|
m_pCloud->clear();
|
|
m_bShow = false;
|
|
}
|
|
|
|
void CCloudMaker::Process( DWORD dwTime )
|
|
{
|
|
DWORD dwFrameTick = dwTime - m_dwTickOld;
|
|
|
|
if(m_bShow)
|
|
{
|
|
m_pCloud->Process( dwTime );
|
|
|
|
if( g_nFadeState != FADE_NONE )
|
|
{
|
|
// int nState = m_pCloud->Process( dwTime );
|
|
// if( nState == FADE_IN_COMPLETE )
|
|
if( g_nFadeState == FADE_IN_COMPLETE )
|
|
{
|
|
CompleteFadeIn();
|
|
m_pCloud->Process( dwTime );
|
|
|
|
// FadeInOutCloud( FADE_OUT ); // 구름 서서히 불투명하게 나타남
|
|
}
|
|
// else if( nState == FADE_OUT_COMPLETE )
|
|
else if( g_nFadeState == FADE_OUT_COMPLETE )
|
|
{
|
|
CompleteFadeOut();
|
|
|
|
m_pCloud->UpdateAlphaBrightLayer();
|
|
|
|
m_pCloud->Process( dwTime );
|
|
|
|
// FadeInOutCloud( FADE_NONE );
|
|
}
|
|
else if( g_nFadeState == FADE_IN )
|
|
{
|
|
m_fAlpha -= (float)dwFrameTick / FADE_ALPHA_TIME;
|
|
if( m_fAlpha < 0.0f )
|
|
{
|
|
m_fAlpha = 0.0f;
|
|
g_nFadeState = FADE_IN_COMPLETE;
|
|
}
|
|
|
|
m_pCloud->UpdateAlpha( m_fAlpha * 255.0f );
|
|
}
|
|
else if( g_nFadeState == FADE_OUT )
|
|
{
|
|
m_fAlpha += (float)dwFrameTick / FADE_ALPHA_TIME;
|
|
if( m_fAlpha > 1.0f )
|
|
{
|
|
m_fAlpha = 1.0f;
|
|
g_nFadeState = FADE_OUT_COMPLETE;
|
|
}
|
|
|
|
m_pCloud->UpdateAlpha( m_fAlpha * 255.0f );
|
|
}
|
|
}
|
|
}
|
|
m_dwTickOld = dwTime;
|
|
}
|
|
|
|
void CCloudMaker::Render( KViewportObject *viewport )
|
|
{
|
|
if(m_bShow)
|
|
m_pCloud->Render( viewport );
|
|
}
|
|
|
|
void CCloudMaker::SetPosition( float fx, float fy, float fz )
|
|
{
|
|
m_pCloud->SetPosition( fx, fy, fz );
|
|
}
|
|
|
|
void CCloudMaker::UpdatePosition(float fx, float fy, float fz)
|
|
{
|
|
m_pCloud->UpdatePosition(fx, fy, fz);
|
|
}
|
|
|
|
void CCloudMaker::FadeInOutCloud(int nFadeState)
|
|
{
|
|
if( true == CompareCloudID() )
|
|
return ;
|
|
|
|
g_nFadeState = nFadeState;
|
|
if ( g_nFadeState == FADE_IN )
|
|
m_fAlpha = 1.0f;
|
|
else if( g_nFadeState == FADE_OUT )
|
|
m_fAlpha = 0.0f;
|
|
|
|
m_bShow = true;
|
|
}
|
|
|
|
void CCloudMaker::CompleteFadeIn()
|
|
{
|
|
if( m_nWillCloudID > -1 && m_nWillCloudID != GetRenderCloudID() )
|
|
{
|
|
m_bShow = false;
|
|
|
|
ClearRenderCloudID();
|
|
|
|
clearCloud();
|
|
|
|
makeCloud( m_nWillCloudID ); // 다른 종류의 구름 세트로 바꿈
|
|
|
|
m_pCloud->SetRenderCloudID( m_nWillCloudID );
|
|
|
|
g_nFadeState = FADE_OUT;
|
|
}
|
|
}
|
|
|
|
void CCloudMaker::CompleteFadeOut()
|
|
{
|
|
m_bShow = true;
|
|
g_nFadeState = FADE_NONE;
|
|
}
|
|
|
|
bool CCloudMaker::CompareCloudID()
|
|
{
|
|
if(m_nWillCloudID == GetRenderCloudID())
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
void CCloudMaker::ChangeCloudColor(int nR, int nG, int nB)
|
|
{
|
|
m_pCloud->ChangeCloudColor(nR, nG, nB);
|
|
}
|
|
#endif |