[DirectX 11] Terrain 12 - 혼합 구름 효과

Terrain 12 - 혼합 구름 효과

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

 이번 DirectX 11 지형 튜토리얼은 이전 비트맵 구름 듀토리얼을 기반으로 합니다. 우리는 혼합된 구름을 구현하기 위해 앞의 튜토리얼 코드를 약간 수정합니다. DirectX 11 Basic 강좌란의 [DirectX11] Tutorial 33 - 불효과(http://copynull.tistory.com/284) 튜토리얼을 살펴보고 이해했다면 이번 듀토리얼은 이해하기 아주 쉬울 것입니다. 그러나 셰이더 작동 방식에 대한 구체적인 부분을 공부하고 싶다면 해당 듀토리얼을 먼저 읽어보는 것이 좋습니다.

이전 튜토리얼에서는 두 개의 구름 텍스처를 사용하여 하늘 평면을 따라 다른 속도로 스크롤하여 기본적인 구름이 흘러가는 시스템을 시뮬레이션 했습니다. 그러나 구름이 하늘을 지나감에 따라 그들의 형성은 약간 수정됩니다. 따라서 이 튜토리얼에서는 단일 구름 텍스처를 사용하지만 2 차 노이즈 텍스처로 텍스처 샘플링을 혼합합니다. 우리가 구름을 샘플링하는 곳에서 약간 오프셋함으로써 하늘의 면 위로 움직일 때 구름의 가장자리와 내부가 팽창하고 붕괴되는 효과를 줍니다.

우리가 사용할 비트 맵 구름 텍스처는 다음과 같습니다.

그런 다음 perturbed 샘플링에 perlin 스타일 노이즈 텍스처를 사용합니다.

우리가 구름 텍스쳐를 샘플링하는 곳에서 노이즈 텍스쳐를 혼합된 좌표로 사용하는 것을 상쇄함으로써, 하늘 표면 모델 위로 스크롤 할 때 구름의 형성을 변화시키는 원하는 효과를 얻을 수 있습니다.

Skyplane_vs.hlsl

////////////////////////////////////////////////////////////////////////////////
// Filename: skyplane_vs.hlsl
////////////////////////////////////////////////////////////////////////////////
 
 
/////////////
// GLOBALS //
/////////////
cbuffer MatrixBuffer
{
    matrix worldMatrix;
    matrix viewMatrix;
    matrix projectionMatrix;
};
 
 
//////////////
// TYPEDEFS //
//////////////
struct VertexInputType
{
    float4 position : POSITION;
    float2 tex : TEXCOORD0;
};
 
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// Vertex Shader
////////////////////////////////////////////////////////////////////////////////
PixelInputType SkyPlaneVertexShader(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;
    
    return output;
}

픽셀 쉐이더는 이 튜토리얼에서 모든 작업을 수행하여 혼합된 구름 효과를 만듭니다. 이제 셰이더는 구름과 노이즈 텍스처를 입력 텍스처로 사용합니다. 우리가 하나의 클라우드 레이어만 처리하기 때문에 하늘 상수 버퍼도 수정되었습니다. 셰이더 자체에서 노이즈 텍스처를 샘플링하여 시작하여 구름 텍스처의 샘플링을 오프셋하는데 사용하는 기본 섭동 값을 얻습니다. 그런 다음 이를 퍼터 스케일로 곱하고 텍스처 좌표를 추가합니다. 이것은 구름 텍스처를 샘플링하는 좌표를 줍니다. 두 가지 모두 상수 버퍼의 변환 값으로 변환되어 스크롤 효과를 만듭니다.

Skyplane_ps.hlsl

////////////////////////////////////////////////////////////////////////////////
// Filename: skyplane_ps.hlsl
////////////////////////////////////////////////////////////////////////////////
 
 
/////////////
// GLOBALS //
/////////////
Texture2D cloudTexture : register(t0);
Texture2D perturbTexture : register(t1);
SamplerState SampleType;
 
cbuffer SkyBuffer
{
    float translation;
    float scale;
    float brightness;
    float padding;
};
 
 
//////////////
// TYPEDEFS //
//////////////
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// Pixel Shader
////////////////////////////////////////////////////////////////////////////////
float4 SkyPlanePixelShader(PixelInputType input) : SV_TARGET
{
    float4 perturbValue;
    float4 cloudColor;
 
 
    // 텍스처 좌표 샘플링 위치를 변환 값으로 변환합니다.
    input.tex.x = input.tex.x + translation;
 
    // 번역된 텍스처 좌표를 사용하여 섭동 텍스처에서 텍스처 값을 샘플링합니다.
    perturbValue = perturbTexture.Sample(SampleType, input.tex);
 
    // 섭동 값에 섭동 스케일을 곱합니다.
    perturbValue = perturbValue * scale;
 
    // 교란 된 텍스처 좌표 샘플링 위치를 얻기 위해 변환 값과 텍스처 좌표를 추가합니다.
    perturbValue.xy = perturbValue.xy + input.tex.xy + translation;
 
    // 이제 섭동 샘플링 좌표를 사용하여 구름 텍스처에서 색상을 샘플링합니다.
    cloudColor = cloudTexture.Sample(SampleType, perturbValue.xy);
 
    // 밝기 값으로 색상 구름을 줄입니다.
    cloudColor = cloudColor * brightness;
 
    return cloudColor;
}

Skyplaneshaderclass.h

#pragma once
 
 
class SkyPlaneShaderClass
{
private:
    struct MatrixBufferType
    {
        XMMATRIX world;
        XMMATRIX view;
        XMMATRIX projection;
    };
 
    struct SkyBufferType
    {
        float translation;
        float scale;
        float brightness;
        float padding;
    };
 
public:
    SkyPlaneShaderClass();
    SkyPlaneShaderClass(const SkyPlaneShaderClass&);
    ~SkyPlaneShaderClass();
 
    bool Initialize(ID3D11Device*, HWND);
    void Shutdown();
    bool Render(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*,
                float, float, float);
 
private:
    bool InitializeShader(ID3D11Device*, HWND, const WCHAR*, const WCHAR*);
    void ShutdownShader();
    void OutputShaderErrorMessage(ID3D10Blob*, HWND, const WCHAR*);
 
    bool SetShaderParameters(ID3D11DeviceContext*, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*,
                             ID3D11ShaderResourceView*, float, float, float);
    void RenderShader(ID3D11DeviceContext*, int);
 
private:
    ID3D11VertexShader* m_vertexShader;
    ID3D11PixelShader* m_pixelShader;
    ID3D11InputLayout* m_layout;
    ID3D11SamplerState* m_sampleState;
    ID3D11Buffer* m_matrixBuffer;
    ID3D11Buffer* m_skyBuffer;
};

Skyplaneshaderclass.cpp

#include "stdafx.h"
#include "skyplaneshaderclass.h"
 
 
 
SkyPlaneShaderClass::SkyPlaneShaderClass()
{
}
 
 
SkyPlaneShaderClass::SkyPlaneShaderClass(const SkyPlaneShaderClass& other)
{
}
 
 
SkyPlaneShaderClass::~SkyPlaneShaderClass()
{
}
 
 
bool SkyPlaneShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
    // 정점 및 픽셀 쉐이더를 초기화합니다.
    return InitializeShader(device, hwnd, L"../Dx11Terrain_12/skyplane_vs.hlsl", L"../Dx11Terrain_12/skyplane_ps.hlsl");
}
 
 
void SkyPlaneShaderClass::Shutdown()
{
    // 버텍스 및 픽셀 쉐이더와 관련된 객체를 종료합니다.
    ShutdownShader();
}
 
 
bool SkyPlaneShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX worldMatrix, XMMATRIX viewMatrix, 
                                 XMMATRIX projectionMatrix, ID3D11ShaderResourceView* cloudTexture,
                                 ID3D11ShaderResourceView* perturbTexture, float translation, float scale, float brightness)
{
    // 렌더링에 사용할 셰이더 매개 변수를 설정합니다.
    if (!SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, cloudTexture, perturbTexture,
                             translation, scale, brightness))
    {
        return false;
    }
 
    // 설정된 버퍼를 셰이더로 렌더링한다.
    RenderShader(deviceContext, indexCount);
 
    return true;
}
 
 
bool SkyPlaneShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, const WCHAR* vsFilename, const WCHAR* psFilename)
{
    HRESULT result;
    ID3D10Blob* errorMessage = nullptr;
 
    // 버텍스 쉐이더 코드를 컴파일한다.
    ID3D10Blob* vertexShaderBuffer = nullptr;
    result = D3DCompileFromFile(vsFilename, NULL, NULL, "SkyPlaneVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS,
                                0, &vertexShaderBuffer, &errorMessage);
    if (FAILED(result))
    {
        // 셰이더 컴파일 실패시 오류메시지를 출력합니다.
        if (errorMessage)
        {
            OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
        }
        // 컴파일 오류가 아니라면 셰이더 파일을 찾을 수 없는 경우입니다.
        else
        {
            MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
        }
 
        return false;
    }
 
    // 픽셀 쉐이더 코드를 컴파일한다.
    ID3D10Blob* pixelShaderBuffer = nullptr;
    result = D3DCompileFromFile(psFilename, NULL, NULL, "SkyPlanePixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS,
                                0, &pixelShaderBuffer, &errorMessage);
    if (FAILED(result))
    {
        // 셰이더 컴파일 실패시 오류메시지를 출력합니다.
        if (errorMessage)
        {
            OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
        }
        // 컴파일 오류가 아니라면 셰이더 파일을 찾을 수 없는 경우입니다.
        else
        {
            MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
        }
 
        return false;
    }
 
    // 버퍼로부터 정점 셰이더를 생성한다.
    result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL,
                                        &m_vertexShader);
    if (FAILED(result))
    {
        return false;
    }
 
    // 버퍼에서 픽셀 쉐이더를 생성합니다.
    result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL,
                                       &m_pixelShader);
    if (FAILED(result))
    {
        return false;
    }
 
    // 정점 입력 레이아웃 구조체를 설정합니다.
    // 이 설정은 ModelClass와 셰이더의 VertexType 구조와 일치해야합니다.
    D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
    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;
 
    // 레이아웃의 요소 수를 가져옵니다.
    UINT numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
 
    // 정점 입력 레이아웃을 만듭니다.
    result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(),
        vertexShaderBuffer->GetBufferSize(), &m_layout);
    if (FAILED(result))
    {
        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;
 
    // 텍스처 샘플러 상태를 만듭니다.
    result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
    if (FAILED(result))
    {
        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;
 
    // 이 클래스 내에서 정점 셰이더 상수 버퍼에 액세스 할 수 있도록 상수 버퍼 포인터를 만듭니다.
    result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
    if(FAILED(result))
    {
        return false;
    }
 
    // 픽셀 쉐이더에있는 하늘 상수 버퍼의 구조체를 설정합니다.
    D3D11_BUFFER_DESC skyBufferDesc;
    skyBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    skyBufferDesc.ByteWidth = sizeof(SkyBufferType);
    skyBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    skyBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    skyBufferDesc.MiscFlags = 0;
    skyBufferDesc.StructureByteStride = 0;
 
    // 이 클래스 내에서 픽셀 쉐이더 상수 버퍼에 액세스 할 수 있도록 상수 버퍼 포인터를 만듭니다.
    result = device->CreateBuffer(&skyBufferDesc, NULL, &m_skyBuffer);
    if(FAILED(result))
    {
        return false;
    }
 
    return true;
}
 
 
void SkyPlaneShaderClass::ShutdownShader()
{
    // 하늘 상수 버퍼를 해제합니다.
    if(m_skyBuffer)
    {
        m_skyBuffer->Release();
        m_skyBuffer = 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 SkyPlaneShaderClass::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 SkyPlaneShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, XMMATRIX worldMatrix, XMMATRIX viewMatrix, 
                                              XMMATRIX projectionMatrix, ID3D11ShaderResourceView* cloudTexture, 
                                              ID3D11ShaderResourceView* perturbTexture, float translation, float scale,
                                              float brightness)
{
    // 상수 버퍼의 내용을 쓸 수 있도록 잠급니다.
    D3D11_MAPPED_SUBRESOURCE mappedResource;
    if (FAILED(deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource)))
    {
        return false;
    }
 
    // 상수 버퍼의 데이터에 대한 포인터를 가져옵니다.
    MatrixBufferType* dataPtr = (MatrixBufferType*)mappedResource.pData;
 
    // 행렬을 transpose하여 셰이더에서 사용할 수 있게 합니다
    worldMatrix = XMMatrixTranspose(worldMatrix);
    viewMatrix = XMMatrixTranspose(viewMatrix);
    projectionMatrix = XMMatrixTranspose(projectionMatrix);
 
    // 상수 버퍼에 행렬을 복사합니다.
    dataPtr->world = worldMatrix;
    dataPtr->view = viewMatrix;
    dataPtr->projection = projectionMatrix;
 
    // 상수 버퍼의 잠금을 풉니다.
    deviceContext->Unmap(m_matrixBuffer, 0);
 
    // 정점 셰이더에서의 상수 버퍼의 위치를 설정합니다.
    unsigned int bufferNumber = 0;
 
    // 마지막으로 정점 셰이더의 상수 버퍼를 바뀐 값으로 바꿉니다.
    deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer);
 
    // 쓸 수 있도록 픽셀 상수 버퍼를 잠급니다..
    if (FAILED(deviceContext->Map(m_skyBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource)))
    {
        return false;
    }
 
    // 상수 버퍼의 데이터에 대한 포인터를 가져옵니다.
    SkyBufferType* dataPtr2 = (SkyBufferType*)mappedResource.pData;
 
    // 하늘 변수를 상수 버퍼에 복사합니다.
    dataPtr2->translation = translation;
    dataPtr2->scale = scale;
    dataPtr2->brightness = brightness;
    dataPtr2->padding = 0.0f;
 
    // 상수 버퍼의 잠금을 해제합니다.
    deviceContext->Unmap(m_skyBuffer, 0);
 
    // 픽셀 쉐이더에서 하늘 상수 버퍼의 위치를 ​​설정합니다.
    bufferNumber = 0;
 
    // 마지막으로 업데이트 된 값으로 픽셀 쉐이더의 하늘 상수 버퍼를 설정합니다.
    deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_skyBuffer);
 
    // 픽셀 쉐이더에서 쉐이더 텍스처 리소스를 설정합니다.
    deviceContext->PSSetShaderResources(0, 1, &cloudTexture);
    deviceContext->PSSetShaderResources(1, 1, &perturbTexture);
 
    return true;
}
 
 
void SkyPlaneShaderClass::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);
}

Skyplaneclass.h

#pragma once
 
 
class TextureClass;
 
 
class SkyPlaneClass
{
private:
    struct SkyPlaneType
    {
        float x, y, z;
        float tu, tv;
    };
 
    struct VertexType
    {
        XMFLOAT3 position;
        XMFLOAT2 texture;
    };
 
public:
    SkyPlaneClass();
    SkyPlaneClass(const SkyPlaneClass&);
    ~SkyPlaneClass();
 
    bool Initialize(ID3D11Device*, const WCHAR*, const WCHAR*);
    void Shutdown();
    void Render(ID3D11DeviceContext*);
    void Frame();
 
    int GetIndexCount();
    ID3D11ShaderResourceView* GetCloudTexture();
    ID3D11ShaderResourceView* GetPerturbTexture();
    
    float GetScale();
    float GetBrightness();
    float GetTranslation();
 
private:
    bool InitializeSkyPlane(int, float, float, float, int);
    void ShutdownSkyPlane();
 
    bool InitializeBuffers(ID3D11Device*, int);
    void ShutdownBuffers();
    void RenderBuffers(ID3D11DeviceContext*);
 
    bool LoadTextures(ID3D11Device*, const WCHAR*, const WCHAR*);
    void ReleaseTextures();
 
private:
    SkyPlaneType* m_skyPlane = nullptr;
    int m_vertexCount = 0;
    int m_indexCount = 0;
    ID3D11Buffer *m_vertexBuffer = nullptr;
    ID3D11Buffer *m_indexBuffer = nullptr;
    TextureClass *m_CloudTexture = nullptr;
    TextureClass *m_PerturbTexture = nullptr;
    float m_scale = 0.0f;
    float m_brightness = 0.0f;
    float m_translation = 0.0f;
};

Skyplaneclass.cpp

#include "stdafx.h"
#include "TextureClass.h"
#include "skyplaneclass.h"
 
 
SkyPlaneClass::SkyPlaneClass()
{
}
 
 
SkyPlaneClass::SkyPlaneClass(const SkyPlaneClass& other)
{
}
 
 
SkyPlaneClass::~SkyPlaneClass()
{
}
 
 
bool SkyPlaneClass::Initialize(ID3D11Device* device, const WCHAR* cloudTextureFilename, const WCHAR* perturbTextureFilename)
{
    // 하늘 평면 매개 변수를 설정합니다.
    int skyPlaneResolution = 50;
    float skyPlaneWidth = 10.0f;
    float skyPlaneTop = 0.5f;
    float skyPlaneBottom = 0.0f;
    int textureRepeat = 2;
 
    // 하늘 평면 쉐이더 관련 매개 변수를 설정합니다.
    m_scale = 0.3f;
    m_brightness = 0.5f;
 
    // 번역을 0으로 초기화합니다.
    m_translation = 0.0f;
 
    // 하늘 평면을 만듭니다.
    if(!InitializeSkyPlane(skyPlaneResolution, skyPlaneWidth, skyPlaneTop, skyPlaneBottom, textureRepeat))
    {
        return false;
    }
 
    // 하늘 평면에 대한 정점 및 인덱스 버퍼를 만듭니다.
    if(!InitializeBuffers(device, skyPlaneResolution))
    {
        return false;
    }
 
    // 하늘 평면 텍스처를 로드합니다. 
    if(!LoadTextures(device, cloudTextureFilename, perturbTextureFilename))
    {
        return false;
    }
 
    return true;
}
 
 
void SkyPlaneClass::Shutdown()
{
    // 하늘 평면 텍스처를 해제합니다.
    ReleaseTextures();
 
    // 하늘 평면 렌더링에 사용 된 정점 및 인덱스 버퍼를 해제합니다.
    ShutdownBuffers();
 
    // 하늘 평면 배열을 해제합니다.
    ShutdownSkyPlane();
}
 
 
void SkyPlaneClass::Render(ID3D11DeviceContext* deviceContext)
{
    // 하늘 평면을 렌더링합니다.
    RenderBuffers(deviceContext);
}
 
 
void SkyPlaneClass::Frame()
{
    // 각 프레임의 텍스처 변환 값을 증가시킵니다.
    m_translation += 0.0001f;
    if(m_translation > 1.0f)
    {
        m_translation -= 1.0f;
    }
}
 
 
int SkyPlaneClass::GetIndexCount()
{
    return m_indexCount;
}
 
 
ID3D11ShaderResourceView* SkyPlaneClass::GetCloudTexture()
{
    return m_CloudTexture->GetTexture();
}
 
 
ID3D11ShaderResourceView* SkyPlaneClass::GetPerturbTexture()
{
    return m_PerturbTexture->GetTexture();
}
 
 
float SkyPlaneClass::GetScale()
{
    return m_scale;
}
 
 
float SkyPlaneClass::GetBrightness()
{
    return m_brightness;
}
 
 
float SkyPlaneClass::GetTranslation()
{
    return m_translation;
}
 
 
bool SkyPlaneClass::InitializeSkyPlane(int skyPlaneResolution, float skyPlaneWidth, float skyPlaneTop, float skyPlaneBottom,
                                       int textureRepeat)
{
    float positionX = 0.0f;
    float positionY = 0.0f;
    float positionZ = 0.0f;
    float tu = 0.0f;
    float tv = 0.0f;
 
    // 하늘 평면 좌표를 보유 할 배열을 만듭니다.
    m_skyPlane = new SkyPlaneType[(skyPlaneResolution + 1) * (skyPlaneResolution + 1)];
    if(!m_skyPlane)
    {
        return false;
    }
 
    // 하늘 평면에서 각 쿼드의 크기를 결정합니다.
    float quadSize = skyPlaneWidth / (float)skyPlaneResolution;
 
    // 너비를 기준으로 하늘 평면의 반지름을 계산합니다.
    float radius = skyPlaneWidth / 2.0f;
 
    // 증가 할 높이 상수를 계산합니다.
    float constant = (skyPlaneTop - skyPlaneBottom) / (radius * radius);
 
    // 텍스처 좌표 증가 값을 계산합니다.
    float textureDelta = (float)textureRepeat / (float)skyPlaneResolution;
 
    // 하늘 평면을 반복하고 제공된 증분 값을 기반으로 좌표를 만듭니다.
    for(int j=0; j<=skyPlaneResolution; j++)
    {
        for(int i=0; i<=skyPlaneResolution; i++)
        {
            // 정점 좌표를 계산합니다.
            positionX = (-0.5f * skyPlaneWidth) + ((float)i * quadSize);
            positionZ = (-0.5f * skyPlaneWidth) + ((float)j * quadSize);
            positionY = skyPlaneTop - (constant * ((positionX * positionX) + (positionZ * positionZ)));
 
            // 텍스처 좌표를 계산합니다.
            tu = (float)i * textureDelta;
            tv = (float)j * textureDelta;
 
            // 이 좌표를 추가하기 위해 하늘 평면 배열에 인덱스를 계산합니다.
            int index = j * (skyPlaneResolution + 1) + i;
 
            // 하늘 평면 배열에 좌표를 추가합니다.
            m_skyPlane[index].x = positionX;
            m_skyPlane[index].y = positionY;
            m_skyPlane[index].z = positionZ;
            m_skyPlane[index].tu = tu;
            m_skyPlane[index].tv = tv;
        }
    }
 
    return true;
}
 
 
void SkyPlaneClass::ShutdownSkyPlane()
{
    // 하늘 평면 배열을 해제합니다.
    if(m_skyPlane)
    {
        delete [] m_skyPlane;
        m_skyPlane = 0;
    }
}
 
 
bool SkyPlaneClass::InitializeBuffers(ID3D11Device* device, int skyPlaneResolution)
{
    int index1 = 0;
    int index2 = 0;
    int index3 = 0;
    int index4 = 0;
 
    // 하늘 평면 메쉬의 정점 수를 계산합니다.
    m_vertexCount = (skyPlaneResolution + 1) * (skyPlaneResolution + 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<skyPlaneResolution; j++)
    {
        for(int i=0; i<skyPlaneResolution; i++)
        {
            index1 = j * (skyPlaneResolution + 1) + i;
            index2 = j * (skyPlaneResolution + 1) + (i+1);
            index3 = (j+1) * (skyPlaneResolution + 1) + i;
            index4 = (j+1) * (skyPlaneResolution + 1) + (i+1);
 
            // 삼각형 1 - 왼쪽 위
            vertices[index].position = XMFLOAT3(m_skyPlane[index1].x, m_skyPlane[index1].y, m_skyPlane[index1].z);
            vertices[index].texture = XMFLOAT2(m_skyPlane[index1].tu, m_skyPlane[index1].tv);
            indices[index] = index;
            index++;
 
            // 삼각형 1 - 오른쪽 위
            vertices[index].position = XMFLOAT3(m_skyPlane[index2].x, m_skyPlane[index2].y, m_skyPlane[index2].z);
            vertices[index].texture = XMFLOAT2(m_skyPlane[index2].tu, m_skyPlane[index2].tv);
            indices[index] = index;
            index++;
 
            // 삼각형 1 - 왼쪽 아래
            vertices[index].position = XMFLOAT3(m_skyPlane[index3].x, m_skyPlane[index3].y, m_skyPlane[index3].z);
            vertices[index].texture = XMFLOAT2(m_skyPlane[index3].tu, m_skyPlane[index3].tv);
            indices[index] = index;
            index++;
 
            // 삼각형 2 - 왼쪽 아래
            vertices[index].position = XMFLOAT3(m_skyPlane[index3].x, m_skyPlane[index3].y, m_skyPlane[index3].z);
            vertices[index].texture = XMFLOAT2(m_skyPlane[index3].tu, m_skyPlane[index3].tv);
            indices[index] = index;
            index++;
 
            // 삼각형 2 - 오른쪽 위
            vertices[index].position = XMFLOAT3(m_skyPlane[index2].x, m_skyPlane[index2].y, m_skyPlane[index2].z);
            vertices[index].texture = XMFLOAT2(m_skyPlane[index2].tu, m_skyPlane[index2].tv);
            indices[index] = index;
            index++;
 
            // 삼각형 2 - 오른쪽 아래
            vertices[index].position = XMFLOAT3(m_skyPlane[index4].x, m_skyPlane[index4].y, m_skyPlane[index4].z);
            vertices[index].texture = XMFLOAT2(m_skyPlane[index4].tu, m_skyPlane[index4].tv);
            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 SkyPlaneClass::ShutdownBuffers()
{
    // 인덱스 버퍼를 해제합니다.
    if(m_indexBuffer)
    {
        m_indexBuffer->Release();
        m_indexBuffer = 0;
    }
 
    // 버텍스 버퍼를 해제합니다.
    if(m_vertexBuffer)
    {
        m_vertexBuffer->Release();
        m_vertexBuffer = 0;
    }
}
 
 
void SkyPlaneClass::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);
}
 
 
bool SkyPlaneClass::LoadTextures(ID3D11Device* device, const WCHAR* textureFilename1, const WCHAR* textureFilename2)
{
    // 클라우드 텍스처 객체를 생성합니다.
    m_CloudTexture = new TextureClass;
    if(!m_CloudTexture)
    {
        return false;
    }
 
    // 구름 텍스처 객체를 초기화합니다.
    if(!m_CloudTexture->Initialize(device, textureFilename1))
    {
        return false;
    }
 
    // 섭동 텍스처 오브젝트를 생성합니다.
    m_PerturbTexture = new TextureClass;
    if(!m_PerturbTexture)
    {
        return false;
    }
 
    // 섭동 텍스처 오브젝트를 초기화합니다.
    if(!m_PerturbTexture->Initialize(device, textureFilename2))
    {
        return false;
    }
 
    return true;
}
 
 
void SkyPlaneClass::ReleaseTextures()
{
    // 텍스처 오브젝트를 해제합니다..
    if(m_PerturbTexture)
    {
        m_PerturbTexture->Shutdown();
        delete m_PerturbTexture;
        m_PerturbTexture = 0;
    }
 
    if(m_CloudTexture)
    {
        m_CloudTexture->Shutdown();
        delete m_CloudTexture;
        m_CloudTexture = 0;
    }
}

Applicationclass.cpp

#include "stdafx.h"
#include "inputclass.h"
#include "d3dclass.h"
#include "cameraclass.h"
#include "terrainclass.h"
#include "timerclass.h"
#include "positionclass.h"
#include "fpsclass.h"
#include "cpuclass.h"
#include "fontshaderclass.h"
#include "textclass.h"
#include "terrainshaderclass.h"
#include "lightclass.h"
#include "skydomeclass.h"
#include "skydomeshaderclass.h"
#include "skyplaneclass.h"
#include "skyplaneshaderclass.h"
#include "ApplicationClass.h"
 
 
ApplicationClass::ApplicationClass()
{
}
 
 
ApplicationClass::ApplicationClass(const ApplicationClass& other)
{
}
 
 
ApplicationClass::~ApplicationClass()
{
}
 
 
bool ApplicationClass::Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int screenHeight)
{
    // 입력 개체를 생성합니다.
    m_Input = new InputClass;
    if(!m_Input)
    {
        return false;
    }
 
    // 입력 개체를 초기화 합니다.
    bool result = m_Input->Initialize(hinstance, hwnd, screenWidth, screenHeight);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the input object.", L"Error", MB_OK);
        return false;
    }
 
    // Direct3D 개체를 생성합니다.
    m_Direct3D = new D3DClass;
    if(!m_Direct3D)
    {
        return false;
    }
 
    // Direct3D 개체를 초기화 합니다.
    result = m_Direct3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize DirectX 11.", L"Error", MB_OK);
        return false;
    }
 
    // 카메라 객체를 생성합니다.
    m_Camera = new CameraClass;
    if(!m_Camera)
    {
        return false;
    }
 
    // 2D 사용자 인터페이스 렌더링을 위해 카메라로 기본 뷰 행렬을 초기화 합니다.
    XMMATRIX baseViewMatrix;
    m_Camera->SetPosition(XMFLOAT3(0.0f, 0.0f, -1.0f));
    m_Camera->Render();
    m_Camera->GetViewMatrix(baseViewMatrix);
 
    // 카메라의 초기 위치를 설정합니다.
    XMFLOAT3 camera = XMFLOAT3(50.0f, 2.0f, -7.0f);
    m_Camera->SetPosition(camera);
 
    // 지형 객체를 생성합니다.
    m_Terrain = new TerrainClass;
    if(!m_Terrain)
    {
        return false;
    }
 
    // 지형 객체를 초기화 합니다.
    result = m_Terrain->Initialize(m_Direct3D->GetDevice(), "../Dx11Terrain_12/data/heightmap01.bmp",
                                                           L"../Dx11Terrain_12/data/dirt01.dds",
                                                            "../Dx11Terrain_12/data/colorm01.bmp");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the terrain object.", L"Error", MB_OK);
        return false;
    }
 
    // 타이머 객체를 생성합니다.
    m_Timer = new TimerClass;
    if(!m_Timer)
    {
        return false;
    }
 
    // 타이머 객체를 초기화 합니다.
    result = m_Timer->Initialize();
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the timer object.", L"Error", MB_OK);
        return false;
    }
 
    // 위치 개체를 생성합니다.
    m_Position = new PositionClass;
    if(!m_Position)
    {
        return false;
    }
 
    // 뷰어의 초기 위치를 초기 카메라 위치와 동일하게 설정합니다.
    m_Position->SetPosition(camera);
 
    // fps 객체를 생성합니다.
    m_Fps = new FpsClass;
    if(!m_Fps)
    {
        return false;
    }
 
    // fps 객체를 초기화 합니다.
    m_Fps->Initialize();
 
    // cpu 객체를 생성합니다.
    m_Cpu = new CpuClass;
    if(!m_Cpu)
    {
        return false;
    }
 
    // cpu 객체를 초기화 합니다.
    m_Cpu->Initialize();
 
    // 폰트 셰이더 객체를 생성합니다.
    m_FontShader = new FontShaderClass;
    if(!m_FontShader)
    {
        return false;
    }
 
    // 폰트 셰이더 객체를 초기화 합니다.
    result = m_FontShader->Initialize(m_Direct3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the font shader object.", L"Error", MB_OK);
        return false;
    }
 
    // 텍스트 객체를 생성합니다.
    m_Text = new TextClass;
    if(!m_Text)
    {
        return false;
    }
 
    // 텍스트 객체를 초기화 합니다.
    result = m_Text->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), hwnd, screenWidth, screenHeight,
                                baseViewMatrix);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the text object.", L"Error", MB_OK);
        return false;
    }
 
    // 비디오 카드 정보를 가져옵니다.
    char videoCard[128] = { 0, };
    int videoMemory = 0;
    m_Direct3D->GetVideoCardInfo(videoCard, videoMemory);
 
    // 텍스트 객체에 비디오 카드 정보를 설정합니다.
    result = m_Text->SetVideoCardInfo(videoCard, videoMemory, m_Direct3D->GetDeviceContext());
    if(!result)
    {
        MessageBox(hwnd, L"Could not set video card info in the text object.", L"Error", MB_OK);
        return false;
    }
 
    // 지형 쉐이더 객체를 생성합니다.
    m_TerrainShader = new TerrainShaderClass;
    if(!m_TerrainShader)
    {
        return false;
    }
 
    // 지형 쉐이더 객체를 초기화 합니다.
    result = m_TerrainShader->Initialize(m_Direct3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the terrain shader object.", L"Error", MB_OK);
        return false;
    }
 
    // 조명 객체를 생성합니다.
    m_Light = new LightClass;
    if(!m_Light)
    {
        return false;
    }
 
    // 조명 객체를 초기화 합니다.
    m_Light->SetAmbientColor(XMFLOAT4(0.05f, 0.05f, 0.05f, 1.0f));
    m_Light->SetDiffuseColor(XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f));
    m_Light->SetDirection(XMFLOAT3(-0.5f, -1.0f, 0.0f));
 
    // 스카이 돔 객체를 생성합니다.
    m_SkyDome = new SkyDomeClass;
    if(!m_SkyDome)
    {
        return false;
    }
 
    // 스카이 돔 객체를 초기화 합니다.
    result = m_SkyDome->Initialize(m_Direct3D->GetDevice());
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the sky dome object.", L"Error", MB_OK);
        return false;
    }
 
    // 스카이 돔 쉐이더 객체를 생성합니다.
    m_SkyDomeShader = new SkyDomeShaderClass;
    if(!m_SkyDomeShader)
    {
        return false;
    }
 
    // 스카이 돔 쉐이더 객체를 초기화 합니다.
    result = m_SkyDomeShader->Initialize(m_Direct3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the sky dome shader object.", L"Error", MB_OK);
        return false;
    }
 
    // 하늘 평면 객체를 생성합니다.
    m_SkyPlane = new SkyPlaneClass;
    if(!m_SkyPlane)
    {
        return false;
    }
 
    // 하늘 평면 객체를 초기화 합니다.
    result = m_SkyPlane->Initialize(m_Direct3D->GetDevice(), L"../Dx11Terrain_12/data/cloud001.dds",
                                                             L"../Dx11Terrain_12/data/perturb001.dds");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the sky plane object.", L"Error", MB_OK);
        return false;
    }
 
    // 하늘 평면 쉐이더 객체를 생성합니다.
    m_SkyPlaneShader = new SkyPlaneShaderClass;
    if(!m_SkyPlaneShader)
    {
        return false;
    }
 
    // 하늘 평면 쉐이더 객체를 초기화 합니다.
    result = m_SkyPlaneShader->Initialize(m_Direct3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the sky plane shader object.", L"Error", MB_OK);
        return false;
    }
 
    return true;
}
 
 
void ApplicationClass::Shutdown()
{
    // 하늘 평면 쉐이더 객체를 해제합니다.
    if(m_SkyPlaneShader)
    {
        m_SkyPlaneShader->Shutdown();
        delete m_SkyPlaneShader;
        m_SkyPlaneShader = 0;
    }
 
    // 하늘 평면 객체를 해제합니다.
    if(m_SkyPlane)
    {
        m_SkyPlane->Shutdown();
        delete m_SkyPlane;
        m_SkyPlane = 0;
    }
 
    // 스카이 돔 쉐이더 객체를 해제합니다.
    if(m_SkyDomeShader)
    {
        m_SkyDomeShader->Shutdown();
        delete m_SkyDomeShader;
        m_SkyDomeShader = 0;
    }
 
    // 스카이 돔 객체를 해제합니다.
    if(m_SkyDome)
    {
        m_SkyDome->Shutdown();
        delete m_SkyDome;
        m_SkyDome = 0;
    }
 
    // 조명 객체를 해제합니다.
    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;
    }
 
    // 하늘 평면 프레임 처리를 수행합니다.
    m_SkyPlane->Frame();
 
    // 그래픽을 렌더링 합니다.
    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;
    XMFLOAT3 cameraPosition;
 
    // 장면을 지웁니다.
    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);
 
    // 카메라 위치를 얻는다.
    cameraPosition = m_Camera->GetPosition();
 
    // 스카이 돔을 카메라 위치를 중심으로 변환합니다.
    worldMatrix = XMMatrixTranslation(cameraPosition.x, cameraPosition.y, cameraPosition.z);
 
    // 표면 컬링을 끕니다.
    m_Direct3D->TurnOffCulling();
 
    // Z 버퍼를 끈다.
    m_Direct3D->TurnZBufferOff();
 
    // 스카이 돔 셰이더를 사용하여 하늘 돔을 렌더링합니다.
    m_SkyDome->Render(m_Direct3D->GetDeviceContext());
    m_SkyDomeShader->Render(m_Direct3D->GetDeviceContext(), m_SkyDome->GetIndexCount(), worldMatrix, viewMatrix,
                            projectionMatrix, m_SkyDome->GetApexColor(), m_SkyDome->GetCenterColor());
 
    // 다시 표면 컬링을 되돌립니다.
    m_Direct3D->TurnOnCulling();
 
    // 구름이 sky dome color와 혼합되도록 첨가물 블렌딩을 가능하게합니다.
    m_Direct3D->EnableSecondBlendState();
 
    // 하늘 평면 쉐이더를 사용하여 하늘 평면을 렌더링합니다.
    m_SkyPlane->Render(m_Direct3D->GetDeviceContext());
    m_SkyPlaneShader->Render(m_Direct3D->GetDeviceContext(), m_SkyPlane->GetIndexCount(), worldMatrix, viewMatrix,
                             projectionMatrix, m_SkyPlane->GetCloudTexture(), m_SkyPlane->GetPerturbTexture(),
                             m_SkyPlane->GetTranslation(), m_SkyPlane->GetScale(), m_SkyPlane->GetBrightness());
 
    // 블렌드를 끕니다.
    m_Direct3D->TurnOffAlphaBlending();
 
    // Z 버퍼를 다시 켭니다.
    m_Direct3D->TurnZBufferOn();
 
    // 월드 행렬을 재설정합니다.
    m_Direct3D->GetWorldMatrix(worldMatrix);
    
    // 지형 버퍼를 렌더링 합니다.
    m_Terrain->Render(m_Direct3D->GetDeviceContext());
 
    // 지형 셰이더를 사용하여 지형을 렌더링 합니다.
    if(!m_TerrainShader->Render(m_Direct3D->GetDeviceContext(), m_Terrain->GetIndexCount(), worldMatrix, viewMatrix,
                                projectionMatrix, m_Light->GetAmbientColor(), m_Light->GetDiffuseColor(),
                                m_Light->GetDirection(), m_Terrain->GetTexture()))
    {
        return false;
    }
 
    // 모든 2D 렌더링을 시작하려면 Z 버퍼를 끕니다.
    m_Direct3D->TurnZBufferOff();
        
    // 텍스트를 렌더링하기 전에 알파 블렌딩을 켭니다.
    m_Direct3D->TurnOnAlphaBlending();
 
    // 텍스트 사용자 인터페이스 요소를 렌더링 합니다.
    if(!m_Text->Render(m_Direct3D->GetDeviceContext(), m_FontShader, worldMatrix, orthoMatrix))
    {
        return false;
    }
 
    // 텍스트를 렌더링 한 후 알파 블렌딩을 끕니다.
    m_Direct3D->TurnOffAlphaBlending();
 
    // 모든 2D 렌더링이 완료되었으므로 Z 버퍼를 다시 켭니다.
    m_Direct3D->TurnZBufferOn();
 
    // 렌더링 된 장면을 화면에 표시합니다.
    m_Direct3D->EndScene();
 
    return true;
}

출력 화면

마치면서

우리는 이제 구름이 하늘 평면을 가로 질러 이동할 때 혼합된 구름의 모습을 볼수 있게 됩니다.

연습문제

1. 프로그램을 컴파일하고 실행하십시오. PgUp 키를 사용하여 하늘을 들여다 보면 효과를 볼 수 있습니다. 완료되면 ESC 를 눌러 종료합니다.

2. SkyPlane 클래스의 스케일 값을 수정하여 픽셀 쉐이더에 미치는 영향을 확인합니다.

3. 노이즈 텍스처를 수정하여 샘플링에 미치는 영향을 확인합니다.

4. 혼합된 구름의 두 번째 레이어를 추가하고, 스케일을 파동시키는지 확인하십시오. 이전 듀토리얼과 마찬가지로 레이어를 결합하십시오.

5. 구름과 노이즈에 더 높은 해상도의 텍스처를 사용하여 개선된 모양을 보십시오.

소스코드

소스코드 : Dx11Terrain_12.zip