[DirectX 11] Terrain 17 - 지형 텍스처 레이어

Terrain 17 - 지형 텍스처 레이어

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

 이번 DirectX 11 지형 튜토리얼에서는 지형 텍스처 레이어 구현에 대해 설명합니다. 이 듀토리얼의 코드는 이전 지형 듀토리얼을 기반으로합니다.

픽셀 쉐이더는 엄청나게 강력한 도구로서 우리의 지형을 픽셀 단위로 볼 수 있는 방법을 완벽하게 제어 할 수 있습니다. 이 세밀한 픽셀 컨트롤을 사용하여 Photoshop에서 사용하는 것과 유사한 방법을 사용할 수 있습니다. 레이어 및 마스크. 레이어와 마스크를 사용하면 서로 위에 여러 텍스처 레이어를 칠할 수 있습니다. 이는 아티스트가 매번 다른 색상의 페인트를 적용하여 레이어별로 지형을 페인트하는 것과 같습니다.

이 개념을 설명하기 위해 먼저 지형에 대한 흙의 기본 레이어를 그려 다음 이미지를 만듭니다.

다음으로 노이즈를 사용하여 무작위로 배치 된 다른 먼지 텍스처로 첫 번째 레이어의 맨 위에 두 번째 레이어를 칠합니다.

그 후 지형 위에 모래 경로를 만들기 위해 모래 텍스처를 사용하여 수동으로 세 번째 레이어를 칠할 수 있습니다.

마지막으로 벽돌 텍스처를 사용하여 다른 네 번째 레이어를 수동으로 페인트하여 모래 경로 위에 벽돌 도로를 만듭니다.

지형에 대한 정확한 모습을 얻을 때까지 레이어를 계속 추가 할 수 있습니다. 이 모든 레이어는 텍스처 마스크라고 불리는 것을 사용하여 서로 겹쳐서 그려집니다. 텍스처 마스크는 일반적으로 아티스트가 수동으로 만들거나 노이즈 알고리즘 및 기타 렌더링 기술을 사용하여 생성 할 수 있습니다. 예를 들어 기본 레이어 위에 두 번째 레이어를 놓는 데 사용되는 첫 번째 텍스처 마스크는 다음과 같습니다.

흰색에서 검은색 값은 새 텍스처 픽셀을 이전 픽셀 위에 추가해야 하는 강도 또는 백분율 양을 나타냅니다.

모래 경로를 그리는데 사용된 두 번째 텍스처 마스크는 다음과 같습니다.

그리고 마지막으로 모래길 위에 벽돌 도로를 칠하는데 사용된 세 번째 텍스처 마스크는 다음과 같습니다.

효율성을 위해 우리는 그것들 모두를 하나의 텍스처로 묶었습니다. 첫 번째 레이어는 빨간색 채널로, 두 번째 레이어는 녹색 채널로, 세 번째 레이어는 파란색 채널로 이동했습니다. 모두 함께 볼 때 다음 이미지가 생성됩니다.

결과 지형의 오버 헤드 뷰는 다음과 같습니다.

픽셀 쉐이더에서 텍스처를 샘플링하면 빨강, 녹색, 파랑 또는 알파 채널만 빼내어 지형의 특정 레이어에 대해 픽셀 단위 텍스처 마스크로 사용하는 것이 간단합니다. 알파 블렌딩 듀토리얼과 같은 아이디어입니다. 하나의 RGBA 텍스처에 4개의 텍스처 마스크를 패키징 할 수 있습니다 (또는 더 많은 텍스처 아트라스를 사용하는 경우). 지형의 4개 레이어마다 하나의 RGBA 텍스처 마스크를 픽셀 쉐이더에 보내야합니다. 따라서 12개의 지형 레이어가 있는 경우 모든 필요한 텍스처 마스크를 픽셀 쉐이더로 보내려면 RGBA 텍스처가 3개 필요합니다.

위의 이미지에서 지형은 다른 듀토리얼보다 작음을 알 수 있습니다. 정확한 32x32 높이 맵만 사용하고 있습니다. 그 이유는 전체 지형을 32x32 섹션으로 분할해야 하기 때문입니다. 각 32x32 섹션에는 자체 텍스처 마스크가 있습니다. 이 듀토리얼에 사용된 텍스처 마스크의 해상도는 256x256 입니다. 이 크기는 너무 많은 텍스처 메모리를 사용하지 않고도 충분히 32x32를 포괄합니다. 그러나 더 작은 것은 많은 세부 사항을 포기해야 합니다.

지형을 이 섹션으로 분할하고 각 섹션에 고유한 텍스처 마스크를 지정하면 쿼드트리 구조에 잘 통합됩니다. 이제 노드는 텍스처 마스크와 관련이 있는 고정된 크기 (예: 32x32)가 됩니다. 또한 텍스처 마스크 텍스처는 쿼드가 아닌 32x32 섹션에 대한 샘플링이므로 텍스처 좌표의 두 번째 세트가 필요합니다.

참고로 이 방법을 사용하여 지형의 이 섹션에 대한 색상지도를 만들 수 있습니다. 그런 다음 세부 최적화 수준의 경우이 섹션이 카메라에서 충분히 멀리 떨어져 있는 경우 32x32 섹션의 색상맵만 렌더링하도록 전환 할 수 있습니다.

튜토리얼의 코드 섹션을 시작하기 위해 수정된 지형 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;
    float3 tangent : TANGENT;
    float3 binormal : BINORMAL;
    float2 tex2 : TEXCOORD1;
};
 
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
       float3 normal : NORMAL;
    float3 tangent : TANGENT;
    float3 binormal : BINORMAL;
    float2 tex2 : TEXCOORD1;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// 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.tex2 = input.tex2;
 
    // Calculate the normal vector against the world matrix only and then normalize the final value.
    output.normal = mul(input.normal, (float3x3)worldMatrix);
    output.normal = normalize(output.normal);
 
    // 월드 행렬에 대해서만 접선 벡터를 계산 한 다음 최종 값을 정규화합니다.
    output.tangent = mul(input.tangent, (float3x3)worldMatrix);
    output.tangent = normalize(output.tangent);
 
    // 월드 매트릭스에 대해서만 바이 노멀 벡터를 계산 한 다음 최종 값을 정규화합니다.
    output.binormal = mul(input.binormal, (float3x3)worldMatrix);
    output.binormal = normalize(output.binormal);
 
    return output;
}

Terrain_ps.hlsl

////////////////////////////////////////////////////////////////////////////////
// Filename: terrain_ps.hlsl
////////////////////////////////////////////////////////////////////////////////
 
 
//////////////
// TEXTURES //
//////////////
Texture2D colorTexture1 : register(t0);
Texture2D colorTexture2 : register(t1);
Texture2D colorTexture3 : register(t2);
Texture2D colorTexture4 : register(t3);
Texture2D alphaTexture1 : register(t4);
Texture2D normalMap1 : register(t5);
Texture2D normalMap2 : register(t6);
 
 
//////////////
// SAMPLERS //
//////////////
SamplerState SampleType;
 
 
//////////////////////
// CONSTANT BUFFERS //
//////////////////////
cbuffer LightBuffer
{
    float3 lightDirection;
    float padding;
};
 
 
//////////////
// TYPEDEFS //
//////////////
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
       float3 normal : NORMAL;
    float3 tangent : TANGENT;
    float3 binormal : BINORMAL;
    float2 tex2 : TEXCOORD1;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// Pixel Shader
////////////////////////////////////////////////////////////////////////////////
float4 TerrainPixelShader(PixelInputType input) : SV_TARGET
{
    float3 lightDir;
    float4 bumpMap;
    float3 bumpNormal;
    float lightIntensity1;
    float lightIntensity2;
    float4 textureColor1;
    float4 textureColor2;
    float4 textureColor3;
    float4 textureColor4;
    float4 alphaMap1;
    float4 baseColor;
    float4 color;
 
 
    // 계산을 위해 빛 방향을 반전시킵니다.
    lightDir = -lightDirection;
 
    // 첫 번째 법선 맵을 사용하여 첫 번째 범프 맵을 계산합니다.
    bumpMap = normalMap1.Sample(SampleType, input.tex);
    bumpMap = (bumpMap * 2.0f) - 1.0f;
    bumpNormal = input.normal + bumpMap.x * input.tangent + bumpMap.y * input.binormal;
    bumpNormal = normalize(bumpNormal);
    lightIntensity1 = saturate(dot(bumpNormal, lightDir));
 
    // 두 번째 법선 맵을 사용하여 두 번째 범프 맵을 계산합니다.
    bumpMap = normalMap2.Sample(SampleType, input.tex);
    bumpMap = (bumpMap * 2.0f) - 1.0f;
    bumpNormal = input.normal + bumpMap.x * input.tangent + bumpMap.y * input.binormal;
    bumpNormal = normalize(bumpNormal);
    lightIntensity2 = saturate(dot(bumpNormal, lightDir));
 
    // 색상 텍스처를 샘플링 합니다.
    textureColor1 = colorTexture1.Sample(SampleType, input.tex);
    textureColor2 = colorTexture2.Sample(SampleType, input.tex);
    textureColor3 = colorTexture3.Sample(SampleType, input.tex);
    textureColor4 = colorTexture4.Sample(SampleType, input.tex);
 
    // 각각의 텍스처에 범프 맵을 추가합니다.
    textureColor1 = saturate(lightIntensity1 * textureColor1);
    textureColor2 = saturate(lightIntensity1 * textureColor2);
    textureColor3 = saturate(lightIntensity1 * textureColor3);
    textureColor4 = saturate(lightIntensity2 * textureColor4);
 
    // 텍스처 좌표의 두 번째 세트를 사용하여 알파 맵을 샘플링합니다.
    alphaMap1 = alphaTexture1.Sample(SampleType, input.tex2);
 
    // 기본 색상을 첫 번째 색상 텍스처로 설정합니다.
    baseColor = textureColor1;
 
    // 알파 맵의 빨강 채널을 사용하여 두 번째 레이어를 추가합니다.
    color = lerp(baseColor, textureColor2, alphaMap1.r);
 
    // 알파 맵의 녹색 채널을 사용하여 세 번째 레이어를 추가합니다.
    color = lerp(color, textureColor3, alphaMap1.g);
 
    // 알파 맵의 파란색 채널을 사용하여 네 번째 레이어를 추가합니다.
    color = lerp(color, textureColor4, alphaMap1.b);
    
    return color;
}

Terrainshaderclass.h

#pragma once
 
class TerrainShaderClass : public AlignedAllocationPolicy<16>
{
private:
    struct MatrixBufferType
    {
        XMMATRIX world;
        XMMATRIX view;
        XMMATRIX projection;
    };
 
    struct LightBufferType
    {
        XMFLOAT3 lightDirection;
        float padding;
    };
 
public:
    TerrainShaderClass();
    TerrainShaderClass(const TerrainShaderClass&);
    ~TerrainShaderClass();
 
    bool Initialize(ID3D11Device*, HWND);
    void Shutdown();
    bool Render(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX, XMFLOAT3, ID3D11ShaderResourceView*,
                ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*,
                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, XMFLOAT3, ID3D11ShaderResourceView*,
                             ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, 
                             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_17/terrain_vs.hlsl", L"../Dx11Terrain_17/terrain_ps.hlsl");
}
 
 
void TerrainShaderClass::Shutdown()
{
    // 버텍스 및 픽셀 쉐이더와 관련된 객체를 종료합니다.
    ShutdownShader();
}
 
 
bool TerrainShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX worldMatrix, XMMATRIX viewMatrix,
                                XMMATRIX projectionMatrix, XMFLOAT3 lightDirection, ID3D11ShaderResourceView* colorTexture1,
                                ID3D11ShaderResourceView* colorTexture2, ID3D11ShaderResourceView* colorTexture3,
\                               ID3D11ShaderResourceView* colorTexture4, ID3D11ShaderResourceView* alphaTexture1,
                                ID3D11ShaderResourceView* normalMap1, ID3D11ShaderResourceView* normalMap2)
{
    // 렌더링에 사용할 셰이더 매개 변수를 설정합니다.
    if(!SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, lightDirection, colorTexture1,
                            colorTexture2, colorTexture3, colorTexture4, alphaTexture1, normalMap1, normalMap2))
    {
        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[6];
    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 = "TANGENT";
    polygonLayout[3].SemanticIndex = 0;
    polygonLayout[3].Format = DXGI_FORMAT_R32G32B32_FLOAT;
    polygonLayout[3].InputSlot = 0;
    polygonLayout[3].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[3].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[3].InstanceDataStepRate = 0;
 
    polygonLayout[4].SemanticName = "BINORMAL";
    polygonLayout[4].SemanticIndex = 0;
    polygonLayout[4].Format = DXGI_FORMAT_R32G32B32_FLOAT;
    polygonLayout[4].InputSlot = 0;
    polygonLayout[4].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[4].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[4].InstanceDataStepRate = 0;
 
    polygonLayout[5].SemanticName = "TEXCOORD";
    polygonLayout[5].SemanticIndex = 1;
    polygonLayout[5].Format = DXGI_FORMAT_R32G32_FLOAT;
    polygonLayout[5].InputSlot = 0;
    polygonLayout[5].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[5].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[5].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_CLAMP;
    samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
    samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
    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, XMFLOAT3 lightDirection, ID3D11ShaderResourceView* colorTexture1,
                                ID3D11ShaderResourceView* colorTexture2, ID3D11ShaderResourceView* colorTexture3, 
                                ID3D11ShaderResourceView* colorTexture4, ID3D11ShaderResourceView* alphaTexture1,
                                ID3D11ShaderResourceView* normalMap1, ID3D11ShaderResourceView* normalMap2)
{
    // 행렬을 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->lightDirection = lightDirection;
    dataPtr2->padding = 0.0f;
 
    // 상수 버퍼의 잠금을 해제합니다.
    deviceContext->Unmap(m_lightBuffer, 0);
 
    // 픽셀 쉐이더에서 광원 상수 버퍼의 위치를 ​​설정합니다.
    bufferNumber = 0;
 
    // 마지막으로 업데이트 된 값으로 픽셀 쉐이더에서 광원 상수 버퍼를 설정합니다.
    deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_lightBuffer);
 
    // 셰이더 텍스처 리소스를 픽셀 셰이더에 설정합니다.
    deviceContext->PSSetShaderResources(0, 1, &colorTexture1);
    deviceContext->PSSetShaderResources(1, 1, &colorTexture2);
    deviceContext->PSSetShaderResources(2, 1, &colorTexture3);
    deviceContext->PSSetShaderResources(3, 1, &colorTexture4);
    deviceContext->PSSetShaderResources(4, 1, &alphaTexture1);
    deviceContext->PSSetShaderResources(5, 1, &normalMap1);
    deviceContext->PSSetShaderResources(6, 1, &normalMap2);
 
    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
 
 
 
class TerrainClass
{
private:
    struct HeightMapType 
    { 
        float x, y, z;
        float nx, ny, nz;
    };
 
    struct VectorType 
    { 
        float x, y, z;
    };
 
    struct ModelType 
    { 
        float x, y, z;
        float tu, tv;
        float nx, ny, nz;
        float tx, ty, tz;
        float bx, by, bz;
        float tu2, tv2;
    };
 
    struct TempVertexType
    {
        float x, y, z;
        float tu, tv;
        float nx, ny, nz;
    };
 
    struct VertexType
    {
        XMFLOAT3 position;
        XMFLOAT2 texture;
        XMFLOAT3 normal;
        XMFLOAT3 tangent;
        XMFLOAT3 binormal;
        XMFLOAT2 texture2;
    };
    
public:
    TerrainClass();
    TerrainClass(const TerrainClass&);
    ~TerrainClass();
 
    bool Initialize(ID3D11Device*, const char*, float);
    void Shutdown();
    void Render(ID3D11DeviceContext*);
 
    int GetIndexCount();
 
private:
    bool LoadHeightMap(const char*);
    void ReduceHeightMap(float);
    bool CalculateNormals();
    bool BuildModel();
    void CalculateModelVectors();
    void CalculateTangentBinormal(TempVertexType, TempVertexType, TempVertexType, VectorType&, VectorType&);
    bool InitializeBuffers(ID3D11Device*);
 
    void ReleaseHeightMap();
    void ReleaseModel();
    void ReleaseBuffers();
 
    void RenderBuffers(ID3D11DeviceContext*);
 
private:
    int m_terrainWidth = 0;
    int m_terrainHeight = 0;
    int m_vertexCount = 0;
    int m_indexCount = 0;
    HeightMapType* m_heightMap = nullptr;
    ModelType* m_model = nullptr;
    ID3D11Buffer *m_vertexBuffer = nullptr;
    ID3D11Buffer *m_indexBuffer = 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, float maximumHeight)
{
    // 지형의 높이 맵을 로드합니다.
    if(!LoadHeightMap(heightMapFilename))
    {
        return false;
    }
 
    // 높이 맵의 높이를 줄입니다.
    ReduceHeightMap(maximumHeight);
 
    // 지형 데이터의 법선을 계산합니다.
    if(!CalculateNormals())
    {
        return false;
    }
 
    // 높이 맵과 일반 데이터로 3D 모델을 만듭니다.
    if(!BuildModel())
    {
        return false;
    }
 
    // 지형 모델의 법선 벡터, 접선 벡터 및 바이 노멀 벡터를 계산합니다.
    CalculateModelVectors();
 
    // 지형에 대한 정점 및 인덱스 버퍼를 초기화합니다.
    if(!InitializeBuffers(device))
    {
        return false;
    }
 
    // 이제 데이터가 정점 버퍼와 인덱스 버퍼에 로드되므로 높이 맵과 모델을 해제합니다.
    ReleaseHeightMap();
    ReleaseModel();
 
    return true;
}
 
 
void TerrainClass::Shutdown()
{
    // 버퍼를 해제합니다.
    ReleaseBuffers();
 
    // 모델을 해제합니다.
    ReleaseModel();
 
    // 높이 맵을 해제합니다.
    ReleaseHeightMap();
}
 
 
void TerrainClass::Render(ID3D11DeviceContext* deviceContext)
{
    // 그리기를 준비하기 위해 그래픽 파이프 라인에 꼭지점과 인덱스 버퍼를 놓습니다.
    RenderBuffers(deviceContext);
}
 
 
int TerrainClass::GetIndexCount()
{
    return m_indexCount;
}
 
 
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_terrainWidth * 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::ReduceHeightMap(float value)
{
    for(int j=0; j<m_terrainHeight; j++)
    {
        for(int i=0; i<m_terrainWidth; i++)
        {
            m_heightMap[(m_terrainWidth * j) + i].y /= value;
        }
    }
}
 
 
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_terrainWidth) + i;
            index2 = (j * m_terrainWidth) + (i+1);
            index3 = ((j+1) * m_terrainWidth) + 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_terrainWidth-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_terrainWidth-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_terrainWidth-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_terrainWidth-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_terrainWidth-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_terrainWidth) + 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;
}
 
 
bool TerrainClass::BuildModel()
{
    int index1 = 0;
    int index2 = 0;
    int index3 = 0;
    int index4 = 0;
 
    // 모델의 정점 수를 설정합니다.
    m_vertexCount = (m_terrainWidth - 1) * (m_terrainHeight - 1) * 6;
 
    // 지형 모델 배열을 만듭니다.
    m_model = new ModelType[m_vertexCount];
    if(!m_model)
    {
        return false;
    }
 
    // 텍스처의 두 번째 세트 (알파 맵)의 증가 크기를 설정합니다.
    float incrementSize = 1.0f / 31.0f;
 
    // 텍스처 증가를 초기화합니다.
    float tu2Left = 0.0f;
    float tu2Right = incrementSize;
    float tv2Bottom = 1.0f;
    float tv2Top = 1.0f - incrementSize;
    
    // 높이 맵 지형 데이터로 지형 모델을 로드합니다.
    int index = 0;
 
    for(int j=0; j<(m_terrainHeight-1); j++)
    {
        for(int i=0; i<(m_terrainWidth-1); i++)
        {
            index1 = (m_terrainWidth * j) + i;          // 왼쪽 아래.
            index2 = (m_terrainWidth * j) + (i+1);      // 오른쪽 아래.
            index3 = (m_terrainWidth * (j+1)) + i;      // 왼쪽 위.
            index4 = (m_terrainWidth * (j+1)) + (i+1);  // 오른쪽 위.
 
            // 왼쪽 위.
            m_model[index].x  = m_heightMap[index3].x;
            m_model[index].y  = m_heightMap[index3].y;
            m_model[index].z  = m_heightMap[index3].z;
            m_model[index].nx = m_heightMap[index3].nx;
            m_model[index].ny = m_heightMap[index3].ny;
            m_model[index].nz = m_heightMap[index3].nz;
            m_model[index].tu = 0.0f;
            m_model[index].tv = 0.0f;
            m_model[index].tu2 = tu2Left;
            m_model[index].tv2 = tv2Top;
            index++;
 
            // 오른쪽 위.
            m_model[index].x  = m_heightMap[index4].x;
            m_model[index].y  = m_heightMap[index4].y;
            m_model[index].z  = m_heightMap[index4].z;
            m_model[index].nx = m_heightMap[index4].nx;
            m_model[index].ny = m_heightMap[index4].ny;
            m_model[index].nz = m_heightMap[index4].nz;
            m_model[index].tu = 1.0f;
            m_model[index].tv = 0.0f;
            m_model[index].tu2 = tu2Right;
            m_model[index].tv2 = tv2Top;
            index++;
 
            // 왼쪽 아래.
            m_model[index].x  = m_heightMap[index1].x;
            m_model[index].y  = m_heightMap[index1].y;
            m_model[index].z  = m_heightMap[index1].z;
            m_model[index].nx = m_heightMap[index1].nx;
            m_model[index].ny = m_heightMap[index1].ny;
            m_model[index].nz = m_heightMap[index1].nz;
            m_model[index].tu = 0.0f;
            m_model[index].tv = 1.0f;
            m_model[index].tu2 = tu2Left;
            m_model[index].tv2 = tv2Bottom;
            index++;
 
            // 왼쪽 아래.
            m_model[index].x  = m_heightMap[index1].x;
            m_model[index].y  = m_heightMap[index1].y;
            m_model[index].z  = m_heightMap[index1].z;
            m_model[index].nx = m_heightMap[index1].nx;
            m_model[index].ny = m_heightMap[index1].ny;
            m_model[index].nz = m_heightMap[index1].nz;
            m_model[index].tu = 0.0f;
            m_model[index].tv = 1.0f;
            m_model[index].tu2 = tu2Left;
            m_model[index].tv2 = tv2Bottom;
            index++;
 
            // 오른쪽 위.
            m_model[index].x  = m_heightMap[index4].x;
            m_model[index].y  = m_heightMap[index4].y;
            m_model[index].z  = m_heightMap[index4].z;
            m_model[index].nx = m_heightMap[index4].nx;
            m_model[index].ny = m_heightMap[index4].ny;
            m_model[index].nz = m_heightMap[index4].nz;
            m_model[index].tu = 1.0f;
            m_model[index].tv = 0.0f;
            m_model[index].tu2 = tu2Right;
            m_model[index].tv2 = tv2Top;
            index++;
 
            // 오른쪽 아래.
            m_model[index].x  = m_heightMap[index2].x;
            m_model[index].y  = m_heightMap[index2].y;
            m_model[index].z  = m_heightMap[index2].z;
            m_model[index].nx = m_heightMap[index2].nx;
            m_model[index].ny = m_heightMap[index2].ny;
            m_model[index].nz = m_heightMap[index2].nz;
            m_model[index].tu = 1.0f;
            m_model[index].tv = 1.0f;
            m_model[index].tu2 = tu2Right;
            m_model[index].tv2 = tv2Bottom;
            index++;
 
            // 알파 맵에 대해 tu 텍스처 좌표를 증가시킵니다.
            tu2Left += incrementSize;
            tu2Right += incrementSize;
        }
 
        // 알파 맵에 대해 tu 텍스처 좌표를 재설정합니다.
        tu2Left = 0.0f;
        tu2Right = incrementSize;
 
        // 알파 맵의 tv 텍스처 좌표를 증가시킵니다.
        tv2Top -= incrementSize;
        tv2Bottom -= incrementSize;
    }
 
    return true;
}
 
 
void TerrainClass::CalculateModelVectors()
{
    TempVertexType vertex1, vertex2, vertex3;
    VectorType tangent, binormal;
 
 
    // 지형 모델에서면의 수를 계산합니다.
    int faceCount = m_vertexCount / 3;
 
    // 모델 데이터에 대한 인덱스를 초기화합니다.
    int index = 0;
 
    // 모든면을 살펴보고 접선, 비공식 및 법선 벡터를 계산합니다.
    for(int i=0; i<faceCount; i++)
    {
        // 지형 모델에서이면에 대한 세 개의 정점을 가져옵니다.
        vertex1.x  = m_model[index].x;
        vertex1.y  = m_model[index].y;
        vertex1.z  = m_model[index].z;
        vertex1.tu = m_model[index].tu;
        vertex1.tv = m_model[index].tv;
        vertex1.nx = m_model[index].nx;
        vertex1.ny = m_model[index].ny;
        vertex1.nz = m_model[index].nz;
        index++;
 
        vertex2.x  = m_model[index].x;
        vertex2.y  = m_model[index].y;
        vertex2.z  = m_model[index].z;
        vertex2.tu = m_model[index].tu;
        vertex2.tv = m_model[index].tv;
        vertex2.nx = m_model[index].nx;
        vertex2.ny = m_model[index].ny;
        vertex2.nz = m_model[index].nz;
        index++;
 
        vertex3.x  = m_model[index].x;
        vertex3.y  = m_model[index].y;
        vertex3.z  = m_model[index].z;
        vertex3.tu = m_model[index].tu;
        vertex3.tv = m_model[index].tv;
        vertex3.nx = m_model[index].nx;
        vertex3.ny = m_model[index].ny;
        vertex3.nz = m_model[index].nz;
        index++;
 
        // 그 얼굴의 탄젠트와 바이 노멀을 계산합니다.
        CalculateTangentBinormal(vertex1, vertex2, vertex3, tangent, binormal);
 
        // 이면에 대한 접선과 binormal을 모델 구조에 다시 저장하십시오.
        m_model[index-1].tx = tangent.x;
        m_model[index-1].ty = tangent.y;
        m_model[index-1].tz = tangent.z;
        m_model[index-1].bx = binormal.x;
        m_model[index-1].by = binormal.y;
        m_model[index-1].bz = binormal.z;
 
        m_model[index-2].tx = tangent.x;
        m_model[index-2].ty = tangent.y;
        m_model[index-2].tz = tangent.z;
        m_model[index-2].bx = binormal.x;
        m_model[index-2].by = binormal.y;
        m_model[index-2].bz = binormal.z;
 
        m_model[index-3].tx = tangent.x;
        m_model[index-3].ty = tangent.y;
        m_model[index-3].tz = tangent.z;
        m_model[index-3].bx = binormal.x;
        m_model[index-3].by = binormal.y;
        m_model[index-3].bz = binormal.z;
    }
}
 
 
void TerrainClass::CalculateTangentBinormal(TempVertexType vertex1, TempVertexType vertex2, TempVertexType vertex3,
                                            VectorType& tangent, VectorType& binormal)
{
    float vector1[3] = { 0.0f, 0.0f, 0.0f };
    float vector2[3] = { 0.0f, 0.0f, 0.0f };
    float tuVector[2] = { 0.0f, 0.0f };
    float tvVector[2] = { 0.0f, 0.0f };
 
 
    // 이면의 두 벡터를 계산합니다.
    vector1[0] = vertex2.x - vertex1.x;
    vector1[1] = vertex2.y - vertex1.y;
    vector1[2] = vertex2.z - vertex1.z;
 
    vector2[0] = vertex3.x - vertex1.x;
    vector2[1] = vertex3.y - vertex1.y;
    vector2[2] = vertex3.z - vertex1.z;
 
    // tu 및 tv 텍스처 공간 벡터를 계산합니다.
    tuVector[0] = vertex2.tu - vertex1.tu;
    tvVector[0] = vertex2.tv - vertex1.tv;
 
    tuVector[1] = vertex3.tu - vertex1.tu;
    tvVector[1] = vertex3.tv - vertex1.tv;
 
    // 탄젠트 / 바이 노멀 방정식의 분모를 계산합니다.
    float den = 1.0f / (tuVector[0] * tvVector[1] - tuVector[1] * tvVector[0]);
 
    // 교차 곱을 계산하고 계수로 곱하여 접선과 비 구식을 얻습니다.
    tangent.x = (tvVector[1] * vector1[0] - tvVector[0] * vector2[0]) * den;
    tangent.y = (tvVector[1] * vector1[1] - tvVector[0] * vector2[1]) * den;
    tangent.z = (tvVector[1] * vector1[2] - tvVector[0] * vector2[2]) * den;
 
    binormal.x = (tuVector[0] * vector2[0] - tuVector[1] * vector1[0]) * den;
    binormal.y = (tuVector[0] * vector2[1] - tuVector[1] * vector1[1]) * den;
    binormal.z = (tuVector[0] * vector2[2] - tuVector[1] * vector1[2]) * den;
 
    // 이 법선의 길이를 계산합니다.
    float length = (float)sqrt((tangent.x * tangent.x) + (tangent.y * tangent.y) + (tangent.z * tangent.z));
            
    // 법선을 표준화 한 다음 저장합니다.
    tangent.x = tangent.x / length;
    tangent.y = tangent.y / length;
    tangent.z = tangent.z / length;
 
    // 이 법선의 길이를 계산합니다.
    length = (float)sqrt((binormal.x * binormal.x) + (binormal.y * binormal.y) + (binormal.z * binormal.z));
            
    // 법선을 표준화 한 다음 저장합니다.
    binormal.x = binormal.x / length;
    binormal.y = binormal.y / length;
    binormal.z = binormal.z / length;
}
 
 
bool TerrainClass::InitializeBuffers(ID3D11Device* device)
{
    // 인덱스 수를 꼭지점 수와 같게 설정합니다.
    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;
    }
 
    // 지형 모델의 데이터로 정점 및 인덱스 배열을 로드합니다.
    for(int i=0; i<m_vertexCount; i++)
    {
        vertices[i].position = XMFLOAT3(m_model[i].x, m_model[i].y, m_model[i].z);
        vertices[i].texture = XMFLOAT2(m_model[i].tu, m_model[i].tv);
        vertices[i].normal = XMFLOAT3(m_model[i].nx, m_model[i].ny, m_model[i].nz);
        vertices[i].tangent = XMFLOAT3(m_model[i].tx, m_model[i].ty, m_model[i].tz);
        vertices[i].binormal = XMFLOAT3(m_model[i].bx, m_model[i].by, m_model[i].bz);
        vertices[i].texture2 = XMFLOAT2(m_model[i].tu2, m_model[i].tv2);
 
        indices[i] = i;
    }
 
    // 정적 정점 버퍼의 설명을 설정한다.
    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::ReleaseHeightMap()
{
    if(m_heightMap)
    {
        delete [] m_heightMap;
        m_heightMap = 0;
    }
}
 
 
void TerrainClass::ReleaseModel()
{
    if(m_model)
    {
        delete [] m_model;
        m_model = 0;
    }
}
 
 
void TerrainClass::ReleaseBuffers()
{
    // 인덱스 버퍼를 해제합니다.
    if (m_indexBuffer)
    {
        m_indexBuffer->Release();
        m_indexBuffer = 0;
    }
 
    // 버텍스 버퍼를 해제합니다.
    if(m_vertexBuffer)
    {
        m_vertexBuffer->Release();
        m_vertexBuffer = 0;
    }
}
 
 
void TerrainClass::RenderBuffers(ID3D11DeviceContext* deviceContext)
{
    // 정점 버퍼 보폭 및 오프셋을 설정합니다.
    UINT stride = sizeof(VertexType);
    UINT 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.h

#pragma once
 
/////////////
// GLOBALS //
/////////////
const bool FULL_SCREEN = false;
const bool VSYNC_ENABLED = true;
const float SCREEN_DEPTH = 1000.0f;
const float SCREEN_NEAR = 0.1f;
 
 
class InputClass;
class D3DClass;
class TimerClass;
class PositionClass;
class CameraClass;
class LightClass;
class TerrainClass;
class TerrainShaderClass;
class TextureClass;
 
 
class ApplicationClass
{
public:
    ApplicationClass();
    ApplicationClass(const ApplicationClass&);
    ~ApplicationClass();
 
    bool Initialize(HINSTANCE, HWND, int, int);
    void Shutdown();
    bool Frame();
 
private:
    bool HandleMovementInput(float);
    bool Render();
 
private:
    InputClass* m_Input = nullptr;
    D3DClass* m_Direct3D = nullptr;
    TimerClass* m_Timer = nullptr;
    PositionClass* m_Position = nullptr;
    CameraClass* m_Camera = nullptr;
    LightClass* m_Light = nullptr;
    TerrainClass* m_Terrain = nullptr;
    TerrainShaderClass* m_TerrainShader = nullptr;
 
    TextureClass *m_ColorTexture1 = nullptr;
    TextureClass *m_ColorTexture2 = nullptr;
    TextureClass *m_ColorTexture3 = nullptr;
    TextureClass *m_ColorTexture4 = nullptr;
    TextureClass *m_AlphaTexture1 = nullptr;
    TextureClass *m_NormalTexture1 = nullptr;
    TextureClass *m_NormalTexture2 = nullptr;
};

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

#include "stdafx.h" #include "inputclass.h" #include "d3dclass.h" #include "timerclass.h" #include "positionclass.h" #include "cameraclass.h" #include "lightclass.h" #include "terrainclass.h" #include "terrainshaderclass.h" #include "textureclass.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_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(XMFLOAT3(14.0f, 13.0f, 10.0f));     m_Position->SetRotation(XMFLOAT3(25.0f, 0.0f, 0.0f));          // 카메라 객체를 생성합니다.     m_Camera = new CameraClass;     if(!m_Camera)     {         return false;     }       // 조명 객체를 생성합니다.     m_Light = new LightClass;     if(!m_Light)     {         return false;     }       // 조명 객체를 초기화 합니다.     m_Light->SetDirection(XMFLOAT3(0.5f, -0.75f, 0.0f));          // 지형 객체를 생성합니다.     m_Terrain = new TerrainClass;     if(!m_Terrain)     {         return false;     }       // 지형 객체를 초기화 합니다.     result = m_Terrain->Initialize(m_Direct3D->GetDevice(), "../Dx11Terrain_17/data/hm.bmp", 10.0f);     if(!result)     {         MessageBox(hwnd, L"Could not initialize the terrain 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;     }          // Create the first color texture object.     m_ColorTexture1 = new TextureClass;     if(!m_ColorTexture1)     {         return false;     }       // Load the first color texture object.     result = m_ColorTexture1->Initialize(m_Direct3D->GetDevice(), L"../Dx11Terrain_17/data/dirt001.dds");     if(!result)     {         return false;     }       // Create the second color texture object.     m_ColorTexture2 = new TextureClass;     if(!m_ColorTexture2)     {         return false;     }       // Load the second color texture object.     result = m_ColorTexture2->Initialize(m_Direct3D->GetDevice(), L"../Dx11Terrain_17/data/dirt004.dds");     if(!result)     {         return false;     }       // Create the third color texture object.     m_ColorTexture3 = new TextureClass;     if(!m_ColorTexture3)     {         return false;     }       // Load the third color texture object.     result = m_ColorTexture3->Initialize(m_Direct3D->GetDevice(), L"../Dx11Terrain_17/data/dirt002.dds");     if(!result)     {         return false;     }       // Create the fourth color texture object.     m_ColorTexture4 = new TextureClass;     if(!m_ColorTexture4)     {         return false;     }       // Load the fourth color texture object.     result = m_ColorTexture4->Initialize(m_Direct3D->GetDevice(), L"../Dx11Terrain_17/data/stone001.dds");     if(!result)     {         return false;     }       // Create the first alpha texture object.     m_AlphaTexture1 = new TextureClass;     if(!m_AlphaTexture1)     {         return false;     }       // Load the first alpha texture object.     result = m_AlphaTexture1->Initialize(m_Direct3D->GetDevice(), L"../Dx11Terrain_17/data/alpha001.dds");     if(!result)     {         return false;     }       // Create the first normal texture object.     m_NormalTexture1 = new TextureClass;     if(!m_NormalTexture1)     {         return false;     }       // Load the first alpha texture object.     result = m_NormalTexture1->Initialize(m_Direct3D->GetDevice(), L"../Dx11Terrain_17/data/normal001.dds");     if(!result)     {         return false;     }       // Create the second normal texture object.     m_NormalTexture2 = new TextureClass;     if(!m_NormalTexture2)     {         return false;     }       // Load the second alpha texture object.     result = m_NormalTexture2->Initialize(m_Direct3D->GetDevice(), L"../Dx11Terrain_17/data/normal002.dds");     if(!result)     {         return false;     }       return true; }     void ApplicationClass::Shutdown() {     // Release the texture objects.     if(m_ColorTexture1)     {         m_ColorTexture1->Shutdown();         delete m_ColorTexture1;         m_ColorTexture1 = 0;     }       if(m_ColorTexture2)     {         m_ColorTexture2->Shutdown();         delete m_ColorTexture2;         m_ColorTexture2 = 0;     }       if(m_ColorTexture3)     {         m_ColorTexture3->Shutdown();         delete m_ColorTexture3;         m_ColorTexture3 = 0;     }       if(m_ColorTexture4)     {         m_ColorTexture4->Shutdown();         delete m_ColorTexture4;         m_ColorTexture4 = 0;     }       if(m_AlphaTexture1)     {         m_AlphaTexture1->Shutdown();         delete m_AlphaTexture1;         m_AlphaTexture1 = 0;     }       if(m_NormalTexture1)     {         m_NormalTexture1->Shutdown();         delete m_NormalTexture1;         m_NormalTexture1 = 0;     }       if(m_NormalTexture2)     {         m_NormalTexture2->Shutdown();         delete m_NormalTexture2;         m_NormalTexture2 = 0;     }       // 지형 셰이더 객체를 해제합니다.     if(m_TerrainShader)     {         m_TerrainShader->Shutdown();         delete m_TerrainShader;         m_TerrainShader = 0;     }       // 지형 객체를 해제합니다.     if(m_Terrain)     {         m_Terrain->Shutdown();         delete m_Terrain;         m_Terrain = 0;     }          // 조명 객체를 해제합니다.     if(m_Light)     {         delete m_Light;         m_Light = 0;     }       // 카메라 객체를 해제합니다.     if(m_Camera)     {         delete m_Camera;         m_Camera = 0;     }          // 위치 객체를 해제합니다.     if(m_Position)     {         delete m_Position;         m_Position = 0;     }       // 타이머 객체를 해제합니다.     if(m_Timer)     {         delete m_Timer;         m_Timer = 0;     }       // Direct3D 객체를 해제합니다.     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() {     // 시스템 통계를 업데이트 합니다.     m_Timer->Frame();       // 사용자 입력을 읽습니다.     bool result = m_Input->Frame();     if(!result)     {         return false;     }          // 사용자가 ESC를 눌렀을 때 응용 프로그램을 종료 할 것인지 확인합니다.     if(m_Input->IsEscapePressed() == true)     {         return false;     }       // 프레임 입력 처리를 수행합니다.     result = HandleMovementInput(m_Timer->GetTime());     if(!result)     {         return false;     }       // 그래픽을 렌더링합니다.     return Render(); }     bool ApplicationClass::HandleMovementInput(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);       return true;   }     bool ApplicationClass::Render() {     XMMATRIX worldMatrix, viewMatrix, projectionMatrix;       // 장면을 지웁니다.     m_Direct3D->BeginScene(0.0f, 0.0f, 0.0f, 1.0f);       // 카메라의 위치에 따라 뷰 행렬을 생성합니다.     m_Camera->Render();       // 카메라, Direct3D 객체로부터 월드, 뷰, 프로젝션, 오쏘,베이스 뷰 매트릭스를 가져옵니다.     m_Direct3D->GetWorldMatrix(worldMatrix);     m_Camera->GetViewMatrix(viewMatrix);     m_Direct3D->GetProjectionMatrix(projectionMatrix);       // 지형 셰이더를 사용하여 지형을 렌더링합니다.     m_Terrain->Render(m_Direct3D->GetDeviceContext());          if(!m_TerrainShader->Render(m_Direct3D->GetDeviceContext(), m_Terrain->GetIndexCount(), worldMatrix, viewMatrix,  projectionMatrix, m_Light->GetDirection(), m_ColorTexture1->GetTexture(),                                  m_ColorTexture2->GetTexture(), m_ColorTexture3->GetTexture(), m_ColorTexture4->GetTexture(),  m_AlphaTexture1->GetTexture(), m_NormalTexture1->GetTexture(),  m_NormalTexture2->GetTexture()))     {         return false;     }       // 렌더링 된 장면을 화면에 표시합니다.     m_Direct3D->EndScene();       return true; } Colored by Color Scripter

cs

출력 화면

마치면서

이제 레이어 렌더링이 픽셀 단위로 제어되는 다중 레이어 지형을 갖게 되었습니다.

연습문제

1. 프로그램을 컴파일하고 실행하십시오. 화살표 키 A, Z, PgUp 및 PgDn을 사용하여 주위를 이동하십시오. 종료하려면 ESC 키를 누릅니다.

2. alpha001.dds 텍스처의 빨강, 녹색 및 파랑 채널을 수정하여 지형에 미치는 영향을 확인합니다.

3. 지형에 다섯 번째 레이어를 추가합니다. 새 텍스처 마스크 레이어를 alpha001.dds 텍스처의 알파 채널에 배치합니다.

4. 고유한 텍스처 레이어 마스크 및 지형 텍스처를 만들어 다른 지형 장면을 만듭니다.

5. 여러 레이어를 함께 렌더링할 때 생성되는 차이를 확인하려면 텍스처 레이어 마스크에 대해 다른 해상도를 사용해 보십시오.

6. 지형 섹션을 지형 노드로 수정합니다. 그런 다음 4 개의 지형 노드를 로드하고 (현재는 각각 동일한 텍스처와 마스크가 될 수 있음) 가시성을 기준으로 렌더링합니다 (쿼드 트리 듀토리얼에서 이것이 어떻게 작동하는지에 대한 일반적인 설명을 참조하십시오. 그러나 수정해야 함을 유의하십시오.) 이것이 올바르게 작동하려면).

7. 이 기술을 사용하여 각 섹션에 대한 색상 맵을 만든 다음 카메라가 없는 섹션을 색상맵으로 렌더링하는 간단한 수준의 상세 시스템을 만듭니다.

소스코드

소스코드 : Dx11Terrain_17.zip