gsg_txg.cpp

混乱竞技场的全套代码,客户端资源可以网上搜

// GSG_TXG.cpp: implementation of the GSG_TXG class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "gstools.h"
#include "GSG_TXG.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

GSG_TXG::GSG_TXG(CGsEngine*	pEngine)
:CGsGame(pEngine)
{
	m_pos_grid				= GPOINT(200,200);
	m_pos_base				= GPOINT(200,200);
	m_pos_show				= GPOINT(200,200);
	m_pos_show_action		= GPOINT(200,200);
	m_pos_drag				= GPOINT(0,0);
	m_pos_base_fix			= GPOINT(0,0);
	m_color_base_grid		= D3DRGBA(0.7f,0.7f,0.7f,0.5f);




	m_scale					= 1.0f;

	m_bStartDrag			= false;

	m_key_style				= "GSG_TXG";

	m_ani.SetGsEngine(pEngine);
	m_ani.Create((LPCSTR)g_pWizard->GetCurrentItemPath());


	m_is_setting_base_point		= FALSE;
	dlg_tools.Create(m_ani);


}

GSG_TXG::~GSG_TXG()
{

}



LRESULT	GSG_TXG::MsgProc( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
	return CGsGame::MsgProc( uMsg, wParam, lParam );
}



ID GSG_TXG::OnMouseMove(UINT nFlags, GPOINT point)
{
	if(m_is_setting_base_point)
	{
//		CGsTextureGroup* pTxg	= m_ani.GetTextureGroup();
//		pTxg->m_base_point.x += (point.x - m_pos_grid.x)/dlg_tools.m_fShowScale;
//		pTxg->m_base_point.y += (point.y - m_pos_grid.y)/dlg_tools.m_fShowScale;
//		m_pos_show	= point;
//		m_pos_grid	= point;
//		pTxg->ClearCache();
		m_pos_grid	= point;
	}
	else
	{
		switch(nFlags)
		{
		case MK_RBUTTON:
			{
				if(!m_bStartDrag)
					break;
				m_pos_base	+= (point - m_pos_drag);
				m_pos_drag	= point;
				m_pos_grid	= m_pos_base;
				m_pos_show		= m_pos_base - m_pos_base_fix;
			}
			break;
		case MK_LBUTTON:
//			{
//				if(!m_bStartDrag)
//					break;
//				m_pos_base_fix	+= (point - m_pos_drag);
//				m_pos_base	+=	(point - m_pos_drag);
//				m_pos_drag	= point;
//				m_pos_grid	= m_pos_base;
//				//m_pos_show		= m_pos_base + point_s;
//			}
			break;
		}
	}
	return CGsGame::OnMouseMove(nFlags, point);
}

ID GSG_TXG::OnLButtonDown( UINT nFlags, GPOINT point )			
{ 
	m_bStartDrag	= true;
	m_pos_drag	= point; 
	
	return CGsGame::OnLButtonDown( nFlags, point );
}
ID GSG_TXG::OnLButtonUp( UINT nFlags, GPOINT point )				
{ 
	if(m_is_setting_base_point)
	{
		CGsTextureGroup* pTxg	= m_ani.GetTextureGroup();
		switch(pTxg->GetSourceFFT())
		{
		case	GSF_TXG:
			{
				pTxg->m_base_point.x += (point.x - m_pos_show.x)/dlg_tools.m_fShowScale;
				pTxg->m_base_point.y += (point.y - m_pos_show.y)/dlg_tools.m_fShowScale;
				m_pos_grid	= point;
				m_pos_show	= point;
				m_pos_base	= m_pos_show;
				m_pos_drag	= m_pos_show; 
				pTxg->ClearCache();
				pTxg->SaveHeader();
				ReleaseCapture();
				ClipCursor(NULL);
				ShowDlgTools(TRUE);
			}
		}
		m_is_setting_base_point	= FALSE;
	}
	return CGsGame::OnLButtonUp( nFlags, point );
}
ID GSG_TXG::OnLButtonDbClk( UINT nFlags, GPOINT point )			
{ 
	ResetBasePoint();
	
	return CGsGame::OnLButtonDbClk( nFlags, point );
}
ID GSG_TXG::OnRButtonDown( UINT nFlags, GPOINT point )			
{ 
	m_bStartDrag	= true;
	m_pos_drag	= point; 
	
	return CGsGame::OnRButtonDown( nFlags, point );
}
ID GSG_TXG::OnRButtonUp( UINT nFlags, GPOINT point )				
{ 
	if(m_is_setting_base_point)
	{
		m_is_setting_base_point = FALSE;
		m_pos_grid	= m_pos_show;
		m_pos_base	= m_pos_show;
		m_pos_drag	= m_pos_show; 
		ReleaseCapture();
		ClipCursor(NULL);
		ShowDlgTools(TRUE);

	}
	return CGsGame::OnRButtonUp( nFlags, point );
}
ID GSG_TXG::OnRButtonDbClk( UINT nFlags, GPOINT point )			
{ 
	
	return CGsGame::OnRButtonDbClk( nFlags, point );
}


ID GSG_TXG::OnMouseWheel(UINT nFlags, short zDelta, GPOINT point)
{

	return CGsGame::OnMouseWheel(nFlags, zDelta, point);
}

ID GSG_TXG::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
{

	return CGsGame::OnChar(nChar, nRepCnt, nFlags);
}

ID GSG_TXG::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
	if(m_is_setting_base_point)
	{
		GPOINT point;
		::GetCursorPos(&point);
		switch(nChar)
		{
		case VK_UP:
			point -= GPOINT(0,nRepCnt);
			break;
		case VK_DOWN:
			point += GPOINT(0,nRepCnt);
			break;
		case VK_LEFT:
			point -= GPOINT(nRepCnt,0);
			break;
		case VK_RIGHT:
			point += GPOINT(nRepCnt,0);
			break;
		}
		::SetCursorPos(point.x, point.y);
	}
	return CGsGame::OnKeyDown(nChar, nRepCnt, nFlags);
}

ID GSG_TXG::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
{
	return CGsGame::OnKeyUp(nChar, nRepCnt, nFlags);
}

void GSG_TXG::ResetBasePoint()
{
	m_pos_base		-= m_pos_base_fix;
	m_pos_base_fix	= GPOINT(0,0);
	m_pos_drag		= GPOINT(0,0);
	m_pos_grid		= m_pos_base;
	m_pos_show		= m_pos_base - m_pos_base_fix;
}



FLAG GSG_TXG::Update(DWORD dwPassTime)
{
	if(dlg_tools.m_bShowAnimation)
	{
		FLAG flag = m_ani.Update();
		if(flag==GS_ANI_UPDATE_END && dlg_tools.m_bShowAuto)
		{
			m_ani.SetDirection();
		}
	}

	return 0;
}

HRESULT GSG_TXG::Render()
{
	
	LPDIRECT3DDEVICE7	pd3dDevice	= m_pEngine->GetD3dDevice();
	CGsSurface* pBackSurface	= m_pEngine->GetBackSurface();

	GRECT	rc	= pBackSurface->GetRect();
    // Clear the viewport

//	pBackSurface->RGBClear(RGB(132,132,132));

	switch(dlg_tools.m_nAction)
	{
//	case	0:
//		break;
	case	1:
		{
			m_pos_show_action.x	= m_pos_show.x 
								  + m_pEngine->ValueCycle(-dlg_tools.m_size_preview_length, dlg_tools.m_size_preview_length, 0, dlg_tools.m_size_preview_speed, 1);
			float	angle = m_pEngine->ValueLoop(0, const_2_PI, 0, dlg_tools.m_size_preview_speed*2, 1);
			m_pos_show_action.y	= m_pos_show.y;
			m_ani.SetFaceTo((angle<const_PI)?const_PI:0);
		}
		break;
	case	2:
		{
			float	angle = m_pEngine->ValueLoop(0, const_2_PI, 0, dlg_tools.m_size_preview_speed*const_PI, 1);
			m_pos_show_action.x	= m_pos_show.x 
								  + dlg_tools.m_size_preview_length * cosf(angle);
			m_pos_show_action.y	= m_pos_show.y 
								  + dlg_tools.m_size_preview_length * sinf(angle);
			m_ani.SetFaceTo(const_PI_DIV_2 + angle);
		}
		break;
	default:
		m_pos_show_action	= m_pos_show;
	}


	if(dlg_tools.m_bAlpha)
	{
		m_pEngine->PreparePaint();
	}
	else
	{
		m_pEngine->PreparePaint(D3DBLEND_SRCALPHA, D3DBLEND_ONE);
	}
//	m_pEngine->PreparePaint();//D3DBLEND_SRCALPHA, D3DBLEND_INVSRCALPHA, D3DTOP_MODULATE4X, D3DTOP_MODULATE);
	if(!dlg_tools.m_is_optimize)
	{
		m_pEngine->SetTextureStageState( 0, D3DTSS_MINFILTER, D3DTFN_POINT );
		m_pEngine->SetTextureStageState( 0, D3DTSS_MAGFILTER, D3DTFN_POINT );
	}
//	m_pEngine->PreparePaint();
	if(dlg_tools.m_bShowFrame)
	{
		HRESULT hr;
		CGsTexture* pTex;
		pTex	= m_ani.GetCurrentFrame();
		if(pTex)
		{
			pTex->UpdateFromCache();
			if(FAILED(hr = m_pEngine->Render_PaintFrame( m_pos_show_action.x, m_pos_show_action.y, pTex, FALSE, RGBA_MAKE(255,255,255,255), RGBA_MAKE(255,255,255,255), RGBA_MAKE(255,255,255,255), RGBA_MAKE(255,255,255,255), 0.0f, dlg_tools.m_fShowScale, dlg_tools.m_fShowScale, dlg_tools.m_fShowAlpha, D3DXToRadian(dlg_tools.m_nRotateAngle),
				   D3DRGBA(dlg_tools.m_fRed, dlg_tools.m_fGreen, dlg_tools.m_fBlue, 1.0f))));
				return hr;
		}
		pTex	= m_ani.GetCurrentShadow();
		if(pTex)
		{
			pTex->UpdateFromCache();
			if(FAILED(hr = m_pEngine->Render_PaintFrame( m_pos_show_action.x, m_pos_show_action.y, pTex, FALSE, RGBA_MAKE(255,255,255,255), RGBA_MAKE(255,255,255,255), RGBA_MAKE(255,255,255,255), RGBA_MAKE(255,255,255,255), 0.0f, dlg_tools.m_fShowScale, dlg_tools.m_fShowScale, dlg_tools.m_fShowAlpha, D3DXToRadian(dlg_tools.m_nRotateAngle),
				   D3DRGBA(dlg_tools.m_fRed, dlg_tools.m_fGreen, dlg_tools.m_fBlue, 1.0f))));
				return hr;
		}
	}
	else
	{
		m_ani.Draw(m_pos_show_action.x, m_pos_show_action.y, 0.0f, dlg_tools.m_fShowScale, dlg_tools.m_fShowScale, dlg_tools.m_fShowAlpha, D3DXToRadian(dlg_tools.m_nRotateAngle),
				   D3DRGBA(dlg_tools.m_fRed, dlg_tools.m_fGreen, dlg_tools.m_fBlue, 1.0f));
	}

	m_pEngine->PreparePaint();//D3DBLEND_SRCALPHA, D3DBLEND_INVSRCALPHA, D3DTOP_MODULATE4X, D3DTOP_MODULATE);
	m_pEngine->SetTextureStageState( 0, D3DTSS_MINFILTER, D3DTFN_POINT );
	m_pEngine->SetTextureStageState( 0, D3DTSS_MAGFILTER, D3DTFN_POINT );

	m_pEngine->Render_DrawLine(m_pos_grid.x, rc.top, m_pos_grid.x, rc.bottom, m_color_base_grid);
	m_pEngine->Render_DrawLine(rc.left, m_pos_grid.y, rc.right, m_pos_grid.y, m_color_base_grid);


//	GRECT rcLight(50, 50, 200,200);
//	m_pEngine->Render_LightRect(&rcLight, m_pEngine->ValueLoop(0.5f, 2.0f, 0, 100, 1));
//	m_pEngine->Render_LightRect(&rcLight, m_pEngine->ValueCycle(1.0f, 2.0f, 0, 1000, 1));

//	m_pEngine->DarkenScene(0.5f);
//		m_pEngine->PreparePaint(D3DBLEND_ZERO, D3DBLEND_SRCALPHA);
	return S_OK;
}
HRESULT GSG_TXG::Draw(CGsSurface *pSurface)
{




	return S_OK;
}

VOID GSG_TXG::Cleanup()
{
	CGsGame::Cleanup();
}


VOID GSG_TXG::SetBasePoint()
{
	ShowDlgTools(false);
	g_pGSEView->SetFocus();
	g_pGSEView->SetCapture();
	CRect rc;
	g_pGSEView->GetWindowRect(&rc);
	ClipCursor(&rc);
	GPOINT point = m_pos_grid;
	g_pGSEView->ClientToScreen(&point);
	::SetCursorPos(point.x, point.y);
	m_is_setting_base_point	= TRUE;

}