scene_view.cpp

大家好！这是一个网络游戏源码

#include "runner_game.h"
#include "scene_view.h"
#include "d3dtextr.h"
#include "d3dx.h"

	 
SCENE_VIEW::SCENE_VIEW()
{
	pGridVB				= NULL; 
	pAttrVB				= NULL;
	psurMap				= NULL;
	psurAttr			= NULL;
	m_iGridNum			= 0;
	m_fGridSize			= 0;
}

SCENE_VIEW::~SCENE_VIEW()
{
	Release();
}

VOID SCENE_VIEW::Release()
{
	FreeMemory(pAttrVB);
	FreeMemory(pGridVB);
}

VOID SCENE_VIEW::ReleaseDeviceObj()
{
	SAFE_RELEASE(psurMap);
	SAFE_RELEASE(psurCover);
	SAFE_RELEASE(psurAttr);
}

BOOL SCENE_VIEW::Init(SCENE_VIEW_INIT *pSceneViewInit) 
{
	
	CreateGridObj(pSceneViewInit->iGridNum , pSceneViewInit->fGridSize);

	psurMap = GetSurfaceFromSurFile16(pSceneViewInit->strMapFileName);
    if(psurMap==NULL)
	{
		Out("ERR : %s\n" , "Load Map Surface Failed!");
	}

	psurCover = GetSurfaceFromRleFile16(pSceneViewInit->strCoverFileName);
	if(psurCover==NULL)
	{
		Out("ERR : %s\n" , "Load Cover Surface Failed!");
	}
    
	DWORD w , h; GetSurfaceSize(psurMap , &w , &h);
	RECT rc;
	rc.left   = 0;
	rc.right  = w;
	rc.top    = 0;
	rc.bottom = h;
	if(psurMap)	psurMap->Blt(&rc , psurCover , &rc , DDBLT_WAIT|DDBLT_KEYSRC , 0);
	
	
	//	创建属性颜色贴图
	psurAttr = CreateSurface(pSceneViewInit->iGridNum , pSceneViewInit->iGridNum , SURFACE_TYPE_TEXTURE);
	SetSurfaceColorKey(psurAttr , 0);
	
	m_dwGridColor	= RGB_MAKE(0   , 0 , 0);                                                   
	m_dwBlockColor	= RGB_MAKE(255 , 0 , 0);
	
	SetView();
	CaluGridInfo();
	return S_OK;
}


HRESULT SCENE_VIEW::CreateGridObj(int iNum , float fGridSize)
{
	if(m_iGridNum!=iNum)
	{
		m_iGridNum = iNum;
		
		//格子顶点 + 原点轴线2个顶点 + 世界边界线8个顶点
		m_iGridVertexAmount = (2 * ( m_iGridNum * 2 + 2)) + 2 + 8;

        GetMemory(pGridVB , GRID_VERTEX , m_iGridVertexAmount);
	}

	m_fGridSize = fGridSize;
	
	float ft ;
	int i , x , y , n = 0 , s;
	for(y = 0 ; y < m_iGridNum + 1; y++)
	{
		ft = (float)y * m_fGridSize ;
		pGridVB[n].p   = D3DXVECTOR3( ft  ,  0.0f , 0.0f );
		pGridVB[n+1].p = D3DXVECTOR3( ft  ,  (float)m_iGridNum * m_fGridSize , 0.0f);
		n+=2;
	}	
	for(x = 0 ; x < m_iGridNum + 1; x++)
	{
		ft = (float)x * m_fGridSize;
		pGridVB[n].p   = D3DXVECTOR3( 0.0f ,  ft ,  0.0f);
		pGridVB[n+1].p = D3DXVECTOR3( (float)m_iGridNum * m_fGridSize ,  ft ,  0.0f);
		n+=2;
	}	
	for(i = 0 ; i < n ; i++)	pGridVB[i].c = m_dwGridColor;
	
	
	//轴线的2个顶点
	pGridVB[n].p   = D3DXVECTOR3( 0.0f ,  0.0f ,  0.0f);
	pGridVB[n+1].p = D3DXVECTOR3( 0.0f ,  0.0f ,  m_fGridSize * 10.0f);
	pGridVB[n].c   = 0xffffffff;
	pGridVB[n+1].c = 0xffffffff;
	n+=2;
		
	//世界边界线的8个顶点
	s = n;
	float off = m_fGridSize * (float)m_iGridNum / 2 ;
	pGridVB[n].p   = D3DXVECTOR3(off * -1.0f ,  off       ,  0.0f);
	pGridVB[n+1].p = D3DXVECTOR3(off         , off * 3.0f ,  0.0f);
	n+=2;
	pGridVB[n].p   = D3DXVECTOR3(off        ,  off * 3.0f  ,  0.0f);
	pGridVB[n+1].p = D3DXVECTOR3(off * 3.0f ,  off         ,  0.0f);
	n+=2;
	pGridVB[n].p   = D3DXVECTOR3(off * 3.0f ,  off         ,  0.0f);
	pGridVB[n+1].p = D3DXVECTOR3(off        ,  off * -1.0f ,  0.0f);
	n+=2;
	pGridVB[n].p   = D3DXVECTOR3(off        ,  off * -1.0f ,  0.0f);
	pGridVB[n+1].p = D3DXVECTOR3(off * -1.0f,  off         ,  0.0f);
	n+=2;
	for(i = s ; i < n ; i++) pGridVB[i].c = 0xffffffff;
	
	
	//用于属性显示的多边形的4个顶点
	if(pAttrVB==NULL)
	{
       GetMemory(pAttrVB  , ATTRIB_VERTEX , 4);
	}
	float size = m_iGridNum * m_fGridSize;
	pAttrVB[0].p = D3DXVECTOR3( 0.0f ,  size , 0.0f );
	pAttrVB[0].u = 0.0f;	
	pAttrVB[0].v = 1.0f;
	
	pAttrVB[1].p = D3DXVECTOR3( 0.0f ,  0.0f , 0.0f );
	pAttrVB[1].u = 0.0f;	
	pAttrVB[1].v = 0.0f;
	
	pAttrVB[2].p = D3DXVECTOR3( size ,  size , 0.0f );
	pAttrVB[2].u = 1.0f;	
	pAttrVB[2].v = 1.0f;
	
	pAttrVB[3].p = D3DXVECTOR3( size ,  0.0f , 0.0f );
	pAttrVB[3].u = 1.0f;
	pAttrVB[3].v = 0.0f;

	return S_OK;
}


VOID SCENE_VIEW::ResetGridNum(int iNum)
{
	CreateGridObj(iNum , m_fGridSize);
}

VOID SCENE_VIEW::ResetGridSize(float fSizeChange)
{
    CreateGridObj(m_iGridNum , m_fGridSize + fSizeChange);
}

VOID SCENE_VIEW::DrawGridObj()
{
	D3DXMATRIX matWorld;
    D3DXMatrixIdentity(&matWorld);
    g_pd3dDevice->SetTransform( D3DTRANSFORMSTATE_WORLD , matWorld );
 	
	
	g_pd3dDevice->DrawPrimitive( D3DPT_LINELIST , D3DFVF_XYZ|D3DFVF_DIFFUSE , 
								pGridVB , m_iGridVertexAmount , 0);
	
}

VOID SCENE_VIEW::DrawSingleGridObj(int iGridX , int iGridY)
{
	GRID_VERTEX gridVB[5];
	float fx = (float)iGridX * m_fGridSize;
	float fy = (float)iGridY * m_fGridSize;
	gridVB[0].p = D3DXVECTOR3(fx               , fy ,0);
	gridVB[1].p = D3DXVECTOR3(fx + m_fGridSize , fy ,0);
	gridVB[2].p = D3DXVECTOR3(fx + m_fGridSize , fy + m_fGridSize , 0);
	gridVB[3].p = D3DXVECTOR3(fx               , fy + m_fGridSize , 0);
	gridVB[4].p = D3DXVECTOR3(fx               , fy               , 0);
	for(int i = 0 ; i < 5 ; i++)
	{
		gridVB[i].c = RGB_MAKE(0 , 0 , 255);
	}
	g_pd3dDevice->SetRenderState( D3DRENDERSTATE_ZENABLE	  , FALSE );
	g_pd3dDevice->DrawPrimitive( D3DPT_LINESTRIP , D3DFVF_XYZ|D3DFVF_DIFFUSE , 
								&gridVB , 5 , 0);


}

VOID SCENE_VIEW::SetView()
{
	m_Camera.fEyeX = m_Camera.m_EyePos.x;
	m_Camera.fEyeY = m_Camera.m_EyePos.y;
	m_Camera.fEyeZ = m_Camera.m_EyePos.z;
	
	m_Camera.fRefX = m_Camera.m_RefPos.x;
	m_Camera.fRefY = m_Camera.m_RefPos.y;
	m_Camera.fRefZ = m_Camera.m_RefPos.z; 
	
	D3DXVECTOR3 vEyePt    = D3DXVECTOR3( m_Camera.fEyeX , m_Camera.fEyeY , m_Camera.fEyeZ );
    D3DXVECTOR3 vLookatPt = D3DXVECTOR3( m_Camera.fRefX , m_Camera.fRefY , m_Camera.fRefZ );
    
	        
    // Set the view matrix 
    D3DXMATRIX matView;
    D3DXMatrixLookAt( &matView , &vEyePt , &vLookatPt , &D3DXVECTOR3( 0.0 , 0.0f , 1.0f ) );
    g_pd3dDevice->SetTransform( D3DTRANSFORMSTATE_VIEW , matView );
   
	 
	D3DXMATRIX matProj;
    float scale = 0.1f;
	float w = (float)g_iViewWidth  * scale;
	float h = (float)g_iViewHeight * scale;
	D3DXMatrixOrtho(&matProj , w , h , 1.0f , 1000.0f);
    
	//D3DXMatrixPerspectiveFov( &matProj, D3DXToRadian(42.185f) , 600.0f/800.0f ,  1.0f , 1000.0f );
  	g_pd3dDevice->SetTransform( D3DTRANSFORMSTATE_PROJECTION , matProj );

}


VOID SCENE_VIEW::CaluGridInfo()
{
	D3DMATRIX matWorld , matView , matProj;
	g_pd3dDevice->GetTransform(D3DTRANSFORMSTATE_WORLD      , &matWorld);
	g_pd3dDevice->GetTransform(D3DTRANSFORMSTATE_VIEW       , &matView);
	g_pd3dDevice->GetTransform(D3DTRANSFORMSTATE_PROJECTION , &matProj);
	D3DXMatrixIdentity((D3DXMATRIX*)&matWorld);
	
	float up_x    , up_y;
	float down_x  , down_y;
	float left_x  , left_y;
	float right_x , right_y;
	
	D3DVECTOR u;
	u = D3DVECTOR(0 , 0 , 0);
	Coord_3DWorldToScreen(&up_x , &up_y , u , matProj , matView , matWorld);
    
	u = D3DVECTOR(m_fGridSize , m_fGridSize , 0);
	Coord_3DWorldToScreen(&down_x , &down_y , u , matProj , matView , matWorld);
    
	u = D3DVECTOR(m_fGridSize , 0 , 0);
	Coord_3DWorldToScreen(&left_x , &left_y , u , matProj , matView , matWorld);
    
	u = D3DVECTOR(0 , m_fGridSize , 0);
	Coord_3DWorldToScreen(&right_x , &right_y , u , matProj , matView , matWorld);
    
	float w = right_x - left_x;
	float h = down_y  - up_y;
	
	m_fGridSizeX  = w;
	m_fGridSizeY  = h;
	
	        
	float x1 , y1 , x2 , y2;
	u = D3DVECTOR(0 , 0 , 0);
	Coord_3DWorldToScreen(&x1 , &y1 , u , matProj , matView , matWorld);
    
	u = D3DVECTOR(m_fGridSize * m_iGridNum , 0 , 0);
	Coord_3DWorldToScreen(&x2 , &y2 , u , matProj , matView , matWorld);
            
	DWORD dwWidth = (DWORD)(sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)));
			
	float off = m_fGridSize * (float)m_iGridNum / 2 ;
	u = D3DVECTOR(off  ,  off * -1.0f ,  0.0f);
	
	float fWorldInViewStartX , fWorldInViewStartY;
	Coord_3DWorldToScreen(&fWorldInViewStartX , &fWorldInViewStartY , u , matProj , matView , matWorld);
	
	g_iViewAtWorldX = (int)fWorldInViewStartX * -1;
	g_iViewAtWorldY = (int)fWorldInViewStartY * -1;
	
}