[DirectX 11] Terrain 19 - 단풍

Terrain 19 - 단풍

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

 이 지형 튜토리얼에서는 HLSL 및 C ++을 사용하여 DirectX 11에서 단풍을 구현하는 방법 중 하나를 다룹니다.

지형에 단풍을 렌더링하는 방법에는 여러 가지가 있습니다. 첫 번째 방법은 여러 가지 완전한 식물 모델을 렌더링하는 것입니다. 두 번째 또는 세 번째 쿼드를 사용하여 식물 텍스처와 교차시켜 완벽한 플랜트 모델의 가상 이미지를 만듭니다. 사용된 세 번째 방법은 식물 질감이 땅에 수백번 놓여져 있고 뷰어쪽으로 회전하는 단일 쿼드입니다. 마지막으로 네 번째 방법은 뷰어의 위치에 따라 일부 LOD 설정과 함께 세 가지 방법의 조합을 사용합니다.

첫 번째 방법은 아주 높은 수준의 결과를 제공하지만 사용되는 자원의 한계가 높습니다. 두 번째 방법은 아주 작은 폴리곤 수를 가진 모델을 생성하므로 좋은 해결책입니다. 세 번째 방법은 더 낮은 다각형 수를 가지며 많은 양의 나뭇잎을 배치 할 수 있습니다. 마지막으로 세 가지 방법을 결합하면 최상의 결과를 얻을 수 있습니다. 이 듀토리얼에서는 세 번째 방법을 구현할 것입니다.

단풍을 렌더링 할 때는 일반적으로 먼 거리에서 렌더링 할 필요가 없습니다. 실제로 대부분의 엔진은 50 미터 이상의 경우 단풍을 렌더링하지 않습니다. 자신의 엔진에 가장 적합한 것이 무엇인지 보기 위해 조작할 수 있는 거리값을 설정하는 것이 좋습니다.

또한 대부분의 엔진은 그렇게 하기 쉽지 않기 때문에 기본적으로 잎사귀를 움직입니다. 일부는 단순히 앞뒤로 회전시키고, 다른 일부는 펄린 노이즈 텍스처와 같은 고급 시스템을 사용하여 서로 다른 속도의 일관된 속도를 시뮬레이션하여 잔디밭을 통해 바람을 불어 넣습니다. 단풍의 애니메이션을 얼마나 멀리 찍고 싶은지는 당신에게 달려 있습니다.

대부분의 시스템은 알파 채널이 있는 식물 텍스처를 사용하기 때문에 좋은 혼합 방법을 사용해야 합니다. 심도별로 정렬하고 역순으로 렌더링할 수 있지만 DirectX 알파 대 커버리지 혼합 방법을 사용하는 것이 훨씬 쉽고 인공물이 없습니다. 이 듀토리얼에서는 알파 대 커버리지 혼합 모드를 사용합니다.

마지막으로 인스턴싱을 사용하여 각 잔디에 고유한 특성을 부여합니다. 이 튜토리얼에서는 각 잔디 쿼드에 고유한 위치, 회전 및 색상을 지정합니다. 인스턴스화를 사용하기 때문에 파이프 라인에 단일 잔디 쿼드만 넣고 나머지는 인스턴스 데이터입니다.

우리는 새로운 FoliageClass를 보면서 튜토리얼을 시작할 것입니다.

FoliageClass는 모델, 텍스처, 인스턴스 데이터 및 애니메이션을 포함하여 단풍과 관련된 모든 것을 캡슐화합니다. 이 클래스에는 튜토리얼을 단순하게 유지하기 위한 기초만 포함되어 있습니다.

Foliageclass.h

#pragma once
 
 
class TextureClass;
 
 
class FoliageClass
{
private:
    struct VertexType
    {
        XMFLOAT3 position;
        XMFLOAT2 texture;
    };
 
    struct FoliageType
    {
        float x, z;
        float r, g, b;
    };
 
    struct InstanceType
    {
        XMMATRIX matrix;
        XMFLOAT3 color;
    };
 
public:
    FoliageClass();
    FoliageClass(const FoliageClass&);
    ~FoliageClass();
 
    bool Initialize(ID3D11Device*, const WCHAR*, int);
    void Shutdown();
    void Render(ID3D11DeviceContext*);
    bool Frame(XMFLOAT3, ID3D11DeviceContext*);
 
    int GetVertexCount();
    int GetInstanceCount();
 
    ID3D11ShaderResourceView* GetTexture();
 
private:
    bool InitializeBuffers(ID3D11Device*);
    void ShutdownBuffers();
    void RenderBuffers(ID3D11DeviceContext*);
 
    bool LoadTexture(ID3D11Device*, const WCHAR*);
    void ReleaseTexture();
 
    bool GeneratePositions();
 
private:
    int m_foliageCount = 0;
    FoliageType* m_foliageArray = nullptr;
    InstanceType* m_Instances = nullptr;
    ID3D11Buffer *m_vertexBuffer = nullptr;
    ID3D11Buffer *m_instanceBuffer = nullptr;
    int m_vertexCount = 0;
    int m_instanceCount = 0;
    TextureClass* m_Texture = nullptr;
    float m_windRotation = 0.0f;
    int m_windDirection = 0;
};

Foliageclass.cpp

#include "stdafx.h"
#include "TextureClass.h"
#include "foliageclass.h"
#include <time.h>
 
 
FoliageClass::FoliageClass()
{
}
 
 
FoliageClass::FoliageClass(const FoliageClass& other)
{
}
 
 
FoliageClass::~FoliageClass()
{
}
 
 
bool FoliageClass::Initialize(ID3D11Device* device, const WCHAR* textureFilename, int fCount)
{
    // 단풍 수를 설정합니다.
    m_foliageCount = fCount;
 
    // 단풍의 위치를 ​​생성합니다.
    if(!GeneratePositions())
    {
        return false;
    }
 
    // 단풍 모델의 지오메트리를 포함하는 정점과 인스턴스 버퍼를 초기화합니다.
    if(!InitializeBuffers(device))
    {
        return false;
    }
 
    //이 모델의 텍스처를 로드합니다.
    if(!LoadTexture(device, textureFilename))
    {
        return false;
    }
 
    // 초기 바람 회전과 방향을 설정합니다.
    m_windRotation = 0.0f;
    m_windDirection = 1;
 
    return true;
}
 
 
void FoliageClass::Shutdown()
{
    // 모델 텍스처를 릴리즈한다.
    ReleaseTexture();
 
    // 버텍스와 인스턴스 버퍼를 해제한다.
    ShutdownBuffers();
 
    // 잎 배열을 놓습니다.
    if(m_foliageArray)
    {
        delete [] m_foliageArray;
        m_foliageArray = 0;
    }
}
 
 
void FoliageClass::Render(ID3D11DeviceContext* deviceContext)
{
    // 버텍스와 인스턴스 버퍼를 그래픽 파이프 라인에 배치하여 그리기를 준비합니다.
    RenderBuffers(deviceContext);
}
 
 
bool FoliageClass::Frame(XMFLOAT3 cameraPosition, ID3D11DeviceContext* deviceContext)
{
    XMMATRIX rotateMatrix, translationMatrix, rotateMatrix2, finalMatrix;
    XMFLOAT3 modelPosition = { 0.0f, 0.0f, 0.0f };
    double angle = 0.0f;
    float rotation = 0.0f;
    float windRotation = 0.0f;
 
    // 바람 회전을 업데이트합니다.
    if(m_windDirection == 1)
    {
        m_windRotation += 0.1f;
        if(m_windRotation > 10.0f)
        {
            m_windDirection = 2;
        }
    }
    else
    {
        m_windRotation -= 0.1f;
        if(m_windRotation < -10.0f)
        {
            m_windDirection = 1;
        }
    }
 
    // 업데이트 된 위치로 인스턴스 버퍼를 로드합니다.
    for(int i=0; i<m_foliageCount; i++)
    {
        // 이 조각의 위치를 ​​얻는다.
        modelPosition.x = m_foliageArray[i].x;
        modelPosition.y = -0.1f;
        modelPosition.z = m_foliageArray[i].z;
 
        // 아크 탄젠트 함수를 사용하여 현재 카메라 위치를 향하도록 빌보드 모델에 적용해야하는 회전을 계산합니다.
        double angle = atan2(modelPosition.x - cameraPosition.x, modelPosition.z - cameraPosition.z) * (180.0 / XM_PI);
 
        // 회전을 라디안으로 변환합니다.
        rotation = (float)angle * 0.0174532925f;
 
        // 빌보드의 X 회전을 설정합니다.
        rotateMatrix = XMMatrixRotationY(rotation);
 
        // 단풍의 바람 회전을 얻는다.
        windRotation = m_windRotation * 0.0174532925f;
 
        // 바람 회전을 설정합니다.
        rotateMatrix2 = XMMatrixRotationX(windRotation);
 
        // 변환 행렬을 설정합니다.
        translationMatrix = XMMatrixTranslation(modelPosition.x, modelPosition.y, modelPosition.z);
 
        // 최종 행렬을 만들고 인스턴스 배열에 저장합니다.
        finalMatrix = XMMatrixMultiply(rotateMatrix, rotateMatrix2);
        m_Instances[i].matrix = XMMatrixMultiply(finalMatrix, translationMatrix);
    }
 
    // 쓸 수 있도록 인스턴스 버퍼를 잠급니다.
    D3D11_MAPPED_SUBRESOURCE mappedResource;
    if(FAILED(deviceContext->Map(m_instanceBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource)))
    {
        return false;
    }
 
    // 인스턴스 버퍼의 데이터에 대한 포인터를 가져옵니다.
    InstanceType* instancesPtr = (InstanceType*)mappedResource.pData;
 
    // 인스턴스 배열을 인스턴스 버퍼에 복사합니다.
    memcpy(instancesPtr, (void*)m_Instances, (sizeof(InstanceType) * m_foliageCount));
 
    // 인스턴스 버퍼를 잠금 해제합니다.
    deviceContext->Unmap(m_instanceBuffer, 0);
 
    return true;
}
 
 
int FoliageClass::GetVertexCount()
{
    return m_vertexCount;
}
 
 
int FoliageClass::GetInstanceCount()
{
    return m_instanceCount;
}
 
 
ID3D11ShaderResourceView* FoliageClass::GetTexture()
{
    return m_Texture->GetTexture();
}
 
 
bool FoliageClass::InitializeBuffers(ID3D11Device* device)
{
    // 정점 배열의 정점 수를 설정합니다.
    m_vertexCount = 6;
 
    // 정점 배열을 만듭니다.
    VertexType* vertices = new VertexType[m_vertexCount];
    if(!vertices)
    {
        return false;
    }
 
    // 정점 배열에 데이터를 로드합니다.
    vertices[0].position = XMFLOAT3(0.0f, 0.0f, 0.0f);  // 왼쪽 아래.
    vertices[0].texture = XMFLOAT2(0.0f, 1.0f);
 
    vertices[1].position = XMFLOAT3(0.0f, 1.0f, 0.0f);  // 왼쪽 위.
    vertices[1].texture = XMFLOAT2(0.0f, 0.0f);
 
    vertices[2].position = XMFLOAT3(1.0f, 0.0f, 0.0f);  // 오른쪽 아래.
    vertices[2].texture = XMFLOAT2(1.0f, 1.0f);
 
    vertices[3].position = XMFLOAT3(1.0f, 0.0f, 0.0f);  // 오른쪽 아래.
    vertices[3].texture = XMFLOAT2(1.0f, 1.0f);
 
    vertices[4].position = XMFLOAT3(0.0f, 1.0f, 0.0f);  // 왼쪽 위.
    vertices[4].texture = XMFLOAT2(0.0f, 0.0f);
 
    vertices[5].position = XMFLOAT3(1.0f, 1.0f, 0.0f);  // 오른쪽 위.
    vertices[5].texture = XMFLOAT2(1.0f, 0.0f);
 
    // 정점 버퍼의 구조체를 설정한다.
    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;
    }
 
    // 이제 버텍스 버퍼가 생성되고 로드된 배열을 해제하십시오.
    delete [] vertices;
    vertices = 0;
 
    // 배열의 인스턴스 수를 설정합니다.
    m_instanceCount = m_foliageCount;
 
    // 인스턴스 배열을 만듭니다.
    m_Instances = new InstanceType[m_instanceCount];
    if(!m_Instances)
    {
        return false;
    }
 
    // 초기 매트릭스를 설정합니다.
    XMMATRIX matrix = XMMatrixIdentity();
 
    // 데이터로 인스턴스 배열을로드합니다.
    for(int i=0; i<m_instanceCount; i++)
    {
        m_Instances[i].matrix = matrix;
        m_Instances[i].color = XMFLOAT3(m_foliageArray[i].r, m_foliageArray[i].g, m_foliageArray[i].b);
    }
 
    // 인스턴스 버퍼의 구조체를 설정합니다.
    D3D11_BUFFER_DESC instanceBufferDesc;
    instanceBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    instanceBufferDesc.ByteWidth = sizeof(InstanceType) * m_instanceCount;
    instanceBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    instanceBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    instanceBufferDesc.MiscFlags = 0;
    instanceBufferDesc.StructureByteStride = 0;
 
    // 하위 리소스 구조에 인스턴스 데이터에 대한 포인터를 제공합니다.
    D3D11_SUBRESOURCE_DATA instanceData;
    instanceData.pSysMem = m_Instances;
    instanceData.SysMemPitch = 0;
    instanceData.SysMemSlicePitch = 0;
 
    // 인스턴스 버퍼를 만듭니다.
    if(FAILED(device->CreateBuffer(&instanceBufferDesc, &instanceData, &m_instanceBuffer)))
    {
        return false;
    }
 
    return true;
}
 
 
void FoliageClass::ShutdownBuffers()
{
    // 인스턴스 버퍼를 해제합니다.
    if(m_instanceBuffer)
    {
        m_instanceBuffer->Release();
        m_instanceBuffer = 0;
    }
 
    // 버텍스 버퍼를 해제합니다.
    if(m_vertexBuffer)
    {
        m_vertexBuffer->Release();
        m_vertexBuffer = 0;
    }
 
    // 인스턴스 배열을 해제합니다.
    if(m_Instances)
    {
        delete [] m_Instances;
        m_Instances = 0;
    }
}
 
 
void FoliageClass::RenderBuffers(ID3D11DeviceContext* deviceContext)
{
    // 버퍼 스트라이드를 설정합니다.
    unsigned int strides[2] = { sizeof(VertexType), sizeof(InstanceType) };
 
    // 버퍼 오프셋을 설정합니다.
    unsigned int offsets[2] = { 0, 0 };
 
    // 포인터의 배열을 정점 버퍼와 인스턴스 버퍼로 설정합니다.
    ID3D11Buffer* bufferPointers[2] = { m_vertexBuffer, m_instanceBuffer };
 
    // 렌더링 할 수 있도록 입력 어셈블러에서 꼭지점 버퍼와 인스턴스 버퍼를 활성화로 설정합니다.
    deviceContext->IASetVertexBuffers(0, 2, bufferPointers, strides, offsets);
 
    // 이 꼭지점 버퍼에서 렌더링되어야하는 프리미티브 유형을 설정합니다.이 경우에는 삼각형입니다.
    deviceContext->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
}
 
 
bool FoliageClass::LoadTexture(ID3D11Device* device, const WCHAR* filename)
{
    // 텍스처 오브젝트를 생성한다.
    m_Texture = new TextureClass;
    if(!m_Texture)
    {
        return false;
    }
 
    // 텍스처 오브젝트를 초기화한다.
    if(!m_Texture->Initialize(device, filename))
    {
        return false;
    }
 
    return true;
}
 
 
void FoliageClass::ReleaseTexture()
{
    // 텍스처 오브젝트를 릴리즈한다.
    if(m_Texture)
    {
        m_Texture->Shutdown();
        delete m_Texture;
        m_Texture = 0;
    }
}
 
 
bool FoliageClass::GeneratePositions()
{
    // 모든 단풍 정보를 저장할 배열을 만듭니다.
    m_foliageArray = new FoliageType[m_foliageCount];
    if(!m_foliageArray)
    {
        return false;
    }
 
    // 난수 생성기에 시드합니다.
    srand((int)time(NULL));
 
    // 각 조각에 임의의 위치와 임의의 색상을 설정합니다.
    for(int i=0; i<m_foliageCount; i++)
    {
        m_foliageArray[i].x = ((float)rand() / (float)(RAND_MAX)) * 9.0f - 4.5f;
        m_foliageArray[i].z = ((float)rand() / (float)(RAND_MAX)) * 9.0f - 4.5f;
 
        float red = ((float)rand() / (float)(RAND_MAX)) * 1.0f;
        float green = ((float)rand() / (float)(RAND_MAX)) * 1.0f;
 
        m_foliageArray[i].r = red + 1.0f;
        m_foliageArray[i].g = green + 0.5f;
        m_foliageArray[i].b = 0.0f;
    }
 
    return true;
}

foliage HLSL shader는 인스턴스화를 사용하여 하나의 두 삼각형 모델 조각을 렌더링합니다.

Foliage_vs.hlsl

////////////////////////////////////////////////////////////////////////////////
// Filename: foliage_vs.hlsl
////////////////////////////////////////////////////////////////////////////////
 
 
/////////////
// GLOBALS //
/////////////
cbuffer MatrixBuffer
{
    matrix viewMatrix;
    matrix projectionMatrix;
};
 
 
//////////////
// TYPEDEFS //
//////////////
struct VertexInputType
{
    float4 position : POSITION;
    float2 tex : TEXCOORD0;
    row_major matrix instanceWorld : WORLD;
    float3 instanceColor : TEXCOORD1;
};
 
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
    float3 foliageColor : TEXCOORD1;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// Vertex Shader
////////////////////////////////////////////////////////////////////////////////
PixelInputType FoliageVertexShader(VertexInputType input)
{
    PixelInputType output;
    
    // 적절한 행렬 계산을 위해 위치 벡터를 4 단위로 변경합니다.
    input.position.w = 1.0f;
 
    // 월드, 뷰 및 투영 행렬에 대한 정점의 위치를 ​​계산합니다.
    output.position = mul(input.position, input.instanceWorld);
    output.position = mul(output.position, viewMatrix);
    output.position = mul(output.position, projectionMatrix);
    
    // 픽셀 쉐이더의 텍스처 좌표를 저장한다.
    output.tex = input.tex;
    
    // 인스턴스화 된 foliage color를 픽셀 쉐이더로 보낸다.
    output.foliageColor = input.instanceColor;
 
    return output;
}

Foliage_ps.hlsl

////////////////////////////////////////////////////////////////////////////////
// Filename: foliage_ps.hlsl
////////////////////////////////////////////////////////////////////////////////
 
 
/////////////
// GLOBALS //
/////////////
Texture2D shaderTexture;
SamplerState SampleType;
 
 
//////////////
// TYPEDEFS //
//////////////
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
    float3 foliageColor : TEXCOORD1;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// Pixel Shader
////////////////////////////////////////////////////////////////////////////////
float4 FoliagePixelShader(PixelInputType input) : SV_TARGET
{
    float4 textureColor;
    float4 color;
 
 
    // 이 텍스처 좌표 위치에서 샘플러를 사용하여 텍스처에서 픽셀 색상을 샘플링합니다.
    textureColor = shaderTexture.Sample(SampleType, input.tex);
 
    // 텍스처와 단풍 색을 결합합니다.
    color = textureColor * float4(input.foliageColor, 1.0f);
 
    // 최종 색상 결과를 포화시킵니다.
    color = saturate(color);
 
    return color;
}

Foliageshaderclass.h

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

Foliageshaderclass.cpp

#include "stdafx.h"
#include "foliageshaderclass.h"
 
 
FoliageShaderClass::FoliageShaderClass()
{
}
 
 
FoliageShaderClass::FoliageShaderClass(const FoliageShaderClass& other)
{
}
 
 
FoliageShaderClass::~FoliageShaderClass()
{
}
 
 
bool FoliageShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
    // 정점 및 픽셀 쉐이더를 초기화합니다.
    return InitializeShader(device, hwnd, L"../Dx11Terrain_19/foliage_vs.hlsl", L"../Dx11Terrain_19/foliage_ps.hlsl");
}
 
 
void FoliageShaderClass::Shutdown()
{
    // 버텍스 및 픽셀 쉐이더와 관련된 객체를 종료합니다.
    ShutdownShader();
}
 
 
bool FoliageShaderClass::Render(ID3D11DeviceContext* deviceContext, int vertexCount, int instanceCount, XMMATRIX viewMatrix, 
                                XMMATRIX projectionMatrix, ID3D11ShaderResourceView* texture)
{
    // 렌더링에 사용할 셰이더 매개 변수를 설정합니다.
    if (!SetShaderParameters(deviceContext, viewMatrix, projectionMatrix, texture))
    {
        return false;
    }
 
    // 설정된 버퍼를 셰이더로 렌더링한다.
    RenderShader(deviceContext, vertexCount, instanceCount);
 
    return true;
}
 
 
bool FoliageShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, const WCHAR* vsFilename, const WCHAR* psFilename)
{
    HRESULT result;
    ID3D10Blob* errorMessage = nullptr;
 
    // 버텍스 쉐이더 코드를 컴파일한다.
    ID3D10Blob* vertexShaderBuffer = nullptr;
    result = D3DCompileFromFile(vsFilename, NULL, NULL, "FoliageVertexShader", "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, "FoliagePixelShader", "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[7];
    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 = "WORLD";
    polygonLayout[2].SemanticIndex = 0;
    polygonLayout[2].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
    polygonLayout[2].InputSlot = 1;
    polygonLayout[2].AlignedByteOffset = 0;
    polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_INSTANCE_DATA;
    polygonLayout[2].InstanceDataStepRate = 1;
 
    polygonLayout[3].SemanticName = "WORLD";
    polygonLayout[3].SemanticIndex = 1;
    polygonLayout[3].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
    polygonLayout[3].InputSlot = 1;
    polygonLayout[3].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[3].InputSlotClass = D3D11_INPUT_PER_INSTANCE_DATA;
    polygonLayout[3].InstanceDataStepRate = 1;
 
    polygonLayout[4].SemanticName = "WORLD";
    polygonLayout[4].SemanticIndex = 2;
    polygonLayout[4].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
    polygonLayout[4].InputSlot = 1;
    polygonLayout[4].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[4].InputSlotClass = D3D11_INPUT_PER_INSTANCE_DATA;
    polygonLayout[4].InstanceDataStepRate = 1;
 
    polygonLayout[5].SemanticName = "WORLD";
    polygonLayout[5].SemanticIndex = 3;
    polygonLayout[5].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
    polygonLayout[5].InputSlot = 1;
    polygonLayout[5].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[5].InputSlotClass = D3D11_INPUT_PER_INSTANCE_DATA;
    polygonLayout[5].InstanceDataStepRate = 1;
 
    polygonLayout[6].SemanticName = "TEXCOORD";
    polygonLayout[6].SemanticIndex = 1;
    polygonLayout[6].Format = DXGI_FORMAT_R32G32B32_FLOAT;
    polygonLayout[6].InputSlot = 1;
    polygonLayout[6].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[6].InputSlotClass = D3D11_INPUT_PER_INSTANCE_DATA;
    polygonLayout[6].InstanceDataStepRate = 1;
 
    // 레이아웃의 요소 수를 가져옵니다.
    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_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_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;
    }
 
    return true;
}
 
 
void FoliageShaderClass::ShutdownShader()
{
    // 샘플러 상태를 해제한다.
    if (m_sampleState)
    {
        m_sampleState->Release();
        m_sampleState = 0;
    }
 
    // 행렬 상수 버퍼를 해제합니다.
    if(m_matrixBuffer)
    {
        m_matrixBuffer->Release();
        m_matrixBuffer = 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 FoliageShaderClass::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 FoliageShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, XMMATRIX viewMatrix, 
                                             XMMATRIX projectionMatrix, ID3D11ShaderResourceView* texture)
{
    // 행렬을 transpose하여 셰이더에서 사용할 수 있게 합니다
    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->view = viewMatrix;
    dataPtr->projection = projectionMatrix;
 
    // 상수 버퍼의 잠금을 풉니다.
    deviceContext->Unmap(m_matrixBuffer, 0);
 
    // 정점 셰이더에서의 상수 버퍼의 위치를 설정합니다.
    unsigned int bufferNumber = 0;
 
    // 마지막으로 정점 셰이더의 상수 버퍼를 바뀐 값으로 바꿉니다.
    deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer);
 
    // 픽셀 셰이더에서 셰이더 텍스처 리소스를 설정합니다.
    deviceContext->PSSetShaderResources(0, 1, &texture);
 
    return true;
}
 
 
void FoliageShaderClass::RenderShader(ID3D11DeviceContext* deviceContext, int vertexCount, int instanceCount)
{
    // 정점 입력 레이아웃을 설정합니다.
    deviceContext->IASetInputLayout(m_layout);
 
    // 삼각형을 그릴 정점 셰이더와 픽셀 셰이더를 설정합니다.
    deviceContext->VSSetShader(m_vertexShader, NULL, 0);
    deviceContext->PSSetShader(m_pixelShader, NULL, 0);
 
    // 픽셀 쉐이더에서 샘플러 상태를 설정합니다.
    deviceContext->PSSetSamplers(0, 1, &m_sampleState);
 
    // 삼각형을 그립니다.
    deviceContext->DrawInstanced(vertexCount, instanceCount, 0, 0);
}

Applicationclass.h

#pragma once
 
/////////////
// GLOBALS //
/////////////
const bool FULL_SCREEN = false;
const bool VSYNC_ENABLED = true;
const float SCREEN_DEPTH = 100.0f;
const float SCREEN_NEAR = 0.1f;
 
 
class InputClass;
class D3DClass;
class ShaderManagerClass;
class TimerClass;
class PositionClass;
class CameraClass;
class FpsClass;
class UserInterfaceClass;
class ModelClass;
class FoliageClass;
 
 
class ApplicationClass
{
public:
    ApplicationClass();
    ApplicationClass(const ApplicationClass&);
    ~ApplicationClass();
 
    bool Initialize(HINSTANCE, HWND, int, int);
    void Shutdown();
    bool Frame();
 
private:
    bool HandleMovementInput(float);
    bool Render();
    bool RenderSceneToTexture();
 
private:
    InputClass* m_Input = nullptr;
    D3DClass* m_Direct3D = nullptr;
    ShaderManagerClass* m_ShaderManager = nullptr;
    TimerClass* m_Timer = nullptr;
    PositionClass* m_Position = nullptr;
    CameraClass* m_Camera = nullptr;
    FpsClass* m_Fps = nullptr;
    UserInterfaceClass* m_UserInterface = nullptr;
    ModelClass* m_GroundModel = nullptr;
    FoliageClass* m_Foliage = nullptr;
};

Applicationclass.cpp

#include "stdafx.h"
#include "inputclass.h"
#include "d3dclass.h"
#include "shadermanagerclass.h"
#include "timerclass.h"
#include "positionclass.h"
#include "cameraclass.h"
#include "fpsclass.h"
#include "userinterfaceclass.h"
#include "modelclass.h"
#include "foliageclass.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_ShaderManager = new ShaderManagerClass;
    if(!m_ShaderManager)
    {
        return false;
    }
 
    // 쉐이더 매니저 객체를 초기화 합니다.
    result = m_ShaderManager->Initialize(m_Direct3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the shader manager 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(XMFLOAT3(0.0f, 1.5f, -4.0f));
    m_Position->SetRotation(XMFLOAT3(15.0f, 0.0f, 0.0f));
    
    // 카메라 객체를 생성합니다.
    m_Camera = new CameraClass;
    if(!m_Camera)
    {
        return false;
    }
 
    // 2D 사용자 인터페이스 렌더링을 위해 카메라로 기본 뷰 행렬을 초기화 합니다.
    m_Camera->SetPosition(XMFLOAT3(0.0f, 0.0f, -10.0f));
    m_Camera->Render();
    m_Camera->RenderBaseViewMatrix();
 
    // fps 객체를 생성합니다.
    m_Fps = new FpsClass;
    if(!m_Fps)
    {
        return false;
    }
 
    // fps 객체를 초기화 합니다.
    m_Fps->Initialize();
 
    // 사용자 인터페이스 객체를 생성합니다.
    m_UserInterface = new UserInterfaceClass;
    if(!m_UserInterface)
    {
        return false;
    }
 
    // 사용자 인터페이스 객체를 초기화합니다.
    result = m_UserInterface->Initialize(m_Direct3D, screenWidth, screenHeight);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the user interface object.", L"Error", MB_OK);
        return false;
    }
 
    // 지면 모델 객체를 생성합니다.
    m_GroundModel = new ModelClass;
    if(!m_GroundModel)
    {
        return false;
    }
 
    // 지면 모델 객체를 초기화합니다.
    result = m_GroundModel->Initialize(m_Direct3D->GetDevice(), "../Dx11Terrain_19/data/plane01.txt", 
                                                               L"../Dx11Terrain_19/data/rock015.dds");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the ground model object.", L"Error", MB_OK);
        return false;
    }
 
    // 단풍 객체를 생성합니다.
    m_Foliage = new FoliageClass;
    if(!m_Foliage)
    {
        return false;
    }
 
    // 단풍 객체를 초기화 합니다.
    result = m_Foliage->Initialize(m_Direct3D->GetDevice(), L"../Dx11Terrain_19/data/grass.dds", 500);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the foliage object.", L"Error", MB_OK);
        return false;
    }
 
    return true;
}
 
 
void ApplicationClass::Shutdown()
{
    // 단풍 객체를 해제합니다.
    if(m_Foliage)
    {
        m_Foliage->Shutdown();
        delete m_Foliage;
        m_Foliage = 0;
    }
 
    // 지면 모델 객체를 해제합니다.
    if(m_GroundModel)
    {
        m_GroundModel->Shutdown();
        delete m_GroundModel;
        m_GroundModel = 0;
    }
 
    // 사용자 인터페이스 객체를 해제합니다.
    if(m_UserInterface)
    {
        m_UserInterface->Shutdown();
        delete m_UserInterface;
        m_UserInterface = 0;
    }
 
    // fps 객체를 해제합니다.
    if(m_Fps)
    {
        delete m_Fps;
        m_Fps = 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;
    }
 
    // 쉐이더 관리자 객체를 해제합니다.
    if(m_ShaderManager)
    {
        m_ShaderManager->Shutdown();
        delete m_ShaderManager;
        m_ShaderManager = 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()
{
    XMFLOAT3 pos = XMFLOAT3(0.0f, 0.0f, 0.0f);
    XMFLOAT3 rot = XMFLOAT3(0.0f, 0.0f, 0.0f);
    
    // 시스템 통계를 업데이트 합니다.
    m_Timer->Frame();
    m_Fps->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;
    }
 
    // 시점 위치 / 회전을 가져옵니다.
    m_Position->GetPosition(pos);
    m_Position->GetRotation(rot);
    
    // 사용자 인터페이스에 대한 프레임 처리를 수행합니다.
    result = m_UserInterface->Frame(m_Fps->GetFps(), pos, rot, m_Direct3D->GetDeviceContext());
    if(!result)
    {
        return false;
    }
 
    // 카메라 위치를 얻는다.
    XMFLOAT3 cameraPosition = m_Camera->GetPosition();
 
    // 단풍에 대한 프레임 처리를 수행합니다.
    result = m_Foliage->Frame(cameraPosition, m_Direct3D->GetDeviceContext());
    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, orthoMatrix, baseViewMatrix;
 
    // 장면을 지웁니다.
    m_Direct3D->BeginScene(0.0f, 0.65f, 1.0f, 1.0f);
 
    // 카메라의 위치에 따라 뷰 행렬을 생성합니다.
    m_Camera->Render();
 
    // 카메라, Direct3D 객체로부터 월드, 뷰, 프로젝션, 오쏘,베이스 뷰 매트릭스를 가져옵니다.
    m_Direct3D->GetWorldMatrix(worldMatrix);
    m_Camera->GetViewMatrix(viewMatrix);
    m_Direct3D->GetProjectionMatrix(projectionMatrix);
    m_Direct3D->GetOrthoMatrix(orthoMatrix);
    m_Camera->GetBaseViewMatrix(baseViewMatrix);
 
    // 그라운드 모델을 렌더링합니다.
    m_GroundModel->Render(m_Direct3D->GetDeviceContext());
    m_ShaderManager->RenderTextureShader(m_Direct3D->GetDeviceContext(), m_GroundModel->GetIndexCount(), worldMatrix,
                                         viewMatrix, projectionMatrix, m_GroundModel->GetColorTexture());
 
    // 알파 대 커버리지 블렌드를 켭니다.
    m_Direct3D->EnableAlphaToCoverageBlending();
 
    // 단풍을 렌더링합니다.
    m_Foliage->Render(m_Direct3D->GetDeviceContext());
    m_ShaderManager->RenderFoliageShader(m_Direct3D->GetDeviceContext(), m_Foliage->GetVertexCount(), 
                                         m_Foliage->GetInstanceCount(), viewMatrix, projectionMatrix,
                                         m_Foliage->GetTexture());
 
    // 알파 블렌딩을 끕니다.
    m_Direct3D->TurnOffAlphaBlending();
 
    // 사용자 인터페이스를 렌더링합니다.
    m_UserInterface->Render(m_Direct3D, m_ShaderManager, worldMatrix, baseViewMatrix, orthoMatrix);
    
    // 렌더링 된 장면을 화면에 표시합니다.
    m_Direct3D->EndScene();
 
    return true;
}

출력 화면

마치면서

이제는 단 하나의 쿼드를 사용하여 각 조각에 고유한 색상, 위치 및 회전을 가진 인스턴스가 있는 샘플을 렌더링 할 수 있습니다.

연습문제

1. 프로그램을 컴파일하고 실행하십시오. 화살표 키와 A, Z, PgUp, PgDn을 사용하여 잎사귀를 검사하십시오.

2. 단풍의 인스턴스 컬러를 수정합니다.

3. 잎 수를 늘리거나 줄입니다.

4. 더 크고 다른 애니메이션 속도를 가지며 더 적은 수의 다른 꽃의 단풍 개체를 추가하십시오 (간단히 FoliageClass를 수정하십시오).

5. 움직이지 않는 정적인 단풍을 추가하십시오.

6. 각 조각의 크기 (규모)에 대한 인스턴스를 추가합니다.

7. 단일 쿼드 대신 교차하는 접기 방법을 사용하여 차이점을 확인하십시오 (카메라를 향해 회전시키지 않으므로 다시 표면 컬링을 해제해야 합니다).

8. 잔디밭에서 바람의 돌풍을 만들기 위해 펄린 노이즈와 같은 더 진보된 바람 애니메이션을 시도해 보십시오.

9. 잎이 항상 즉각적인 영역에서 렌더링되지만 25 미터가 넘지 않도록 거리에 대한 LOD를 설정하십시오.

10. 밀도 매개 변수를 설정하여 낮은, 중간 및 높은 밀도 수준의 단풍을 가질 수 있습니다 (배열마다 매 3 번째 단풍을 낮게 표시 할 때마다 매초마다).

11. 자신의 지형 엔진에 단풍을 구현하십시오. 쿼드 트리를 사용하여 각 경관을 배치할 높이를 결정하십시오.

12. 색상 맵과 유사한 "단풍지도"를 만들고 각 엽서에 지형의 특정 또는 완전히 임의의 위치를 지정하는 대신 허용된 색상 영역 내에 무작위로 단풍을 배치하십시오.

소스코드

소스코드 : Dx11Terrain_19.zip