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(&worldMatrix, &worldMatrix);
D3DXMatrixTranspose(&viewMatrix, &viewMatrix);
D3DXMatrixTranspose(&projectionMatrix, &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&);
~CameraClass();
void SetPosition(float, float, float);
void SetRotation(float, float, float);
void Render();
void GetViewMatrix(D3DXMATRIX&);
반사를 위해 두 함수를 선언합니다. 하나는 반사 행렬을 만드는 용도이고 다른 것은 그 행렬을 가져오는 용도입니다.
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;
}
마치면서
이제 거울에 반사된 다른 물체들을 표현할 수 있는 평면 반사 효과를 낼 수 있게 되었습니다.
연습문제
- 프로그램을 다시 컴파일하여 실행해 보십시오. 파란 바닥에 회전하는 육면체가 반사되는 것이 보일 것입니다.
- 블렌딩 상수를 다르게 해 보고 블렌딩 공식을 바꾸어 다른 효과를 만들어 보십시오.
- 반사되는 평면을 Z에 수직인 평면으로 바꾸어 보고 바닥 객체의 위치를 바꾸고 회전시켜서 서 있는 거울 효과를 만들어 보십시오.
소스 코드
Visual Studio 2008 프로젝트: dx11tut27.zip
소스코드만: dx11src27.zip
실행파일만: dx11exe27.zip
'강좌번역 > DirectX 11' 카테고리의 다른 글
| DirectX11 Tutorial 29: 물 (2) | 2017.09.01 |
|---|---|
| DirectX11 Tutorial 28: 페이드 효과 (2) | 2015.09.06 |
| DirectX11 Tutorial 26: 투명도 (1) | 2015.06.14 |
| DirectX11 Tutorial 25: 텍스쳐 이동 (0) | 2015.06.07 |
| DirectX11 Tutorial 24: 클리핑 평면 (2) | 2015.03.21 |
