Direct3D轮回：游戏场景之植被

完成天空、陆地、河流模块的构建之后，这一节再为我们的游戏场景添加一点其他的装饰——植被~

游戏中的植被可以选用D3D中的广告板来实现，这个后续我们会讲解，不过为了增加其立体感，大都会构建一个这样形状的结构：

三个方形表面分别成120度交叉对齐，而后贴上植被的纹理，再开启Alpha通道，便可实现一个很好的视觉体验：

我习惯称这个形状为“PlantBoard” ^ ^

下面，我们首先着手来完成CPlantBoard对象的构建：

/* -------------------------------------

代码清单：PlantBoard.h
来自： http://www.cnblogs.com/kenkao

------------------------------------- */

#include  " D3DInit.h "

#pragma  once

class  CPlantBoard
{
public :
    CPlantBoard(D3DXVECTOR3 CenterPos,  float  bWidth,  float  bHeight);
     ~ CPlantBoard( void );
public :
     void  FlushVertexBuffer(VertexPositionTex *  pVertices,  int &  index);      //  序列化顶点缓冲
     void  FlushIndexBuffer(DWORD *  pIndices,  int &  index);                    //  序列化索引缓冲
private :
    D3DXVECTOR3        m_CenterPos;                                        //  中心位置
     int                 m_bWidth;                                           //  宽度
     int                 m_bHeight;                                          //  高度
};

float  GetRandomFloat( float  min,  float  max);                                //  获取一个float随机数

 

PlantBoard.cpp

/* -------------------------------------

代码清单：PlantBoard.cpp
来自： http://www.cnblogs.com/kenkao

------------------------------------- */

#include  " StdAfx.h "
#include  " PlantBoard.h "

float  GetRandomFloat( float  min,  float  max)
{
     return  min  +  rand() % (( int )max  +   1   -  ( int )min);
}

CPlantBoard::CPlantBoard(D3DXVECTOR3 CenterPos,  float  bWidth,  float  bHeight):
                                                    m_CenterPos(CenterPos),
                                                    m_bWidth(bWidth),
                                                    m_bHeight(bHeight)
{
}

CPlantBoard:: ~ CPlantBoard( void )
{
}

void  CPlantBoard::FlushVertexBuffer(VertexPositionTex *  pVertices,  int &  index)
{
     //  第一面各点偏移位置
    D3DXVECTOR3 pos_LU  =  D3DXVECTOR3( -  m_bWidth  /   2 ,  +  m_bHeight  /   2 ,  0 );
    D3DXVECTOR3 pos_RU  =  D3DXVECTOR3( +  m_bWidth  /   2 ,  +  m_bHeight  /   2 ,  0 );
    D3DXVECTOR3 pos_LB  =  D3DXVECTOR3( -  m_bWidth  /   2 ,  -  m_bHeight  /   2 ,  0 );
    D3DXVECTOR3 pos_RB  =  D3DXVECTOR3( +  m_bWidth  /   2 ,  -  m_bHeight  /   2 ,  0 );

     //  通用的纹理映射坐标
    D3DXVECTOR2 uv_LU  =  D3DXVECTOR2( 0 , 0 );
    D3DXVECTOR2 uv_RU  =  D3DXVECTOR2( 1 , 0 );
    D3DXVECTOR2 uv_LB  =  D3DXVECTOR2( 0 , 1 );
    D3DXVECTOR2 uv_RB  =  D3DXVECTOR2( 1 , 1 );

     //  产生一个随机的偏转角，使得植被看起来形状各异
     float  randomAngle  =  GetRandomFloat(MATH_PI / 4.0f , MATH_PI * 5.0f / 12.0f );
    D3DXMATRIX rotateMatrix;
    D3DXMatrixRotationY( & rotateMatrix, randomAngle);
    D3DXMATRIX rotateMatrix2;
    D3DXMatrixRotationY( & rotateMatrix2, MATH_PI  -  randomAngle);

     //  第二面各点偏移位置
    D3DXVECTOR3 pos_LU2;
    D3DXVECTOR3 pos_RU2;
    D3DXVECTOR3 pos_LB2;
    D3DXVECTOR3 pos_RB2;

    D3DXVec3TransformCoord( & pos_LU2,  & pos_LU,  & rotateMatrix);
    D3DXVec3TransformCoord( & pos_RU2,  & pos_RU,  & rotateMatrix);
    D3DXVec3TransformCoord( & pos_LB2,  & pos_LB,  & rotateMatrix);
    D3DXVec3TransformCoord( & pos_RB2,  & pos_RB,  & rotateMatrix);

     //  第三面各点偏移位置
    D3DXVECTOR3 pos_LU3;
    D3DXVECTOR3 pos_RU3;
    D3DXVECTOR3 pos_LB3;
    D3DXVECTOR3 pos_RB3;

    D3DXVec3TransformCoord( & pos_LU3,  & pos_LU,  & rotateMatrix2);
    D3DXVec3TransformCoord( & pos_RU3,  & pos_RU,  & rotateMatrix2);
    D3DXVec3TransformCoord( & pos_LB3,  & pos_LB,  & rotateMatrix2);
    D3DXVec3TransformCoord( & pos_RB3,  & pos_RB,  & rotateMatrix2);

     //  各面顶点序列化到顶点缓冲
    pVertices[index ++ ]  =  VertexPositionTex(m_CenterPos  +  pos_LU, uv_LU);
    pVertices[index ++ ]  =  VertexPositionTex(m_CenterPos  +  pos_RU, uv_RU);
    pVertices[index ++ ]  =  VertexPositionTex(m_CenterPos  +  pos_LB, uv_LB);
    pVertices[index ++ ]  =  VertexPositionTex(m_CenterPos  +  pos_RB, uv_RB);

    pVertices[index ++ ]  =  VertexPositionTex(m_CenterPos  +  pos_LU2, uv_LU);
    pVertices[index ++ ]  =  VertexPositionTex(m_CenterPos  +  pos_RU2, uv_RU);
    pVertices[index ++ ]  =  VertexPositionTex(m_CenterPos  +  pos_LB2, uv_LB);
    pVertices[index ++ ]  =  VertexPositionTex(m_CenterPos  +  pos_RB2, uv_RB);

    pVertices[index ++ ]  =  VertexPositionTex(m_CenterPos  +  pos_LU3, uv_LU);
    pVertices[index ++ ]  =  VertexPositionTex(m_CenterPos  +  pos_RU3, uv_RU);
    pVertices[index ++ ]  =  VertexPositionTex(m_CenterPos  +  pos_LB3, uv_LB);
    pVertices[index ++ ]  =  VertexPositionTex(m_CenterPos  +  pos_RB3, uv_RB);
}

void  CPlantBoard::FlushIndexBuffer(DWORD *  pIndices,  int &  index)
{
     //  每面4个顶点对应6个索引，其比率为2：3
    DWORD vindex  =  (DWORD)index  *   2   /   3 ;

     //  序列化第一面各点索引
    pIndices[index ++ ]  =  vindex;
    pIndices[index ++ ]  =  vindex  +   1 ;
    pIndices[index ++ ]  =  vindex  +   2 ;

    pIndices[index ++ ]  =  vindex  +   1 ;
    pIndices[index ++ ]  =  vindex  +   3 ;
    pIndices[index ++ ]  =  vindex  +   2 ;

     //  序列化第二面各点索引
    pIndices[index ++ ]  =  vindex  +   4 ;
    pIndices[index ++ ]  =  vindex  +   5 ;
    pIndices[index ++ ]  =  vindex  +   6 ;

    pIndices[index ++ ]  =  vindex  +   5 ;
    pIndices[index ++ ]  =  vindex  +   7 ;
    pIndices[index ++ ]  =  vindex  +   6 ;

     //  序列化第三面各点索引
    pIndices[index ++ ]  =  vindex  +   8 ;
    pIndices[index ++ ]  =  vindex  +   9 ;
    pIndices[index ++ ]  =  vindex  +   10 ;

    pIndices[index ++ ]  =  vindex  +   9 ;
    pIndices[index ++ ]  =  vindex  +   11 ;
    pIndices[index ++ ]  =  vindex  +   10 ;
}

 

有了前几节的基础，构建这样一个结构相信对大家而言已不再是什么难事~

需要大致提一下的是这个类的一点设计思路。

CPlantBoard自身并不持有自己的顶点缓冲与索引缓冲，而是通过两个主要方法FlushVertexBuffer跟FlushIndexBuffer将自身所要形成的顶点缓冲与索引缓冲序列化到外部传入的一个更大的缓冲区内，同时自行累加传入的索引下标。——这样做无疑是灵活而高效的。

如我们所知，一个场景中的植被单位数量有很多，而如果每个CPlantBoard都含有自己的顶点与索引缓冲，那么绘制多个CPlantBoard的方法无非有二：

1> 设备反复调用顶点绘制，渲染全部的CPlantBoard——这无疑是下下策。反复调用顶点绘制，而每次都绘制少量顶点，在任何GraphySdk设计中都是费力不讨好的事情~

2> 合并每个CPlantBoard持有的顶点缓冲与索引缓冲，而后统一绘制——既然以后还要做同样的工作，不如直接写入一个统一的缓冲区中。

 

完成基本单位的构建之后，我们再来实现一个CPlantBoard的集合类CPlantCollect：

 

/* -------------------------------------

代码清单：PlantCollect.h
来自： http://www.cnblogs.com/kenkao

------------------------------------- */

#include  " PlantBoard.h "
#include  < list >

using   namespace  std;

#pragma  once

class  CPlantCollect
{
public :
    CPlantCollect( void );
     ~ CPlantCollect( void );
public :
     bool  Create(                                   //  生成植被
         float  minHeight,                           //  最低海拔
         float  maxHeight,                           //  最高海拔
         float  density);                            //  密度(间距)
     void  Draw( float  gameTick);                     //  绘制植被
     void  Release();                                //  资源释放
private :
     bool   LoadContent();                           //  加载资源
     void   CreateVertices();                        //  生成顶点及索引缓冲
     void   CreatePlantNode();                       //  生成植被节点
    POINT GetPlantSize();                          //  获得植被尺寸
private :
    list < CPlantBoard >*  m_pPlantNodeList;           //  植被节点列表
    IDirect3DTexture9 *  m_pGrassTexture;            //  草地纹理
    IDirect3DVertexBuffer9 *   m_pVB;                //  顶点缓冲
    IDirect3DIndexBuffer9 *    m_pIB;                //  索引缓冲
private :
     float  m_minHeight;                             //  最低海拔
     float  m_maxHeight;                             //  最高海拔
     float  m_density;                               //  密度
     int    m_vertexNum;                             //  顶点总数
     int    m_indexNum;                              //  索引总数
};

 

PlantCollect.cpp

/* -------------------------------------

代码清单：PlantCollect.cpp
来自： http://www.cnblogs.com/kenkao

------------------------------------- */

#include  " StdAfx.h "
#include  " PlantCollect.h "
#include  " D3DGame.h "
#include  " BaseTerrain.h "

extern  IDirect3DDevice9  * g_pD3DDevice;
extern  CBaseTerrain      * g_pBaseTerrain;

CPlantCollect::CPlantCollect( void ) : m_pPlantNodeList(NULL),
                                     m_pGrassTexture(NULL),
                                     m_pVB(NULL),
                                     m_pIB(NULL),
                                     m_minHeight( 0 ),
                                     m_maxHeight( 0 ),
                                     m_density( 0 ),
                                     m_vertexNum( 0 ),
                                     m_indexNum( 0 )
{
    m_pPlantNodeList  =   new  list < CPlantBoard > ;
}

CPlantCollect:: ~ CPlantCollect( void )
{
}

void  CPlantCollect::Release()
{
    ReleaseCOM(m_pVB);
    ReleaseCOM(m_pIB);
    ReleaseCOM(m_pGrassTexture);
     if (m_pPlantNodeList -> size() > 0 )
        m_pPlantNodeList -> clear();
    delete m_pPlantNodeList;
}

bool  CPlantCollect::Create( float  minHeight,  float  maxHeight,  float  density)
{
     //  异常检测，如果没有创建陆地，则不予创建植被
     if ( ! g_pBaseTerrain)
         return   false ;
    m_minHeight  =  minHeight;
    m_maxHeight  =  maxHeight;
    m_density  =  density;
     //  内容加载
     if ( ! LoadContent())
    {
        Release();
         return   false ;
    }
     //  创建植被节点
    CreatePlantNode();
     //  创建顶点缓冲及索引缓冲
    CreateVertices();
     return   true ;
}

bool  CPlantCollect::LoadContent()
{
     //  创建纹理
    HRESULT hr  =  D3DXCreateTextureFromFile(g_pD3DDevice, " grass.png " , & m_pGrassTexture);
     if (FAILED(hr))
         return   false ;
     return   true ;
}

void  CPlantCollect::CreatePlantNode()
{
     //  遍历整个陆地区域
     for  ( int  j = 0 ;j < g_pBaseTerrain -> GetSizeY();j += m_density)
    {
         for  ( int  i = 0 ;i < g_pBaseTerrain -> GetSizeX();i += m_density)
        {
             //  横纵坐标各添加一个随机值，以防种草变成种麦子 ^_^
             float  posX  =  g_pBaseTerrain -> GetPosX()  +  i  +  rand() % ( int )m_density;
             float  posZ  =  g_pBaseTerrain -> GetPosY()  +  j  +  rand() % ( int )m_density;
             //  获得陆地上该点高度
             float  posY  =  g_pBaseTerrain -> GetExactHeightAt(posX,posZ);
             //  如果高度在允许海拔范围之间，则创建植被节点
             if (posY  >=  m_minHeight  &&  posY  <=  m_maxHeight)
            {
                D3DXVECTOR3 pos  =  D3DXVECTOR3(posX, posY, posZ);
                POINT Size  =  GetPlantSize();
                pos.y  +=  Size.y / 2 ;
                m_pPlantNodeList -> push_back(CPlantBoard(pos,Size.x,Size.y));
            }
        }
    }
}

void  CPlantCollect::CreateVertices()
{
     //  获得植被节点数目
     int  NodeNum  =  m_pPlantNodeList -> size();
     //  计算得顶点总数
    m_vertexNum  =  NodeNum  *   12 ;
     //  计算得索引总数
    m_indexNum   =  NodeNum  *   18 ;

     //  创建顶点缓冲
    g_pD3DDevice -> CreateVertexBuffer(
        m_vertexNum  *   sizeof (VertexPositionTex),
        D3DUSAGE_WRITEONLY,
        VertexPositionTex::FVF,
        D3DPOOL_MANAGED,
         & m_pVB,
         0 );

    VertexPositionTex *  pVertices;
    m_pVB -> Lock( 0 , 0 ,( void ** ) & pVertices, 0 );
    
     //  序列化全部植被节点顶点
     int  vindex  =   0 ;
     for (list < CPlantBoard > ::iterator ptr  =  m_pPlantNodeList -> begin(); ptr  !=  m_pPlantNodeList -> end();  ++ ptr)
    {
        ptr -> FlushVertexBuffer(pVertices,vindex);
    }

    m_pVB -> Unlock();

     //  创建索引缓冲
    g_pD3DDevice -> CreateIndexBuffer(
        m_indexNum   *   sizeof (DWORD),
        D3DUSAGE_WRITEONLY,
        D3DFMT_INDEX32,
        D3DPOOL_MANAGED,
         & m_pIB,
         0 );

    DWORD *  pIndices;
    m_pIB -> Lock( 0 , 0 ,( void ** ) & pIndices, 0 );

     //  序列化全部植被节点索引
     int  index  =   0 ;
     for (list < CPlantBoard > ::iterator ptr  =  m_pPlantNodeList -> begin(); ptr  !=  m_pPlantNodeList -> end();  ++ ptr)
    {
        ptr -> FlushIndexBuffer(pIndices,index);
    }

    m_pIB -> Unlock();
}

void  CPlantCollect::Draw( float  gameTick)
{
     //  禁用背面剔除
    g_pD3DDevice -> SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);

     //  启用Alpha通道
    g_pD3DDevice -> SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
    g_pD3DDevice -> SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
    g_pD3DDevice -> SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);

     //  开启Alpha检测
    g_pD3DDevice -> SetRenderState(D3DRS_ALPHATESTENABLE, TRUE);
    g_pD3DDevice -> SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL);
    g_pD3DDevice -> SetRenderState(D3DRS_ALPHAREF,  150 );

     //  设置纹理、顶点缓冲区、索引缓冲区及顶点格式
    g_pD3DDevice -> SetTexture( 0 ,m_pGrassTexture);
    g_pD3DDevice -> SetStreamSource( 0 , m_pVB,  0 ,  sizeof (VertexPositionTex));
    g_pD3DDevice -> SetIndices(m_pIB);
    g_pD3DDevice -> SetFVF(VertexPositionTex::FVF);

     //  绘制顶点
    g_pD3DDevice -> DrawIndexedPrimitive(D3DPT_TRIANGLELIST,  0 ,  0 , m_vertexNum,  0 , m_indexNum / 3 );

     //  关闭Alpha检测
    g_pD3DDevice -> SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);

     //  禁用Alpha通道
    g_pD3DDevice -> SetRenderState(D3DRS_ALPHABLENDENABLE,FALSE);

     //  重用背面剔除
    g_pD3DDevice -> SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
}

POINT CPlantCollect::GetPlantSize()
{
     //  获得植被尺寸
    POINT Size;
    Size.x  =   16 ;
    Size.y  =   16 ;
     return  Size;
     //  大家也可以在这里返回一个随机值，使得创建的植被大小各异 ^_^
}

 

CPlantCollect自身含有一个CPlantBoard列表以及独立的顶点及索引缓冲，按照特定的海拔和间距(当然你也可以定制属于你自己的标准)创建CPlantBoard节点，而后遍历列表调用每一个CPlantBoard对象的FlushVertexBuffer跟FlushIndexBuffer方法序列化自身缓冲到CPlantCollent总的缓冲区中。之后由CPlantCollect对象调用自身Draw方法一气呵成即可^ ^

 

剩下的主体代码就很简单了：

D3DGame.cpp

/* -------------------------------------

代码清单：D3DGame.cpp
来自： http://www.cnblogs.com/kenkao

------------------------------------- */

#include  " StdAfx.h "
#include  " D3DGame.h "
#include  " D3DCamera.h "
#include  " D3DEffect.h "
#include  " CoordCross.h "
#include  " SimpleXMesh.h "
#include  " Texture2D.h "
#include  " D3DSprite.h "
#include  " Skybox.h "
#include  " SpriteBatch.h "
#include  " BaseTerrain.h "
#include  " Water.h "
#include  " PlantCollect.h "
#include  < stdio.h >
#include  < time.h >

// ---通用全局变量

HINSTANCE  g_hInst;
HWND       g_hWnd;
D3DXMATRIX g_matProjection;
D3DPRESENT_PARAMETERS g_D3DPP;

// ---D3D全局变量

IDirect3D9        * g_pD3D            =  NULL;
IDirect3DDevice9  * g_pD3DDevice      =  NULL;
CMouseInput       * g_pMouseInput     =  NULL;
CKeyboardInput    * g_pKeyboardInput  =  NULL;
CD3DCamera        * g_pD3DCamera      =  NULL;
CSkybox           * g_pSkybox         =  NULL;
CBaseTerrain      * g_pBaseTerrain    =  NULL;
CWater            * g_pWater          =  NULL;
CPlantCollect     * g_pPlant          =  NULL;
CSimpleXMesh      * g_pMesh           =  NULL;

//  场景绘制
void  DrawScene( bool  isReflect, bool  isRefract);

void  Initialize(HINSTANCE hInst, HWND hWnd)
{
    g_hInst  =  hInst;
    g_hWnd   =  hWnd;
    InitD3D( & g_pD3D,  & g_pD3DDevice, g_D3DPP, g_matProjection, hWnd);
    g_pMouseInput  =   new  CMouseInput;
    g_pMouseInput -> Initialize(hInst,hWnd);
    g_pKeyboardInput  =   new  CKeyboardInput;
    g_pKeyboardInput -> Initialize(hInst,hWnd);
    g_pD3DCamera  =   new  CD3DCamera;
    srand(time( 0 ));
}

void  LoadContent()
{
    g_pD3DCamera -> SetCameraPos(D3DXVECTOR3( 600.0f , 0.0f , 600.0f ));

    g_pSkybox  =   new  CSkybox;
    g_pSkybox -> Create( " Skybox_0.JPG " , " Skybox_1.JPG " , " Skybox_2.JPG "
        , " Skybox_3.JPG " , " Skybox_4.JPG " , " Skybox_5.JPG " );

    g_pBaseTerrain  =   new  CBaseTerrain;
    g_pBaseTerrain -> Create( 128 , 128 , 10 , " HeightData_128x128.raw " , " Grass.dds " );

    g_pWater  =   new  CWater;
    g_pWater -> Create( 1280 , 1280 , 0.0f , 0.0f , 40.0f );

    g_pPlant  =   new  CPlantCollect;
    g_pPlant -> Create( 60 , 90 , 15 );

    g_pMesh  =   new  CSimpleXMesh;
    g_pMesh -> LoadXMesh( " WindMill.x " );
}

void  Update( float  gameTick)
{
    g_pMouseInput -> GetState();
    g_pKeyboardInput -> GetState();

     //  更新摄影机高度
    D3DXVECTOR3 CameraPos  =  g_pD3DCamera -> GetCameraPos();
     float  roleHeight  =   25.0f ;
     float  Ty  =  g_pBaseTerrain -> GetExactHeightAt(CameraPos.x,CameraPos.z)  +  roleHeight;
    g_pD3DCamera -> SetCameraPos(D3DXVECTOR3(
        CameraPos.x,
        Ty,
        CameraPos.z));

    g_pD3DCamera -> Update();
}

void  Draw( float  gameTick)
{
    g_pD3DDevice -> SetTransform(D3DTS_VIEW, & g_pD3DCamera -> GetViewMatrix());
     if (SUCCEEDED(g_pD3DDevice -> BeginScene())) 
    {
        g_pWater -> BeginReflect();
        DrawScene( true , false );
        g_pWater -> EndReflect();

        g_pWater -> BeginRefract();
        DrawScene( false , true );
        g_pWater -> EndRefract();

        g_pD3DDevice -> Clear( 0 , NULL, D3DCLEAR_TARGET  |  D3DCLEAR_ZBUFFER, D3DCOLOR_RGBA( 100 , 149 , 237 , 255 ),  1.0f ,  0 );
        DrawScene( false , false );
        g_pWater -> Draw(gameTick);
        g_pPlant -> Draw(gameTick);

        g_pD3DDevice -> EndScene();
    }
    g_pD3DDevice -> Present(NULL, NULL, NULL, NULL);
}

void  DrawScene( bool  isReflect, bool  isRefract)
{
    g_pSkybox -> Draw(isReflect,isRefract);
    g_pBaseTerrain -> Draw();

    D3DXMATRIX scalTrans;
    D3DXMatrixScaling( & scalTrans, 5.0f , 5.0f , 5.0f );
    D3DXMATRIX movTrans;
    D3DXMatrixTranslation( & movTrans, 366 ,g_pBaseTerrain -> GetExactHeightAt( 366 , 190 ) - 5.0f , 190 );
    g_pMesh -> DrawXMesh(scalTrans  *  movTrans);
}

void  UnloadContent()
{
    ReleaseCOM(g_pPlant);
    ReleaseCOM(g_pWater);
    ReleaseCOM(g_pBaseTerrain);
    ReleaseCOM(g_pSkybox);
}

void  Dispose()
{
    ReleaseCOM(g_pD3DCamera);
    ReleaseCOM(g_pKeyboardInput);
    ReleaseCOM(g_pMouseInput);
    ReleaseCOM(g_pD3DDevice);
    ReleaseCOM(g_pD3D);
}

需要注意的是，植被属于场景中的细节部分，绘制又比较耗性能，不建议使其被水面反射而多次绘制。

如下效果图：

植被仅分布在地势较低的河流附近，不会出现在山顶之上~

以上，谢谢~