[DirectX 11] Terrain 07 - 지형 컬러 맵핑

Terrain 07 - 지형 컬러 맵핑

원문 : http://www.rastertek.com/tertut07.html

 이 튜토리얼에서는 HLSL 및 C ++을 사용하여 DirectX 11에서 지형에 대한 컬러 맵을 구현하는 방법에 대해 설명합니다. 이 듀토리얼의 코드는 '[DirectX11] Terrain 04 - 지형 텍스처'를 기반으로 합니다.

지형 컬러 매핑은 지형 메쉬의 정점 색상을 결정하기 위해 컬러 비트맵 이미지를 사용하는 것입니다. 비트맵 이미지는 일반적으로 높이맵 정점에 대한 비트맵 픽셀 색상의 1 대 1 변환을 보장하기 위해 높이맵과 동일한 크기입니다. 예를 들어 지형에 대한 색상맵으로 다음 256x256 비트맵 이미지를 사용합니다.

높이맵에서 읽은 각 정점에 대해서도 컬러맵에서 동시에 그 정점의 색을 읽습니다. 그러면 각 정점에 RGB 구성 요소가 생깁니다. 색상과 밝은 법선을 사용할 때 우리는 이제 지형에 대해 다음과 같은 모습을 보입니다.

컬러맵이 작동하면 다음과 같은 텍스쳐링을 다시 적용합니다

색상맵이 지형에 대한 최종 모양을 더 많이 제어 할 수 있도록 텍스처에서 색상을 제거해야 하는 경우가 있습니다. 이 방식으로 사용되는 색상이 없는 텍스처는 일반적으로 최종 출력 결과를 제공하지만 색상은 제공하지 않으므로 상세맵이라고합니다.

색상 맵핑 작업을 수행하는 코드에는 몇 가지 변경 사항이 있습니다. 이제 살펴 보겠습니다.

Terrainclass.h

#pragma once
 
/////////////
// GLOBALS //
/////////////
const int TEXTURE_REPEAT = 8;
 
 
class TextureClass;
 
 
class TerrainClass
{
private:
    struct VertexType
    {
        XMFLOAT3 position;
        XMFLOAT2 texture;
        XMFLOAT3 normal;
        XMFLOAT4 color;
    };
 
    struct HeightMapType 
    { 
        float x, y, z;
        float tu, tv;
        float nx, ny, nz;
        float r, g, b;
    };
 
    struct VectorType 
    { 
        float x, y, z;
    };
 
public:
    TerrainClass();
    TerrainClass(const TerrainClass&);
    ~TerrainClass();
 
    bool Initialize(ID3D11Device*, const char*, const WCHAR*, const char*);
    void Shutdown();
    void Render(ID3D11DeviceContext*);
 
    int GetIndexCount();
    ID3D11ShaderResourceView* GetTexture();
 
private:
    bool LoadHeightMap(const char*);
    void NormalizeHeightMap();
    bool CalculateNormals();
    void ShutdownHeightMap();
 
    void CalculateTextureCoordinates();
    bool LoadTexture(ID3D11Device*, const WCHAR*);
    void ReleaseTexture();
 
    bool LoadColorMap(const char*);
 
    bool InitializeBuffers(ID3D11Device*);
    void ShutdownBuffers();
    void RenderBuffers(ID3D11DeviceContext*);
    
private:
    int m_terrainWidth = 0;
    int m_terrainHeight = 0;
    int m_vertexCount = 0;
    int m_indexCount = 0;
    ID3D11Buffer* m_vertexBuffer = nullptr;
    ID3D11Buffer* m_indexBuffer = nullptr;
    HeightMapType* m_heightMap = nullptr;
    TextureClass* m_Texture = nullptr;
};

Terrainclass.cpp

#include "stdafx.h"
#include "textureclass.h"
#include "terrainclass.h"
#include <stdio.h>
 
 
TerrainClass::TerrainClass()
{
}
 
 
TerrainClass::TerrainClass(const TerrainClass& other)
{
}
 
 
TerrainClass::~TerrainClass()
{
}
 
 
bool TerrainClass::Initialize(ID3D11Device* device, const char* heightMapFilename, const WCHAR* textureFilename,
                              const char* colorMapFilename)
{
    // 지형의 높이 맵을 로드합니다.
    if(!LoadHeightMap(heightMapFilename))
    {
        return false;
    }
 
    // 높이 맵의 높이를 표준화합니다.
    NormalizeHeightMap();
 
    // 지형 데이터의 법선을 계산합니다.
    if(!CalculateNormals())
    {
        return false;
    }
 
    // 텍스처 좌표를 계산합니다.
    CalculateTextureCoordinates();
 
    // 텍스처를 로드합니다.
    if(!LoadTexture(device, textureFilename))
    {
        return false;
    }
 
    // 컬러 맵을 지형에 로드합니다.
    if(!LoadColorMap(colorMapFilename))
    {
        return false;
    }
 
    // 지형에 대한 지오 메트릭을 포함하는 정점 및 인덱스 버퍼를 초기화합니다.
    return InitializeBuffers(device);
}
 
 
void TerrainClass::Shutdown()
{
    // 텍스처를 해제합니다.
    ReleaseTexture();
 
    // 버텍스와 인덱스 버퍼를 해제합니다.
    ShutdownBuffers();
 
    // 높이맵 데이터를 해제합니다.
    ShutdownHeightMap();
}
 
 
void TerrainClass::Render(ID3D11DeviceContext* deviceContext)
{
    // 그리기를 준비하기 위해 그래픽 파이프 라인에 꼭지점과 인덱스 버퍼를 놓습니다.
    RenderBuffers(deviceContext);
}
 
 
int TerrainClass::GetIndexCount()
{
    return m_indexCount;
}
 
 
ID3D11ShaderResourceView* TerrainClass::GetTexture()
{
    return m_Texture->GetTexture();
}
 
 
bool TerrainClass::LoadHeightMap(const char* filename)
{
    // 바이너리 모드로 높이맵 파일을 엽니다.
    FILE* filePtr = nullptr;
    if(fopen_s(&filePtr, filename, "rb") != 0)
    {
        return false;
    }
 
    // 파일 헤더를 읽습니다.
    BITMAPFILEHEADER bitmapFileHeader;
    if(fread(&bitmapFileHeader, sizeof(BITMAPFILEHEADER), 1, filePtr) != 1)
    {
        return false;
    }
 
    // 비트맵 정보 헤더를 읽습니다.
    BITMAPINFOHEADER bitmapInfoHeader;
    if(fread(&bitmapInfoHeader, sizeof(BITMAPINFOHEADER), 1, filePtr) != 1)
    {
        return false;
    }
 
    // 지형의 크기를 저장합니다.
    m_terrainWidth = bitmapInfoHeader.biWidth;
    m_terrainHeight = bitmapInfoHeader.biHeight;
 
    // 비트맵 이미지 데이터의 크기를 계산합니다.
    int imageSize = m_terrainWidth * m_terrainHeight * 3;
 
    // 비트맵 이미지 데이터에 메모리를 할당합니다.
    unsigned char* bitmapImage = new unsigned char[imageSize];
    if(!bitmapImage)
    {
        return false;
    }
 
    // 비트맵 데이터의 시작 부분으로 이동합니다.
    fseek(filePtr, bitmapFileHeader.bfOffBits, SEEK_SET);
 
    // 비트맵 이미지 데이터를 읽습니다.
    if(fread(bitmapImage, 1, imageSize, filePtr) != imageSize)
    {
        return false;
    }
 
    // 파일을 닫습니다.
    if(fclose(filePtr) != 0)
    {
        return false;
    }
 
    // 높이 맵 데이터를 저장할 구조체를 만듭니다.
    m_heightMap = new HeightMapType[m_terrainWidth * m_terrainHeight];
    if(!m_heightMap)
    {
        return false;
    }
 
    // 이미지 데이터 버퍼의 위치를 ​​초기화합니다.
    int k = 0;
 
    // 이미지 데이터를 높이 맵으로 읽어들입니다.
    for(int j=0; j<m_terrainHeight; j++)
    {
        for(int i=0; i<m_terrainWidth; i++)
        {
            unsigned char height = bitmapImage[k];
            
            int index = (m_terrainHeight * j) + i;
 
            m_heightMap[index].x = (float)i;
            m_heightMap[index].y = (float)height;
            m_heightMap[index].z = (float)j;
 
            k+=3;
        }
    }
 
    // 비트맵 이미지 데이터를 해제합니다.
    delete [] bitmapImage;
    bitmapImage = 0;
 
    return true;
}
 
 
void TerrainClass::NormalizeHeightMap()
{
    for(int j=0; j<m_terrainHeight; j++)
    {
        for(int i=0; i<m_terrainWidth; i++)
        {
            m_heightMap[(m_terrainHeight * j) + i].y /= 15.0f;
        }
    }
}
 
 
bool TerrainClass::CalculateNormals()
{
    int index1 = 0;
    int index2 = 0;
    int index3 = 0;
    int index = 0;
    int count = 0;
    float vertex1[3] = { 0.f, 0.f, 0.f };
    float vertex2[3] = { 0.f, 0.f, 0.f };
    float vertex3[3] = { 0.f, 0.f, 0.f };
    float vector1[3] = { 0.f, 0.f, 0.f };
    float vector2[3] = { 0.f, 0.f, 0.f };
    float sum[3] = { 0.f, 0.f, 0.f };
    float length = 0.0f;
 
 
    // 정규화되지 않은 법선 벡터를 저장할 임시 배열을 만듭니다.
    VectorType* normals = new VectorType[(m_terrainHeight-1) * (m_terrainWidth-1)];
    if(!normals)
    {
        return false;
    }
 
    // 메쉬의 모든면을 살펴보고 법선을 계산합니다.
    for(int j=0; j<(m_terrainHeight-1); j++)
    {
        for(int i=0; i<(m_terrainWidth-1); i++)
        {
            index1 = (j * m_terrainHeight) + i;
            index2 = (j * m_terrainHeight) + (i+1);
            index3 = ((j+1) * m_terrainHeight) + i;
 
            // 표면에서 세 개의 꼭지점을 가져옵니다.
            vertex1[0] = m_heightMap[index1].x;
            vertex1[1] = m_heightMap[index1].y;
            vertex1[2] = m_heightMap[index1].z;
        
            vertex2[0] = m_heightMap[index2].x;
            vertex2[1] = m_heightMap[index2].y;
            vertex2[2] = m_heightMap[index2].z;
        
            vertex3[0] = m_heightMap[index3].x;
            vertex3[1] = m_heightMap[index3].y;
            vertex3[2] = m_heightMap[index3].z;
 
            // 표면의 두 벡터를 계산합니다.
            vector1[0] = vertex1[0] - vertex3[0];
            vector1[1] = vertex1[1] - vertex3[1];
            vector1[2] = vertex1[2] - vertex3[2];
            vector2[0] = vertex3[0] - vertex2[0];
            vector2[1] = vertex3[1] - vertex2[1];
            vector2[2] = vertex3[2] - vertex2[2];
 
            index = (j * (m_terrainHeight-1)) + i;
 
            // 이 두 법선에 대한 정규화되지 않은 값을 얻기 위해 두 벡터의 외적을 계산합니다.
            normals[index].x = (vector1[1] * vector2[2]) - (vector1[2] * vector2[1]);
            normals[index].y = (vector1[2] * vector2[0]) - (vector1[0] * vector2[2]);
            normals[index].z = (vector1[0] * vector2[1]) - (vector1[1] * vector2[0]);
        }
    }
 
    // 이제 모든 정점을 살펴보고 각면의 평균을 취합니다.     
    // 정점이 닿아 그 정점에 대한 평균 평균값을 얻는다.
    for(int j=0; j<m_terrainHeight; j++)
    {
        for(int i=0; i<m_terrainWidth; i++)
        {
            // 합계를 초기화합니다.
            sum[0] = 0.0f;
            sum[1] = 0.0f;
            sum[2] = 0.0f;
 
            // 카운트를 초기화합니다.
            count = 0;
 
            // 왼쪽 아래면.
            if(((i-1) >= 0) && ((j-1) >= 0))
            {
                index = ((j-1) * (m_terrainHeight-1)) + (i-1);
 
                sum[0] += normals[index].x;
                sum[1] += normals[index].y;
                sum[2] += normals[index].z;
                count++;
            }
 
            // 오른쪽 아래 면.
            if((i < (m_terrainWidth-1)) && ((j-1) >= 0))
            {
                index = ((j-1) * (m_terrainHeight-1)) + i;
 
                sum[0] += normals[index].x;
                sum[1] += normals[index].y;
                sum[2] += normals[index].z;
                count++;
            }
 
            // 왼쪽 위 면.
            if(((i-1) >= 0) && (j < (m_terrainHeight-1)))
            {
                index = (j * (m_terrainHeight-1)) + (i-1);
 
                sum[0] += normals[index].x;
                sum[1] += normals[index].y;
                sum[2] += normals[index].z;
                count++;
            }
 
            // 오른쪽 위 면.
            if((i < (m_terrainWidth-1)) && (j < (m_terrainHeight-1)))
            {
                index = (j * (m_terrainHeight-1)) + i;
 
                sum[0] += normals[index].x;
                sum[1] += normals[index].y;
                sum[2] += normals[index].z;
                count++;
            }
            
            // 이 정점에 닿는면의 평균을 취합니다.
            sum[0] = (sum[0] / (float)count);
            sum[1] = (sum[1] / (float)count);
            sum[2] = (sum[2] / (float)count);
 
            // 이 법선의 길이를 계산합니다.
            length = (float)sqrt((sum[0] * sum[0]) + (sum[1] * sum[1]) + (sum[2] * sum[2]));
            
            // 높이 맵 배열의 정점 위치에 대한 인덱스를 가져옵니다.
            index = (j * m_terrainHeight) + i;
 
            // 이 정점의 최종 공유 법선을 표준화하여 높이 맵 배열에 저장합니다.
            m_heightMap[index].nx = (sum[0] / length);
            m_heightMap[index].ny = (sum[1] / length);
            m_heightMap[index].nz = (sum[2] / length);
        }
    }
 
    // 임시 법선을 해제합니다.
    delete [] normals;
    normals = 0;
 
    return true;
}
 
 
void TerrainClass::ShutdownHeightMap()
{
    if(m_heightMap)
    {
        delete [] m_heightMap;
        m_heightMap = 0;
    }
}
 
 
void TerrainClass::CalculateTextureCoordinates()
{
    // 텍스처 좌표를 얼마나 많이 증가 시킬지 계산합니다.
    float incrementValue = (float)TEXTURE_REPEAT / (float)m_terrainWidth;
 
    // 텍스처를 반복 할 횟수를 계산합니다.
    int incrementCount = m_terrainWidth / TEXTURE_REPEAT;
 
    // tu 및 tv 좌표 값을 초기화합니다.
    float tuCoordinate = 0.0f;
    float tvCoordinate = 1.0f;
 
    //  tu 및 tv 좌표 인덱스를 초기화합니다.
    int tuCount = 0;
    int tvCount = 0;
 
    // 전체 높이 맵을 반복하고 각 꼭지점의 tu 및 tv 텍스처 좌표를 계산합니다.
    for(int j=0; j<m_terrainHeight; j++)
    {
        for(int i=0; i<m_terrainWidth; i++)
        {
            // 높이 맵에 텍스처 좌표를 저장한다.
            m_heightMap[(m_terrainHeight * j) + i].tu = tuCoordinate;
            m_heightMap[(m_terrainHeight * j) + i].tv = tvCoordinate;
 
            // tu 텍스처 좌표를 증가 값만큼 증가시키고 인덱스를 1 씩 증가시킨다.
            tuCoordinate += incrementValue;
            tuCount++;
 
            // 텍스처의 오른쪽 끝에 있는지 확인하고, 그렇다면 처음부터 다시 시작하십시오.
            if(tuCount == incrementCount)
            {
                tuCoordinate = 0.0f;
                tuCount = 0;
            }
        }
 
        // tv 텍스처 좌표를 증가 값만큼 증가시키고 인덱스를 1 씩 증가시킵니다.
        tvCoordinate -= incrementValue;
        tvCount++;
 
        // 텍스처의 상단에 있는지 확인하고, 그렇다면 하단에서 다시 시작합니다.
        if(tvCount == incrementCount)
        {
            tvCoordinate = 1.0f;
            tvCount = 0;
        }
    }
}
 
 
bool TerrainClass::LoadTexture(ID3D11Device* device, const WCHAR* filename)
{
    // 텍스처 객체를 생성합니다.
    m_Texture = new TextureClass;
    if(!m_Texture)
    {
        return false;
    }
 
    // 텍스처 오브젝트를 초기화한다.
    return m_Texture->Initialize(device, filename);
}
 
 
void TerrainClass::ReleaseTexture()
{
    //텍스처 객체를 해제합니다.
    if(m_Texture)
    {
        m_Texture->Shutdown();
        delete m_Texture;
        m_Texture = 0;
    }
}
 
 
bool TerrainClass::LoadColorMap(const char* filename)
{
    FILE* filePtr = nullptr;
 
    // 바이너리로 컬러 맵 파일을 엽니다.
    if(fopen_s(&filePtr, filename, "rb") != 0)
    {
        return false;
    }
 
    // 파일 헤더를 읽습니다.
    BITMAPFILEHEADER bitmapFileHeader;
    if(fread(&bitmapFileHeader, sizeof(BITMAPFILEHEADER), 1, filePtr) != 1)
    {
        return false;
    }
 
    // 비트맵 정보 헤더를 읽습니다.
    BITMAPINFOHEADER bitmapInfoHeader;
    if(fread(&bitmapInfoHeader, sizeof(BITMAPINFOHEADER), 1, filePtr) != 1)
    {
        return false;
    }
 
    // 컬러 맵 치수가 쉬운 1 : 1 매핑을위한 지형 치수와 동일한지 확인하십시오.
    int colorMapWidth = bitmapInfoHeader.biWidth;
    int colorMapHeight = bitmapInfoHeader.biHeight;
 
    if((colorMapWidth != m_terrainWidth) || (colorMapHeight != m_terrainHeight))
    {
        return false;
    }
 
    // 비트맵 이미지 데이터의 크기를 계산합니다.
    int imageSize = colorMapWidth * colorMapHeight * 3;
 
    // 비트맵 이미지 데이터에 메모리를 할당합니다.
    unsigned char* bitmapImage = new unsigned char[imageSize];
    if(!bitmapImage)
    {
        return false;
    }
 
    // 비트맵 데이터의 시작 부분으로 이동합니다.
    fseek(filePtr, bitmapFileHeader.bfOffBits, SEEK_SET);
 
    // 비트맵 이미지 데이터를 읽습니다.
    if(fread(bitmapImage, 1, imageSize, filePtr) != imageSize)
    {
        return false;
    }
 
    // 파일을 닫습니다.
    if(fclose(filePtr) != 0)
    {
        return false;
    }
 
    // 이미지 데이터 버퍼의 위치를 ​​초기화합니다.
    int k=0;
 
    // 이미지 데이터를 높이 맵 구조의 색상 맵 부분으로 읽습니다.
    for(int j=0; j<colorMapHeight; j++)
    {
        for(int i=0; i<colorMapWidth; i++)
        {
            int index = (colorMapHeight * j) + i;
 
            m_heightMap[index].b = (float)bitmapImage[k]   / 255.0f;
            m_heightMap[index].g = (float)bitmapImage[k+1] / 255.0f;
            m_heightMap[index].r = (float)bitmapImage[k+2] / 255.0f;
 
            k+=3;
        }
    }
 
    // 비트맵 이미지 데이터를 해제합니다.
    delete [] bitmapImage;
    bitmapImage = 0;
 
    return true;
}
 
 
bool TerrainClass::InitializeBuffers(ID3D11Device* device)
{
    float tu = 0.0f;
    float tv = 0.0f;
 
    // 지형 메쉬의 정점 수를 계산합니다.
    m_vertexCount = (m_terrainWidth - 1) * (m_terrainHeight - 1) * 6;
 
    // 인덱스 수를 꼭지점 수와 같게 설정합니다.
    m_indexCount = m_vertexCount;
 
    // 정점 배열을 만듭니다.
    VertexType* vertices = new VertexType[m_vertexCount];
    if(!vertices)
    {
        return false;
    }
 
    // 인덱스 배열을 만듭니다.
    unsigned long* indices = new unsigned long[m_indexCount];
    if(!indices)
    {
        return false;
    }
 
    // 정점 배열에 대한 인덱스를 초기화합니다.
    int index = 0;
 
    // 지형 데이터로 정점 및 인덱스 배열을 로드합니다.
    for(int j=0; j<(m_terrainHeight-1); j++)
    {
        for(int i=0; i<(m_terrainWidth-1); i++)
        {
            int index1 = (m_terrainHeight * j) + i;          // 왼쪽 아래.
            int index2 = (m_terrainHeight * j) + (i+1);      // 오른쪽 아래.
            int index3 = (m_terrainHeight * (j+1)) + i;      // 왼쪽 위.
            int index4 = (m_terrainHeight * (j+1)) + (i+1);  // 오른쪽 위.
 
            // 왼쪽 위.
            tv = m_heightMap[index3].tv;
 
            // 상단 가장자리를 덮도록 텍스처 좌표를 수정합니다.
            if(tv == 1.0f) { tv = 0.0f; }
 
            vertices[index].position = XMFLOAT3(m_heightMap[index3].x, m_heightMap[index3].y, m_heightMap[index3].z);
            vertices[index].texture = XMFLOAT2(m_heightMap[index3].tu, tv);
            vertices[index].normal = XMFLOAT3(m_heightMap[index3].nx, m_heightMap[index3].ny, m_heightMap[index3].nz);
            vertices[index].color = XMFLOAT4(m_heightMap[index3].r, m_heightMap[index3].g, m_heightMap[index3].b, 1.0f);
            indices[index] = index;
            index++;
 
            // 오른쪽 위.
            tu = m_heightMap[index4].tu;
            tv = m_heightMap[index4].tv;
 
            // 위쪽과 오른쪽 가장자리를 덮도록 텍스처 좌표를 수정합니다.
            if(tu == 0.0f) { tu = 1.0f; }
            if(tv == 1.0f) { tv = 0.0f; }
 
            vertices[index].position = XMFLOAT3(m_heightMap[index4].x, m_heightMap[index4].y, m_heightMap[index4].z);
            vertices[index].texture = XMFLOAT2(tu, tv);
            vertices[index].normal = XMFLOAT3(m_heightMap[index4].nx, m_heightMap[index4].ny, m_heightMap[index4].nz);
            vertices[index].color = XMFLOAT4(m_heightMap[index4].r, m_heightMap[index4].g, m_heightMap[index4].b, 1.0f);
            indices[index] = index;
            index++;
 
            // 왼쪽 아래.
            vertices[index].position = XMFLOAT3(m_heightMap[index1].x, m_heightMap[index1].y, m_heightMap[index1].z);
            vertices[index].texture = XMFLOAT2(m_heightMap[index1].tu, m_heightMap[index1].tv);
            vertices[index].normal = XMFLOAT3(m_heightMap[index1].nx, m_heightMap[index1].ny, m_heightMap[index1].nz);
            vertices[index].color = XMFLOAT4(m_heightMap[index1].r, m_heightMap[index1].g, m_heightMap[index1].b, 1.0f);
            indices[index] = index;
            index++;
 
            // 왼쪽 아래.
            vertices[index].position = XMFLOAT3(m_heightMap[index1].x, m_heightMap[index1].y, m_heightMap[index1].z);
            vertices[index].texture = XMFLOAT2(m_heightMap[index1].tu, m_heightMap[index1].tv);
            vertices[index].normal = XMFLOAT3(m_heightMap[index1].nx, m_heightMap[index1].ny, m_heightMap[index1].nz);
            vertices[index].color = XMFLOAT4(m_heightMap[index1].r, m_heightMap[index1].g, m_heightMap[index1].b, 1.0f);
            indices[index] = index;
            index++;
 
            // 오른쪽 위.
            tu = m_heightMap[index4].tu;
            tv = m_heightMap[index4].tv;
 
            // 위쪽과 오른쪽 가장자리를 덮도록 텍스처 좌표를 수정합니다.
            if(tu == 0.0f) { tu = 1.0f; }
            if(tv == 1.0f) { tv = 0.0f; }
 
            vertices[index].position = XMFLOAT3(m_heightMap[index4].x, m_heightMap[index4].y, m_heightMap[index4].z);
            vertices[index].texture = XMFLOAT2(tu, tv);
            vertices[index].normal = XMFLOAT3(m_heightMap[index4].nx, m_heightMap[index4].ny, m_heightMap[index4].nz);
            vertices[index].color = XMFLOAT4(m_heightMap[index4].r, m_heightMap[index4].g, m_heightMap[index4].b, 1.0f);
            indices[index] = index;
            index++;
 
            // 오른쪽 아래.
            tu = m_heightMap[index2].tu;
 
            // 오른쪽 가장자리를 덮도록 텍스처 좌표를 수정합니다.
            if(tu == 0.0f) { tu = 1.0f; }
 
            vertices[index].position = XMFLOAT3(m_heightMap[index2].x, m_heightMap[index2].y, m_heightMap[index2].z);
            vertices[index].texture = XMFLOAT2(tu, m_heightMap[index2].tv);
            vertices[index].normal = XMFLOAT3(m_heightMap[index2].nx, m_heightMap[index2].ny, m_heightMap[index2].nz);
            vertices[index].color = XMFLOAT4(m_heightMap[index2].r, m_heightMap[index2].g, m_heightMap[index2].b, 1.0f);
            indices[index] = index;
            index++;            
        }
    }
 
    // 정적 정점 버퍼의 구조체를 설정한다.
    D3D11_BUFFER_DESC vertexBufferDesc;
    vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_vertexCount;
    vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vertexBufferDesc.CPUAccessFlags = 0;
    vertexBufferDesc.MiscFlags = 0;
    vertexBufferDesc.StructureByteStride = 0;
 
    // subresource 구조에 정점 데이터에 대한 포인터를 제공합니다.
    D3D11_SUBRESOURCE_DATA vertexData;
    vertexData.pSysMem = vertices;
    vertexData.SysMemPitch = 0;
    vertexData.SysMemSlicePitch = 0;
 
    // 이제 정점 버퍼를 만듭니다.
    if(FAILED(device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer)))
    {
        return false;
    }
 
    // 정적 인덱스 버퍼의 구조체를 설정합니다.
    D3D11_BUFFER_DESC indexBufferDesc;
    indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    indexBufferDesc.ByteWidth = sizeof(unsigned long) * m_indexCount;
    indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
    indexBufferDesc.CPUAccessFlags = 0;
    indexBufferDesc.MiscFlags = 0;
    indexBufferDesc.StructureByteStride = 0;
 
    // 하위 리소스 구조에 인덱스 데이터에 대한 포인터를 제공합니다.
    D3D11_SUBRESOURCE_DATA indexData;
    indexData.pSysMem = indices;
    indexData.SysMemPitch = 0;
    indexData.SysMemSlicePitch = 0;
 
    // 인덱스 버퍼를 만듭니다.
    if(FAILED(device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer)))
    {
        return false;
    }
 
    // 이제 버퍼가 생성되고 로드된 배열을 해제하십시오.
    delete [] vertices;
    vertices = 0;
 
    delete [] indices;
    indices = 0;
 
    return true;
}
 
 
void TerrainClass::ShutdownBuffers()
{
    // 인덱스 버퍼를 해제합니다.
    if(m_indexBuffer)
    {
        m_indexBuffer->Release();
        m_indexBuffer = 0;
    }
 
    // 버텍스 버퍼를 해제합니다.
    if(m_vertexBuffer)
    {
        m_vertexBuffer->Release();
        m_vertexBuffer = 0;
    }
}
 
 
void TerrainClass::RenderBuffers(ID3D11DeviceContext* deviceContext)
{
    // 정점 버퍼 보폭 및 오프셋을 설정합니다.
    unsigned int stride = sizeof(VertexType); 
    unsigned int offset = 0;
    
    // 렌더링 할 수 있도록 입력 어셈블러에서 정점 버퍼를 활성으로 설정합니다.
    deviceContext->IASetVertexBuffers(0, 1, &m_vertexBuffer, &stride, &offset);
 
    // 렌더링 할 수 있도록 입력 어셈블러에서 인덱스 버퍼를 활성으로 설정합니다.
    deviceContext->IASetIndexBuffer(m_indexBuffer, DXGI_FORMAT_R32_UINT, 0);
 
    // 이 꼭지점 버퍼에서 렌더링 되어야 하는 프리미티브 유형을 설정합니다. 이 경우에는 삼각형입니다.
    deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
}

Terrain_vs.hlsl

////////////////////////////////////////////////////////////////////////////////
// Filename: terrain_vs.hlsl
////////////////////////////////////////////////////////////////////////////////
 
 
/////////////
// GLOBALS //
/////////////
cbuffer MatrixBuffer
{
    matrix worldMatrix;
    matrix viewMatrix;
    matrix projectionMatrix;
};
 
 
//////////////
// TYPEDEFS //
//////////////
struct VertexInputType
{
    float4 position : POSITION;
    float2 tex : TEXCOORD0;
    float3 normal : NORMAL;
    float4 color : COLOR;
};
 
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
    float3 normal : NORMAL;
    float4 color : COLOR;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// Vertex Shader
////////////////////////////////////////////////////////////////////////////////
PixelInputType TerrainVertexShader(VertexInputType input)
{
    PixelInputType output;
    
    // 적절한 행렬 계산을 위해 위치 벡터를 4 단위로 변경합니다.
    input.position.w = 1.0f;
 
    // 월드, 뷰 및 투영 행렬에 대한 정점의 위치를 ​​계산합니다.
    output.position = mul(input.position, worldMatrix);
    output.position = mul(output.position, viewMatrix);
    output.position = mul(output.position, projectionMatrix);
    
    // 픽셀 쉐이더의 텍스처 좌표를 저장한다.
    output.tex = input.tex;
 
    // 월드 행렬에 대해서만 법선 벡터를 계산합니다.
    output.normal = mul(input.normal, (float3x3)worldMatrix);
    
    // 법선 벡터를 정규화합니다.
    output.normal = normalize(output.normal);
 
    // 픽셀 쉐이더에 색상 맵 색상을 보냅니다.
    output.color = input.color;
    return output;
}

Terrain_ps.hlsl

////////////////////////////////////////////////////////////////////////////////
// Filename: terrain_ps.hlsl
////////////////////////////////////////////////////////////////////////////////
 
 
/////////////
// GLOBALS //
/////////////
Texture2D shaderTexture;
SamplerState SampleType;
 
cbuffer LightBuffer
{
    float4 ambientColor;
    float4 diffuseColor;
    float3 lightDirection;
    float padding;
};
 
 
//////////////
// TYPEDEFS //
//////////////
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
    float3 normal : NORMAL;
    float4 color : COLOR;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// Pixel Shader
////////////////////////////////////////////////////////////////////////////////
float4 TerrainPixelShader(PixelInputType input) : SV_TARGET
{
    float4 textureColor;
    float3 lightDir;
    float lightIntensity;
    float4 color;
 
 
    // 이 텍스처 좌표 위치에서 샘플러를 사용하여 텍스처에서 픽셀 색상을 샘플링합니다.
    textureColor = shaderTexture.Sample(SampleType, input.tex);
 
    // 모든 픽셀에 대해 기본 출력 색상을 주변 광원 값으로 설정합니다.
    color = ambientColor;
 
    // 계산을 위해 빛 방향을 반전시킵니다.
    lightDir = -lightDirection;
 
    // 이 픽셀의 빛의 양을 계산합니다.
    lightIntensity = saturate(dot(input.normal, lightDir));
 
    if(lightIntensity > 0.0f)
    {
        // 확산 색과 광 강도의 양에 따라 최종 확산 색을 결정합니다.
        color += (diffuseColor * lightIntensity);
    }
 
    // 최종 빛의 색상을 채웁니다.
    color = saturate(color);
 
    // 텍스처 픽셀과 최종 밝은 색을 곱하여 결과를 얻습니다.
    color = color * textureColor;
 
    // 컬러 맵 값을 최종 색상으로 결합합니다.
    color = saturate(color * input.color * 2.0f);
 
    return color;
}

Terrainshaderclass.h

#pragma once
 
class TerrainShaderClass : public AlignedAllocationPolicy<16>
{
private:
    struct MatrixBufferType
    {
        XMMATRIX world;
        XMMATRIX view;
        XMMATRIX projection;
    };
 
    struct LightBufferType
    {
        XMFLOAT4 ambientColor;
        XMFLOAT4 diffuseColor;
        XMFLOAT3 lightDirection;
        float padding;
    };
 
public:
    TerrainShaderClass();
    TerrainShaderClass(const TerrainShaderClass&);
    ~TerrainShaderClass();
 
    bool Initialize(ID3D11Device*, HWND);
    void Shutdown();
    bool Render(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX, XMFLOAT4, XMFLOAT4, XMFLOAT3,
                ID3D11ShaderResourceView*);
 
private:
    bool InitializeShader(ID3D11Device*, HWND, const WCHAR*, const WCHAR*);
    void ShutdownShader();
    void OutputShaderErrorMessage(ID3D10Blob*, HWND, const WCHAR*);
 
    bool SetShaderParameters(ID3D11DeviceContext*, XMMATRIX, XMMATRIX, XMMATRIX, XMFLOAT4, XMFLOAT4, XMFLOAT3,
                             ID3D11ShaderResourceView*);
    void RenderShader(ID3D11DeviceContext*, int);
 
private:
    ID3D11VertexShader* m_vertexShader = nullptr;
    ID3D11PixelShader* m_pixelShader = nullptr;
    ID3D11InputLayout* m_layout = nullptr;
    ID3D11SamplerState* m_sampleState = nullptr;
    ID3D11Buffer* m_matrixBuffer = nullptr;
    ID3D11Buffer* m_lightBuffer = nullptr;
};

Terrainshaderclass.cpp

#include "stdafx.h"
#include "terrainshaderclass.h"
 
 
TerrainShaderClass::TerrainShaderClass()
{
}
 
 
TerrainShaderClass::TerrainShaderClass(const TerrainShaderClass& other)
{
}
 
 
TerrainShaderClass::~TerrainShaderClass()
{
}
 
 
bool TerrainShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
    // 정점 및 픽셀 쉐이더를 초기화합니다.
    return InitializeShader(device, hwnd, L"../Dx11Terrain_07/terrain_vs.hlsl", L"../Dx11Terrain_07/terrain_ps.hlsl");
}
 
 
void TerrainShaderClass::Shutdown()
{
    // 버텍스 및 픽셀 쉐이더와 관련된 객체를 종료합니다.
    ShutdownShader();
}
 
 
bool TerrainShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX worldMatrix, XMMATRIX viewMatrix, 
                            XMMATRIX projectionMatrix, XMFLOAT4 ambientColor, XMFLOAT4 diffuseColor, XMFLOAT3 lightDirection,
                            ID3D11ShaderResourceView* texture)
{
    // 렌더링에 사용할 셰이더 매개 변수를 설정합니다.
    if(!SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, ambientColor, diffuseColor,
                            lightDirection, texture))
    {
        return false;
    }
 
    // 설정된 버퍼를 셰이더로 렌더링한다.
    RenderShader(deviceContext, indexCount);
 
    return true;
}
 
 
bool TerrainShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, const WCHAR* vsFilename, const WCHAR* psFilename)
{
    ID3D10Blob* errorMessage = nullptr;
 
    // 버텍스 쉐이더 코드를 컴파일한다.
    ID3D10Blob* vertexShaderBuffer = nullptr;
    if(FAILED(D3DCompileFromFile(vsFilename, NULL, NULL, "TerrainVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS,
                                 0, &vertexShaderBuffer, &errorMessage)))
    {
        // 셰이더 컴파일 실패시 오류메시지를 출력합니다.
        if(errorMessage)
        {
            OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
        }
        // 컴파일 오류가 아니라면 셰이더 파일을 찾을 수 없는 경우입니다.
        else
        {
            MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
        }
 
        return false;
    }
 
    // 픽셀 쉐이더 코드를 컴파일한다.
    ID3D10Blob* pixelShaderBuffer = nullptr;
    if(FAILED(D3DCompileFromFile(psFilename, NULL, NULL, "TerrainPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS,
                                 0, &pixelShaderBuffer, &errorMessage)))
    {
        // 셰이더 컴파일 실패시 오류메시지를 출력합니다.
        if(errorMessage)
        {
            OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
        }
        // 컴파일 오류가 아니라면 셰이더 파일을 찾을 수 없는 경우입니다.
        else
        {
            MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
        }
 
        return false;
    }
 
    // 버퍼로부터 정점 셰이더를 생성한다.
    if(FAILED(device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(),
                                         NULL, &m_vertexShader)))
    {
        return false;
    }
 
    // 버퍼에서 픽셀 쉐이더를 생성합니다.
    if(FAILED(device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(),
                                        NULL, &m_pixelShader)))
    {
        return false;
    }
 
    // 정점 입력 레이아웃 구조체를 설정합니다.
    // 이 설정은 ModelClass와 셰이더의 VertexType 구조와 일치해야합니다.
    D3D11_INPUT_ELEMENT_DESC polygonLayout[4];
    polygonLayout[0].SemanticName = "POSITION";
    polygonLayout[0].SemanticIndex = 0;
    polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
    polygonLayout[0].InputSlot = 0;
    polygonLayout[0].AlignedByteOffset = 0;
    polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[0].InstanceDataStepRate = 0;
 
    polygonLayout[1].SemanticName = "TEXCOORD";
    polygonLayout[1].SemanticIndex = 0;
    polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
    polygonLayout[1].InputSlot = 0;
    polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[1].InstanceDataStepRate = 0;
 
    polygonLayout[2].SemanticName = "NORMAL";
    polygonLayout[2].SemanticIndex = 0;
    polygonLayout[2].Format = DXGI_FORMAT_R32G32B32_FLOAT;
    polygonLayout[2].InputSlot = 0;
    polygonLayout[2].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[2].InstanceDataStepRate = 0;
 
    polygonLayout[3].SemanticName = "COLOR";
    polygonLayout[3].SemanticIndex = 0;
    polygonLayout[3].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
    polygonLayout[3].InputSlot = 0;
    polygonLayout[3].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[3].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[3].InstanceDataStepRate = 0;
 
    // 레이아웃의 요소 수를 가져옵니다.
    UINT numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
 
    // 정점 입력 레이아웃을 만듭니다.
    if(FAILED(device->CreateInputLayout(polygonLayout, numElements, 
        vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout)))
    {
        return false;
    }
 
    // 더 이상 사용되지 않는 정점 셰이더 퍼버와 픽셀 셰이더 버퍼를 해제합니다.
    vertexShaderBuffer->Release();
    vertexShaderBuffer = 0;
 
    pixelShaderBuffer->Release();
    pixelShaderBuffer = 0;
 
    // 텍스처 샘플러 상태 구조체를 설정합니다.
    D3D11_SAMPLER_DESC samplerDesc;
    samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
    samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.MipLODBias = 0.0f;
    samplerDesc.MaxAnisotropy = 1;
    samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
    samplerDesc.BorderColor[0] = 0;
    samplerDesc.BorderColor[1] = 0;
    samplerDesc.BorderColor[2] = 0;
    samplerDesc.BorderColor[3] = 0;
    samplerDesc.MinLOD = 0;
    samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
 
    // 텍스처 샘플러 상태를 만듭니다.
    if(FAILED(device->CreateSamplerState(&samplerDesc, &m_sampleState)))
    {
        return false;
    }
 
    // 버텍스 쉐이더에있는 동적 행렬 상수 버퍼의 구조체를 설정합니다.
    D3D11_BUFFER_DESC matrixBufferDesc;
    matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
    matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    matrixBufferDesc.MiscFlags = 0;
    matrixBufferDesc.StructureByteStride = 0;
 
    // 이 클래스 내에서 정점 셰이더 상수 버퍼에 액세스 할 수 있도록 상수 버퍼 포인터를 만듭니다.
    if(FAILED(device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer)))
    {
        return false;
    }
 
    // 픽셀 쉐이더에있는 광원 동적 상수 버퍼의 설명을 설정합니다.
    // D3D11_BIND_CONSTANT_BUFFER를 사용하면 ByteWidth가 항상 16의 배수 여야하며 그렇지 않으면 CreateBuffer가 실패합니다.
    D3D11_BUFFER_DESC lightBufferDesc;
    lightBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    lightBufferDesc.ByteWidth = sizeof(LightBufferType);
    lightBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    lightBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    lightBufferDesc.MiscFlags = 0;
    lightBufferDesc.StructureByteStride = 0;
 
    // 이 클래스 내에서 정점 셰이더 상수 버퍼에 액세스 할 수 있도록 상수 버퍼 포인터를 만듭니다.
    if(FAILED(device->CreateBuffer(&lightBufferDesc, NULL, &m_lightBuffer)))
    {
        return false;
    }
 
    return true;
}
 
 
void TerrainShaderClass::ShutdownShader()
{
    // 조명 상수 버퍼를 해제합니다.
    if(m_lightBuffer)
    {
        m_lightBuffer->Release();
        m_lightBuffer = 0;
    }
 
    // 행렬 상수 버퍼를 해제합니다.
    if(m_matrixBuffer)
    {
        m_matrixBuffer->Release();
        m_matrixBuffer = 0;
    }
 
    // 샘플러 상태를 해제합니다.
    if(m_sampleState)
    {
        m_sampleState->Release();
        m_sampleState = 0;
    }
 
    // 레이아웃을 해제합니다.
    if(m_layout)
    {
        m_layout->Release();
        m_layout = 0;
    }
 
    // 픽셀 쉐이더를 해제합니다.
    if(m_pixelShader)
    {
        m_pixelShader->Release();
        m_pixelShader = 0;
    }
 
    // 버텍스 쉐이더를 해제합니다.
    if(m_vertexShader)
    {
        m_vertexShader->Release();
        m_vertexShader = 0;
    }
}
 
 
void TerrainShaderClass::OutputShaderErrorMessage(ID3D10Blob* errorMessage, HWND hwnd, const WCHAR* shaderFilename)
{
    // 에러 메시지를 출력창에 표시합니다.
    OutputDebugStringA(reinterpret_cast<const char*>(errorMessage->GetBufferPointer()));
 
    // 에러 메세지를 반환합니다.
    errorMessage->Release();
    errorMessage = 0;
 
    // 컴파일 에러가 있음을 팝업 메세지로 알려줍니다.
    MessageBox(hwnd, L"Error compiling shader.", shaderFilename, MB_OK);
}
 
 
bool TerrainShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, XMMATRIX worldMatrix, XMMATRIX viewMatrix,
                                             XMMATRIX projectionMatrix, XMFLOAT4 ambientColor, XMFLOAT4 diffuseColor,
                                             XMFLOAT3 lightDirection, ID3D11ShaderResourceView* texture)
{
    // 행렬을 transpose하여 셰이더에서 사용할 수 있게 합니다
    worldMatrix = XMMatrixTranspose(worldMatrix);
    viewMatrix = XMMatrixTranspose(viewMatrix);
    projectionMatrix = XMMatrixTranspose(projectionMatrix);
 
    // 상수 버퍼의 내용을 쓸 수 있도록 잠급니다.
    D3D11_MAPPED_SUBRESOURCE mappedResource;
    if(FAILED(deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource)))
    {
        return false;
    }
 
    // 상수 버퍼의 데이터에 대한 포인터를 가져옵니다.
    MatrixBufferType* dataPtr = (MatrixBufferType*)mappedResource.pData;
 
    // 상수 버퍼에 행렬을 복사합니다.
    dataPtr->world = worldMatrix;
    dataPtr->view = viewMatrix;
    dataPtr->projection = projectionMatrix;
 
    // 상수 버퍼의 잠금을 풉니다.
    deviceContext->Unmap(m_matrixBuffer, 0);
 
    // 정점 셰이더에서의 상수 버퍼의 위치를 설정합니다.
    unsigned bufferNumber = 0;
 
    // 마지막으로 정점 셰이더의 상수 버퍼를 바뀐 값으로 바꿉니다.
    deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer);
 
    // 조명 상수 버퍼를 잠글 수 있도록 기록한다.
    if(FAILED(deviceContext->Map(m_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource)))
    {
        return false;
    }
 
    // 상수 버퍼의 데이터에 대한 포인터를 가져옵니다.
    LightBufferType* dataPtr2 = (LightBufferType*)mappedResource.pData;
 
    // 조명 변수를 상수 버퍼에 복사합니다.
    dataPtr2->ambientColor = ambientColor;
    dataPtr2->diffuseColor = diffuseColor;
    dataPtr2->lightDirection = lightDirection;
    dataPtr2->padding = 0.0f;
 
    // 상수 버퍼의 잠금을 해제합니다.
    deviceContext->Unmap(m_lightBuffer, 0);
 
    // 픽셀 쉐이더에서 광원 상수 버퍼의 위치를 ​​설정합니다.
    bufferNumber = 0;
 
    // 마지막으로 업데이트 된 값으로 픽셀 쉐이더에서 광원 상수 버퍼를 설정합니다.
    deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_lightBuffer);
 
    // 셰이더 텍스처 리소스를 픽셀 셰이더에 설정합니다.
    deviceContext->PSSetShaderResources(0, 1, &texture);
 
    return true;
}
 
 
void TerrainShaderClass::RenderShader(ID3D11DeviceContext* deviceContext, int indexCount)
{
    // 정점 입력 레이아웃을 설정합니다.
    deviceContext->IASetInputLayout(m_layout);
 
    // 삼각형을 그릴 정점 셰이더와 픽셀 셰이더를 설정합니다.
    deviceContext->VSSetShader(m_vertexShader, NULL, 0);
    deviceContext->PSSetShader(m_pixelShader, NULL, 0);
 
    // 픽셀 쉐이더에서 샘플러 상태를 설정합니다.
    deviceContext->PSSetSamplers(0, 1, &m_sampleState);
    
    // 삼각형을 그립니다.
    deviceContext->DrawIndexed(indexCount, 0, 0);
}

Applicationclass.h

#pragma once
 
/////////////
// GLOBALS //
/////////////
const bool FULL_SCREEN = false;
const bool VSYNC_ENABLED = true;
const float SCREEN_DEPTH = 1000.0f;
const float SCREEN_NEAR = 0.1f;
 
 
class D3DClass;
class InputClass;
class CameraClass;
class TerrainClass;
 
class TimerClass;
class PositionClass;
class FpsClass;
class CpuClass;
class FontShaderClass;
class TextClass;
class TerrainShaderClass;
class LightClass;
 
 
class ApplicationClass
{
public:
    ApplicationClass();
    ApplicationClass(const ApplicationClass&);
    ~ApplicationClass();
 
    bool Initialize(HINSTANCE, HWND, int, int);
    void Shutdown();
    bool Frame();
 
private:
    bool HandleInput(float);
    bool RenderGraphics();
 
private:
    InputClass* m_Input = nullptr;
    D3DClass* m_Direct3D = nullptr;
    CameraClass* m_Camera = nullptr;
    TerrainClass* m_Terrain = nullptr;
    TimerClass* m_Timer = nullptr;
    PositionClass* m_Position = nullptr;
    FpsClass* m_Fps = nullptr;
    CpuClass* m_Cpu = nullptr;
    FontShaderClass* m_FontShader = nullptr;
    TextClass* m_Text = nullptr;
    TerrainShaderClass* m_TerrainShader = nullptr;
    LightClass* m_Light = nullptr;
};

Applicationclass.cpp

#include "stdafx.h"
#include "inputclass.h"
#include "d3dclass.h"
#include "cameraclass.h"
#include "terrainclass.h"
#include "timerclass.h"
#include "positionclass.h"
#include "fpsclass.h"
#include "cpuclass.h"
#include "fontshaderclass.h"
#include "textclass.h"
#include "terrainshaderclass.h"
#include "lightclass.h"
#include "ApplicationClass.h"
 
 
ApplicationClass::ApplicationClass()
{
}
 
 
ApplicationClass::ApplicationClass(const ApplicationClass& other)
{
}
 
 
ApplicationClass::~ApplicationClass()
{
}
 
 
bool ApplicationClass::Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int screenHeight)
{
    // 입력 개체를 생성합니다.
    m_Input = new InputClass;
    if(!m_Input)
    {
        return false;
    }
 
    // 입력 개체를 초기화 합니다.
    bool result = m_Input->Initialize(hinstance, hwnd, screenWidth, screenHeight);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the input object.", L"Error", MB_OK);
        return false;
    }
 
    // Direct3D 개체를 생성합니다.
    m_Direct3D = new D3DClass;
    if(!m_Direct3D)
    {
        return false;
    }
 
    // Direct3D 개체를 초기화 합니다.
    result = m_Direct3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize DirectX 11.", L"Error", MB_OK);
        return false;
    }
 
    // 카메라 객체를 생성합니다.
    m_Camera = new CameraClass;
    if(!m_Camera)
    {
        return false;
    }
 
    // 2D 사용자 인터페이스 렌더링을 위해 카메라로 기본 뷰 행렬을 초기화 합니다.
    XMMATRIX baseViewMatrix;
    m_Camera->SetPosition(XMFLOAT3(0.0f, 0.0f, -1.0f));
    m_Camera->Render();
    m_Camera->GetViewMatrix(baseViewMatrix);
 
    // 카메라의 초기 위치를 설정합니다.
    XMFLOAT3 camera = XMFLOAT3(50.0f, 2.0f, -7.0f);
    m_Camera->SetPosition(camera);
 
    // 지형 객체를 생성합니다.
    m_Terrain = new TerrainClass;
    if(!m_Terrain)
    {
        return false;
    }
 
    // 지형 객체를 초기화 합니다.
    result = m_Terrain->Initialize(m_Direct3D->GetDevice(), "../Dx11Terrain_07/data/heightmap01.bmp",
                                                           L"../Dx11Terrain_07/data/dirt01.dds",
                                                            "../Dx11Terrain_07/data/colorm01.bmp");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the terrain object.", L"Error", MB_OK);
        return false;
    }
 
    // 타이머 객체를 생성합니다.
    m_Timer = new TimerClass;
    if(!m_Timer)
    {
        return false;
    }
 
    // 타이머 객체를 초기화 합니다.
    result = m_Timer->Initialize();
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the timer object.", L"Error", MB_OK);
        return false;
    }
 
    // 위치 개체를 생성합니다.
    m_Position = new PositionClass;
    if(!m_Position)
    {
        return false;
    }
 
    // 뷰어의 초기 위치를 초기 카메라 위치와 동일하게 설정합니다.
    m_Position->SetPosition(camera);
 
    // fps 객체를 생성합니다.
    m_Fps = new FpsClass;
    if(!m_Fps)
    {
        return false;
    }
 
    // fps 객체를 초기화 합니다.
    m_Fps->Initialize();
 
    // cpu 객체를 생성합니다.
    m_Cpu = new CpuClass;
    if(!m_Cpu)
    {
        return false;
    }
 
    // cpu 객체를 초기화 합니다.
    m_Cpu->Initialize();
 
    // 폰트 셰이더 객체를 생성합니다.
    m_FontShader = new FontShaderClass;
    if(!m_FontShader)
    {
        return false;
    }
 
    // 폰트 셰이더 객체를 초기화 합니다.
    result = m_FontShader->Initialize(m_Direct3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the font shader object.", L"Error", MB_OK);
        return false;
    }
 
    // 텍스트 객체를 생성합니다.
    m_Text = new TextClass;
    if(!m_Text)
    {
        return false;
    }
 
    // 텍스트 객체를 초기화 합니다.
    result = m_Text->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), hwnd, screenWidth, screenHeight,
                                baseViewMatrix);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the text object.", L"Error", MB_OK);
        return false;
    }
 
    // 비디오 카드 정보를 가져옵니다.
    char videoCard[128] = { 0, };
    int videoMemory = 0;
    m_Direct3D->GetVideoCardInfo(videoCard, videoMemory);
 
    // 텍스트 객체에 비디오 카드 정보를 설정합니다.
    result = m_Text->SetVideoCardInfo(videoCard, videoMemory, m_Direct3D->GetDeviceContext());
    if(!result)
    {
        MessageBox(hwnd, L"Could not set video card info in the text object.", L"Error", MB_OK);
        return false;
    }
 
    // 지형 쉐이더 객체를 생성합니다.
    m_TerrainShader = new TerrainShaderClass;
    if(!m_TerrainShader)
    {
        return false;
    }
 
    // 지형 쉐이더 객체를 초기화 합니다.
    result = m_TerrainShader->Initialize(m_Direct3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the terrain shader object.", L"Error", MB_OK);
        return false;
    }
 
    // 조명 객체를 생성합니다.
    m_Light = new LightClass;
    if(!m_Light)
    {
        return false;
    }
 
    // 조명 객체를 초기화 합니다.
    m_Light->SetAmbientColor(XMFLOAT4(0.05f, 0.05f, 0.05f, 1.0f));
    m_Light->SetDiffuseColor(XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f));
    m_Light->SetDirection(XMFLOAT3(-0.5f, -1.0f, 0.0f));
 
    return true;
}
 
 
void ApplicationClass::Shutdown()
{
    // 조명 객체를 해제합니다.
    if(m_Light)
    {
        delete m_Light;
        m_Light = 0;
    }
 
    // 지형 쉐이더 객체를 해제합니다.
    if(m_TerrainShader)
    {
        m_TerrainShader->Shutdown();
        delete m_TerrainShader;
        m_TerrainShader = 0;
    }
 
    // 텍스트 객체를 해제합니다.
    if(m_Text)
    {
        m_Text->Shutdown();
        delete m_Text;
        m_Text = 0;
    }
 
    // 폰트 쉐이더 객체를 해제합니다..
    if(m_FontShader)
    {
        m_FontShader->Shutdown();
        delete m_FontShader;
        m_FontShader = 0;
    }
 
    // cpu 객체를 해제합니다.
    if(m_Cpu)
    {
        m_Cpu->Shutdown();
        delete m_Cpu;
        m_Cpu = 0;
    }
 
    // fps 객체를 해제합니다.
    if(m_Fps)
    {
        delete m_Fps;
        m_Fps = 0;
    }
 
    // 위치 객체를 해제합니다.
    if(m_Position)
    {
        delete m_Position;
        m_Position = 0;
    }
 
    // 타이머 객체를 해제합니다.
    if(m_Timer)
    {
        delete m_Timer;
        m_Timer = 0;
    }
 
    // 지형 객체를 해제합니다.
    if(m_Terrain)
    {
        m_Terrain->Shutdown();
        delete m_Terrain;
        m_Terrain = 0;
    }
 
    // 카메라 객체를 해제합니다.
    if(m_Camera)
    {
        delete m_Camera;
        m_Camera = 0;
    }
 
    // D3D 객체를 해제합니다.
    if (m_Direct3D)
    {
        m_Direct3D->Shutdown();
        delete m_Direct3D;
        m_Direct3D = 0;
    }
 
    // 입력 객체를 해제합니다.
    if(m_Input)
    {
        m_Input->Shutdown();
        delete m_Input;
        m_Input = 0;
    }
}
 
 
bool ApplicationClass::Frame()
{
    // 사용자 입력을 읽습니다.
    bool result = m_Input->Frame();
    if(!result)
    {
        return false;
    }
    
    // 사용자가 ESC를 눌렀을 때 응용 프로그램을 종료 할 것인지 확인합니다.
    if(m_Input->IsEscapePressed() == true)
    {
        return false;
    }
 
    // 시스템 통계를 업데이트 합니다.
    m_Timer->Frame();
    m_Fps->Frame();
    m_Cpu->Frame();
 
    // 텍스트 개체에서 FPS 값을 업데이트 합니다.
    result = m_Text->SetFps(m_Fps->GetFps(), m_Direct3D->GetDeviceContext());
    if(!result)
    {
        return false;
    }
    
    // 텍스트 개체의 CPU 사용값을 업데이트 합니다.
    result = m_Text->SetCpu(m_Cpu->GetCpuPercentage(), m_Direct3D->GetDeviceContext());
    if(!result)
    {
        return false;
    }
 
    // 프레임 입력 처리를 수행합니다.
    result = HandleInput(m_Timer->GetTime());
    if(!result)
    {
        return false;
    }
 
    // 그래픽을 렌더링 합니다.
    result = RenderGraphics();
    if(!result)
    {
        return false;
    }
 
    return result;
}
 
 
bool ApplicationClass::HandleInput(float frameTime)
{
    XMFLOAT3 pos = XMFLOAT3(0.0f, 0.0f, 0.0f);
    XMFLOAT3 rot = XMFLOAT3(0.0f, 0.0f, 0.0f);
 
 
    // 갱신된 위치를 계산하기 위한 프레임 시간을 설정합니다.
    m_Position->SetFrameTime(frameTime);
 
    // 입력을 처리합니다.
    m_Position->TurnLeft(m_Input->IsLeftPressed());
    m_Position->TurnRight(m_Input->IsRightPressed());
    m_Position->MoveForward(m_Input->IsUpPressed());
    m_Position->MoveBackward(m_Input->IsDownPressed());
    m_Position->MoveUpward(m_Input->IsAPressed());
    m_Position->MoveDownward(m_Input->IsZPressed());
    m_Position->LookUpward(m_Input->IsPgUpPressed());
    m_Position->LookDownward(m_Input->IsPgDownPressed());
    
    // 시점 위치 / 회전을 가져옵니다.
    m_Position->GetPosition(pos);
    m_Position->GetRotation(rot);
 
    // 카메라의 위치를 ​​설정합니다.
    m_Camera->SetPosition(pos);
    m_Camera->SetRotation(rot);
 
    // 텍스트 개체의 위치 값을 업데이트 합니다.
    if(!m_Text->SetCameraPosition(pos, m_Direct3D->GetDeviceContext()))
    {
        return false;
    }
 
    // 텍스트 객체의 회전 값을 업데이트 합니다.
    if(!m_Text->SetCameraRotation(rot, m_Direct3D->GetDeviceContext()))
    {
        return false;
    }
 
    return true;
}
 
 
bool ApplicationClass::RenderGraphics()
{
    XMMATRIX worldMatrix, viewMatrix, projectionMatrix, orthoMatrix;
 
    // 장면을 지웁니다.
    m_Direct3D->BeginScene(0.0f, 0.0f, 0.0f, 1.0f);
 
    // 카메라의 위치에 따라 뷰 행렬을 생성합니다.
    m_Camera->Render();
 
    // 카메라 및 Direct3D 객체에서 월드, 뷰, 투영 및 ortho 행렬을 가져옵니다.
    m_Direct3D->GetWorldMatrix(worldMatrix);
    m_Camera->GetViewMatrix(viewMatrix);
    m_Direct3D->GetProjectionMatrix(projectionMatrix);
    m_Direct3D->GetOrthoMatrix(orthoMatrix);
 
    // 지형 버퍼를 렌더링 합니다.
    m_Terrain->Render(m_Direct3D->GetDeviceContext());
 
    // 지형 쉐이더를 사용하여 모델을 렌더링 합니다.
    if(!m_TerrainShader->Render(m_Direct3D->GetDeviceContext(), m_Terrain->GetIndexCount(), worldMatrix, viewMatrix,
                  projectionMatrix, m_Light->GetAmbientColor(), m_Light->GetDiffuseColor(), m_Light->GetDirection(),
                  m_Terrain->GetTexture()))
    {
        return false;
    }
 
    // 모든 2D 렌더링을 시작하려면 Z 버퍼를 끕니다.
    m_Direct3D->TurnZBufferOff();
        
    // 텍스트를 렌더링하기 전에 알파 블렌딩을 켭니다.
    m_Direct3D->TurnOnAlphaBlending();
 
    // 텍스트 사용자 인터페이스 요소를 렌더링 합니다.
    if(!m_Text->Render(m_Direct3D->GetDeviceContext(), m_FontShader, worldMatrix, orthoMatrix))
    {
        return false;
    }
 
    // 텍스트를 렌더링 한 후 알파 블렌딩을 끕니다.
    m_Direct3D->TurnOffAlphaBlending();
 
    // 모든 2D 렌더링이 완료되었으므로 Z 버퍼를 다시 켭니다.
    m_Direct3D->TurnZBufferOn();
 
    // 렌더링 된 장면을 화면에 표시합니다.
    m_Direct3D->EndScene();
 
    return true;
}

출력 화면

마치면서

컬러 맵핑을 추가하여 지형의 모양과 색상을 미세하게 조정할 수 있습니다.

연습문제

1. 프로그램을 컴파일하고 실행하십시오. 조명, 텍스처링 및 색상 매핑이 적용된 지형이 표시되어야 합니다.

2. 셰이더를 수정하여 픽셀 쉐이더에서 색상 맵 색상을 반환합니다.

3. 자신만의 컬러맵을 만들고 이를 사용하여 프로그램을 실행하십시오.

소스코드

소스코드 : Dx11Terrain_07.zip