Leviathan/Client/Game/engine/Renderer/KPrimitiveSpriteScroll.cpp

#include "stdafx.h"
/// 2011.01.18 - prodongi
#include "KPrimitiveSpriteScroll.h"
#include "KPrimitiveSprite.h"
#include "KRenderDeviceDx.h"
#include <mmo/ArTime.h>

///
void sSpritePrimitiveScrollType::updateVertList(sSpritePrimitiveScroll* scroll, void* vertList)
{
	KSpritePrimitive::TEMPEXTVERTEX* _vertList = (KSpritePrimitive::TEMPEXTVERTEX*)vertList;
	for (int i = 0; i < 4; ++i)
	{
		_vertList[i].u = scroll->m_uvOri[i].u + scroll->m_offset.u;
		_vertList[i].v = scroll->m_uvOri[i].v + scroll->m_offset.v;
	}
}
void sSpritePrimitiveScrollType::checkInitOffset(sSpritePrimitiveScroll* scroll)
{
	if (m_initOffset)
	{
		initOffset(scroll);
		m_initOffset = false;
	}
}

/// left
void sSpritePrimitiveScrollLeft::update(sSpritePrimitiveScroll* scroll, void* vertList, float s)
{
	scroll->m_offset.u += s;
	updateVertList(scroll, vertList);
	checkEnd(scroll, vertList);
}
void sSpritePrimitiveScrollLeft::checkEnd(sSpritePrimitiveScroll* scroll, void* vertList)
{
	KSpritePrimitive::TEMPEXTVERTEX* _vertList = (KSpritePrimitive::TEMPEXTVERTEX*)vertList;
	if (_vertList[0].u > scroll->m_imgUv.u + scroll->m_margin)
	{
		initOffset(scroll);
		m_bEnd = true;   // 2011.03.23 - servantes
	}
}
void sSpritePrimitiveScrollLeft::initOffset(sSpritePrimitiveScroll* scroll)
{
	scroll->m_offset.u = -(scroll->m_uvOri[3].u - scroll->m_uvOri[0].u);
}

/// right
void sSpritePrimitiveScrollRight::update(sSpritePrimitiveScroll* scroll, void* vertList, float s)
{
	scroll->m_offset.u -= s;
	updateVertList(scroll, vertList);
	checkEnd(scroll, vertList);
}
void sSpritePrimitiveScrollRight::checkEnd(sSpritePrimitiveScroll* scroll, void* vertList)
{
	KSpritePrimitive::TEMPEXTVERTEX* _vertList = (KSpritePrimitive::TEMPEXTVERTEX*)vertList;
	if (_vertList[3].u < scroll->m_uvOri[0].u - scroll->m_margin)
	{
		initOffset(scroll);
		m_bEnd = true;   // 2011.03.23 - servantes
	}
}
void sSpritePrimitiveScrollRight::initOffset(sSpritePrimitiveScroll* scroll)
{
	scroll->m_offset.u = scroll->m_imgUv.u;
}

/// up
void sSpritePrimitiveScrollUp::update(sSpritePrimitiveScroll* scroll, void* vertList, float s)
{
	scroll->m_offset.v += s;
	updateVertList(scroll, vertList);
	checkEnd(scroll, vertList);
}
void sSpritePrimitiveScrollUp::checkEnd(sSpritePrimitiveScroll* scroll, void* vertList)
{
	KSpritePrimitive::TEMPEXTVERTEX* _vertList = (KSpritePrimitive::TEMPEXTVERTEX*)vertList;
	if (_vertList[0].v > scroll->m_imgUv.v + scroll->m_margin)
	{
		initOffset(scroll);
		m_bEnd = true;   // 2011.03.23 - servantes
	}
}
void sSpritePrimitiveScrollUp::initOffset(sSpritePrimitiveScroll* scroll)
{
	scroll->m_offset.v = -(scroll->m_uvOri[3].v - scroll->m_uvOri[0].v);
}

/// down
void sSpritePrimitiveScrollDown::update(sSpritePrimitiveScroll* scroll, void* vertList, float s)
{
	scroll->m_offset.v -= s;
	updateVertList(scroll, vertList);
	checkEnd(scroll, vertList);
}
void sSpritePrimitiveScrollDown::checkEnd(sSpritePrimitiveScroll* scroll, void* vertList)
{
	KSpritePrimitive::TEMPEXTVERTEX* _vertList = (KSpritePrimitive::TEMPEXTVERTEX*)vertList;
	if (_vertList[3].v < scroll->m_uvOri[0].v - scroll->m_margin)
	{
		initOffset(scroll);
		m_bEnd = true;   // 2011.03.23 - servantes
	}
}
void sSpritePrimitiveScrollDown::initOffset(sSpritePrimitiveScroll* scroll)
{
	scroll->m_offset.v = scroll->m_imgUv.v;
}


sSpritePrimitiveScroll::~sSpritePrimitiveScroll()
{
	if (m_type)
		delete m_type;
}

void sSpritePrimitiveScroll::initialize(bool is, unsigned int type, float v, float margin, void const* vertList)
{
	m_is = is;
	if (!m_is) 
		return ;
	if (!vertList)
	{
		m_is = false;
		return ;
	}

	m_offset.u = 0.0f;
	m_offset.v = 0.0f;
	m_v = v;
	m_margin = margin;
	m_oldTime = 0;
	createType(type);
	setOriVert(vertList);
}

void sSpritePrimitiveScroll::createType(unsigned int type)
{
	if (m_type)
	{
		delete m_type;
		m_type = NULL;
	}
	switch (type)
	{
	case sSpritePrimitiveScrollType::LEFT:	m_type = new sSpritePrimitiveScrollLeft;	break;
	case sSpritePrimitiveScrollType::RIGHT:	m_type = new sSpritePrimitiveScrollRight;	break;
	case sSpritePrimitiveScrollType::UP:	m_type = new sSpritePrimitiveScrollUp;		break;
	case sSpritePrimitiveScrollType::DOWN:	m_type = new sSpritePrimitiveScrollDown;	break;
	}
}

void sSpritePrimitiveScroll::setImgUv(float u, float v)
{
	m_imgUv.u = u;
	m_imgUv.v = v;
}

void sSpritePrimitiveScroll::setOriVert(void const* vertList)
{
	KSpritePrimitive::TEMPEXTVERTEX const* _vertList = (KSpritePrimitive::TEMPEXTVERTEX const*)vertList;

	for (int i = 0; i < 4; ++i)
	{
		m_uvOri[i].u = _vertList[i].u;
		m_uvOri[i].v = _vertList[i].v;
	}
}

void sSpritePrimitiveScroll::update(void* vertList)
{
	if (!m_is)
		return ;

	unsigned int curTime = GetSafeTickCount();
	if (0 == m_oldTime) m_oldTime = curTime;
	unsigned int elapsedTime = curTime - m_oldTime;
	m_oldTime = curTime;
	float elapsedtime = (float)elapsedTime/1000.0f;
	float s = m_v * elapsedtime;

	setOriVert(vertList);
	m_type->checkInitOffset(this);
	m_type->update(this, vertList, s);
}

void sSpritePrimitiveScroll::setTextureAddressMode(K3DRenderDevice *dev)
{
	if (!m_is)
		return ;

	K3DRenderDeviceDX* dxDev = dynamic_cast<K3DRenderDeviceDX*>(dev);
	IDirect3DDevice9* device = dxDev->GetD3DDevice();

	device->GetSamplerState(0, D3DSAMP_ADDRESSU, &m_oldAddressModeU);
	device->GetSamplerState(0, D3DSAMP_ADDRESSV, &m_oldAddressModeV);

	device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER);
	device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER);

	DWORD newBorderColor = 0;
	device->GetSamplerState(0, D3DSAMP_BORDERCOLOR, &m_oldBorderColor);
	device->SetSamplerState(0, D3DSAMP_BORDERCOLOR, newBorderColor);
}

void sSpritePrimitiveScroll::restoreTextureAddressMode(K3DRenderDevice *dev)
{
	if (!m_is)
		return ;

	K3DRenderDeviceDX* dxDev = dynamic_cast<K3DRenderDeviceDX*>(dev);
	IDirect3DDevice9* device = dxDev->GetD3DDevice();

	device->SetSamplerState(0, D3DSAMP_ADDRESSU, m_oldAddressModeU);
	device->SetSamplerState(0, D3DSAMP_ADDRESSV, m_oldAddressModeV);
	device->SetSamplerState(0, D3DSAMP_BORDERCOLOR, m_oldBorderColor);
}