Directx11学习笔记【十三】 实现一个简单地形

本文由zhangbaochong原创，转载请注明出处http://www.cnblogs.com/zhangbaochong/p/5510294.html

上一个教程我们实现了渲染一个会旋转的立方体，这次我们来实现一个简单地形。

先来看看最终实现效果吧(蓝色是背景色，地形的不同高度分别渲染了不同颜色)

实现原理其实很简单，我们现在xz平面定义一个二维网格，然后y值可以根据一定的函数得到，比如正余弦函数组成等等，便可以得到一个看似不错的地形

或者水面效果。

1.创建二维网格

首先我们在GeometryGenerator中定义了一个只有XMFLOAT3 Position一个变量的结构Vertex用来描述顶点信息，MeshData中保存了整个grid所有

顶点的顶点信息和索引信息。CreateGrid函数负责创建grid。

#pragma once

#include<vector>
#include "Dx11DemoBase.h"

class GeometryGenerator
{
public:
    struct  Vertex 
    {
        Vertex(){}
        Vertex(const XMFLOAT3& p)
            : Position(p){}
        Vertex(float px, float py, float pz): Position(px, py, pz){}
        XMFLOAT3 Position;
    };

    struct MeshData
    {
        std::vector<Vertex> vertices;
        std::vector<UINT> indices;
    };

    void CreateGrid(float width, float depth, UINT m, UINT n, MeshData& meshData);
};

顶点索引的计算关键是推导出一个用于求构成第i行，第j列的顶点处右下方两个三角形的顶点索引的通用公式。

对顶点缓存中的任意一点A，如果该点位于地形中的第i行、第j列的话，那么该点在顶点缓存中所对应的位置应该就是i*m+j（m为每行的顶点数）。如果A点在索引缓存中的位置为k的话，那么A点为起始点构成的三角形ABC中，B、C顶点在顶点缓存中的位置就为（i+1）x m+j和i x m+（j+1）。且B点索引值为k+1，C点索引值为k+2.这样。这样，公式就可以推导为如下：

三角形ABC=【i*每行顶点数+j，i*每行顶点数+（j+1），（i+1）*行顶点数+j】

三角形CBD=【（i+1）*每行顶点数+j，i*每行顶点数+（j+1），（i+1）*行顶点数+（j+1）】

#include "GeometryGenerator.h"


void GeometryGenerator::CreateGrid(float width, float depth, UINT m, UINT n, MeshData& meshData)
{
    UINT vertexCount = m*n;
    UINT faceCount = (m - 1)*(n - 1) * 2;

    // Create the vertices.

    float halfWidth = 0.5f*width;
    float halfDepth = 0.5f*depth;

    float dx = width / (n - 1);
    float dz = depth / (m - 1);

    meshData.vertices.resize(vertexCount);
    for (UINT i = 0; i < m; ++i)
    {
        float z = halfDepth - i*dz;
        for (UINT j = 0; j < n; ++j)
        {
            float x = -halfWidth + j*dx;
            meshData.vertices[i*n + j].Position = XMFLOAT3(x, 0.0f, z);
        }
    }

    // Create the indices.

    meshData.indices.resize(faceCount * 3); // 3 indices per face

    UINT k = 0;
    for (UINT i = 0; i < m - 1; ++i)
    {
        for (UINT j = 0; j < n - 1; ++j)
        {
            meshData.indices[k] = i*n + j;
            meshData.indices[k + 1] = i*n + j + 1;
            meshData.indices[k + 2] = (i + 1)*n + j;

            meshData.indices[k + 3] = (i + 1)*n + j;
            meshData.indices[k + 4] = i*n + j + 1;
            meshData.indices[k + 5] = (i + 1)*n + j + 1;

            k += 6; // next quad
        }
    }
}

2.鼠标拖动控制视角

为了方便观察最后创建出的地形，我们采用鼠标拖动旋转的方式，通过鼠标拖动改变相应的视图矩阵，因此我们Dx11DemoBase中添加了三个函数

//鼠标事件
virtual void OnMouseDown(WPARAM btnState, int x, int y){}
virtual void OnMouseUp(WPARAM btnState, int x, int y){}
virtual void OnMouseMove(WPARAM btnState, int x, int y){}

main函数消息循环中添加

case WM_LBUTTONDOWN:
    case WM_MBUTTONDOWN:
    case WM_RBUTTONDOWN:
        demo->OnMouseDown(wParam, GET_X_LPARAM(lParam),GET_Y_LPARAM(lParam));
        return 0;
    case WM_LBUTTONUP:
    case WM_MBUTTONUP:
    case WM_RBUTTONUP:
        demo->OnMouseUp(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
        return 0;
    case WM_MOUSEMOVE:
        demo->OnMouseMove(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));

具体函数的实现在下面给出

3.顶点缓冲和索引缓冲的创建

    GeometryGenerator::MeshData grid;
    GeometryGenerator geoGen;
    geoGen.CreateGrid(160.0f, 160.0f, 50, 50, grid);
    m_gridIndexCount = grid.indices.size();

    std::vector<Vertex> vertices(grid.vertices.size(),Vertex(XMFLOAT3(0,0,0),XMFLOAT4(0,0,0,0)));
    for (UINT i = 0; i < grid.vertices.size(); ++i)
    {
        XMFLOAT3 p = grid.vertices[i].Position;
        p.y = GetHeight(p.x, p.z);

        vertices[i].pos = p;
        
        //渲染顶点根据高度给出不同颜色
        if (p.y < -10.0f)
        {
            //sandy beach color
            vertices[i].color = XMFLOAT4(1.0f, 0.96f, 0.62f, 1.0f);
        }
        else if (p.y < 5.0f)
        {
            //light yellow-green color
            vertices[i].color = XMFLOAT4(0.48f, 0.77f, 0.46f, 1.0f);
        }
        else if (p.y < 12.0f)
        {
            //dark yellow-green color
            vertices[i].color = XMFLOAT4(0.1f, 0.48f, 0.19f, 1.0f);
        }
        else if (p.y < 20.f)
        {
            //dark brown color
            vertices[i].color = XMFLOAT4(0.45f, 0.39f, 0.34f, 1.0f);
        }
        else
        {
            //white snow color
            vertices[i].color = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);
        }
    }

    D3D11_BUFFER_DESC vertexDesc;
    ZeroMemory(&vertexDesc, sizeof(vertexDesc));
    vertexDesc.Usage = D3D11_USAGE_IMMUTABLE;
    vertexDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vertexDesc.ByteWidth = sizeof(Vertex)* grid.vertices.size();
    D3D11_SUBRESOURCE_DATA resourceData;
    ZeroMemory(&resourceData, sizeof(resourceData));
    resourceData.pSysMem = &vertices[0];
    result = m_pd3dDevice->CreateBuffer(&vertexDesc, &resourceData, &m_pVertexBuffer);
    if (FAILED(result))
    {
        return false;
    }



    D3D11_BUFFER_DESC indexDesc;
    ZeroMemory(&indexDesc, sizeof(indexDesc));
    indexDesc.Usage = D3D11_USAGE_IMMUTABLE;
    indexDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
    indexDesc.ByteWidth = sizeof(UINT)* m_gridIndexCount;

    D3D11_SUBRESOURCE_DATA indexData;
    ZeroMemory(&indexData, sizeof(indexData));
    indexData.pSysMem = &grid.indices[0];
    result = m_pd3dDevice->CreateBuffer(&indexDesc, &indexData, &m_pIndexBuffer);
    if (FAILED(result))
    {
        return false;
    }

加载shader代码与之前相同，故不再给出

GetHeight函数根据xz的值得到y的值

float HillsDemo::GetHeight(float x, float z) const
{
    return 0.3f*(z*sinf(0.1f*x) + x*cosf(0.1f*z));
}

下面给出鼠标控制的具体做法：

定义4了个变量

    float m_theta;
    float m_phi;
    float m_radius;
    POINT m_lastMousePos;

其中m_lastMousePos意思明确很容易理解，那么其他三个分别代表什么意思呢？看下面的图就明白了

m_radius为半径,m_phi和m_theta为两个角度。

初始化半径和角度

HillsDemo::HillsDemo()//其他变量初始化省略了
: m_theta(1.5f*XM_PI), m_phi(0.1f*XM_PI), m_radius(200.0f){}

在Update函数中，给world,view,proj矩阵赋值

void HillsDemo::Update(float dt)
{
    float x = m_radius*sinf(m_phi)*cosf(m_theta);
    float z = m_radius*sinf(m_phi)*sinf(m_theta);
    float y = m_radius*cosf(m_phi);

    XMVECTOR pos = XMVectorSet(x, y, z, 1.0f);
    XMVECTOR target = XMVectorSet(0.0f, 0.0f, 0.0f, 1.0f);
    XMVECTOR up = XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);

    XMMATRIX V = XMMatrixLookAtLH(pos, target, up);
    XMStoreFloat4x4(&m_view, V);
    XMMATRIX T = XMMatrixPerspectiveFovLH(XM_PIDIV4, m_width / static_cast<float>(m_height),
        1.0f, 1000.0f);
    XMStoreFloat4x4(&m_proj, T);
    
}

拖动鼠标时适当改变半径和角度的值，便可以间接改变view矩阵，从而改变视角

void HillsDemo::OnMouseDown(WPARAM btnState, int x, int y)
{
    m_lastMousePos.x = x;
    m_lastMousePos.y = y;
    SetCapture(m_hWnd);
}

void HillsDemo::OnMouseUp(WPARAM btnState, int x, int y)
{
    ReleaseCapture();
}

//限定数值范围
template<typename T>
static T Clamp(const T& x, const T& low, const T& high)
{
    return x < low ? low : (x > high ? high : x);
}

void HillsDemo::OnMouseMove(WPARAM btnState, int x, int y)
{
    if ((btnState & MK_LBUTTON) != 0)
    {
        // Make each pixel correspond to a quarter of a degree.
        float dx = XMConvertToRadians(0.25f*static_cast<float>(x - m_lastMousePos.x));
        float dy = XMConvertToRadians(0.25f*static_cast<float>(y - m_lastMousePos.y));

        // Update angles based on input to orbit camera around box.
        m_theta += dx;
        m_phi += dy;

        // Restrict the angle mPhi.
        m_phi = Clamp(m_phi, 0.1f, XM_PI - 0.1f);
    }
    else if ((btnState & MK_RBUTTON) != 0)
    {
        // Make each pixel correspond to 0.2 unit in the scene.
        float dx = 0.2f*static_cast<float>(x - m_lastMousePos.x);
        float dy = 0.2f*static_cast<float>(y - m_lastMousePos.y);

        // Update the camera radius based on input.
        m_radius += dx - dy;

        // Restrict the radius.
        m_radius = Clamp(m_radius, 50.0f, 500.0f);
    }

    m_lastMousePos.x = x;
    m_lastMousePos.y = y;
}

4.渲染Render()函数

因为同之前教程中代码并没有什么改变，所以不再给出了。

这样运行程序就能得到之前给出图片所示的效果了，是不是很简单呢？