cterrain.cpp

骨骼动画 此程序演示了如何在你的游戏中使用骨骼动画技术。

}
bool CTerrain::computeVertices(float MaxHeight)
{
	 m_pDevice->CreateVertexBuffer( m_uiNumVertices*sizeof(TerrainVertex),
                                      D3DUSAGE_WRITEONLY, TerrainVertex::FVF_Flags,
									  D3DPOOL_DEFAULT, &m_pTerrainVB, NULL );

	

    TerrainVertex *v;
    m_pTerrainVB->Lock( 0,0, (void**)&v, 0 );

	// 创建Mesh需要的所有顶点
    for(UINT z = 0; z < m_nNumVertsAlongZ; ++z )
    {
        for(UINT x = 0; x < m_nNumVertsAlongX; ++x )
        {
			UINT uiDetailX = x % m_uiDetailLevel;
			UINT uiDetailY = z % m_uiDetailLevel;
			float fDetailPitch = 1.f/m_uiDetailLevel;
			int uiIndex = z*m_nNumVertsAlongX+x;
			 v[uiIndex].x = x*m_fTileLengthX;
			 v[uiIndex].y = rand()%(int)MaxHeight;
		     v[uiIndex].z = z*m_fTileLengthZ;
			 v[uiIndex].tu = static_cast<float>(x) / static_cast<float>(m_uiNumXTile);
			 v[uiIndex].tv = static_cast<float>(z) / static_cast<float>(m_uiNumZTile);
			 v[uiIndex].tu2 = static_cast<float>(uiDetailX*fDetailPitch);
			 v[uiIndex].tv2 = static_cast<float>(uiDetailY*fDetailPitch);      
        }
    }
    m_pTerrainVB->Unlock();
	return true;

}
bool CTerrain::computeVertices()
{
	 m_pDevice->CreateVertexBuffer( m_uiNumVertices*sizeof(TerrainVertex),
                                      D3DUSAGE_WRITEONLY, TerrainVertex::FVF_Flags,
									  D3DPOOL_DEFAULT, &m_pTerrainVB, NULL );

	

    TerrainVertex *v;
    m_pTerrainVB->Lock( 0,0, (void**)&v, 0 );

	if(m_HeightBuffer == NULL)
	{
		for(UINT z = 0; z < m_nNumVertsAlongZ; ++z )
    {
        for(UINT x = 0; x < m_nNumVertsAlongX; ++x )
        {
			UINT uiDetailX = x % m_uiDetailLevel;
			UINT uiDetailY = z % m_uiDetailLevel;
			float fDetailPitch = 1.f/m_uiDetailLevel;
			int uiIndex = z*m_nNumVertsAlongX+x;
			 v[uiIndex].x = x*m_fTileLengthX;
			 v[uiIndex].y = _heightmap[uiIndex];
		     v[uiIndex].z = z*m_fTileLengthZ;
			 v[uiIndex].tu = static_cast<float>(x) / static_cast<float>(m_uiNumXTile);
			 v[uiIndex].tv = static_cast<float>(z) / static_cast<float>(m_uiNumZTile);
			 v[uiIndex].tu2 = static_cast<float>(uiDetailX*fDetailPitch);
			 v[uiIndex].tv2 = static_cast<float>(uiDetailY*fDetailPitch);      
        }
    }
	}
	else{
	// 创建Mesh需要的所有顶点
    for(UINT z = 0; z < m_nNumVertsAlongZ; ++z )
    {
        for(UINT x = 0; x < m_nNumVertsAlongX; ++x )
        {
			UINT uiDetailX = x % m_uiDetailLevel;
			UINT uiDetailY = z % m_uiDetailLevel;
			float fDetailPitch = 1.f/m_uiDetailLevel;
			int uiIndex = z*m_nNumVertsAlongX+x;
			 v[uiIndex].x = x*m_fTileLengthX;
			 v[uiIndex].y = getHeight( x*m_fTileLengthX,z*m_fTileLengthZ);
		     v[uiIndex].z = z*m_fTileLengthZ;
			 v[uiIndex].tu = static_cast<float>(x) / static_cast<float>(m_uiNumXTile);
			 v[uiIndex].tv = static_cast<float>(z) / static_cast<float>(m_uiNumZTile);
			 v[uiIndex].tu2 = static_cast<float>(uiDetailX*fDetailPitch);
			 v[uiIndex].tv2 = static_cast<float>(uiDetailY*fDetailPitch);      
        }
    }
	}
    m_pTerrainVB->Unlock();
	return true;
}

bool CTerrain::computeIndices()
{
	m_pDevice->CreateIndexBuffer( m_uiNumIndices*sizeof(WORD),D3DUSAGE_WRITEONLY,
		                           D3DFMT_INDEX16,D3DPOOL_DEFAULT,&m_pTerrainIB,NULL);
    WORD* pIndices;
	m_pTerrainIB->Lock(0,0,(void**)&pIndices, 0);
	//int dd = 0;
	for(int z =0;z<(m_nNumVertsAlongZ-1);z++)
	{
		for(int x=0;x<(m_nNumVertsAlongX-1);x++)
		{
			// 1 ___ 2
			//  |  /|
			//  |/__|
			// 0     3
			//(z*(m_nNumVertsAlongX-1)+x )*6
			pIndices[(z*(m_nNumVertsAlongX-1)+x )*6] = z*m_nNumVertsAlongX+x;//0
			pIndices[(z*(m_nNumVertsAlongX-1)+x )*6+1] = (z+1)*m_nNumVertsAlongX+x;//1
			pIndices[(z*(m_nNumVertsAlongX-1)+x )*6+2] = (z+1)*m_nNumVertsAlongX+x+1;//2
			pIndices[(z*(m_nNumVertsAlongX-1)+x )*6+3] = z*m_nNumVertsAlongX+x;//0
			pIndices[(z*(m_nNumVertsAlongX-1)+x )*6+4] = (z+1)*m_nNumVertsAlongX+x+1;//2
			pIndices[(z*(m_nNumVertsAlongX-1)+x )*6+5] = z*m_nNumVertsAlongX+(x+1);//3
			
			//dd +=6;
		}
	}
	m_pTerrainIB->Unlock();
	return true;
}
bool CTerrain::readMap(string fileName)
{
    std::vector<BYTE> in( m_uiNumVertices );

	std::ifstream inFile(fileName.c_str(), std::ios_base::binary);

	if( inFile == 0 )
		return false;

	inFile.read(
		(char*)&in[0], // buffer
		in.size());// number of bytes to read into buffer

	inFile.close();

	// 设置vector大小
	_heightmap.resize( m_uiNumVertices );
	// copy高度图高度信息，到一个int型vector中
	 for(int i = 0; i < in.size(); i++)
	 {
		_heightmap[i] = in[i]*m_fTempBase;
	 }

	return true;
}
float CTerrain::getHeight(float x, float z)
{
	x = x-m_matWorld._41;
	z = z-m_matWorld._43;
	if( x > m_fMeshLengthAlongX || x < 0 || 
		z > m_fMeshLengthAlongZ || z < 0 )
	{
		return 10.f;
	}

	// (-fHalfWidth, -fHalfWidth)
	float fXLength = x;
	float fZLength = z;
	float fXTileIndex = fXLength / m_fTileLengthX;
	float fZTileIndex = fZLength / m_fTileLengthZ;
	UINT uiXTileIndex = static_cast<UINT>(fXTileIndex);
	UINT uiZTileIndex = static_cast<UINT>(fZTileIndex);
	// ( uiXTileIndex, uiYTileIndex )

	/* 
	2-----3
	|    /|
	|  /  |
	|/    |
	0-----1
	*/
	float fHeight0 = m_HeightBuffer[ uiZTileIndex * m_HeightMapDesc.Width + uiXTileIndex ] * m_fTempBase;
	float fHeight1 = m_HeightBuffer[ uiZTileIndex * m_HeightMapDesc.Width + uiXTileIndex + 1 ] * m_fTempBase;
	float fHeight2 = m_HeightBuffer[ ( uiZTileIndex + 1 ) * m_HeightMapDesc.Width + uiXTileIndex ] * m_fTempBase;
	float fHeight3 = m_HeightBuffer[ ( uiZTileIndex + 1 ) * m_HeightMapDesc.Width + uiXTileIndex + 1 ] * m_fTempBase;


	float t1 = fHeight0;
	float t2 = fHeight1;
	float b1 = fHeight2;
	float b2 = fHeight3;

	float x_pct = fXTileIndex - uiXTileIndex;
	float z_pct = fZTileIndex - uiZTileIndex;

	float midpoint = (b1 + t2) / 2.0f;

	if (x_pct + z_pct <= 1) {
		b2 = midpoint + (midpoint - t1);
	} else {
		t1 = midpoint + (midpoint - b2);
	}

	float t = ( t1 * ( 1 - x_pct ) ) + ( t2 * ( x_pct ) );
	float b = ( b1 * ( 1 - x_pct ) ) + ( b2 * ( x_pct ) );

	float h = ( t * ( 1 - z_pct ) ) + ( b * ( z_pct ) );

	return h;
}

//void CTerrain::Render()
//{
//		if( !m_pTerrainVB || !m_pTerrainIB )
//		return;
//
//	D3DXMATRIX matWorld,matTrans;
//	D3DXMatrixIdentity(&matWorld);
//	D3DXMatrixIdentity(&matTrans);
//	//D3DXMatrixTranslation( &matTrans,-100.0f,-20.0f,-20.0f );
//	matWorld = matWorld * matTrans;
//	m_pDevice->SetTransform( D3DTS_WORLD, &matWorld );
//	m_pDevice->SetMaterial( &m_TerrainMaterial );
//	m_pDevice->LightEnable( 0, TRUE );
//	m_pDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
//	m_pDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW );
//	m_pDevice->SetRenderState( D3DRS_AMBIENT, 0xffffffff );
//	m_pDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
//	m_pDevice->SetRenderState( D3DRS_LIGHTING, TRUE );
//	m_pDevice->SetRenderState( D3DRS_LIGHTING, FALSE );
//	m_pDevice->SetRenderState( D3DRS_FOGENABLE, FALSE );
//	m_pDevice->SetSamplerState(0, D3DSAMP_MINFILTER,D3DTEXF_LINEAR);
//	m_pDevice->SetSamplerState(0, D3DSAMP_MAGFILTER,D3DTEXF_LINEAR);
//	m_pDevice->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE );
//	m_pDevice->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
//	m_pDevice->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
//	m_pDevice->SetSamplerState(1, D3DSAMP_MINFILTER,D3DTEXF_LINEAR);
//	m_pDevice->SetSamplerState(1, D3DSAMP_MAGFILTER,D3DTEXF_LINEAR);
//	m_pDevice->SetStreamSource( 0, m_pTerrainVB, 0, sizeof(TerrainVertex) );
//	m_pDevice->SetIndices( m_pTerrainIB );
//	m_pDevice->SetTexture( 0, m_pTerrainTextures );
//	m_pDevice->SetTexture( 1, m_pDetailTexture );
//	m_pDevice->SetFVF( TerrainVertex::FVF_Flags );
//
//	m_pDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, m_uiNumVertices,
//		0, m_uiNumTiles*2 );
//	//m_pDevice->LightEnable( 0, FALSE );
//	m_pDevice->SetRenderState( D3DRS_LIGHTING, FALSE );
//	m_pDevice->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
//};

void CTerrain::Render(D3DXMATRIX matWorld1)
{
		if( !m_pTerrainVB || !m_pTerrainIB )
		return;

	/*D3DXMATRIX matWorld,matTrans;
	D3DXMatrixIdentity(&matWorld);
	D3DXMatrixIdentity(&matTrans);
	D3DXMatrixTranslation( &matTrans,-100.0f,-20.0f,-20.0f );
	matWorld = matWorld * matTrans;*/
	m_matWorld = matWorld1;
	m_pDevice->SetTransform( D3DTS_WORLD, &m_matWorld );
	m_pDevice->SetMaterial( &m_TerrainMaterial );
	m_pDevice->LightEnable( 0, TRUE );
	m_pDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
	m_pDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW );
	m_pDevice->SetRenderState( D3DRS_AMBIENT, 0xffffffff );
	m_pDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
	//m_pDevice->SetRenderState( D3DRS_LIGHTING, TRUE );
	m_pDevice->SetRenderState( D3DRS_LIGHTING, FALSE );
	m_pDevice->SetRenderState( D3DRS_FOGENABLE, FALSE );
	m_pDevice->SetSamplerState(0, D3DSAMP_MINFILTER,D3DTEXF_LINEAR);
	m_pDevice->SetSamplerState(0, D3DSAMP_MAGFILTER,D3DTEXF_LINEAR);
	m_pDevice->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE );
	m_pDevice->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
	m_pDevice->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
	m_pDevice->SetSamplerState(1, D3DSAMP_MINFILTER,D3DTEXF_LINEAR);
	m_pDevice->SetSamplerState(1, D3DSAMP_MAGFILTER,D3DTEXF_LINEAR);
	m_pDevice->SetStreamSource( 0, m_pTerrainVB, 0, sizeof(TerrainVertex) );
	m_pDevice->SetIndices( m_pTerrainIB );
	m_pDevice->SetTexture( 0, m_pTerrainTextures );
	m_pDevice->SetTexture( 1, m_pDetailTexture );
	m_pDevice->SetFVF( TerrainVertex::FVF_Flags );

	m_pDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, m_uiNumVertices,
		0, m_uiNumTiles*2 );
	m_pDevice->LightEnable( 0, FALSE );
	m_pDevice->SetRenderState( D3DRS_LIGHTING, FALSE );
	m_pDevice->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
};