[DirectX 11] Terrain 09 - 지형 블렌딩

Terrain 09 - 지형 블렌딩

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

 이번 튜토리얼에서는 알파 맵을 사용하여 지형에 텍스처를 혼합하여 서로 다른 텍스처간에 부드러운 전환을 만드는 방법에 대해 설명합니다. 이 듀토리얼은 [DirectX 11] Terrain 07 - 지형 컬러 맵핑 코드를 기반으로 합니다.

지형에 텍스처를 혼합하기 위해 [DirectX11] Tutorial 19 - 알파 맵핑 에서 설명한 것과 같은 원칙을 사용합니다. 우리는 두 가지 색상 텍스처를 취해 알파 맵 텍스처를 블렌딩 값으로 사용하여 픽셀별로 결합합니다. 이제 큰 지형에서 이 작업을 수행하려면 다양한 텍스처 전환을 얻기 위해 상당히 다른 알파 맵이 필요합니다. 또한 앞으로 갈 모양을 만들기 위해 여러 가지 질감이 필요합니다. 두 텍스처와 알파 맵의 조합을 재료라고 합니다.

각 머티리얼에 대해 두 텍스처와 알파 맵을 한 번 설정 한 다음이 머티리얼과 관련된 모든 지형을 그려야 합니다. 이를 위해 우리는 지형을 재질에 기반한 버텍스 버퍼로 분해해야 합니다. 머티리얼과 버텍스 / 인덱스 버퍼의 조합을 머티리얼 그룹이라고 합니다. [DirectX 11] Terrain 05 - 쿼드 트리 튜토리얼에서 똑같은 종류의 것을 보았습니다. 여기서는 각 노드의 버퍼에 지형을 분해시켰습니다. 이것은 머티리얼을 제외하고는 똑같은 것입니다.

지형에 대한 머티리얼 기반 렌더링 시스템을 설정하려면 먼저 지형에 사용될 모든 텍스처와 알파 맵을 포함하는 텍스트 파일이 필요합니다. 이 파일에는 동일한 텍스처와 알파 맵을 조합한 재료 목록도 포함됩니다. 다음은 이 듀토리얼에서 사용하는 예제입니다.

텍스처 개수 : 7

0 : ../Dx11Terrain_09/data/texture01.dds

1 : ../Dx11Terrain_09/data/texture02.dds

2 : ../Dx11Terrain_09/data/texture03.dds

3 : ../Dx11Terrain_09/data/alpha01.dds

4 : ../Dx11Terrain_09/data/alpha02.dds

5 : ../Dx11Terrain_09/data/alpha03.dds

6 : ../Dx11Terrain_09/data/alpha04.dds

재료 수 : 8

0 : 0 -1 -1 0 255 0

1 : 1 -1 -1 255 0 0

2 : 1 0 4 0 0 255

3 : 1 0 3 0 255 255

4 : 2 -1 -1 255 255 255

5 : 0 2 3 128 128 128

6 : 0 2 5 128 0 0

7 : 0 2 6 0 0 128

보시다시피 텍스처 카운트로 시작한 다음 지형 렌더링에 로드하고 사용해야 하는 모든 텍스처와 알파 맵을 나열합니다. 두 번째 부분은 재료가 정의 된 부분입니다. 머티리얼 카운트로 시작하여 인덱스로 정의 된 각 머티리얼을 나열합니다. 첫 번째 인덱스는 첫 번째 텍스처입니다. 예를 들어 인덱스가 1이면 texture02.dds 파일을 참조합니다. 두 번째 인덱스는 블렌드 할 텍스처이며, -1과 같이 정의 된 경우 이 머티리얼이 블렌드되지 않고 텍스처만 있는 것을 제외하고는 동일한 방식으로 작동합니다. 세 번째 인덱스는 알파 맵입니다. 예를 들어 세 번째 인덱스가 3이면 alpha01.dds 알파 맵을 참조합니다.

마지막 세 숫자는 빨간색, 녹색, 파란색 색인입니다. 이러한 특정 재료를 나타내는 색상을 정의하는 데 함께 사용됩니다. 예를 들어 첫 번째 머티리얼은 0, 255, 0입니다. 이는 머티리얼이 녹색으로 정의됨을 의미합니다. 이제 우리는 각 색상을 지형으로 렌더링해야 하는 위치와 색인으로 비트 맵을 사용합니다. 이 튜토리얼에서는 재질 맵으로 다음 비트 맵을 사용합니다.

이제 초록색이 머티리얼 맵의 오른쪽 하단에 표시됩니다. 따라서 오른쪽 아래 부분의 지형에 있는 모든 쿼드는 첫 번째 머티리얼을 사용합니다. 왼쪽 상단의 섹션이 대부분 흰색인 것을 볼 수 있습니다. 즉, 255, 255, 255 로 정의 된 재질 4가 지형의 해당 부분을 렌더링 하는데 사용됩니다. 두 개의 텍스처 사이의 알파 맵인 경계선을 따라 얇은 선이 있기 때문에 두 영역의 두 재료 사이의 블렌딩으로 전환됩니다.

이것을 사용하는 주된 이유는 지형이 어떻게 보이는지 100 % 제어 할 수 있기 때문입니다. 대부분의 절차적 방법은 일반적으로 일반적인 지형을 가진 무인 지역에서 잘 작동하는 일종의 기울기와 높이 방정식을 사용합니다. 그러나 거주되는 곳이나 독특한 특징이 있는 곳이라면 그 기능을 정의할 방법이 필요합니다. 머티리얼 맵을 사용하는 것이 쉬운 방법 중 하나입니다.

또한 대부분의 프로그래머는 도구 내부에서 이를 수행하는 별도의 지형 생성 도구를 작성한 다음 모든 것을 모델로 내보내서 정점 버퍼가 미리 준비되어 엔진에 쉽게 로드 될 수 있습니다. 이 튜토리얼에서는 엔진 내부에서 이를 수행하므로 지형 생성 도구를 설명할 필요없이 어떻게 작동하는지 확인할 수 있습니다. 평소와 마찬가지로 이 듀토리얼은 최적화되지 않았으므로 작동 방법을 읽고 이해하는 것이 더 쉽습니다. 나중에 필요에 맞게 최적화 할 수 있습니다.

HLSL 쉐이더 파일의 변경 사항을 살펴봄으로써 튜토리얼의 코드 섹션을 시작할 것입니다.

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 shaderTexture1 : register(t0);
Texture2D shaderTexture2 : register(t1);
Texture2D alphaMap : register(t2);
SamplerState SampleType;
 
cbuffer LightBuffer
{
    float4 ambientColor;
    float4 diffuseColor;
    float3 lightDirection;
    float padding;
};
 
cbuffer TextureInfoBuffer
{
    bool useAlplha;
    float3 padding2;
};
 
 
//////////////
// 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 color;
    float3 lightDir;
    float lightIntensity;
    float4 textureColor1;
    float4 textureColor2;
    float4 alphaValue;
    float4 blendColor;
 
 
    // Set the default output color to the ambient light value for all pixels.
    color = ambientColor;
 
    // 계산을 위해 빛 방향을 반전시킵니다.
    lightDir = -lightDirection;
 
    // 이 픽셀의 빛의 양을 계산합니다.
    lightIntensity = saturate(dot(input.normal, lightDir));
 
    if(lightIntensity > 0.0f)
    {
        // 확산 색과 광 강도의 양에 따라 최종 확산 색을 결정합니다.
        color += (diffuseColor * lightIntensity);
    }
 
    // 최종 빛의 색상을 채웁니다.
    color = saturate(color);
 
    if(useAlplha)
    {
        // 이 텍스처 좌표 위치에서 샘플러를 사용하여 첫 번째 텍스처에서 픽셀 색상을 샘플링합니다.
        textureColor1 = shaderTexture1.Sample(SampleType, input.tex);
 
        // 이 텍스처 좌표 위치에서 샘플러를 사용하여 두 번째 텍스처에서 픽셀 색상을 샘플링합니다.
        textureColor2 = shaderTexture2.Sample(SampleType, input.tex);
 
        // 알파 블렌딩 값을 샘플링합니다.
        alphaValue = alphaMap.Sample(SampleType, input.tex);
        
        // 알파는 알파 값에 따라 두 색상을 혼합합니다.
        blendColor = (alphaValue * textureColor2) + ((1.0 - alphaValue) * textureColor1);
    }
    else
    {
        // 첫 번째 텍스처에서만 픽셀 색상을 사용합니다.
        blendColor = shaderTexture1.Sample(SampleType, input.tex);
    }
 
    // 혼합 된 텍스처 색상과 최종 밝은 색상을 곱하여 결과를 얻습니다.
    color = color * blendColor;
 
    // 컬러 맵 값을 최종 색상으로 결합합니다.
    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;
    };
 
    struct TextureInfoBufferType
    {
        bool useAlplha;
        XMFLOAT3 padding2;
    };
 
public:
    TerrainShaderClass();
    TerrainShaderClass(const TerrainShaderClass&);
    ~TerrainShaderClass();
 
    bool Initialize(ID3D11Device*, HWND);
    void Shutdown();
 
    bool SetShaderParameters(ID3D11DeviceContext*, XMMATRIX, XMMATRIX, XMMATRIX, XMFLOAT4, XMFLOAT4, XMFLOAT3);
    bool SetShaderTextures(ID3D11DeviceContext*, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*,
                           ID3D11ShaderResourceView*, bool);
    void RenderShader(ID3D11DeviceContext*, int);
 
private:
    bool InitializeShader(ID3D11Device*, HWND, const WCHAR*, const WCHAR*);
    void ShutdownShader();
    void OutputShaderErrorMessage(ID3D10Blob*, HWND, const WCHAR*);
 
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;
    ID3D11Buffer* m_textureInfoBuffer = 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_09/terrain_vs.hlsl", L"../Dx11Terrain_09/terrain_ps.hlsl");
}
 
 
void TerrainShaderClass::Shutdown()
{
    // 버텍스 및 픽셀 쉐이더와 관련된 객체를 종료합니다.
    ShutdownShader();
}
 
 
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;
    }
    
    // 픽셀 쉐이더에있는 텍스처 정보 상수 버퍼의 설명을 설정합니다.
    D3D11_BUFFER_DESC textureInfoBufferDesc;
    textureInfoBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    textureInfoBufferDesc.ByteWidth = sizeof(TextureInfoBufferType);
    textureInfoBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    textureInfoBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    textureInfoBufferDesc.MiscFlags = 0;
    textureInfoBufferDesc.StructureByteStride = 0;
 
    // 이 클래스 내에서 픽셀 쉐이더 상수 버퍼에 액세스 할 수 있도록 상수 버퍼 포인터를 만듭니다.
    if(FAILED(device->CreateBuffer(&textureInfoBufferDesc, NULL, &m_textureInfoBuffer)))
    {
        return false;
    }
 
    return true;
}
 
 
void TerrainShaderClass::ShutdownShader()
{
    // 텍스처 정보의 정수 버퍼를 릴리즈한다.
    if(m_textureInfoBuffer)
    {
        m_textureInfoBuffer->Release();
        m_textureInfoBuffer = 0;
    }
 
    // 조명 상수 버퍼를 해제합니다.
    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)
{
    // 행렬을 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);
 
    return true;
}
 
 
bool TerrainShaderClass::SetShaderTextures(ID3D11DeviceContext* deviceContext, ID3D11ShaderResourceView* texture1, 
                                           ID3D11ShaderResourceView* texture2, ID3D11ShaderResourceView* alphaMap,
                                           bool useAlpha)
{
    // 픽셀 셰이더에서 셰이더 텍스처 리소스를 설정합니다.
    deviceContext->PSSetShaderResources(0, 1, &texture1);
 
    // 블렌드 다각형 인 경우 블렌딩을 위해 두 번째 텍스처와 알파 맵을 설정합니다.
    if(useAlpha)
    {
        deviceContext->PSSetShaderResources(1, 1, &texture2);
        deviceContext->PSSetShaderResources(2, 1, &alphaMap);
    }
 
    // 쓸 수 있도록 텍스처 정보 상수 버퍼를 잠급니다.
    D3D11_MAPPED_SUBRESOURCE mappedResource;
    if(FAILED(deviceContext->Map(m_textureInfoBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource)))
    {
        return false;
    }
 
    // 상수 버퍼의 데이터에 대한 포인터를 가져옵니다.
    TextureInfoBufferType* dataPtr = (TextureInfoBufferType*)mappedResource.pData;
 
    // 텍스처 정보 변수를 상수 버퍼에 복사합니다.
    dataPtr->useAlplha = useAlpha;
    dataPtr->padding2 = XMFLOAT3(0.0f, 0.0f, 0.0f);
 
    // 상수 버퍼의 잠금을 해제합니다.
    deviceContext->Unmap(m_textureInfoBuffer, 0);
 
    // 픽셀 쉐이더에서 텍스처 정보 상수 버퍼의 위치를 ​​설정합니다.
    UINT bufferNumber = 1;
 
    // 마지막으로 픽셀 쉐이더에 텍스처 정보 상수 버퍼를 업데이트 된 값으로 설정합니다.
    deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_textureInfoBuffer);
 
    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);
}

Terrainclass.h

#pragma once
 
/////////////
// GLOBALS //
/////////////
const int TEXTURE_REPEAT = 8;
 
 
class TextureClass;
class TerrainShaderClass;
 
 
class TerrainClass
{
private:
    struct VertexType
    {
        XMFLOAT3 position;
        XMFLOAT2 texture;
        XMFLOAT3 normal;
        XMFLOAT4 color;
    };
 
    struct HeightMapType 
    { 
        float x, y, z;
        float nx, ny, nz;
        float r, g, b;
        int rIndex, gIndex, bIndex;
    };
 
    struct VectorType 
    { 
        float x, y, z;
    };
 
    struct MaterialGroupType 
    { 
        int textureIndex1, textureIndex2, alphaIndex;
        int red, green, blue;
        ID3D11Buffer *vertexBuffer, *indexBuffer;
        int vertexCount, indexCount;
        VertexType* vertices;
        unsigned long* indices;
    };
 
public:
    TerrainClass();
    TerrainClass(const TerrainClass&);
    ~TerrainClass();
 
    bool Initialize(ID3D11Device*, const char*, const char*, const char*, const char*);
    void Shutdown();
 
    bool Render(ID3D11DeviceContext*, TerrainShaderClass*, XMMATRIX, XMMATRIX, XMMATRIX, XMFLOAT4, XMFLOAT4, XMFLOAT3);
 
private:
    bool LoadHeightMap(const char*);
    void NormalizeHeightMap();
    bool CalculateNormals();
    void ShutdownHeightMap();
 
    bool LoadColorMap(const char*);
 
    bool LoadMaterialFile(const char*, const char*, ID3D11Device*);
    bool LoadMaterialMap(const char*);
    bool LoadMaterialBuffers(ID3D11Device*);
    void ReleaseMaterials();
 
private:
    int m_terrainWidth = 0;
    int m_terrainHeight = 0;
    HeightMapType* m_heightMap = nullptr;
    int m_textureCount = 0;
    int m_materialCount = 0;
    TextureClass* m_Textures = nullptr;
    MaterialGroupType* m_Materials = nullptr;
};

Terrainclass.cpp

#include "stdafx.h"
#include "textureclass.h"
#include "TerrainShaderClass.h"
#include "terrainclass.h"
 
#include <stdlib.h>
#include <fstream>
using namespace std;
 
 
TerrainClass::TerrainClass()
{
}
 
 
TerrainClass::TerrainClass(const TerrainClass& other)
{
}
 
 
TerrainClass::~TerrainClass()
{
}
 
 
bool TerrainClass::Initialize(ID3D11Device* device, const char* heightMapFilename, const char* materialsFilename,
                              const char* materialMapFilename, const char* colorMapFilename)
{
    // 지형의 높이 맵을 로드합니다.
    if(!LoadHeightMap(heightMapFilename))
    {
        return false;
    }
 
    // 높이 맵의 높이를 표준화합니다.
    NormalizeHeightMap();
 
    // 지형 데이터의 법선을 계산합니다.
    if(!CalculateNormals())
    {
        return false;
    }
 
    // 컬러 맵을 지형에 로드합니다.
    if(!LoadColorMap(colorMapFilename))
    {
        return false;
    }
 
    // 지형에 대한 머티리얼 그룹을 초기화합니다.
    if(!LoadMaterialFile(materialsFilename, materialMapFilename, device))
    {
        return false;
    }
 
    return true;
}
 
 
void TerrainClass::Shutdown()
{
    // 지형의 재질을 해제합니다.
    ReleaseMaterials();
 
    // 높이맵 데이터를 해제합니다.
    ShutdownHeightMap();
}
 
 
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;
    }
}
 
 
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::LoadMaterialFile(const char* filename, const char* materialMapFilename, ID3D11Device* device)
{
    size_t stringLength = 0;
    char inputFilename[128] = { 0, };
    wchar_t textureFilename[128] = { 0, };
 
    // 재질 정보 텍스트 파일을 엽니다.
    ifstream fin;
    fin.open(filename);
    if(fin.fail())
    {
        return false;
    }
 
    // 텍스처 카운트의 값까지 읽는다.
    char input = 0;
    fin.get(input);
    while(input != ':')
    {
        fin.get(input);
    }
 
    // 텍스처 수를 읽습니다.
    fin >> m_textureCount;
 
    // 텍스처 오브젝트 배열을 만듭니다.
    m_Textures = new TextureClass[m_textureCount];
    if(!m_Textures)
    {
        return false;
    }
 
    // 각 텍스처를 로드합니다.
    for(int i=0; i<m_textureCount; i++)
    {
        fin.get(input);
        while(input != ':')
        {
            fin.get(input);
        }
 
        fin >> inputFilename;
 
        // 문자 파일 이름을 WCHAR로 변환합니다.        
        if(mbstowcs_s(&stringLength, textureFilename, 128, inputFilename, 128) != 0)
        {
            return false;
        }
 
        // 텍스처 또는 알파 맵을 로드합니다.
        if(!m_Textures[i].Initialize(device, textureFilename))
        {
            return false;
        }
    }
 
    // 재질 갯수의 값을 읽습니다.
    fin.get(input);
    while(input != ':')
    {
        fin.get(input);
    }
 
    // 재질 갯수를 읽습니다.
    fin >> m_materialCount;
 
    // 재질 그룹 배열을 만듭니다.
    m_Materials = new MaterialGroupType[m_materialCount];
    if(!m_Materials)
    {
        return false;
    }
 
    // 머티리얼 그룹 배열을 초기화합니다.
    for(int i=0; i<m_materialCount; i++)
    {
        m_Materials[i].vertexBuffer = 0;
        m_Materials[i].indexBuffer = 0;
        m_Materials[i].vertices = 0;
        m_Materials[i].indices = 0;
    }
 
    // 각 머티리얼 그룹 인덱스를 로드합니다.
    for(int i=0; i<m_materialCount; i++)
    {
        fin.get(input);
        while(input != ':')
        {
            fin.get(input);
        }
 
        fin >> m_Materials[i].textureIndex1 >> m_Materials[i].textureIndex2 >> m_Materials[i].alphaIndex;
        fin >> m_Materials[i].red >> m_Materials[i].green >> m_Materials[i].blue;
    }
 
    // 머티리얼 정보 텍스트 파일을 닫습니다.
    fin.close();
    
    // 이제 재질 인덱스 맵을 로드합니다.
    if(!LoadMaterialMap(materialMapFilename))
    {
        return false;
    }
 
    // 지형 데이터로 각 머티리얼 그룹에 대한 정점 버퍼를 로드합니다.
    if(!LoadMaterialBuffers(device))
    {
        return false;
    }
 
    return true;
}
 
 
bool TerrainClass::LoadMaterialMap(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 매핑의 지형 치수와 동일한 지 확인하십시오.
    if((bitmapInfoHeader.biWidth != m_terrainWidth) || (bitmapInfoHeader.biHeight != m_terrainHeight))
    {
        return false;
    }
 
    // 비트 맵 이미지 데이터의 크기를 계산합니다.
    int imageSize = bitmapInfoHeader.biWidth * bitmapInfoHeader.biHeight * 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<m_terrainHeight; j++)
    {
        for(int i=0; i<m_terrainWidth; i++)
        {
            int index = (m_terrainHeight * j) + i;
 
            m_heightMap[index].rIndex = (int)bitmapImage[k+2];
            m_heightMap[index].gIndex = (int)bitmapImage[k+1];
            m_heightMap[index].bIndex = (int)bitmapImage[k];
 
            k+=3;
        }
    }
 
    // 비트 맵 이미지 데이터를 해제합니다.
    delete [] bitmapImage;
    bitmapImage = 0;
 
    return true;
}
 
 
bool TerrainClass::LoadMaterialBuffers(ID3D11Device* device)
{
    // 머티리얼 그룹이 가질 수있는 최대 정점 수의 값을 만듭니다.
    int maxVertexCount = (m_terrainWidth - 1) * (m_terrainHeight - 1) * 6;
 
    // 인덱스 카운트를 최대 정점 수와 같게 설정합니다.
    int maxIndexCount = maxVertexCount;
 
    // 각 재질 그룹의 정점 및 인덱스 배열을 최대 크기로 초기화합니다.
    for(int i=0; i<m_materialCount; i++)
    {
        // 이 머티리얼 그룹에 대한 임시 정점 배열을 만듭니다.
        m_Materials[i].vertices = new VertexType[maxVertexCount];
        if(!m_Materials[i].vertices)
        {
            return false;
        }
 
        // 이 머티리얼 그룹에 대한 임시 인덱스 배열을 만듭니다.
        m_Materials[i].indices = new unsigned long[maxIndexCount];
        if(!m_Materials[i].indices)
        {
            return false;
        }
 
        // 카운트를 0으로 초기화합니다.
        m_Materials[i].vertexCount = 0;
        m_Materials[i].indexCount = 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);  // 오른쪽 위.
 
            // 머티리얼 인덱스의 왼쪽 위 꼭지점을 쿼리합니다.
            int redIndex   = m_heightMap[index3].rIndex;
            int greenIndex = m_heightMap[index3].gIndex;
            int blueIndex  = m_heightMap[index3].bIndex;
 
            // 이 정점이 속하는 재료 그룹을 찾습니다.
            int index = 0;
            int found = false;
            while(!found)
            {
                if((redIndex == m_Materials[index].red) && (greenIndex == m_Materials[index].green) &&
                   (blueIndex == m_Materials[index].blue))
                {
                    found = true;
                }
                else
                {
                    index++;
                }
            }
 
            // 정점 및 인덱스 배열의 인덱스 위치를 개수로 설정합니다.
            int vIndex = m_Materials[index].vertexCount;
 
            // 왼쪽 위.
            m_Materials[index].vertices[vIndex].position = XMFLOAT3(m_heightMap[index3].x, m_heightMap[index3].y,
                                                                    m_heightMap[index3].z);
            m_Materials[index].vertices[vIndex].texture = XMFLOAT2(0.0f, 0.0f);
            m_Materials[index].vertices[vIndex].normal = XMFLOAT3(m_heightMap[index3].nx, m_heightMap[index3].ny,
                                                                  m_heightMap[index3].nz);
            m_Materials[index].vertices[vIndex].color = XMFLOAT4(m_heightMap[index3].r, m_heightMap[index3].g,
                                                                 m_heightMap[index3].b, 1.0f);
            m_Materials[index].indices[vIndex] = vIndex;
            vIndex++;
 
            // 오른쪽 위.
            m_Materials[index].vertices[vIndex].position = XMFLOAT3(m_heightMap[index4].x, m_heightMap[index4].y,
                                                                    m_heightMap[index4].z);
            m_Materials[index].vertices[vIndex].texture = XMFLOAT2(1.0f, 0.0f);
            m_Materials[index].vertices[vIndex].normal = XMFLOAT3(m_heightMap[index4].nx, m_heightMap[index4].ny,
                                                                  m_heightMap[index4].nz);
            m_Materials[index].vertices[vIndex].color = XMFLOAT4(m_heightMap[index4].r, m_heightMap[index4].g,
                                                                 m_heightMap[index4].b, 1.0f);
            m_Materials[index].indices[vIndex] = vIndex;
            vIndex++;
 
            // 왼쪽 아래.
            m_Materials[index].vertices[vIndex].position = XMFLOAT3(m_heightMap[index1].x, m_heightMap[index1].y,
                                                                    m_heightMap[index1].z);
            m_Materials[index].vertices[vIndex].texture = XMFLOAT2(0.0f, 1.0f);
            m_Materials[index].vertices[vIndex].normal = XMFLOAT3(m_heightMap[index1].nx, m_heightMap[index1].ny,
                                                                  m_heightMap[index1].nz);
            m_Materials[index].vertices[vIndex].color = XMFLOAT4(m_heightMap[index1].r, m_heightMap[index1].g,
                                                                 m_heightMap[index1].b, 1.0f);
            m_Materials[index].indices[vIndex] = vIndex;
            vIndex++;
 
            // 왼쪽 아래.
            m_Materials[index].vertices[vIndex].position = XMFLOAT3(m_heightMap[index1].x, m_heightMap[index1].y,
                                                                    m_heightMap[index1].z);
            m_Materials[index].vertices[vIndex].texture = XMFLOAT2(0.0f, 1.0f);
            m_Materials[index].vertices[vIndex].normal = XMFLOAT3(m_heightMap[index1].nx, m_heightMap[index1].ny,
                                                                  m_heightMap[index1].nz);
            m_Materials[index].vertices[vIndex].color = XMFLOAT4(m_heightMap[index1].r, m_heightMap[index1].g,
                                                                 m_heightMap[index1].b, 1.0f);
            m_Materials[index].indices[vIndex] = vIndex;
            vIndex++;
 
            // 오른쪽 위.
            m_Materials[index].vertices[vIndex].position = XMFLOAT3(m_heightMap[index4].x, m_heightMap[index4].y,
                                                                    m_heightMap[index4].z);
            m_Materials[index].vertices[vIndex].texture = XMFLOAT2(1.0f, 0.0f);
            m_Materials[index].vertices[vIndex].normal = XMFLOAT3(m_heightMap[index4].nx, m_heightMap[index4].ny,
                                                                  m_heightMap[index4].nz);
            m_Materials[index].vertices[vIndex].color = XMFLOAT4(m_heightMap[index4].r, m_heightMap[index4].g,
                                                                 m_heightMap[index4].b, 1.0f);
            m_Materials[index].indices[vIndex] = vIndex;
            vIndex++;
 
            // 오른쪽 아래.
            m_Materials[index].vertices[vIndex].position = XMFLOAT3(m_heightMap[index2].x, m_heightMap[index2].y,
                                                                    m_heightMap[index2].z);
            m_Materials[index].vertices[vIndex].texture = XMFLOAT2(1.0f, 1.0f);
            m_Materials[index].vertices[vIndex].normal = XMFLOAT3(m_heightMap[index2].nx, m_heightMap[index2].ny,
                                                                  m_heightMap[index2].nz);
            m_Materials[index].vertices[vIndex].color = XMFLOAT4(m_heightMap[index2].r, m_heightMap[index2].g,
                                                                 m_heightMap[index2].b, 1.0f);
            m_Materials[index].indices[vIndex] = vIndex;
            vIndex++;
 
            // 정점 및 인덱스 배열 수를 증가시킵니다.
            m_Materials[index].vertexCount += 6;
            m_Materials[index].indexCount += 6;
        }
    }
 
    // 이제 각 머티리얼 그룹에 대한 버텍스와 인덱스 배열로부터 버텍스와 인덱스 버퍼를 생성합니다.
    for(int i=0; i<m_materialCount; i++)
    {
        D3D11_BUFFER_DESC vertexBufferDesc;
        
        vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
        vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_Materials[i].vertexCount;
        vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
        vertexBufferDesc.CPUAccessFlags = 0;
        vertexBufferDesc.MiscFlags = 0;
        vertexBufferDesc.StructureByteStride = 0;
 
        D3D11_SUBRESOURCE_DATA vertexData;
        vertexData.pSysMem = m_Materials[i].vertices;
        vertexData.SysMemPitch = 0;
        vertexData.SysMemSlicePitch = 0;
 
        if(FAILED(device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_Materials[i].vertexBuffer)))
        {
            return false;
        }
 
        D3D11_BUFFER_DESC indexBufferDesc;
        indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
        indexBufferDesc.ByteWidth = sizeof(unsigned long) * m_Materials[i].indexCount;
        indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
        indexBufferDesc.CPUAccessFlags = 0;
        indexBufferDesc.MiscFlags = 0;
        indexBufferDesc.StructureByteStride = 0;
 
        D3D11_SUBRESOURCE_DATA indexData;
        indexData.pSysMem = m_Materials[i].indices;
        indexData.SysMemPitch = 0;
        indexData.SysMemSlicePitch = 0;
 
        if(FAILED(device->CreateBuffer(&indexBufferDesc, &indexData, &m_Materials[i].indexBuffer)))
        {
            return false;
        }
 
        delete [] m_Materials[i].vertices;
        m_Materials[i].vertices = 0;
 
        delete [] m_Materials[i].indices;
        m_Materials[i].indices = 0;
    }
 
    return true;
}
 
 
void TerrainClass::ReleaseMaterials()
{
    // 머티리얼 그룹을 해제합니다.
    if(m_Materials)
    {
        for(int i=0; i<m_materialCount; i++)
        {
            if(m_Materials[i].vertexBuffer)
            {
                m_Materials[i].vertexBuffer->Release();
                m_Materials[i].vertexBuffer = 0;
            }
 
            if(m_Materials[i].indexBuffer)
            {
                m_Materials[i].indexBuffer->Release();
                m_Materials[i].indexBuffer = 0;
            }
 
            if(m_Materials[i].vertices)
            {
                delete [] m_Materials[i].vertices;
                m_Materials[i].vertices = 0;
            }
 
            if(m_Materials[i].indices)
            {
                delete [] m_Materials[i].indices;
                m_Materials[i].indices = 0;
            }
        }
 
        delete [] m_Materials;
        m_Materials = 0;
    }
 
    // 지형 텍스처와 알파 맵을 해제합니다.
    if(m_Textures)
    {
        for(int i=0; i<m_textureCount; i++)
        {
            m_Textures[i].Shutdown();
        }
 
        delete [] m_Textures;
        m_Textures = 0;
    }
}
 
 
bool TerrainClass::Render(ID3D11DeviceContext* deviceContext, TerrainShaderClass* shader, XMMATRIX worldMatrix,
       XMMATRIX viewMatrix, XMMATRIX projectionMatrix, XMFLOAT4 ambientColor, XMFLOAT4 diffuseColor, XMFLOAT3 lightDirection)
{
    // 정점 버퍼 보폭 및 오프셋을 설정합니다.
    UINT stride = sizeof(VertexType); 
    UINT offset = 0;
 
    // 렌더링에 사용할 셰이더 매개 변수를 설정합니다.
    bool result = shader->SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, ambientColor,
                                              diffuseColor, lightDirection);
    if(!result)
    {
        return false;
    }
 
    // 꼭지점 버퍼에서 렌더링되어야하는 프리미티브 유형을 설정합니다.이 경우에는 삼각형입니다.
    deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
 
    // 각 머티리얼 그룹을 렌더링합니다.
    for(int i=0; i<m_materialCount; i++)
    {
        // 렌더링 할 수 있도록 입력 어셈블러에서 정점 버퍼를 활성으로 설정합니다.
        deviceContext->IASetVertexBuffers(0, 1, &m_Materials[i].vertexBuffer, &stride, &offset);
 
        // 렌더링 할 수 있도록 입력 어셈블러에서 인덱스 버퍼를 활성으로 설정합니다.
        deviceContext->IASetIndexBuffer(m_Materials[i].indexBuffer, DXGI_FORMAT_R32_UINT, 0);
 
        // 머티리얼 그룹에 유효한 두 번째 텍스처 인덱스가있는 경우 혼합 된 지형 폴리곤입니다.
        if(m_Materials[i].textureIndex2 != -1)
        {
            result = shader->SetShaderTextures(deviceContext,  m_Textures[m_Materials[i].textureIndex1].GetTexture(),  
                                               m_Textures[m_Materials[i].textureIndex2].GetTexture(),
                                               m_Textures[m_Materials[i].alphaIndex].GetTexture(), true);
        }
 
        // 그렇지 않다면 단 하나의 다각형이 됩니다.
        else
        {
            result = shader->SetShaderTextures(deviceContext, m_Textures[m_Materials[i].textureIndex1].GetTexture(), NULL,
                                               NULL, false);
        }
 
        // 텍스처가 설정되었는지 확인하십시오.
        if(!result)
        {
            return false;
        }
 
        // 준비한 버퍼를 셰이더로 렌더링한다.
        shader->RenderShader(deviceContext, m_Materials[i].indexCount);
    }
 
    return true;
}

이번 듀토리얼에서는 Applicationclass 헤더파일이 변경되지 않았으므로 생략하겠습니다.

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_09/data/heightmap01.bmp",
                                                            "../Dx11Terrain_09/data/legend.txt", 
                                                            "../Dx11Terrain_09/data/materialmap01.bmp",
                                                            "../Dx11Terrain_09/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);
 
    // 지형 쉐이더를 사용하여 모델을 렌더링 합니다.
    if(!m_Terrain->Render(m_Direct3D->GetDeviceContext(), m_TerrainShader, worldMatrix, viewMatrix, projectionMatrix,
                          m_Light->GetAmbientColor(), m_Light->GetDiffuseColor(), m_Light->GetDirection()))
    {
        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. 프로그램을 컴파일하고 실행하십시오. 지형에 블렌딩된 텍스처가 표시됩니다. 종료하려면 ESC 키를 누릅니다.

2. 픽셀 쉐이더에서 컬러 맵 추가의 마지막 행을 주석으로 처리하세요. 따라서 지형에서 텍스처의 블렌딩을 명확하게 볼 수 있습니다.

3. 동일한 색상을 사용하여 재료 비트 맵을 수정하여 재료를 지형의 다른 곳에 배치합니다.

4. 자신의 재료 및 재료 그룹을 작성하여 지형에 추가합니다.

소스코드

소스코드 : Dx11Terrain_09.zip