ffs

//.h
using namespace std;

class Terrain
{
public:
    struct InitInfo
    {
        wstring HeightmapFileName,
            LayerMapFileName0,
            LayerMapFileName1,
            LayerMapFileName2,
            LayerMapFileName3,
            LayerMapFileName4,
            BlendMapFileName;

        float HeightScale;
        float HeightOffset;
        UINT NumRows;
        UINT NumCols;
        float CellSpacing;
    };

public:
    Terrain();
    ~Terrain();

    void Init(const InitInfo& info);

    float width()const;
    float depth()const;

    float getHeight(float x, float y)const;
    void SetDirectionToSun(const XMFLOAT3& v);
    void draw(CXMMATRIX world, Camera& cam);

    UINT GetNumVertices()const { return mNumVertices; }

private:
    void BuildFX();
    void loadHeightMap();
    void Smooth();
    bool inBounds(UINT i, UINT j);
    float average(UINT i, UINT j);
    void BuildGeometry();
    void BuildSubMesh(RECT &R, Vertex::Basic32* vertex);
private:
    struct SubMesh
    {
        ID3D11Buffer* VertexBuffer;
        ID3D11Buffer* IndexBuffer;

        GeometryGenerator::MeshData mesh;
        XNA::AxisAlignedBox box;

        const static int NUM_ROWS  = 33;
        const static int NUM_COLS  = 33;
        const static int NUM_TRIS  = (NUM_ROWS-1)*(NUM_COLS-1)*2;
        const static int NUM_VERTS = NUM_ROWS*NUM_COLS;
    };
    InitInfo mInfo;
    UINT mNumVertices;
    UINT mNumFaces;

    vector<float> mHeightmap;
    vector<SubMesh> mSubMesh;


    ID3DX11Effect* mFX;


    ID3D11Buffer* mVB;
    ID3D11Buffer* mIB;

    ID3D11ShaderResourceView* mLayer0;
    ID3D11ShaderResourceView* mLayer1;
    ID3D11ShaderResourceView* mLayer2;
    ID3D11ShaderResourceView* mLayer3;
    ID3D11ShaderResourceView* mLayer4;
    ID3D11ShaderResourceView* mBlendMap;

    ID3DX11EffectTechnique* mTech;
    ID3DX11EffectMatrixVariable* mfxWVPVar;
    ID3DX11EffectMatrixVariable* mfxWorldVar;
    ID3DX11EffectVectorVariable* mfxDirToSunVar;
    ID3DX11EffectShaderResourceVariable* mfxLayer0Var;
    ID3DX11EffectShaderResourceVariable* mfxLayer1Var;
    ID3DX11EffectShaderResourceVariable* mfxLayer2Var;
    ID3DX11EffectShaderResourceVariable* mfxLayer3Var;
    ID3DX11EffectShaderResourceVariable* mfxLayer4Var;
    ID3DX11EffectShaderResourceVariable* mfxBlendMapVar;

};
//.cpp
#include "stdafx.h"
#include <list>

Terrain::Terrain()
{

    mVB = nullptr;
    mIB = nullptr;

    mLayer0 = nullptr;
    mLayer1 = nullptr;
    mLayer2 = nullptr;
    mLayer3 = nullptr;
    mLayer4 = nullptr;
    mBlendMap = nullptr;

    for (int i = 0; i < mSubMesh.size(); i++)
    {
        ReleaseCOM(mSubMesh[i].VertexBuffer);
        ReleaseCOM(mSubMesh[i].IndexBuffer);
    }
}

Terrain::~Terrain()
{
    ReleaseCOM(mVB);
    ReleaseCOM(mIB);
    ReleaseCOM(mFX);


    ReleaseCOM(mBlendMap);
    ReleaseCOM(mLayer0);
    ReleaseCOM(mLayer1);
    ReleaseCOM(mLayer2);
    ReleaseCOM(mLayer3);
    ReleaseCOM(mLayer4);

}

float Terrain::width()const
{
    return (mInfo.NumCols-1)*mInfo.CellSpacing;
}

float Terrain::depth()const
{
    return (mInfo.NumRows-1)*mInfo.CellSpacing;
}

float Terrain::getHeight(float x, float z)const
{
    // Transform from terrain local space to "cell" space.
    float c = (x + 0.5f*width()) /  mInfo.CellSpacing;
    float d = (z - 0.5f*depth()) / -mInfo.CellSpacing;

    // Get the row and column we are in.
    int row = (int)floorf(d);
    int col = (int)floorf(c);

    // Grab the heights of the cell we are in.
    // A*--*B
    //  | /|
    //  |/ |
    // C*--*D
    float A = mHeightmap[row*mInfo.NumCols + col];
    float B = mHeightmap[row*mInfo.NumCols + col + 1];
    float C = mHeightmap[(row+1)*mInfo.NumCols + col];
    float D = mHeightmap[(row+1)*mInfo.NumCols + col + 1];

    // Where we are relative to the cell.
    float s = c - (float)col;
    float t = d - (float)row;

    // If upper triangle ABC.
    if( s + t <= 1.0f)
    {
        float uy = B - A;
        float vy = C - A;
        return A + s*uy + t*vy;
    }
    else // lower triangle DCB.
    {
        float uy = C - D;
        float vy = B - D;
        return D + (1.0f-s)*uy + (1.0f-t)*vy;
    }
}

void Terrain::BuildFX()
{
    std::ifstream fin("Resources\\Shaders\\Terrain.fxo", std::ios::binary);

    fin.seekg(0, std::ios_base::end);
    int size = (int)fin.tellg();
    fin.seekg(0, std::ios_base::beg);
    std::vector<char> compiledShader(size);

    fin.read(&compiledShader[0], size);
    fin.close();

    HR(D3DX11CreateEffectFromMemory(&compiledShader[0], size,
        0, pDevice, &mFX));
}

void Terrain::Init(const InitInfo& initInfo)
{
    BuildFX();

    mTech          = mFX->GetTechniqueByName("TerrainTech");
    mfxWVPVar      = mFX->GetVariableByName("gWVP")->AsMatrix();
    mfxWorldVar    = mFX->GetVariableByName("gWorld")->AsMatrix();
    mfxDirToSunVar = mFX->GetVariableByName("gDirToSunW")->AsVector();
    mfxLayer0Var   = mFX->GetVariableByName("gLayer0")->AsShaderResource();
    mfxLayer1Var   = mFX->GetVariableByName("gLayer1")->AsShaderResource();
    mfxLayer2Var   = mFX->GetVariableByName("gLayer2")->AsShaderResource();
    mfxLayer3Var   = mFX->GetVariableByName("gLayer3")->AsShaderResource();
    mfxLayer4Var   = mFX->GetVariableByName("gLayer4")->AsShaderResource();
    mfxBlendMapVar = mFX->GetVariableByName("gBlendMap")->AsShaderResource();

    mInfo = initInfo;

    mNumVertices = mInfo.NumRows*mInfo.NumCols;
    mNumFaces    = (mInfo.NumRows-1)*(mInfo.NumCols-1)*2;

    loadHeightMap();
    Smooth();

    BuildGeometry();

    HR(D3DX11CreateShaderResourceViewFromFile(pDevice, initInfo.LayerMapFileName0.c_str(), 0, 0, &mLayer0, 0));
    HR(D3DX11CreateShaderResourceViewFromFile(pDevice, initInfo.LayerMapFileName1.c_str(), 0, 0, &mLayer1, 0));
    HR(D3DX11CreateShaderResourceViewFromFile(pDevice, initInfo.LayerMapFileName2.c_str(), 0, 0, &mLayer2, 0));
    HR(D3DX11CreateShaderResourceViewFromFile(pDevice, initInfo.LayerMapFileName3.c_str(), 0, 0, &mLayer3, 0));
    HR(D3DX11CreateShaderResourceViewFromFile(pDevice, initInfo.LayerMapFileName4.c_str(), 0, 0, &mLayer4, 0));
    HR(D3DX11CreateShaderResourceViewFromFile(pDevice, initInfo.BlendMapFileName.c_str(), 0, 0, &mBlendMap, 0));
}

void Terrain::SetDirectionToSun(const XMFLOAT3& v)
{
    XMVECTOR temp = XMVectorSet(v.x, v.y, v.z, 0.0f);
    mfxDirToSunVar->SetFloatVector((float*)&temp);
}

void Terrain::draw(CXMMATRIX world, Camera& cam)
{
    pDeviceContext->IASetInputLayout(InputLayouts::Basic32);

    UINT stride = sizeof(Vertex::Basic32);
    UINT offset = 0;


    for (int a = 0; a < mSubMesh.size(); a++) {
        pDeviceContext->IASetVertexBuffers(0, mSubMesh.size(), &mSubMesh[a].VertexBuffer, &stride, &offset);
        pDeviceContext->IASetIndexBuffer(mSubMesh[a].IndexBuffer, DXGI_FORMAT_R32_UINT, 0);


    XMMATRIX view = cam.View();
    XMMATRIX proj = cam.Proj();

    XMMATRIX WVP = world * view * proj;


    mfxWVPVar->SetMatrix((float*)&WVP);
    mfxWorldVar->SetMatrix((float*)&world);

    mfxLayer0Var->SetResource(mLayer0);
    mfxLayer1Var->SetResource(mLayer1);
    mfxLayer2Var->SetResource(mLayer2);
    mfxLayer3Var->SetResource(mLayer3);
    mfxLayer4Var->SetResource(mLayer4);
    mfxBlendMapVar->SetResource(mBlendMap);

    D3DX11_TECHNIQUE_DESC techDesc;
    mTech->GetDesc(&techDesc);

    for(UINT i = 0; i < techDesc.Passes; ++i)
    {
        ID3DX11EffectPass* pass = mTech->GetPassByIndex(i);
        pass->Apply(0, pDeviceContext);

        pDeviceContext->DrawIndexed(mSubMesh[a].mesh.Indices.size(), 0, 0);
    }

    }
}

void Terrain::loadHeightMap()
{
    // A height for each vertex
    std::vector<unsigned char> in( mInfo.NumRows * mInfo.NumCols );

    // Open the file.
    std::ifstream inFile;
    inFile.open(mInfo.HeightmapFileName.c_str(), std::ios_base::binary);

    if(inFile)
    {
        // Read the RAW bytes.
        inFile.read((char*)&in[0], (std::streamsize)in.size());

        // Done with file.
        inFile.close();
    }

    // Copy the array data into a float array, and scale and offset the heights.
    mHeightmap.resize(mInfo.NumRows * mInfo.NumCols, 0);
    for(UINT i = 0; i < mInfo.NumRows * mInfo.NumCols; ++i)
    {
        mHeightmap[i] = (float)in[i] * mInfo.HeightScale + mInfo.HeightOffset;
    }
}


void Terrain::Smooth()
{
    std::vector<float> dest( mHeightmap.size() );

    for(UINT i = 0; i < mInfo.NumRows; ++i)
    {
        for(UINT j = 0; j < mInfo.NumCols; ++j)
        {
            dest[i*mInfo.NumCols+j] = average(i,j);
        }
    }

    // Replace the old heightmap with the filtered one.
    mHeightmap = dest;
}



bool Terrain::inBounds(UINT i, UINT j)
{
    // True if ij are valid indices; false otherwise.
    return
        i >= 0 && i < mInfo.NumRows &&
        j >= 0 && j < mInfo.NumCols;
}

float Terrain::average(UINT i, UINT j)
{
    // Function computes the average height of the ij element.
    // It averages itself with its eight neighbor pixels.  Note
    // that if a pixel is missing neighbor, we just don't include it
    // in the average--that is, edge pixels don't have a neighbor pixel.
    //
    // ----------
    // | 1| 2| 3|
    // ----------
    // |4 |ij| 6|
    // ----------
    // | 7| 8| 9|
    // ----------

    float avg = 0.0f;
    float num = 0.0f;

    for(UINT m = i-1; m <= i+1; ++m)
    {
        for(UINT n = j-1; n <= j+1; ++n)
        {
            if( inBounds(m,n) )
            {
                avg += mHeightmap[m*mInfo.NumCols + n];
                num += 1.0f;
            }
        }
    }

    return avg / num;
}



void Terrain::BuildGeometry()
{
    //=========================================
    //               Build Vertices
    //=========================================

    std::vector<Vertex::Basic32> vertices(mNumVertices);


    float halfWidth = (mInfo.NumCols-1)*mInfo.CellSpacing*0.5f;
    float halfDepth = (mInfo.NumRows-1)*mInfo.CellSpacing*0.5f;

    float du = 1.0f / (mInfo.NumCols-1);
    float dv = 1.0f / (mInfo.NumRows-1);
    for(UINT i = 0; i < mInfo.NumRows; ++i)
    {
        float z = halfDepth - i*mInfo.CellSpacing;
        for(UINT j = 0; j < mInfo.NumCols; ++j)
        {
            float x = -halfWidth + j*mInfo.CellSpacing;

            float y = mHeightmap[i*mInfo.NumCols+j];
            vertices[i*mInfo.NumCols+j].Pos    = XMFLOAT3(x, y, z);
            vertices[i*mInfo.NumCols+j].Normal = XMFLOAT3(0.0f, 1.0f, 0.0f);

            // Stretch texture over grid.
            vertices[i*mInfo.NumCols+j].Tex.x = j*du;
            vertices[i*mInfo.NumCols+j].Tex.y = i*dv;
        }
    }

    // Estimate normals for interior nodes using central difference.
    float invTwoDX = 1.0f / (2.0f*mInfo.CellSpacing);
    float invTwoDZ = 1.0f / (2.0f*mInfo.CellSpacing);
    for(UINT i = 2; i < mInfo.NumRows-1; ++i)
    {
        for(UINT j = 2; j < mInfo.NumCols-1; ++j)
        {
            float t = mHeightmap[(i-1)*mInfo.NumCols + j];
            float b = mHeightmap[(i+1)*mInfo.NumCols + j];
            float l = mHeightmap[i*mInfo.NumCols + j - 1];
            float r = mHeightmap[i*mInfo.NumCols + j + 1];

            XMFLOAT3 tanZ(0.0f, (t-b)*invTwoDZ, 1.0f);
            XMFLOAT3 tanX(1.0f, (r-l)*invTwoDX, 0.0f);

            XMVECTOR N;
            N = XMVector3Cross(XMLoadFloat3(&tanZ), XMLoadFloat3(&tanX));
            N = XMVector3Normalize(N);

            XMStoreFloat3(&vertices[i*mInfo.NumCols+j].Normal, N);

        }
    }

    //=======================================================
    //                     Build Indices
    //=======================================================

        std::vector<DWORD> indices(mNumFaces*3); // 3 indices per face

    // Iterate over each quad and compute indices.
    int k = 0;
    for(UINT i = 0; i < mInfo.NumRows-1; ++i)
    {
        for(UINT j = 0; j < mInfo.NumCols-1; ++j)
        {
            indices[k]   = i*mInfo.NumCols+j;
            indices[k+1] = i*mInfo.NumCols+j+1;
            indices[k+2] = (i+1)*mInfo.NumCols+j;

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

            k += 6; // next quad
        }
    }


    int subGridRows = (mInfo.NumRows-1) / (SubMesh::NUM_ROWS-1);
    int subGridCols = (mInfo.NumCols-1) / (SubMesh::NUM_COLS-1);

    for(int r = 0; r < subGridRows; ++r)
    {
        for(int c = 0; c < subGridCols; ++c)
        {
            // Rectangle that indicates (via matrix indices ij) the
            // portion of grid vertices to use for this subgrid.
            RECT R =
            {
                    c * (SubMesh::NUM_COLS - 1),
                    r * (SubMesh::NUM_ROWS - 1),
                (c+1) * (SubMesh::NUM_COLS - 1),
                (r+1) * (SubMesh::NUM_ROWS - 1)
            };

            BuildSubMesh(R, &vertices[0]);
        }
    }


  /*  D3D11_BUFFER_DESC vbd;
    vbd.Usage = D3D11_USAGE_IMMUTABLE;
    vbd.ByteWidth = sizeof(Vertex::Basic32) * mNumVertices;
    vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vbd.CPUAccessFlags = 0;
    vbd.MiscFlags = 0;

    D3D11_SUBRESOURCE_DATA vinitData;
    vinitData.pSysMem = &vertices[0];

    HR(pDevice->CreateBuffer(&vbd, &vinitData, &mVB));



    D3D11_BUFFER_DESC ibd;
    ibd.Usage = D3D11_USAGE_IMMUTABLE;
    ibd.ByteWidth = sizeof(DWORD) * mNumFaces * 3;
    ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
    ibd.CPUAccessFlags = 0;
    ibd.MiscFlags = 0;

    D3D11_SUBRESOURCE_DATA iinitData;
    iinitData.pSysMem = &indices[0];

    HR(pDevice->CreateBuffer(&ibd, &iinitData, &mIB));
    */
}

void Terrain::BuildSubMesh(RECT &R, Vertex::Basic32* vertex)
{
    GeometryGenerator::MeshData data;
    GeometryGenerator::MeshData subMesh;
    GeometryGenerator gen;

    gen.CreateGrid(SubMesh::NUM_ROWS, SubMesh::NUM_COLS, SubMesh::NUM_ROWS / mInfo.CellSpacing, SubMesh::NUM_COLS / mInfo.CellSpacing, data);

    int k = 0;
    for(int i = R.top; i <= R.bottom; ++i)
    {
        for(int j = R.left; j <= R.right; ++j)
        {
            subMesh.Vertices[k++].Position = vertex[i*mInfo.NumCols+j].Pos;
            subMesh.Vertices[k++].Normal = vertex[i*mInfo.NumCols+j].Normal;
            subMesh.Vertices[k++].TexC = vertex[i*mInfo.NumCols+j].Tex;
        }
    }

    XNA::AxisAlignedBox box;
    XNA::ComputeBoundingAxisAlignedBoxFromPoints(&box, subMesh.Vertices.size(), &subMesh.Vertices[0].Position, sizeof(Vertex::Basic32));

    for(int i = 0; i < SubMesh::NUM_TRIS; ++i)
    {
        subMesh.Indices[i*3+0] = (WORD)data.Indices[i*3+0];
        subMesh.Indices[i*3+1] = (WORD)data.Indices[i*3+1];
        subMesh.Indices[i*3+2] = (WORD)data.Indices[i*3+2];

    }

    SubMesh m;

    m.box = box;
    m.mesh = subMesh;

    ID3D11Buffer* vbuffer, *ibuffer;

    D3D11_BUFFER_DESC vbd;
    vbd.Usage = D3D11_USAGE_IMMUTABLE;
    vbd.ByteWidth = sizeof(Vertex::Basic32) * subMesh.Vertices.size();
    vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vbd.CPUAccessFlags = 0;
    vbd.MiscFlags = 0;

    D3D11_SUBRESOURCE_DATA vinitData;
    vinitData.pSysMem = &subMesh.Vertices[0];

    HR(pDevice->CreateBuffer(&vbd, &vinitData, &vbuffer));



    D3D11_BUFFER_DESC ibd;
    ibd.Usage = D3D11_USAGE_IMMUTABLE;
    ibd.ByteWidth = sizeof(DWORD) * mNumFaces * 3;
    ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
    ibd.CPUAccessFlags = 0;
    ibd.MiscFlags = 0;

    D3D11_SUBRESOURCE_DATA iinitData;
    iinitData.pSysMem = &subMesh.Indices[0];

    HR(pDevice->CreateBuffer(&ibd, &iinitData, &ibuffer));

    m.VertexBuffer = vbuffer;
    m.IndexBuffer = ibuffer;

    mSubMesh.push_back(m);
}