DirectX11 Tutorial 27: 반사

Tutorial 27: Reflection

원문: http://rastertek.com/dx11tut27.html (이 번역에 나오는 모든 이미지와 소스코드의 출처는 원문입니다.)

이번 튜토리얼에서는 DirectX 11에서 HLSL과 C++를 이용하여 반사효과를 내는 법을 다룹니다. 이 튜토리얼에 사용된 코드는 이전 튜토리얼에서 이어집니다. 여기서는 바닥에 반사된 육면체를 그려볼 것입니다.

반사 효과를 내기 위해서는 반사 뷰 행렬이 필요합니다. 이 행렬은 평면의 반대쪽에서 바라본다는 것을 제외하면 보통 카메라에서 생성한 뷰 행렬과 동일합니다.

육면체가 바닥에 반사되는 것이기 때문에 Y축을 따라 반사 행렬을 만들도록 해야 합니다. 이 튜토리얼에서는 카메라의 Y좌표가 0.0이고 바닥이 -1. 5에 위치해 있습니다. 반사 시점은 바닥과 카메라의 상대 위치의 정반대이기 때문에 Y축 기준으로 -3.0위치가 될 것입니다. 이 예를 그림으로 표현해 보면 다음과 같습니다:

반사 행렬을 구하고 나면 일반 카메라의 뷰를 이용하는 것이 아니라 반사 뷰를 이용하여 화면을 그립니다. 그리고 그 결과는 백버퍼 대신 텍스쳐에 쓰여지게 합니다. 이렇게 하여 반사 화면이 텍스쳐에 그려지게 됩니다.

마지막 단계는 두 번째 렌더링 단계를 만들어 반사체가 그려진 텍스쳐를 바닥에 혼합되게 하는 것입니다. 반사 행렬과 일반 뷰 행렬을 이용하여 바닥의 모양에 맞게 텍스쳐가 그려지게 합니다.

프레임워크

이번 튜토리얼에는 ReflectionShaderClass 클래스가 추가되었습니다. 이 클래스는 TextrueShaderClass 클래스에 HLSL 셰이더 코드에 반사 뷰 행렬과 반사 텍스쳐를 제어하는 기능이 추가된 것입니다.

우선 HLSL 셰이더 코드를 보도록 하겠습니다.

Reflection.vs

////////////////////////////////////////////////////////////////////////////////
// Filename: reflection.vs
////////////////////////////////////////////////////////////////////////////////


/////////////
// GLOBALS //
/////////////
cbuffer MatrixBuffer
{
    matrix worldMatrix;
    matrix viewMatrix;
    matrix projectionMatrix;
};

반사 행렬을 저장할 상수 버퍼를 선언합니다.

cbuffer ReflectionBuffer
{
    matrix reflectionMatrix;
};


//////////////
// TYPEDEFS //
//////////////
struct VertexInputType
{
    float4 position : POSITION;
    float2 tex : TEXCOORD0;
};

PixelInputType에 reflectionPosition이라는 float4 변수를 추가합니다. 이 변수는 투영된 반사 텍스쳐의 입력 위치를 저장하는 데 사용됩니다.

struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
    float4 reflectionPosition : TEXCOORD1;
};


////////////////////////////////////////////////////////////////////////////////
// Vertex Shader
////////////////////////////////////////////////////////////////////////////////
PixelInputType ReflectionVertexShader(VertexInputType input)
{
    PixelInputType output;
    matrix reflectProjectWorld;
    

    // 정상적인 행렬 연산을 위해 위치 벡터의 마지막 값을 수정합니다.
    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;

정점 셰이더의 변화 가운데 한 가지는 입력된 입력 위치값들을 반사된 위치로 변환하는 행렬을 만든다는 것입니다. 이 행렬은 반사 행렬과 프로젝션 행렬, 월드 행렬의 조합으로 만들어집니다.

    // 반사 투영 월드 행렬을 생성합니다.
    reflectProjectWorld = mul(reflectionMatrix, projectionMatrix);
    reflectProjectWorld = mul(worldMatrix, reflectProjectWorld);

이제 입력 위치를 반사된 위치로 바꿔줍니다. 이 바꿔진 좌표들은 픽셀 셰이더에서 반사 텍스쳐의 어느 위치에 투영시킬지 정하는 데 사용될 것입니다.

    // reflectProjectWorld 행렬에 비추어 입력 위치를 계산합니다.
    output.reflectionPosition = mul(input.position, reflectProjectWorld);

    return output;
}

Reflection.ps

////////////////////////////////////////////////////////////////////////////////
// Filename: reflection.ps
////////////////////////////////////////////////////////////////////////////////


/////////////
// GLOBALS //
/////////////
Texture2D shaderTexture;
SamplerState SampleType;

반사가 그려질 텍스쳐를 저장할 변수를 선언합니다.

Texture2D reflectionTexture;


//////////////
// TYPEDEFS //
//////////////
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
    float4 reflectionPosition : TEXCOORD1;
};


////////////////////////////////////////////////////////////////////////////////
// Pixel Shader
////////////////////////////////////////////////////////////////////////////////
float4 ReflectionPixelShader(PixelInputType input) : SV_TARGET
{
    float4 textureColor;
    float2 reflectTexCoord;
    float4 reflectionColor;
    float4 color;


    // 이 위치의 텍스쳐의 픽셀값을 샘플링합니다.
    textureColor = shaderTexture.Sample(SampleType, input.tex);

입력된 반사 위치 좌표는 적절한 텍스쳐 좌표계로 변환되야 합니다. 그렇게 하기 위해서는 우선 w좌표로 나눕니다. 그러면 tu와 tv좌표가 -1과 1사이의 값을 가지게 되기 때문에 2를 더하고 0.5를 곱하여 0과 1사이의 범위로 맞춰줍니다.

    // 반사 텍스쳐에 투영될 좌표를 계산합니다.
    reflectTexCoord.x = input.reflectionPosition.x / input.reflectionPosition.w / 2.0f + 0.5f;
    reflectTexCoord.y = -input.reflectionPosition.y / input.reflectionPosition.w / 2.0f + 0.5f;

반사 텍스쳐에서 샘플링할 때에는 바로 위에서 계산했던 투영된 반사 텍스쳐의 좌표를 사용하여 올바른 위치의 값을 가져옵니다.

    // 투영시킨 텍스쳐 좌표를 이용하여 반사 텍스쳐의 픽셀을 샘플링합니다.
    reflectionColor = reflectionTexture.Sample(SampleType, reflectTexCoord);

마지막으로 바닥에 반사 텍스쳐를 혼합하여 바닥에 육면체가 반사된 듯한 효과를 냅니다. 여기서는 0.15의 값으로 선형 보간(linear interpolation)을 합니다. 이 값을 좀 더 바꿔서 혼합 비율을 바꾸면 강렬하거나 다른 효과들도 줄 수 있습니다.

    // 두 텍스쳐 사이에 선형 보간을 하여 혼합 효과를 줍니다.
    color = lerp(textureColor, reflectionColor, 0.15f);

    return color;
}

Reflectionshaderclass.h

ReflectionShaderClass는 TextureShaderClass에 반사 뷰 행렬 버퍼와 반사 텍스쳐를 다루는 기능이 추가된 것입니다.

////////////////////////////////////////////////////////////////////////////////
// Filename: reflectionshaderclass.h
////////////////////////////////////////////////////////////////////////////////
#ifndef _REFLECTIONSHADERCLASS_H_
#define _REFLECTIONSHADERCLASS_H_


//////////////
// INCLUDES //
//////////////
#include <d3d11.h>
#include <d3dx10math.h>
#include <d3dx11async.h>
#include <fstream>
using namespace std;


////////////////////////////////////////////////////////////////////////////////
// Class name: ReflectionShaderClass
////////////////////////////////////////////////////////////////////////////////
class ReflectionShaderClass
{
private:
    struct MatrixBufferType
    {
        D3DXMATRIX world;
        D3DXMATRIX view;
        D3DXMATRIX projection;
    };

반사 뷰 행렬을 위한 동적 상수 버퍼의 구조체입니다.

    struct ReflectionBufferType
    {
        D3DXMATRIX reflectionMatrix;
    };

public:
    ReflectionShaderClass();
    ReflectionShaderClass(const ReflectionShaderClass&);
    ~ReflectionShaderClass();

    bool Initialize(ID3D11Device*, HWND);
    void Shutdown();
    bool Render(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, 
            ID3D11ShaderResourceView*, D3DXMATRIX);

private:
    bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*);
    void ShutdownShader();
    void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*);

    bool SetShaderParameters(ID3D11DeviceContext*, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, 
                 ID3D11ShaderResourceView*, D3DXMATRIX);
    void RenderShader(ID3D11DeviceContext*, int);

private:
    ID3D11VertexShader* m_vertexShader;
    ID3D11PixelShader* m_pixelShader;
    ID3D11InputLayout* m_layout;
    ID3D11Buffer* m_matrixBuffer;
    ID3D11SamplerState* m_sampleState;

반사 뷰 행렬을 위한 버퍼를 선언합니다.

    ID3D11Buffer* m_reflectionBuffer;
};

#endif

Reflectionshaderclass.cpp

////////////////////////////////////////////////////////////////////////////////
// Filename: reflectionshaderclass.cpp
////////////////////////////////////////////////////////////////////////////////
#include "reflectionshaderclass.h"


ReflectionShaderClass::ReflectionShaderClass()
{
    m_vertexShader = 0;
    m_pixelShader = 0;
    m_layout = 0;
    m_matrixBuffer = 0;
    m_sampleState = 0;

반사 상수 버퍼를 null로 초기화합니다.

    m_reflectionBuffer = 0;
}


ReflectionShaderClass::ReflectionShaderClass(const ReflectionShaderClass& other)
{
}


ReflectionShaderClass::~ReflectionShaderClass()
{
}


bool ReflectionShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
    bool result;

반사 HLSL 셰이더를 로드합니다.

    // 정점 및 픽셀 셰이더를 초기화합니다.
    result = InitializeShader(device, hwnd, L"../Engine/reflection.vs", L"../Engine/reflection.ps");
    if(!result)
    {
        return false;
    }

    return true;
}


void ReflectionShaderClass::Shutdown()
{
    // 정점 및 픽셀 셰이더, 그리고 관련된 객체들을 해제합니다.
    ShutdownShader();

    return;
}

Render함수는 반사 텍스쳐와 반사 행렬을 인자로 받습니다. 렌더링이 일어나기 전에 셰이더에 이 값을 세팅합니다.

bool ReflectionShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, D3DXMATRIX worldMatrix, 
                   D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture,
                   ID3D11ShaderResourceView* reflectionTexture, D3DXMATRIX reflectionMatrix)
{
    bool result;


    // 렌더링에 사용할 셰이더 인자들을 설정합니다.
    result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, reflectionTexture, 
                     reflectionMatrix);
    if(!result)
    {
        return false;
    }

    // 셰이더를 이용하여 버퍼에 렌더링합니다.
    RenderShader(deviceContext, indexCount);

    return true;
}


bool ReflectionShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
    HRESULT result;
    ID3D10Blob* errorMessage;
    ID3D10Blob* vertexShaderBuffer;
    ID3D10Blob* pixelShaderBuffer;
    D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
    unsigned int numElements;
    D3D11_BUFFER_DESC matrixBufferDesc;
    D3D11_SAMPLER_DESC samplerDesc;
    D3D11_BUFFER_DESC reflectionBufferDesc;


    // 이 함수에서 사용할 포인터들을 null로 초기화합니다.
    errorMessage = 0;
    vertexShaderBuffer = 0;
    pixelShaderBuffer = 0;

반사 정점 셰이더를 로드합니다.

    // 정점 셰이더를 컴파일합니다.
    result = D3DX11CompileFromFile(vsFilename, NULL, NULL, "ReflectionVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 
                       0, NULL, &vertexShaderBuffer, &errorMessage, NULL);
    if(FAILED(result))
    {
        // If the shader failed to compile it should have writen something to the error message.
        if(errorMessage)
        {
            OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
        }
        // If there was  nothing in the error message then it simply could not find the shader file itself.
        else
        {
            MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
        }

        return false;
    }

반사 픽셀 셰이더를 로드합니다.

    // 픽셀 셰이더를 컴파일합니다.
    result = D3DX11CompileFromFile(psFilename, NULL, NULL, "ReflectionPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 
                       0, NULL, &pixelShaderBuffer, &errorMessage, NULL);
    if(FAILED(result))
    {
        // If the shader failed to compile it should have writen something to the error message.
        if(errorMessage)
        {
            OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
        }
        // If there was  nothing in the error message then it simply could not find the file itself.
        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;
    }

    // 정점 입력 레이아웃의 description을 작성합니다.
    // 이 레이아웃은 ModelClass와 셰이더에 있는 VertexType과 그 구조가 일치해야 합니다.
    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;

    // 레이아웃의 원소의 수를 구합니다.
    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;

    // 정점 셰이더에 있는 행렬 동적 상수 버퍼를 설정합니다.
    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;
    }

    // 텍스쳐 샘플러의 description을 작성합니다.
    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;
    }

반사 행렬의 동적 상수 버퍼를 생성합니다.

    // 정점 셰이더에 들어가는 반사 행렬의 동적 상수 버퍼에 대한 description을 작성합니다.
    reflectionBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    reflectionBufferDesc.ByteWidth = sizeof(ReflectionBufferType);
    reflectionBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    reflectionBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    reflectionBufferDesc.MiscFlags = 0;
    reflectionBufferDesc.StructureByteStride = 0;

    // 버퍼를 생성하여 정점 셰이더의 상수 버퍼에 접근할 수 있게 합니다.
    result = device->CreateBuffer(&reflectionBufferDesc, NULL, &m_reflectionBuffer);
    if(FAILED(result))
    {
        return false;
    }

    return true;
}


void ReflectionShaderClass::ShutdownShader()
{

ShutdownShader함수에서 반사 버퍼를 해제합니다.

    // 반사 상수 버퍼를 해제합니다.
    if(m_reflectionBuffer)
    {
        m_reflectionBuffer->Release();
        m_reflectionBuffer = 0;
    }

    // 샘플러를 해제합니다.
    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;
    }

    return;
}


void ReflectionShaderClass::OutputShaderErrorMessage(ID3D10Blob* errorMessage, HWND hwnd, WCHAR* shaderFilename)
{
    char* compileErrors;
    unsigned long bufferSize, i;
    ofstream fout;


    // Get a pointer to the error message text buffer.
    compileErrors = (char*)(errorMessage->GetBufferPointer());

    // Get the length of the message.
    bufferSize = errorMessage->GetBufferSize();

    // Open a file to write the error message to.
    fout.open("shader-error.txt");

    // Write out the error message.
    for(i=0; i<bufferSize; i++)
    {
        fout << compileErrors[i];
    }

    // Close the file.
    fout.close();

    // Release the error message.
    errorMessage->Release();
    errorMessage = 0;

    // Pop a message up on the screen to notify the user to check the text file for compile errors.
    MessageBox(hwnd, L"Error compiling shader.  Check shader-error.txt for message.", shaderFilename, MB_OK);

    return;
}


bool ReflectionShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, 
                        D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture,
                        ID3D11ShaderResourceView* reflectionTexture, D3DXMATRIX reflectionMatrix)
{
    HRESULT result;
    D3D11_MAPPED_SUBRESOURCE mappedResource;
    MatrixBufferType* dataPtr;
    unsigned int bufferNumber;
    ReflectionBufferType* dataPtr2;


    // 셰이더에 사용할 행렬을 준비합니다.
    D3DXMatrixTranspose(&amp;worldMatrix, &amp;worldMatrix);
    D3DXMatrixTranspose(&amp;viewMatrix, &amp;viewMatrix);
    D3DXMatrixTranspose(&amp;projectionMatrix, &amp;projectionMatrix);

DirectX 11에서는 메모리 정렬 문제로 모든 입력 행렬들을 변환되어 있어야 하므로 반사 행렬도 변환해 둡니다.

    // 셰이더에 사용할 반사 행렬을 변환해 둡니다.
    D3DXMatrixTranspose(&reflectionMatrix, &reflectionMatrix);

    // 기록할 수 있도록 행렬 상수 버퍼를 잠급니다.
    result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
    if(FAILED(result))
    {
        return false;
    }

    // 행렬 상수 버퍼의 데이터 포인터를 얻어옵니다.
    dataPtr = (MatrixBufferType*)mappedResource.pData;

    // 행렬들을 상수 버퍼에 복사합니다.
    dataPtr->world = worldMatrix;
    dataPtr->view = viewMatrix;
    dataPtr->projection = projectionMatrix;

    // 행렬 상수 버퍼의 잠금을 해제합니다.
    deviceContext->Unmap(m_matrixBuffer, 0);

    // 정점 셰이더상의 행렬 상수 버퍼의 위치입니다.
    bufferNumber = 0;

    // 갱신된 값으로 정점 셰이더의 행렬 상수 버퍼를 설정합니다.
    deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer);

반사 버퍼를 잠근 뒤 반사 행렬을 복사합니다. 그리고 나서 잠금을 해제하고 정점 셰이더에 값을 설정합니다.

    // 기록할 수 있도록 반사 상수 버퍼를 잠급니다.
    result = deviceContext->Map(m_reflectionBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
    if(FAILED(result))
    {
        return false;
    }

    // 행렬 상수 버퍼의 데이터 포인터를 얻어옵니다.
    dataPtr2 = (ReflectionBufferType*)mappedResource.pData;

    // 행렬을 상수 버퍼에 복사합니다.
    dataPtr2->reflectionMatrix = reflectionMatrix;

    // 반사 상수 버퍼의 잠금을 해제합니다.
    deviceContext->Unmap(m_reflectionBuffer, 0);

    // 정점 셰이더상의 반사 상수 버퍼의 위치입니다.
    bufferNumber = 1;

    // 갱신된 값으로 정점 셰이더의 반사 행렬 상수 버퍼를 설정합니다.
    deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_reflectionBuffer);

    // 픽셀 셰이더에 텍스쳐를 설정합니다.
    deviceContext->PSSetShaderResources(0, 1, &texture);

반사 텍스쳐를 픽셀 셰이더의 두 번째 텍스쳐로 설정합니다.

    // 픽셀 셰이더에 반사 텍스쳐를 설정합니다.
    deviceContext->PSSetShaderResources(1, 1, &reflectionTexture);

    return true;
}


void ReflectionShaderClass::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);

    return;
}

Cameraclass.h

CameraClass는 평면 반사를 다루기 위해 조금 수정했습니다.

////////////////////////////////////////////////////////////////////////////////
// Filename: cameraclass.h
////////////////////////////////////////////////////////////////////////////////
#ifndef _CAMERACLASS_H_
#define _CAMERACLASS_H_


//////////////
// INCLUDES //
//////////////
#include <d3dx10math.h>


////////////////////////////////////////////////////////////////////////////////
// Class name: CameraClass
////////////////////////////////////////////////////////////////////////////////
class CameraClass
{
public:
    CameraClass();
    CameraClass(const CameraClass&amp;);
    ~CameraClass();

    void SetPosition(float, float, float);
    void SetRotation(float, float, float);

    void Render();
    void GetViewMatrix(D3DXMATRIX&amp;);

반사를 위해 두 함수를 선언합니다. 하나는 반사 행렬을 만드는 용도이고 다른 것은 그 행렬을 가져오는 용도입니다.

    void RenderReflection(float);
    D3DXMATRIX GetReflectionViewMatrix();

private:
    D3DXMATRIX m_viewMatrix;
    float m_positionX, m_positionY, m_positionZ;
    float m_rotationX, m_rotationY, m_rotationZ;

반사 행렬을 선언합니다.

    D3DXMATRIX m_reflectionViewMatrix;
};

#endif

Cameraclass.cpp

여기서는 CameraClass에 추가된 함수만 다루겠습니다.

////////////////////////////////////////////////////////////////////////////////
// Filename: cameraclass.cpp
////////////////////////////////////////////////////////////////////////////////
#include "cameraclass.h"

RenderReflection함수는 보통 Render함수에서 뷰 행렬을 생성하는 것과 같은 방법으로 반사 행렬을 만듭니다. 한 가지 차이점이라면 Y축에 있는 평면까지의 높이를 인자로 받아 반사를 위해 이 값을 역전시킨다는 것입니다. 이렇게 하여 셰이더에 사용할 반사 뷰 행렬을 만들어냅니다. 참고로 이 함수는 Y축에 수직인 평면에만 적용됩니다.

void CameraClass::RenderReflection(float height)
{
    D3DXVECTOR3 up, position, lookAt;
    float radians;


    // 위쪽을 가리키는 벡터를 만듭니다.
    up.x = 0.0f;
    up.y = 1.0f;
    up.z = 0.0f;

    // 월드에 카메라 위치를 설정합니다.
    // 평면 반사를 위해 카메라의 Y값을 역전시킵니다.
    position.x = m_positionX;
    position.y = -m_positionY + (height * 2.0f);
    position.z = m_positionZ;

    // 회전을 라디안 값으로 계산합니다.
    radians = m_rotationY * 0.0174532925f;

    // 카메라가 보는 방향을 설정합니다.
    lookAt.x = sinf(radians) + m_positionX;
    lookAt.y = position.y;
    lookAt.z = cosf(radians) + m_positionZ;

    // 위의 세 벡터를 이용하여 뷰 행렬을 생성합니다.
    D3DXMatrixLookAtLH(&m_reflectionViewMatrix, &position, &lookAt, &up);

    return;
}

GetReflectionViewMatrix 함수는 반사 뷰 행렬을 리턴합니다.

D3DXMATRIX CameraClass::GetReflectionViewMatrix()
{
    return m_reflectionViewMatrix;
}

Graphicsclass.h

////////////////////////////////////////////////////////////////////////////////
// Filename: graphicsclass.h
////////////////////////////////////////////////////////////////////////////////
#ifndef _GRAPHICSCLASS_H_
#define _GRAPHICSCLASS_H_


/////////////
// GLOBALS //
/////////////
const bool FULL_SCREEN = true;
const bool VSYNC_ENABLED = true;
const float SCREEN_DEPTH = 1000.0f;
const float SCREEN_NEAR = 0.1f;


///////////////////////
// MY CLASS INCLUDES //
///////////////////////
#include "d3dclass.h"
#include "cameraclass.h"
#include "modelclass.h"
#include "textureshaderclass.h"
#include "rendertextureclass.h"

ReflectionShaderClass 헤더 파일을 추가합니다.

#include "reflectionshaderclass.h"


////////////////////////////////////////////////////////////////////////////////
// Class name: GraphicsClass
////////////////////////////////////////////////////////////////////////////////
class GraphicsClass
{
public:
    GraphicsClass();
    GraphicsClass(const GraphicsClass&);
    ~GraphicsClass();

    bool Initialize(int, int, HWND);
    void Shutdown();
    bool Frame();
    bool Render();

private:
    bool RenderToTexture();
    bool RenderScene();

private:
    D3DClass* m_D3D;
    CameraClass* m_Camera;
    ModelClass* m_Model;
    TextureShaderClass* m_TextureShader;

이 튜토리얼에서는 렌더 투 텍스쳐 객체를 사용하게 됩니다.

    RenderTextureClass* m_RenderTexture;

바닥에 해당하는 두 번째 모델을 선언합니다.

    ModelClass* m_FloorModel;

반사 셰이더 객체입니다.

    ReflectionShaderClass* m_ReflectionShader;
};

#endif

Graphicsclass.cpp

////////////////////////////////////////////////////////////////////////////////
// Filename: graphicsclass.cpp
////////////////////////////////////////////////////////////////////////////////
#include "graphicsclass.h"


GraphicsClass::GraphicsClass()
{
    m_D3D = 0;
    m_Camera = 0;
    m_Model = 0;
    m_TextureShader = 0;

렌더 투 텍스쳐, 바닥 모델, 반사 셰이더 객체를 null로 초기화합니다.

    m_RenderTexture = 0;
    m_FloorModel = 0;
    m_ReflectionShader = 0;
}


GraphicsClass::GraphicsClass(const GraphicsClass& other)
{
}


GraphicsClass::~GraphicsClass()
{
}


bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
{
    bool result;

        
    // Create the Direct3D object.
    m_D3D = new D3DClass;
    if(!m_D3D)
    {
        return false;
    }

    // Initialize the Direct3D object.
    result = m_D3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize Direct3D.", L"Error", MB_OK);
        return false;
    }

    // Create the camera object.
    m_Camera = new CameraClass;
    if(!m_Camera)
    {
        return false;
    }

    // Create the model object.
    m_Model = new ModelClass;
    if(!m_Model)
    {
        return false;
    }

    // Initialize the model object.
    result = m_Model->Initialize(m_D3D->GetDevice(), L"../Engine/data/seafloor.dds", "../Engine/data/cube.txt");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the model object.", L"Error", MB_OK);
        return false;
    }

    // Create the texture shader object.
    m_TextureShader = new TextureShaderClass;
    if(!m_TextureShader)
    {
        return false;
    }

    // Initialize the texture shader object.
    result = m_TextureShader->Initialize(m_D3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the texture shader object.", L"Error", MB_OK);
        return false;
    }

렌더 투 텍스쳐 객체를 생성하고 초기화합니다.

    // 렌더 투 텍스쳐 객체를 생성합니다.
    m_RenderTexture = new RenderTextureClass;
    if(!m_RenderTexture)
    {
        return false;
    }

    // 렌더 투 텍스쳐 객체를 초기화합니다.
    result = m_RenderTexture->Initialize(m_D3D->GetDevice(), screenWidth, screenHeight);
    if(!result)
    {
        return false;
    }

파란색의 바닥 모델을 생성합니다.

    // 바닥 모델 객체를 생성합니다.
    m_FloorModel = new ModelClass;
    if(!m_FloorModel)
    {
        return false;
    }

    // 바닥 모델 객체를 초기화합니다.
    result = m_FloorModel->Initialize(m_D3D->GetDevice(), L"../Engine/data/blue01.dds", "../Engine/data/floor.txt");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the floor model object.", L"Error", MB_OK);
        return false;
    }

반사 셰이더 객체를 생성하고 초기화합니다.

    // 반사 셰이더 객체를 생성합니다.
    m_ReflectionShader = new ReflectionShaderClass;
    if(!m_ReflectionShader)
    {
        return false;
    }

    // 반사 셰이더 객체를 초기화합니다.
    result = m_ReflectionShader->Initialize(m_D3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the reflection shader object.", L"Error", MB_OK);
        return false;
    }

    return true;
}


void GraphicsClass::Shutdown()
{

Shutdown함수에서 렌더 투 텍스쳐, 바닥 모델, 반사 셰이더 객체를 해제합니다.

    // 반사 셰이더 객체를 해제합니다.
    if(m_ReflectionShader)
    {
        m_ReflectionShader->Shutdown();
        delete m_ReflectionShader;
        m_ReflectionShader = 0;
    }

    // 바닥 모델을 해제합니다.
    if(m_FloorModel)
    {
        m_FloorModel->Shutdown();
        delete m_FloorModel;
        m_FloorModel = 0;
    }

    // 렌더 투 텍스쳐 객체를 해제합니다.
    if(m_RenderTexture)
    {
        m_RenderTexture->Shutdown();
        delete m_RenderTexture;
        m_RenderTexture = 0;
    }

    // 텍스쳐 셰이더 객체를 해제합니다.
    if(m_TextureShader)
    {
        m_TextureShader->Shutdown();
        delete m_TextureShader;
        m_TextureShader = 0;
    }

    // 모델을 해제합니다.
    if(m_Model)
    {
        m_Model->Shutdown();
        delete m_Model;
        m_Model = 0;
    }

    // 카메라를 해제합니다.
    if(m_Camera)
    {
        delete m_Camera;
        m_Camera = 0;
    }

    // D3D객체를 해제합니다.
    if(m_D3D)
    {
        m_D3D->Shutdown();
        delete m_D3D;
        m_D3D = 0;
    }

    return;
}


bool GraphicsClass::Frame()
{
    // 카메라의 위치를 설정합니다.
    m_Camera->SetPosition(0.0f, 0.0f, -10.0f);

    return true;
}


bool GraphicsClass::Render()
{
    bool result;

우선 텍스쳐에 반사된 장면을 그립니다.

    // 반사된 장면을 텍스쳐에 그립니다.
    result = RenderToTexture();
    if(!result)
    {
        return false;
    }

그리고 나서 일반 장면을 그리고 반사 텍스쳐를 바닥에 혼합하여 반사 효과를 만듭니다.

    // 백버퍼에 일반 장면을 그립니다.
    result = RenderScene();
    if(!result)
    {
        return false;
    }

    return true;
}


bool GraphicsClass::RenderToTexture()
{
    D3DXMATRIX worldMatrix, reflectionViewMatrix, projectionMatrix;
    static float rotation = 0.0f;


    // 렌더링 타겟을 렌더 투 텍스쳐로 설정합니다.
    m_RenderTexture->SetRenderTarget(m_D3D->GetDeviceContext(), m_D3D->GetDepthStencilView());

    // 렌더 투 텍스쳐를 깨끗이 지웁니다.
    m_RenderTexture->ClearRenderTarget(m_D3D->GetDeviceContext(), m_D3D->GetDepthStencilView(), 0.0f, 0.0f, 0.0f, 1.0f);

장면을 텍스쳐에 그리기 전에 높이를 -1.5로 설정한 반사 행렬을 생성해야 합니다.

    // 카메라가 반사 행렬을 계산하도록 합니다.
    m_Camera->RenderReflection(-1.5f);

그리고 나서 평소처럼 장면을 그리게 하는데 일반 뷰 행렬 대신 반사 행렬을 사용하도록 합니다. 또한 바닥 모델 역시 그리지 않을 것입니다.

    // 일반 뷰 행렬 대신 반사 뷰 행렬을 가져옵니다.
    reflectionViewMatrix = m_Camera->GetReflectionViewMatrix();

    // 월드 및 프로젝션 행렬을 가져옵니다.
    m_D3D->GetWorldMatrix(worldMatrix);
    m_D3D->GetProjectionMatrix(projectionMatrix);

    // 매 프레임마다 회전값을 갱신합니다.
    rotation += (float)D3DX_PI * 0.005f;
    if(rotation > 360.0f)
    {
        rotation -= 360.0f;
    }
    D3DXMatrixRotationY(&worldMatrix, rotation);

    // 모델 정점과 인덱스 버퍼를 파이프라인에 넣어 렌더링을 준비합니다.
    m_Model->Render(m_D3D->GetDeviceContext());

    // 텍스쳐 셰이더와 반사 뷰 행렬을 이용하여 모델을 그립니다.
    m_TextureShader->Render(m_D3D->GetDeviceContext(), m_Model->GetIndexCount(), worldMatrix, reflectionViewMatrix, 
                projectionMatrix, m_Model->GetTexture());

    // 렌더링 타겟을 원래대로 백버퍼로 돌려놓습니다.
    m_D3D->SetBackBufferRenderTarget();


    return true;
}


bool GraphicsClass::RenderScene()
{
    D3DXMATRIX worldMatrix, viewMatrix, projectionMatrix, reflectionMatrix;
    bool result;
    static float rotation = 0.0f;


    // 장면을 시작하기 위하여 버퍼를 날립니다.
    m_D3D->BeginScene(0.0f, 0.0f, 0.0f, 1.0f);

    // 카메라의 위치에 기반하여 뷰 행렬을 생성합니다.
    m_Camera->Render();

    // 월드, 뷰, 프로젝션 행렬을 가져옵니다.
    m_D3D->GetWorldMatrix(worldMatrix);
    m_Camera->GetViewMatrix(viewMatrix);
    m_D3D->GetProjectionMatrix(projectionMatrix);

    // 매 프레임마다 회전값을 갱신합니다.
    rotation += (float)D3DX_PI * 0.005f;
    if(rotation > 360.0f)
    {
        rotation -= 360.0f;
    }

    // 월드 행렬을 회전값만큼 돌립니다.
    D3DXMatrixRotationY(&worldMatrix, rotation);

    // 모델의 정점과 인덱스 버퍼를 파이프라인에 넣어 렌더링을 준비합니다.
    m_Model->Render(m_D3D->GetDeviceContext());

    // 텍스쳐 셰이더를 이용하여 모델을 그립니다.
    result = m_TextureShader->Render(m_D3D->GetDeviceContext(), m_Model->GetIndexCount(), worldMatrix, viewMatrix,
                     projectionMatrix, m_Model->GetTexture());
    if(!result)
    {
        return false;
    }

    // 월드 행렬을 다시 가져와서 육면체 아래에 바닥 모델을 그리기 위해 아래로 이동시킵니다.
    m_D3D->GetWorldMatrix(worldMatrix);
    D3DXMatrixTranslation(&worldMatrix, 0.0f, -1.5f, 0.0f); 

    // 카메라의 반사 뷰 행렬을 가져옵니다.
    reflectionMatrix = m_Camera->GetReflectionViewMatrix();

    // 바닥 모델의 정점 및 인덱스 버퍼를 파이프라인에 넣어 렌더링할 준비를 합니다.
    m_FloorModel->Render(m_D3D->GetDeviceContext());

바닥을 그릴 때에는 일반 행렬과 텍스쳐뿐만 아니라 반사 뷰 행렬과 반사 렌더 투 텍스쳐가 필요합니다.

    // 바닥 모델을 반사 셰이더, 반사 텍스쳐, 반사 뷰 행렬을 이용하여 그립니다.
    result = m_ReflectionShader->Render(m_D3D->GetDeviceContext(), m_FloorModel->GetIndexCount(), worldMatrix, viewMatrix,
                        projectionMatrix, m_FloorModel->GetTexture(), m_RenderTexture->GetShaderResourceView(), 
                        reflectionMatrix);

    // 렌더링이 완료된 장면을 화면에 뿌립니다.
    m_D3D->EndScene();

    return true;
}

마치면서

이제 거울에 반사된 다른 물체들을 표현할 수 있는 평면 반사 효과를 낼 수 있게 되었습니다.

연습문제

1. 프로그램을 다시 컴파일하여 실행해 보십시오. 파란 바닥에 회전하는 육면체가 반사되는 것이 보일 것입니다.
2. 블렌딩 상수를 다르게 해 보고 블렌딩 공식을 바꾸어 다른 효과를 만들어 보십시오.
3. 반사되는 평면을 Z에 수직인 평면으로 바꾸어 보고 바닥 객체의 위치를 바꾸고 회전시켜서 서 있는 거울 효과를 만들어 보십시오.

소스 코드

Visual Studio 2008 프로젝트: dx11tut27.zip

소스코드만: dx11src27.zip

실행파일만: dx11exe27.zip