[DirectX 11] Terrain 14 - 기울기 기반 텍스처링

Terrain 14 - 기울기 기반 텍스처링

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

 이번 DirectX 11 지형 튜토리얼은 기울기를 순차적으로 사용하는 지형 텍스처링을 위한 많은 방법 중 하나를 다룹니다. 듀토리얼의 코드는 지형 텍스처링 듀토리얼을 기반으로 합니다.

순차적 방법을 사용하여 지형을 질감 짓는 많은 응용 프로그램이 있습니다. 이는 아티스트가 필요없이 매우 사실적으로 보이는 많은 양의 지형을 생성하는 데 도움이됩니다. Terragen은 순차적 텍스처링을 사용하는 응용 프로그램의 한 예입니다. Terragen에 익숙하지 않은 분이라면 꼭 살펴 보시기 바랍니다. 이 튜토리얼에서 다루는 순차적 방법은 기울기를 사용하여 지형의 주어진 픽셀을 텍스처링하는 방법을 결정합니다. 이것은 우수한 결과를 만들어내는 매우 빠른 방법입니다.

이미 노멀 벡터를 가지고 있다면 모든 픽셀의 기울기를 결정하는 것이 간단합니다. 법선의 Y (높이) 값에서 하나를 뺍니다. 0.0f (완전히 평평한 지형)와 1.0f (지형이 90도에서 똑바로 가리키는) 사이의 값을 제공합니다. 각 픽셀의 기울기를 사용하여 텍스처를 결정할 수 있습니다. 예를 들어, 일부 지형을 렌더링 할 수 있고 0.2f 미만의 경사면은 녹색이며, 0.2f와 0.7f 사이의 모든 요소는 녹색과 파란색의 조합이며 0.7 이상은 파란색과 빨간색의 조합입니다. 이렇게 하면 다음과 같은 기울기 이미지를 얻을 수 있습니다.

이 기울기를 시각화하면 빨간색이 급경사, 파란색은 완만한 경사, 녹색은 대체로 평탄합니다. 이제 똑같은 예제를 추가로 활용하고 다음 텍스처를 사용하십시오.

이제 우리가 0.2f 경사 아래 잔디 텍스처를 만들고 0.2f와 0.7fa의 이끼와 암석 질감의 조합, 그리고 0.7 이상의 암석 질감을 만들면 다음과 같은 모습을 보일 것입니다.

또 다른 예로 우리는 0.2 스노우 보드 이하의 스노우를 사용하고 0.2 스노우 위의 모든 스노우를 사용하고 동일한 지형을 사용하여 다음 이미지를 생성 할 수 있습니다.

기울기가 순차적으로 지형에 텍스처를 렌더링 하는데 효과적이라는 것을 알 수 있습니다. 또한 현실 세계에서 지형이 어떻게 보이는지와 상관 관계가 있는 더 나은 시스템 중 하나입니다. 예를 들어 평평한 표면은 성장을 지원하고 눈과 같은 것들을 유지합니다. 높은 경사 지역은 성장이 적고 더 많은 암석과 땅을 노출시킵니다.

이 튜토리얼에서는 지형 버텍스 셰이더가 수정되지 않았으므로 생략하겠습니다.

Terrain_ps.hlsl

////////////////////////////////////////////////////////////////////////////////
// Filename: terrain_ps.hlsl
////////////////////////////////////////////////////////////////////////////////
 
 
//////////////
// TEXTURES //
//////////////
Texture2D grassTexture : register(t0);
Texture2D slopeTexture : register(t1);
Texture2D rockTexture  : register(t2);
 
 
///////////////////
// SAMPLE STATES //
///////////////////
SamplerState SampleType;
 
 
//////////////////////
// CONSTANT BUFFERS //
//////////////////////
cbuffer LightBuffer
{
    float4 ambientColor;
    float4 diffuseColor;
    float3 lightDirection;
    float padding;
};
 
 
//////////////
// TYPEDEFS //
//////////////
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
    float3 normal : NORMAL;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// Pixel Shader
////////////////////////////////////////////////////////////////////////////////
float4 TerrainPixelShader(PixelInputType input) : SV_TARGET
{
    float4 grassColor;
    float4 slopeColor;
    float4 rockColor;
    float slope;
    float blendAmount;
    float4 textureColor;
    float3 lightDir;
    float lightIntensity;
    float4 color;
 
 
    // 이 텍스처 좌표 위치에서 샘플러를 사용하여 텍스처에서 잔디 색상을 샘플링합니다. 
    grassColor = grassTexture.Sample(SampleType, input.tex);
 
    // 이 텍스처 좌표 위치에서 샘플러를 사용하여 텍스처에서 기울기 색상을 샘플링합니다. 
    slopeColor = slopeTexture.Sample(SampleType, input.tex);
 
    // 이 텍스처 좌표 위치에서 샘플러를 사용하여 텍스처에서 암색을 샘플링합니다. 
    rockColor = rockTexture.Sample(SampleType, input.tex);
 
    // 이 점의 기울기를 계산합니다.
    slope = 1.0f - input.normal.y;
 
    // 높이에 따라 사용할 텍스처를 결정합니다.
    if(slope < 0.2)
    {
        blendAmount = slope / 0.2f;
        textureColor = lerp(grassColor, slopeColor, blendAmount);
    }
    
    if((slope < 0.7) && (slope >= 0.2f))
    {
        blendAmount = (slope - 0.2f) * (1.0f / (0.7f - 0.2f));
        textureColor = lerp(slopeColor, rockColor, blendAmount);
    }
 
    if(slope >= 0.7) 
    {
        textureColor = rockColor;
    }
 
    // 계산을 위해 빛 방향을 반전시킵니다.
    lightDir = -lightDirection;
 
    // 이 픽셀의 빛의 양을 계산합니다.
    lightIntensity = saturate(dot(input.normal, lightDir));
    
    // 확산 색과 광 강도의 양에 따라 최종 확산 색을 결정합니다.
    color = diffuseColor * lightIntensity;
 
    // 최종 빛의 색상을 채웁니다.
    color = saturate(color);
 
    // 텍스쳐 색과 최종 밝은 색을 곱해서 결과를 얻는다.
    color = color * textureColor;
 
    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*, ID3D11ShaderResourceView*, 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*, ID3D11ShaderResourceView*, 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_14/terrain_vs.hlsl", L"../Dx11Terrain_14/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* grassTexture, ID3D11ShaderResourceView* slopeTexture,
                            ID3D11ShaderResourceView* rockTexture)
{
    // 렌더링에 사용할 셰이더 매개 변수를 설정합니다.
    if(!SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, ambientColor, diffuseColor,
                            lightDirection, grassTexture, slopeTexture, rockTexture))
    {
        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[3];
    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;
 
    // 레이아웃의 요소 수를 가져옵니다.
    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* grassTexture,
                                             ID3D11ShaderResourceView* slopeTexture, ID3D11ShaderResourceView* rockTexture)
{
    // 행렬을 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, &grassTexture);
    deviceContext->PSSetShaderResources(1, 1, &slopeTexture);
    deviceContext->PSSetShaderResources(2, 1, &rockTexture);
 
    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 = 32;
 
class TextureClass;
 
 
class TerrainClass
{
private:
    struct VertexType
    {
        XMFLOAT3 position;
        XMFLOAT2 texture;
        XMFLOAT3 normal;
    };
 
    struct HeightMapType 
    { 
        float x, y, z;
        float tu, tv;
        float nx, ny, nz;
    };
 
    struct VectorType 
    { 
        float x, y, z;
    };
 
public:
    TerrainClass();
    TerrainClass(const TerrainClass&);
    ~TerrainClass();
 
    bool Initialize(ID3D11Device*, const char*, const WCHAR*, const WCHAR*, const WCHAR*);
    void Shutdown();
    void Render(ID3D11DeviceContext*);
 
    int GetIndexCount();
 
    ID3D11ShaderResourceView* GetGrassTexture();
    ID3D11ShaderResourceView* GetSlopeTexture();
    ID3D11ShaderResourceView* GetRockTexture();
 
private:
    bool LoadHeightMap(const char*);
    void NormalizeHeightMap();
    bool CalculateNormals();
    void ShutdownHeightMap();
 
    void CalculateTextureCoordinates();
    bool LoadTextures(ID3D11Device*, const WCHAR*, const WCHAR*, const WCHAR*);
    void ReleaseTextures();
 
    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_GrassTexture = nullptr;
    TextureClass* m_SlopeTexture = nullptr;
    TextureClass* m_RockTexture = 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* grassTextureFilename,
                            const WCHAR* slopeTextureFilename, const WCHAR* rockTextureFilename)
{
    // 지형의 높이 맵을 로드합니다.
    if(!LoadHeightMap(heightMapFilename))
    {
        return false;
    }
 
    // 높이 맵의 높이를 표준화합니다.
    NormalizeHeightMap();
 
    // 지형 데이터의 법선을 계산합니다.
    if(!CalculateNormals())
    {
        return false;
    }
 
    // 텍스처 좌표를 계산합니다.
    CalculateTextureCoordinates();
 
    // 텍스처를 로드합니다.
    if(!LoadTextures(device, grassTextureFilename, slopeTextureFilename, rockTextureFilename))
    {
        return false;
    }
 
    // 지형에 대한 지오 메트릭을 포함하는 정점 및 인덱스 버퍼를 초기화합니다.
    return InitializeBuffers(device);
}
 
 
void TerrainClass::Shutdown()
{
    // 텍스처를 해제합니다.
    ReleaseTextures();
 
    // 버텍스와 인덱스 버퍼를 해제합니다.
    ShutdownBuffers();
 
    // 높이맵 데이터를 해제합니다.
    ShutdownHeightMap();
}
 
 
void TerrainClass::Render(ID3D11DeviceContext* deviceContext)
{
    // 그리기를 준비하기 위해 그래픽 파이프 라인에 꼭지점과 인덱스 버퍼를 놓습니다.
    RenderBuffers(deviceContext);
}
 
 
int TerrainClass::GetIndexCount()
{
    return m_indexCount;
}
 
 
ID3D11ShaderResourceView* TerrainClass::GetGrassTexture()
{
    return m_GrassTexture->GetTexture();
}
 
 
ID3D11ShaderResourceView* TerrainClass::GetSlopeTexture()
{
    return m_SlopeTexture->GetTexture();
}
 
 
ID3D11ShaderResourceView* TerrainClass::GetRockTexture()
{
    return m_RockTexture->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::LoadTextures(ID3D11Device* device, const WCHAR* grassTextureFilename, const WCHAR* slopeTextureFilename,
                                const WCHAR* rockTextureFilename)
{
    bool result;
 
 
    // 잔디 텍스처 객체를 만듭니다.
    m_GrassTexture = new TextureClass;
    if(!m_GrassTexture)
    {
        return false;
    }
 
    // 잔디 텍스처 객체를 초기화합니다.
    result = m_GrassTexture->Initialize(device, grassTextureFilename);
    if(!result)
    {
        return false;
    }
 
    // 슬로프 텍스처 객체를 만듭니다.
    m_SlopeTexture = new TextureClass;
    if(!m_SlopeTexture)
    {
        return false;
    }
 
    // 기울기 텍스처 객체를 초기화합니다.
    result = m_SlopeTexture->Initialize(device, slopeTextureFilename);
    if(!result)
    {
        return false;
    }
 
    // 바위 텍스처 객체를 만듭니다.
    m_RockTexture = new TextureClass;
    if(!m_RockTexture)
    {
        return false;
    }
 
    // 암석 텍스처 객체를 초기화합니다.
    result = m_RockTexture->Initialize(device, rockTextureFilename);
    if(!result)
    {
        return false;
    }
 
    return true;
}
 
 
void TerrainClass::ReleaseTextures()
{
    // 텍스처 객체를 해제합니다.
    if(m_GrassTexture)
    {
        m_GrassTexture->Shutdown();
        delete m_GrassTexture;
        m_GrassTexture = 0;
    }
 
    if(m_SlopeTexture)
    {
        m_SlopeTexture->Shutdown();
        delete m_SlopeTexture;
        m_SlopeTexture = 0;
    }
 
    if(m_RockTexture)
    {
        m_RockTexture->Shutdown();
        delete m_RockTexture;
        m_RockTexture = 0;
    }
}
 
 
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);
            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);
            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);
            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);
            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);
            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);
            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);
}

이 튜토리얼에서는 ApplicationClass 헤더가 수정되지 않았으므로 생략하겠습니다.

Applicationclass.cpp

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455

#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(150.0f, 2.0f, 35.0f);     m_Camera->SetPosition(camera);       // 지형 객체를 생성합니다.     m_Terrain = new TerrainClass;     if(!m_Terrain)     {         return false;     }       // 지형 객체를 초기화 합니다.     result = m_Terrain->Initialize(m_Direct3D->GetDevice(), "../Dx11Terrain_14/data/heightmap.bmp",                                      L"../Dx11Terrain_14/data/grass.dds",                                                            L"../Dx11Terrain_14/data/slope.dds",                                                             L"../Dx11Terrain_14/data/rock.dds");     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->GetGrassTexture(), m_Terrain->GetSlopeTexture(),  m_Terrain->GetRockTexture()))     {         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; } Colored by Color Scripter

cs

출력 화면

마치면서

이제 기울기에 따라 픽셀마다 자동으로 텍스처 매핑될 수 있는 지형을 출력하였습니다.

연습문제

1. 프로그램을 컴파일하고 실행하십시오. 지형을 따라 이동하여 경사에 따라 매핑된 텍스처의 효과를 확인합니다.

2. 텍스처를 변경하여 다른 지형을 만듭니다.

3. 픽셀 쉐이더에서 기울기 값을 수정하여 효과를 확인합니다. 텍스처를 빨강, 초록, 파랑과 같은 순수한 색상으로 변경하고자 할 수 있습니다.

4. 픽셀 쉐이더에서 기울기 계산에 네 번째 범위를 추가하고 다른 텍스처를 추가합니다.

소스코드

소스코드 : Dx11Terrain_14.zip