Leviathan/Client/Game/engine/Ui/Controls/KUIControlExpGauge.cpp

#include "stdafx.h"
#include "KUITextureManager.h"
#include "KResourceManager.h"
#include "KUIControlExpGauge.h"
#include "KViewport.h"

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// KUIControlExpGauge Implement
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace
{
	KUIWnd* Creator()
	{
		return new KUIControlExpGauge;
	}
	bool bRegister = KUIFactory::GetInstance()->RegisterCreator( Creator, "exp_gauge");

	const int TOTAL_GAUGE_COUNT = 10;
	const int LEVEL_PER_PERCENT = 20;
	const int TOTAL_GAUGE_LEVEL = 100 / LEVEL_PER_PERCENT;
}

KUIControlExpGauge::KUIControlExpGauge()
{
	m_curPercent = 0;

	_registerSprite(&m_prSpriteBack);

	for(int i = 0; i < 10; ++i)
	{
		for(int j = 0; j < 3; ++j)
			_registerSprite(&m_prSprite[i][j]);
	}
}

KUIControlExpGauge::~KUIControlExpGauge()
{
}

void KUIControlExpGauge::Process( DWORD dwTime )
{
	_processToolTip();
}

void KUIControlExpGauge::SetPercent(size_t percent)
{ 
	size_t curPercent = std::min(static_cast<size_t>( 100 ),percent);
	if( curPercent != m_curPercent )
	{
		m_curPercent = curPercent;
		_UpdateSpriteRes();
		InvalidateWnd();
	}
}


void KUIControlExpGauge::Render(KViewportObject * pViewport, bool isFront )
{
	if(false == m_bShowFlag)
		return;

	_RenderPrimitive( pViewport);

	//툴팁
#ifndef _KUI_INVALIDATION
	_renderToolTip(pViewport, isFront);
#endif
}

void KUIControlExpGauge::OnChagneBackNotify()
{
	_initControl();

#ifdef _KUI_INVALIDATION
	//인벨리데이트로 추가된부분 주의요망
	KUIControl::OnChagneBackNotify();
#endif
}

void KUIControlExpGauge::_initControl()
{
	if( m_sAniName.empty() )
		return;

	m_sizePerGauge = m_rcCaptionArea.GetWidth() / TOTAL_GAUGE_COUNT;

	KResSprite* pFrameSet[3];
	for(size_t i = 0; i < 3; ++i)
	{
		pFrameSet[i] = _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), i );
		assert( pFrameSet[i] && "Cannot find Sprite Res Frame" ); 
		m_gaugeSize[i] = pFrameSet[i]->GetSizeX();
	}
	m_sizePerGauge = std::max(m_sizePerGauge, m_gaugeSize[0] + m_gaugeSize[1] + m_gaugeSize[2] );
	
	m_gaugeSize[1] = m_sizePerGauge - m_gaugeSize[0] - m_gaugeSize[2];

	m_rcRegion.bottom = m_rcRegion.top + pFrameSet[0]->GetSizeY();
	m_rcRegion.right = m_rcRegion.left + m_sizePerGauge * TOTAL_GAUGE_COUNT;

	_UpdateSpriteRes();

}

void KUIControlExpGauge::_UpdateSpriteRes()
{
	
	KResSprite* pFrameSet[3];
	for(size_t i = 0; i < 3; ++i)
	{
		pFrameSet[i] = _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), i );
		assert( pFrameSet[i] && "Cannot find Sprite Res Frame" ); 
	}

	for(size_t i = 0; i < TOTAL_GAUGE_COUNT; ++i)
	{
		size_t offSet = m_sizePerGauge * i;

		m_prSprite[i][0].SetRes(pFrameSet[0]);
		m_prSprite[i][0].SetPosition( m_rcRegion.left + offSet, m_rcRegion.top, m_fZPos );

		m_prSprite[i][1].SetRes(pFrameSet[1]);
		m_prSprite[i][1].SetPosition( m_rcRegion.left + m_gaugeSize[0] + offSet, m_rcRegion.top, m_fZPos );

		m_prSprite[i][2].SetRes(pFrameSet[2]);
		m_prSprite[i][2].SetPosition( m_rcRegion.left + offSet + m_gaugeSize[0] + m_gaugeSize[1],
			m_rcRegion.top, m_fZPos );
	}

	KResSprite* pBackFrame = _getSpriteSet()->GetSpriteRes( m_sAniName.c_str(), 7);
	m_prSpriteBack.SetRes(pBackFrame);
	m_prSpriteBack.SetPosition( m_rcRegion.left, m_rcRegion.top, m_fZPos);
	m_prSpriteBack.SetTargetSize(m_rcRegion.GetWidth(), m_rcRegion.GetHeight());

}


void KUIControlExpGauge::_RenderPrimitive(KViewportObject* pViewport)
{
	size_t renderCount = m_curPercent / TOTAL_GAUGE_COUNT;
	float fModularPercent = static_cast<float>( (m_curPercent % TOTAL_GAUGE_COUNT) ) / static_cast<float>(TOTAL_GAUGE_COUNT);


	pViewport->Register( &m_prSpriteBack);

	for(size_t i = 0; i < renderCount; ++i)
	{
		for(size_t k = 0; k < 3; ++k)
		{
			m_prSprite[i][k].SetTargetSize( m_gaugeSize[k], m_rcRegion.GetHeight() );
			pViewport->Register(&m_prSprite[i][k] );
		}
	}

	// 뒤에 남아있는 잡다한것들 -_-
	int modularGaugeSize = m_sizePerGauge * fModularPercent;
	if(modularGaugeSize != 0)
	{	
		for(int i = 0; i < 3; ++i)
		{
			m_prSprite[renderCount][i].SetTargetSize( std::min(static_cast<size_t>( modularGaugeSize), m_gaugeSize[i]), m_rcRegion.GetHeight() );
			pViewport->Register(&m_prSprite[renderCount][i] );
			modularGaugeSize -= m_gaugeSize[i];
			
			if(modularGaugeSize <= 0)
				break;
		}	
	}
}