[DirectX11] Tutorial 29 - 물

Tutorial 29 - 물

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

 이번 예제에서는 HLSL과 C++를 이용하여 DirectX 11에서 물을 구현하는 방법을 다룹니다. 코드는 이전 예제에 기초합니다.

물의 구현은 현재 여러 가지가 나와 있고, 각각 장단점이 존재합니다. 여기에 구현할 물은 반사와 굴절이 되는 물입니다. 이것이 가장 비주얼적으로 좋은 구현이지만 물결의 높이가 너무 높으면 경계 문제가 발생합니다. 따라서 이 구현은 강물이나 연못, 수영장과 같이 물결이 잔잔한 물을 표현하기에 가장 적합합니다. 물론 비교적 잔잔하다는 가정 하에 호수나 바다에도 이것을 적용할 수 있습니다.

우선 굴절 및 반사가 되는 물을 보여주기 위한 간단한 장면을 만들 것입니다. 이 씬에는 평평한 지면 위에 물을 담아두기 위한 대리석 욕조가 있습니다. 또한 물에 물체가 반사되는 것을 표현하기 위해 돌 기둥을 하나 둘 것입니다. 만든 씬은 아래 그림과 같습니다

그리고 나서 두 개의 삼각형으로 만든 사각형 물을 만듭니다. 그리고 욕조 안에 들어갈 수 있도록 배치합니다. 이 물에 사용할 텍스쳐는 따로 만드는 대신 물에 반사된 장면 자체를 사용할 것입니다. 반사 텍스쳐를 만들기 위해서는 이전 반사 예제에서 사용했던 반사 기술을 사용하여 텍스쳐에 반사 장면을 그릴 것입니다. 물의 높이와 카메라의 위치, 각도를 이용하여 물 위에 있는 모든 것들이 반사된 씬이 물에 그려집니다

반사가 되는 물이 있으니 이제 굴절을 추가할 수 있습니다. 굴절은 기본적으로 반사의 반대 역할입니다. 반사가 물 위에 있는 것들을 그리는 것이었다면, 굴절은 물 아래에 있는 것을 그립니다. 반사 기능을 조금만 수정하면 굴절 기능을 구현할 수 있기 때문에 반사 때와 같은 방법으로 굴절된 씬은 텍스쳐에 렌더링하고 그것을 물 평면에 사용합니다. 기억해야 할 것은 굴절된 물 안쪽에는 욕조만 보여야 하기 때문에 돌기둥이나 땅바닥이 렌더링되어서는 안됩니다. 아래 그림에는 굴절 텍스쳐가 노란색으로 강조되어 있습니다. 굴절 씬이 어떻게 보여야 하는지 명확히 보여드리기 위하여 의도적으로 욕조는 그리지 않았습니다

이제 물 평면에 할당할 반사 텍스쳐와 굴절 텍스쳐 모두 가지고 있기 때문에 두 텍스쳐를 선형 보간으로 혼합하여 두 효과가 동시에 적용된 물을 만들 수 있습니다

구현한 굴절 및 반사 물을 좀 더 발전시키기 위해 잔잔한 물결을 표현할 노말맵을 추가합니다. 이전 범프맵 예제에서 물체의 굴곡을 표현하기 위한 노말맵의 역할을 다루었었습니다. 이를 응용하여 여기서는 물결을 표현하기 위해 노말맵을 사용합니다. 이전 예제에서는 빛의 방향과 범프 노멀의 값을 이용하여 한 픽셀의 라이팅을 계산했습니다. 하지만 물에서는 이 노말값을 이용하여 텍스쳐의 샘플링 위치를 흩뜨려서 실제 물결이 물 아래 있는 물체를 왜곡시키는 효과를 낼 것입니다. 또한 Y축 방향으로 텍스쳐를 흐르게 하여 흐르는 듯한 물을 재현할 것입니다.

참고로 제가 이 예제에서 사용하는 노말맵을 만들기 위해서 포토샵과 Nvidia의 텍스쳐 도구를 사용했습니다(Nvidia의 웹사이트에서 구할 수 있습니다). 우선 포토샵에서 새로운 이미지를 생성합니다(저는 256x256 크기로 했습니다). 그리고 나서 검정과 흰색만으로 필터->렌더->구름 도구를 사용하여 펄린 노이즈를 스타일의 구름 이미지를 만듭니다. 마지막으로 필터->NVIDIA 도구->노말맵 필터 메뉴를 선택하고 스케일을 10 정도로 줍니다. 이렇게 만들어진 이미지를 DirectX 텍스쳐 툴을 이용하여 DDS 파일로 뽑아냅니다

마지막으로 알아야 할 것은 일부 그래픽 엔진은 굴절이나 반사 텍스쳐를 15-30프레임 간격으로 캡쳐하는데, 이렇게 하여 매 프레임마다 비싼 렌더 투 텍스쳐를 하지 않도록 합니다.

프레임워크에는 RefractionShaderClass와 WaterShaderClass가 추가됩니다.

프레임워크

Water_vs.hlsl

////////////////////////////////////////////////////////////////////////////////
// Filename: water_vs.hlsl
////////////////////////////////////////////////////////////////////////////////
 
 
/////////////
// GLOBALS //
/////////////
cbuffer MatrixBuffer
{
    matrix worldMatrix;
    matrix viewMatrix;
    matrix projectionMatrix;
};
 
cbuffer ReflectionBuffer
{
    matrix reflectionMatrix;
};
 
 
//////////////
// TYPEDEFS //
//////////////
struct VertexInputType
{
    float4 position : POSITION;
    float2 tex : TEXCOORD0;
};
 
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
    float4 reflectionPosition : TEXCOORD1;
    float4 refractionPosition : TEXCOORD2;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// Vertex Shader
////////////////////////////////////////////////////////////////////////////////
PixelInputType WaterVertexShader(VertexInputType input)
{
    PixelInputType output;
    matrix reflectProjectWorld;
    matrix viewProjectWorld;
    
    
    // 적절한 행렬 계산을 위해 위치 벡터를 4 단위로 변경합니다.
    input.position.w = 1.0f;
 
    // 월드, 뷰 및 투영 행렬에 대한 정점의 위치를 ​​계산합니다.
    output.position = mul(input.position, worldMatrix);
    output.position = mul(output.position, viewMatrix);
    output.position = mul(output.position, projectionMatrix);
    
    // 픽셀 쉐이더의 텍스처 좌표를 저장한다.
    output.tex = input.tex;
    
    // 반사 투영 세계 행렬을 만듭니다.
    reflectProjectWorld = mul(reflectionMatrix, projectionMatrix);
    reflectProjectWorld = mul(worldMatrix, reflectProjectWorld);
 
    // reflectProjectWorld 행렬에 대한 입력 위치를 계산합니다.
    output.reflectionPosition = mul(input.position, reflectProjectWorld);
 
    // 굴절을위한 뷰 투영 세계 행렬을 만듭니다.
    viewProjectWorld = mul(viewMatrix, projectionMatrix);
    viewProjectWorld = mul(worldMatrix, viewProjectWorld);
   
    // viewProjectWorld 행렬에 대해 입력 위치를 계산합니다.
    output.refractionPosition = mul(input.position, viewProjectWorld);
    
    return output;
}

Water_ps.hlsl

////////////////////////////////////////////////////////////////////////////////
// Filename: water_ps.hlsl
////////////////////////////////////////////////////////////////////////////////
 
 
/////////////
// GLOBALS //
/////////////
SamplerState SampleType;
Texture2D reflectionTexture;
Texture2D refractionTexture;
Texture2D normalTexture;
 
cbuffer WaterBuffer
{
    float waterTranslation;
    float reflectRefractScale;
    float2 padding;
};
 
 
//////////////
// TYPEDEFS //
//////////////
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
    float4 reflectionPosition : TEXCOORD1;
    float4 refractionPosition : TEXCOORD2;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// Pixel Shader
////////////////////////////////////////////////////////////////////////////////
float4 WaterPixelShader(PixelInputType input) : SV_TARGET
{
    float2 reflectTexCoord;
    float2 refractTexCoord;
    float4 normalMap;
    float3 normal;
    float4 reflectionColor;
    float4 refractionColor;
    float4 color;
 
    
    // 움직이는 물을 시뮬레이트하기 위해 물 수직선을 샘플링 한 위치를 이동합니다.
    input.tex.y += waterTranslation;
    
    // 투사 된 반사 텍스처 좌표를 계산합니다.
    reflectTexCoord.x = input.reflectionPosition.x / input.reflectionPosition.w / 2.0f + 0.5f;
    reflectTexCoord.y = -input.reflectionPosition.y / input.reflectionPosition.w / 2.0f + 0.5f;
    
    // 투영 된 굴절 텍스처 좌표를 계산합니다.
    refractTexCoord.x = input.refractionPosition.x / input.refractionPosition.w / 2.0f + 0.5f;
    refractTexCoord.y = -input.refractionPosition.y / input.refractionPosition.w / 2.0f + 0.5f;
 
    // 노멀 맵 텍스처로부터 법선을 샘플링합니다.
    normalMap = normalTexture.Sample(SampleType, input.tex);
 
    // 법선의 범위를 (0,1)에서 (-1, + 1)로 확장합니다.
    normal = (normalMap.xyz * 2.0f) - 1.0f;
 
    // 텍스처 좌표 샘플링 위치를 노멀 맵 값으로 재배치하여 파동 파 효과를 시뮬레이트합니다.
    reflectTexCoord = reflectTexCoord + (normal.xy * reflectRefractScale);
    refractTexCoord = refractTexCoord + (normal.xy * reflectRefractScale);
 
    // 업데이트 된 텍스처 좌표를 사용하여 텍스처에서 텍스처 픽셀을 샘플링합니다.
    reflectionColor = reflectionTexture.Sample(SampleType, reflectTexCoord);
    refractionColor = refractionTexture.Sample(SampleType, refractTexCoord);
 
    // 최종 색상의 반사 및 굴절 결과를 결합합니다.
    color = lerp(reflectionColor, refractionColor, 0.6f);
    
    return color;
}

WaterShaderClass는 water.vs 및 water.ps 셰이더를 사용하여 물을 렌더링합니다.

Watershaderclass.h

#pragma once
 
class WaterShaderClass
{
private:
    struct MatrixBufferType
    {
        XMMATRIX world;
        XMMATRIX view;
        XMMATRIX projection;
    };
 
    struct ReflectionBufferType
    {
        XMMATRIX reflection;
    };
 
    struct WaterBufferType
    {
        float waterTranslation;
        float reflectRefractScale;
        XMFLOAT2 padding;
    };
 
public:
    WaterShaderClass();
    WaterShaderClass(const WaterShaderClass&);
    ~WaterShaderClass();
 
    bool Initialize(ID3D11Device*, HWND);
    void Shutdown();
    bool Render(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX, XMMATRIX,
        ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, float, float);
 
private:
    bool InitializeShader(ID3D11Device*, HWND, const WCHAR*, const WCHAR*);
    void ShutdownShader();
    void OutputShaderErrorMessage(ID3D10Blob*, HWND, const WCHAR * shaderFilename);
 
    bool SetShaderParameters(ID3D11DeviceContext*, XMMATRIX, XMMATRIX, XMMATRIX, XMMATRIX,
        ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, float, float);
    void RenderShader(ID3D11DeviceContext*, int);
 
private:
    ID3D11VertexShader* m_vertexShader = nullptr;
    ID3D11PixelShader* m_pixelShader = nullptr;
    ID3D11InputLayout* m_layout = nullptr;
    ID3D11SamplerState* m_sampleState = nullptr;
    ID3D11Buffer* m_matrixBuffer = nullptr;
    ID3D11Buffer* m_reflectionBuffer = nullptr;
    ID3D11Buffer* m_waterBuffer = nullptr;
};

Watershaderclass.cpp

#include "stdafx.h"
#include "watershaderclass.h"
 
 
WaterShaderClass::WaterShaderClass()
{
}
 
 
WaterShaderClass::WaterShaderClass(const WaterShaderClass& other)
{
}
 
 
WaterShaderClass::~WaterShaderClass()
{
}
 
 
bool WaterShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
    // 정점 및 픽셀 쉐이더를 초기화합니다.
    return InitializeShader(device, hwnd, L"../Dx11Demo_29/water_vs.hlsl", L"../Dx11Demo_29/water_ps.hlsl");
}
 
 
void WaterShaderClass::Shutdown()
{
    // 버텍스 및 픽셀 쉐이더와 관련된 객체를 종료합니다.
    ShutdownShader();
}
 
 
bool WaterShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX worldMatrix, XMMATRIX viewMatrix, 
                              XMMATRIX projectionMatrix, XMMATRIX reflectionMatrix, 
                              ID3D11ShaderResourceView* reflectionTexture, ID3D11ShaderResourceView* refractionTexture,
                              ID3D11ShaderResourceView* normalTexture, float waterTranslation, float reflectRefractScale)
{
    // 렌더링에 사용할 셰이더 매개 변수를 설정합니다.
    if (!SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, reflectionMatrix, reflectionTexture, 
                                 refractionTexture, normalTexture, waterTranslation, reflectRefractScale))
    {
        return false;
    }
 
    // 설정된 버퍼를 셰이더로 렌더링한다.
    RenderShader(deviceContext, indexCount);
 
    return true;
}
 
 
bool WaterShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, const WCHAR * vsFilename, const WCHAR * psFilename)
{
    HRESULT result;
    ID3D10Blob* errorMessage = nullptr;
 
    // 버텍스 쉐이더 코드를 컴파일한다.
    ID3D10Blob* vertexShaderBuffer = nullptr;
    result = D3DCompileFromFile(vsFilename, NULL, NULL, "WaterVertexShader", "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, "WaterPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0,
                                &pixelShaderBuffer, &errorMessage);
    if (FAILED(result))
    {
        // 셰이더 컴파일 실패시 오류메시지를 출력합니다.
        if (errorMessage)
        {
            OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
        }
        // 컴파일 오류가 아니라면 셰이더 파일을 찾을 수 없는 경우입니다.
        else
        {
            MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
        }
 
        return false;
    }
 
    // 버퍼로부터 정점 셰이더를 생성한다.
    result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL,
                                        &m_vertexShader);
    if (FAILED(result))
    {
        return false;
    }
 
    // 버퍼에서 픽셀 쉐이더를 생성합니다.
    result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL,
                                       &m_pixelShader);
    if (FAILED(result))
    {
        return false;
    }
 
    // 정점 입력 레이아웃 구조체를 설정합니다.
    // 이 설정은 ModelClass와 셰이더의 VertexType 구조와 일치해야합니다.
    D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
    polygonLayout[0].SemanticName = "POSITION";
    polygonLayout[0].SemanticIndex = 0;
    polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
    polygonLayout[0].InputSlot = 0;
    polygonLayout[0].AlignedByteOffset = 0;
    polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[0].InstanceDataStepRate = 0;
 
    polygonLayout[1].SemanticName = "TEXCOORD";
    polygonLayout[1].SemanticIndex = 0;
    polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
    polygonLayout[1].InputSlot = 0;
    polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[1].InstanceDataStepRate = 0;
 
    // 레이아웃의 요소 수를 가져옵니다.
    UINT numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
 
    // 정점 입력 레이아웃을 만듭니다.
    result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(),
        vertexShaderBuffer->GetBufferSize(), &m_layout);
    if (FAILED(result))
    {
        return false;
    }
 
    // 더 이상 사용되지 않는 정점 셰이더 퍼버와 픽셀 셰이더 버퍼를 해제합니다.
    vertexShaderBuffer->Release();
    vertexShaderBuffer = 0;
 
    pixelShaderBuffer->Release();
    pixelShaderBuffer = 0;
 
    // 텍스처 샘플러 상태 구조체를 생성 및 설정합니다.
    D3D11_SAMPLER_DESC samplerDesc;
    samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
    samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.MipLODBias = 0.0f;
    samplerDesc.MaxAnisotropy = 1;
    samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
    samplerDesc.BorderColor[0] = 0;
    samplerDesc.BorderColor[1] = 0;
    samplerDesc.BorderColor[2] = 0;
    samplerDesc.BorderColor[3] = 0;
    samplerDesc.MinLOD = 0;
    samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
 
    // 텍스처 샘플러 상태를 만듭니다.
    result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
    if (FAILED(result))
    {
        return false;
    }
 
    // 정점 셰이더에 있는 행렬 상수 버퍼의 구조체를 작성합니다.
    D3D11_BUFFER_DESC matrixBufferDesc;
    matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
    matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    matrixBufferDesc.MiscFlags = 0;
    matrixBufferDesc.StructureByteStride = 0;
 
    // 상수 버퍼 포인터를 만들어 이 클래스에서 정점 셰이더 상수 버퍼에 접근할 수 있게 합니다.
    result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
    if (FAILED(result))
    {
        return false;
    }
    
    D3D11_BUFFER_DESC reflectionBufferDesc;
    // Setup the description of the reflection dynamic constant buffer that is in the vertex shader.
    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;
 
    // Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
    result = device->CreateBuffer(&reflectionBufferDesc, NULL, &m_reflectionBuffer);
    if(FAILED(result))
    {
        return false;
    }
 
    // Setup the description of the water dynamic constant buffer that is in the pixel shader.
    D3D11_BUFFER_DESC waterBufferDesc;
    waterBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    waterBufferDesc.ByteWidth = sizeof(WaterBufferType);
    waterBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    waterBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    waterBufferDesc.MiscFlags = 0;
    waterBufferDesc.StructureByteStride = 0;
 
    // Create the constant buffer pointer so we can access the pixel shader constant buffer from within this class.
    result = device->CreateBuffer(&waterBufferDesc, NULL, &m_waterBuffer);
    if(FAILED(result))
    {
        return false;
    }    
 
    return true;
}
 
 
void WaterShaderClass::ShutdownShader()
{
    // Release the water constant buffer.
    if(m_waterBuffer)
    {
        m_waterBuffer->Release();
        m_waterBuffer = 0;
    }
 
    // Release the reflection constant buffer.
    if(m_reflectionBuffer)
    {
        m_reflectionBuffer->Release();
        m_reflectionBuffer = 0;
    }
 
    // 행렬 상수 버퍼를 해제합니다.
    if (m_matrixBuffer)
    {
        m_matrixBuffer->Release();
        m_matrixBuffer = 0;
    }
 
    // 샘플러 상태를 해제한다.
    if (m_sampleState)
    {
        m_sampleState->Release();
        m_sampleState = 0;
    }
 
    // 레이아웃을 해제합니다.
    if (m_layout)
    {
        m_layout->Release();
        m_layout = 0;
    }
 
    // 픽셀 쉐이더를 해제합니다.
    if (m_pixelShader)
    {
        m_pixelShader->Release();
        m_pixelShader = 0;
    }
 
    // 버텍스 쉐이더를 해제합니다.
    if (m_vertexShader)
    {
        m_vertexShader->Release();
        m_vertexShader = 0;
    }
}
 
 
void WaterShaderClass::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 WaterShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, XMMATRIX worldMatrix, XMMATRIX viewMatrix, 
                                           XMMATRIX projectionMatrix, XMMATRIX reflectionMatrix, 
                                           ID3D11ShaderResourceView* reflectionTexture, 
                                           ID3D11ShaderResourceView* refractionTexture,
                                           ID3D11ShaderResourceView* normalTexture,
                                           float waterTranslation, float reflectRefractScale)
{
    // 행렬을 transpose하여 셰이더에서 사용할 수 있게 합니다
    worldMatrix = XMMatrixTranspose(worldMatrix);
    viewMatrix = XMMatrixTranspose(viewMatrix);
    projectionMatrix = XMMatrixTranspose(projectionMatrix);
    reflectionMatrix = XMMatrixTranspose(reflectionMatrix);
 
    // 상수 버퍼의 내용을 쓸 수 있도록 잠급니다.
    D3D11_MAPPED_SUBRESOURCE mappedResource;
    if (FAILED(deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource)))
    {
        return false;
    }
 
    // 상수 버퍼의 데이터에 대한 포인터를 가져옵니다.
    MatrixBufferType* dataPtr = (MatrixBufferType*)mappedResource.pData;
 
    // 상수 버퍼에 행렬을 복사합니다.
    dataPtr->world = worldMatrix;
    dataPtr->view = viewMatrix;
    dataPtr->projection = projectionMatrix;
 
    // 상수 버퍼의 잠금을 풉니다.
    deviceContext->Unmap(m_matrixBuffer, 0);
 
    // 정점 셰이더에서의 상수 버퍼의 위치를 설정합니다.
    unsigned int bufferNumber = 0;
 
    // 마지막으로 정점 셰이더의 상수 버퍼를 바뀐 값으로 바꿉니다.
    deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer);
 
    // Lock the reflection constant buffer so it can be written to.
    if(FAILED(deviceContext->Map(m_reflectionBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource)))
    {
        return false;
    }
 
    // 상수 버퍼의 데이터에 대한 포인터를 가져옵니다.
    ReflectionBufferType* dataPtr2 = (ReflectionBufferType*)mappedResource.pData;
 
    // 조명 변수를 상수 버퍼에 복사합니다.
    dataPtr2->reflection = reflectionMatrix;
 
    // 상수 버퍼의 잠금을 해제합니다.
    deviceContext->Unmap(m_reflectionBuffer, 0);
 
    // 픽셀 쉐이더에서 광원 상수 버퍼의 위치를 ??설정합니다.
    bufferNumber = 1;
 
    // Finally set the reflection constant buffer in the vertex shader with the updated values.
    deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_reflectionBuffer);
 
    // Set the reflection texture resource in the pixel shader.
    deviceContext->PSSetShaderResources(0, 1, &reflectionTexture);
 
    // Set the refraction texture resource in the pixel shader.
    deviceContext->PSSetShaderResources(1, 1, &refractionTexture);
 
    // Set the normal map texture resource in the pixel shader.
    deviceContext->PSSetShaderResources(2, 1, &normalTexture);
 
    // Lock the water constant buffer so it can be written to.
    if(FAILED(deviceContext->Map(m_waterBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource)))
    {
        return false;
    }
 
    // Get a pointer to the data in the constant buffer.
    WaterBufferType* dataPtr3 = (WaterBufferType*)mappedResource.pData;
 
    // Copy the water data into the constant buffer.
    dataPtr3->waterTranslation = waterTranslation;
    dataPtr3->reflectRefractScale = reflectRefractScale;
    dataPtr3->padding = XMFLOAT2(0.0f, 0.0f);
 
    // Unlock the constant buffer.
    deviceContext->Unmap(m_waterBuffer, 0);
 
    // Set the position of the water constant buffer in the pixel shader.
    bufferNumber = 0;
 
    // Finally set the water constant buffer in the pixel shader with the updated values.
    deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_waterBuffer);
 
    return true;
}
 
 
void WaterShaderClass::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);
}

굴절 셰이더는 라이트 셰이더에 클리핑 평면이 추가된 형태입니다. 굴절이 정상적으로 씬을 렌더링하지만 물 아래 있는 것들만 그려야 하기 때문에 클리핑 평면을 사용하여 해결합니다.

Refraction_vs.hlsl

////////////////////////////////////////////////////////////////////////////////
// Filename: refraction_vs.hlsl
////////////////////////////////////////////////////////////////////////////////
 
 
/////////////
// GLOBALS //
/////////////
cbuffer MatrixBuffer
{
    matrix worldMatrix;
    matrix viewMatrix;
    matrix projectionMatrix;
};
 
cbuffer ClipPlaneBuffer
{
    float4 clipPlane;
};
 
 
//////////////
// TYPEDEFS //
//////////////
struct VertexInputType
{
    float4 position : POSITION;
    float2 tex : TEXCOORD0;
       float3 normal : NORMAL;
};
 
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
    float3 normal : NORMAL;
    float clip : SV_ClipDistance0;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// Vertex Shader
////////////////////////////////////////////////////////////////////////////////
PixelInputType RefractionVertexShader(VertexInputType input)
{
    PixelInputType output;
    
    // 적절한 행렬 계산을 위해 위치 벡터를 4 단위로 변경합니다.
    input.position.w = 1.0f;
 
    // 월드, 뷰 및 투영 행렬에 대한 정점의 위치를 ​​계산합니다.
    output.position = mul(input.position, worldMatrix);
    output.position = mul(output.position, viewMatrix);
    output.position = mul(output.position, projectionMatrix);
    
    // 픽셀 쉐이더의 텍스처 좌표를 저장한다.
    output.tex = input.tex;
 
    // 월드 행렬에 대해서만 법선 벡터를 계산합니다.
    output.normal = mul(input.normal, (float3x3) worldMatrix);
 
    // 법선 벡터를 정규화합니다.
    output.normal = normalize(output.normal);
 
    // 클리핑면을 설정합니다.
    output.clip = dot(mul(input.position, worldMatrix), clipPlane);
 
    return output;
}

Refraction_ps.hlsl

////////////////////////////////////////////////////////////////////////////////
// Filename: refraction_ps.hlsl
////////////////////////////////////////////////////////////////////////////////
 
 
/////////////
// GLOBALS //
/////////////
Texture2D shaderTexture;
SamplerState SampleType;
 
cbuffer LightBuffer
{
    float4 ambientColor;
    float4 diffuseColor;
    float3 lightDirection;
};
 
 
//////////////
// TYPEDEFS //
//////////////
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
    float3 normal : NORMAL;
    float clip : SV_ClipDistance0;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// Pixel Shader
////////////////////////////////////////////////////////////////////////////////
float4 RefractionPixelShader(PixelInputType input) : SV_TARGET
{
    float4 textureColor;
    float3 lightDir;
    float lightIntensity;
    float4 color;
    
 
    // 이 위치에서 텍스처 픽셀을 샘플링합니다.
    textureColor = shaderTexture.Sample(SampleType, input.tex);
    
    // 모든 픽셀의 기본 출력 색상을 주변 광원 값으로 설정합니다.
    color = ambientColor;
 
    // 계산을 위해 빛 방향을 반전시킵니다.
    lightDir = -lightDirection;
 
    // 이 픽셀의 빛의 양을 계산합니다.
    lightIntensity = saturate(dot(input.normal, lightDir));
 
    if(lightIntensity > 0.0f)
    {
        // 확산 색과 광 강도의 양에 따라 최종 확산 색을 결정합니다.
        color += (diffuseColor * lightIntensity);
    }
 
    // 최종 빛의 색상을 채 웁니다.
    color = saturate(color);
 
    // 텍스처 픽셀과 입력 색상을 곱해 최종 결과를 얻습니다.
    color = color * textureColor;
    
    return color;
}
 

RefractionShaderClass는 LightShaderClass에 클리핑 평면 버퍼가 추가된 형태입니다.

Refractionshaderclass.h

#pragma once
 
class RefractionShaderClass
{
private:
    struct MatrixBufferType
    {
        XMMATRIX world;
        XMMATRIX view;
        XMMATRIX projection;
    };
 
    struct LightBufferType
    {
        XMFLOAT4 ambientColor;
        XMFLOAT4 diffuseColor;
        XMFLOAT3 lightDirection;
        float padding;
    };
 
    struct ClipPlaneBufferType
    {
        XMFLOAT4 clipPlane;
    };
 
public:
    RefractionShaderClass();
    RefractionShaderClass(const RefractionShaderClass&);
    ~RefractionShaderClass();
 
    bool Initialize(ID3D11Device*, HWND);
    void Shutdown();
    bool Render(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*, XMFLOAT3, XMFLOAT4,
                XMFLOAT4, XMFLOAT4);
 
private:
    bool InitializeShader(ID3D11Device*, HWND, const WCHAR*, const WCHAR*);
    void ShutdownShader();
    void OutputShaderErrorMessage(ID3D10Blob*, HWND, const WCHAR*);
 
    bool SetShaderParameters(ID3D11DeviceContext*, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*, XMFLOAT3,
                             XMFLOAT4, XMFLOAT4, XMFLOAT4);
    void RenderShader(ID3D11DeviceContext*, int);
 
private:
    ID3D11VertexShader* m_vertexShader = nullptr;
    ID3D11PixelShader* m_pixelShader = nullptr;
    ID3D11InputLayout* m_layout = nullptr;
    ID3D11SamplerState* m_sampleState = nullptr;
    ID3D11Buffer* m_matrixBuffer = nullptr;
    ID3D11Buffer* m_lightBuffer = nullptr;
    ID3D11Buffer* m_clipPlaneBuffer = nullptr;
};

Refractionshaderclass.cpp

#include "stdafx.h"
#include "refractionshaderclass.h"
 
 
RefractionShaderClass::RefractionShaderClass()
{
}
 
 
RefractionShaderClass::RefractionShaderClass(const RefractionShaderClass& other)
{
}
 
 
RefractionShaderClass::~RefractionShaderClass()
{
}
 
 
bool RefractionShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
    // 정점 및 픽셀 쉐이더를 초기화합니다.
    return InitializeShader(device, hwnd, L"../Dx11Demo_29/refraction_vs.hlsl", L"../Dx11Demo_29/refraction_ps.hlsl");
}
 
 
void RefractionShaderClass::Shutdown()
{
    // 버텍스 및 픽셀 쉐이더와 관련된 객체를 종료합니다.
    ShutdownShader();
}
 
 
bool RefractionShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX worldMatrix, 
    XMMATRIX viewMatrix, XMMATRIX projectionMatrix, ID3D11ShaderResourceView* texture, XMFLOAT3 lightDirection,
    XMFLOAT4 ambientColor, XMFLOAT4 diffuseColor, XMFLOAT4 clipPlane)
{
    // 렌더링에 사용할 셰이더 매개 변수를 설정합니다.
    if (!SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, lightDirection, ambientColor,
                             diffuseColor, clipPlane))
    {
        return false;
    }
 
    // 설정된 버퍼를 셰이더로 렌더링한다.
    RenderShader(deviceContext, indexCount);
 
    return true;
}
 
 
bool RefractionShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, const WCHAR* vsFilename, 
                                             const WCHAR* psFilename)
{
    HRESULT result;
    ID3D10Blob* errorMessage = nullptr;
 
    // 버텍스 쉐이더 코드를 컴파일한다.
    ID3D10Blob* vertexShaderBuffer = nullptr;
    result = D3DCompileFromFile(vsFilename, NULL, NULL, "RefractionVertexShader", "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, "RefractionPixelShader", "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[3];
    polygonLayout[0].SemanticName = "POSITION";
    polygonLayout[0].SemanticIndex = 0;
    polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
    polygonLayout[0].InputSlot = 0;
    polygonLayout[0].AlignedByteOffset = 0;
    polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[0].InstanceDataStepRate = 0;
 
    polygonLayout[1].SemanticName = "TEXCOORD";
    polygonLayout[1].SemanticIndex = 0;
    polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
    polygonLayout[1].InputSlot = 0;
    polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[1].InstanceDataStepRate = 0;
 
    polygonLayout[2].SemanticName = "NORMAL";
    polygonLayout[2].SemanticIndex = 0;
    polygonLayout[2].Format = DXGI_FORMAT_R32G32B32_FLOAT;
    polygonLayout[2].InputSlot = 0;
    polygonLayout[2].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[2].InstanceDataStepRate = 0;
 
    // 레이아웃의 요소 수를 가져옵니다.
    UINT numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
 
    // 정점 입력 레이아웃을 만듭니다.
    result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(),
        vertexShaderBuffer->GetBufferSize(), &m_layout);
    if (FAILED(result))
    {
        return false;
    }
 
    // 더 이상 사용되지 않는 정점 셰이더 퍼버와 픽셀 셰이더 버퍼를 해제합니다.
    vertexShaderBuffer->Release();
    vertexShaderBuffer = 0;
 
    pixelShaderBuffer->Release();
    pixelShaderBuffer = 0;
 
    // 텍스처 샘플러 상태 구조체를 생성 및 설정합니다.
    D3D11_SAMPLER_DESC samplerDesc;
    samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
    samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.MipLODBias = 0.0f;
    samplerDesc.MaxAnisotropy = 1;
    samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
    samplerDesc.BorderColor[0] = 0;
    samplerDesc.BorderColor[1] = 0;
    samplerDesc.BorderColor[2] = 0;
    samplerDesc.BorderColor[3] = 0;
    samplerDesc.MinLOD = 0;
    samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
 
    // 텍스처 샘플러 상태를 만듭니다.
    result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
    if (FAILED(result))
    {
        return false;
    }
 
    // 정점 셰이더에 있는 행렬 상수 버퍼의 구조체를 작성합니다.
    D3D11_BUFFER_DESC matrixBufferDesc;
    matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
    matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    matrixBufferDesc.MiscFlags = 0;
    matrixBufferDesc.StructureByteStride = 0;
 
    // 상수 버퍼 포인터를 만들어 이 클래스에서 정점 셰이더 상수 버퍼에 접근할 수 있게 합니다.
    result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
    if (FAILED(result))
    {
        return false;
    }
 
    // 픽셀 쉐이더에있는 광원 동적 상수 버퍼의 설명을 설정합니다.
    // D3D11_BIND_CONSTANT_BUFFER를 사용하면 ByteWidth가 항상 16의 배수 여야하며 그렇지 않으면 CreateBuffer가 실패합니다.
    D3D11_BUFFER_DESC lightBufferDesc;
    lightBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    lightBufferDesc.ByteWidth = sizeof(LightBufferType);
    lightBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    lightBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    lightBufferDesc.MiscFlags = 0;
    lightBufferDesc.StructureByteStride = 0;
 
    // 이 클래스 내에서 정점 셰이더 상수 버퍼에 액세스 할 수 있도록 상수 버퍼 포인터를 만듭니다.
    result = device->CreateBuffer(&lightBufferDesc, NULL, &m_lightBuffer);
    if(FAILED(result))
    {
        return false;
    }    
 
    // Setup the description of the clip plane dynamic constant buffer that is in the vertex shader.
    D3D11_BUFFER_DESC clipPlaneBufferDesc;
    clipPlaneBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    clipPlaneBufferDesc.ByteWidth = sizeof(ClipPlaneBufferType);
    clipPlaneBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    clipPlaneBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    clipPlaneBufferDesc.MiscFlags = 0;
    clipPlaneBufferDesc.StructureByteStride = 0;
 
    // Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
    result = device->CreateBuffer(&clipPlaneBufferDesc, NULL, &m_clipPlaneBuffer);
    if(FAILED(result))
    {
        return false;
    }
 
    return true;
}
 
 
void RefractionShaderClass::ShutdownShader()
{
    // Release the clip plane constant buffer.
    if(m_clipPlaneBuffer)
    {
        m_clipPlaneBuffer->Release();
        m_clipPlaneBuffer = 0;
    }
 
    // 광원 상수 버퍼를 해제합니다.
    if(m_lightBuffer)
    {
        m_lightBuffer->Release();
        m_lightBuffer = 0;
    }
 
    // 행렬 상수 버퍼를 해제합니다.
    if (m_matrixBuffer)
    {
        m_matrixBuffer->Release();
        m_matrixBuffer = 0;
    }
 
    // 샘플러 상태를 해제한다.
    if (m_sampleState)
    {
        m_sampleState->Release();
        m_sampleState = 0;
    }
 
    // 레이아웃을 해제합니다.
    if (m_layout)
    {
        m_layout->Release();
        m_layout = 0;
    }
 
    // 픽셀 쉐이더를 해제합니다.
    if (m_pixelShader)
    {
        m_pixelShader->Release();
        m_pixelShader = 0;
    }
 
    // 버텍스 쉐이더를 해제합니다.
    if (m_vertexShader)
    {
        m_vertexShader->Release();
        m_vertexShader = 0;
    }
}
 
 
void RefractionShaderClass::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 RefractionShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, XMMATRIX worldMatrix,
    XMMATRIX viewMatrix, XMMATRIX projectionMatrix, ID3D11ShaderResourceView* texture, XMFLOAT3 lightDirection,
    XMFLOAT4 ambientColor, XMFLOAT4 diffuseColor, XMFLOAT4 clipPlane)
{
    // Set shader texture resource in the pixel shader.
    deviceContext->PSSetShaderResources(0, 1, &texture);
 
    // 상수 버퍼의 내용을 쓸 수 있도록 잠급니다.
    D3D11_MAPPED_SUBRESOURCE mappedResource;
    if (FAILED(deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource)))
    {
        return false;
    }
 
    // 상수 버퍼의 데이터에 대한 포인터를 가져옵니다.
    MatrixBufferType* dataPtr = (MatrixBufferType*)mappedResource.pData;
 
    // 행렬을 transpose하여 셰이더에서 사용할 수 있게 합니다
    worldMatrix = XMMatrixTranspose(worldMatrix);
    viewMatrix = XMMatrixTranspose(viewMatrix);
    projectionMatrix = XMMatrixTranspose(projectionMatrix);
 
    // 상수 버퍼에 행렬을 복사합니다.
    dataPtr->world = worldMatrix;
    dataPtr->view = viewMatrix;
    dataPtr->projection = projectionMatrix;
 
    // 상수 버퍼의 잠금을 풉니다.
    deviceContext->Unmap(m_matrixBuffer, 0);
 
    // 정점 셰이더에서의 상수 버퍼의 위치를 설정합니다.
    unsigned int bufferNumber = 0;
 
    // 마지막으로 정점 셰이더의 상수 버퍼를 바뀐 값으로 바꿉니다.
    deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer);
 
    // light constant buffer를 잠글 수 있도록 기록한다.
    if(FAILED(deviceContext->Map(m_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource)))
    {
        return false;
    }
 
    // 상수 버퍼의 데이터에 대한 포인터를 가져옵니다.
    LightBufferType* dataPtr2 = (LightBufferType*)mappedResource.pData;
 
    // 조명 변수를 상수 버퍼에 복사합니다.
    dataPtr2->ambientColor = ambientColor;
    dataPtr2->diffuseColor = diffuseColor;
    dataPtr2->lightDirection = lightDirection;
 
    // 상수 버퍼의 잠금을 해제합니다.
    deviceContext->Unmap(m_lightBuffer, 0);
 
    // 픽셀 쉐이더에서 광원 상수 버퍼의 위치를 ??설정합니다.
    bufferNumber = 0;
 
    // 마지막으로 업데이트 된 값으로 픽셀 쉐이더에서 광원 상수 버퍼를 설정합니다.
    deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_lightBuffer);
 
    // Lock the clip plane constant buffer so it can be written to.
    if(FAILED(deviceContext->Map(m_clipPlaneBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource)))
    {
        return false;
    }
 
    // Get a pointer to the data in the clip plane constant buffer.
    ClipPlaneBufferType* dataPtr3 = (ClipPlaneBufferType*)mappedResource.pData;
 
    // Copy the clip plane into the clip plane constant buffer.
    dataPtr3->clipPlane = clipPlane;
 
    // Unlock the buffer.
    deviceContext->Unmap(m_clipPlaneBuffer, 0);
 
    // Set the position of the clip plane constant buffer in the vertex shader.
    bufferNumber = 1;
 
    // Now set the clip plane constant buffer in the vertex shader with the updated values.
    deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_clipPlaneBuffer);
 
    return true;
}
 
 
void RefractionShaderClass::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);
}

GraphicsClass에서 3D 씬과 물을 설정하고 렌더링합니다.

Graphicsclass.h

#pragma once
 
/////////////
// GLOBALS //
/////////////
const bool FULL_SCREEN = false;
const bool VSYNC_ENABLED = true;
const float SCREEN_DEPTH = 1000.0f;
const float SCREEN_NEAR = 0.1f;
 
 
class D3DClass;
class CameraClass;
class ModelClass;
class LightClass;
class RenderTextureClass;
class LightShaderClass;
class RefractionShaderClass;
class WaterShaderClass;
 
class GraphicsClass
{
public:
    GraphicsClass();
    GraphicsClass(const GraphicsClass&);
    ~GraphicsClass();
 
    bool Initialize(int, int, HWND);
    void Shutdown();
    bool Frame();
    bool Render();
 
private:
    bool RenderRefractionToTexture();
    bool RenderReflectionToTexture();
    bool RenderScene();
 
private:
    D3DClass* m_Direct3D = nullptr;
    CameraClass* m_Camera = nullptr;
    ModelClass* m_GroundModel = nullptr;
    ModelClass* m_WallModel = nullptr;
    ModelClass* m_BathModel = nullptr;
    ModelClass* m_WaterModel = nullptr;
    LightClass* m_Light = nullptr;
    RenderTextureClass* m_RefractionTexture = nullptr;
    RenderTextureClass* m_ReflectionTexture = nullptr;
    LightShaderClass* m_LightShader = nullptr;
    RefractionShaderClass* m_RefractionShader = nullptr;
    WaterShaderClass* m_WaterShader = nullptr;
    float m_waterHeight = 0;
    float m_waterTranslation = 0;
};

Graphicsclass.cpp

#include "stdafx.h"
#include "d3dclass.h"
#include "cameraclass.h"
#include "modelclass.h"
#include "lightclass.h"
#include "rendertextureclass.h"
#include "lightshaderclass.h"
#include "refractionshaderclass.h"
#include "watershaderclass.h"
#include "graphicsclass.h"
 
 
GraphicsClass::GraphicsClass()
{
}
 
 
GraphicsClass::GraphicsClass(const GraphicsClass& other)
{
}
 
 
GraphicsClass::~GraphicsClass()
{
}
 
 
bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
{
    // Direct3D 객체 생성
    m_Direct3D = new D3DClass;
    if (!m_Direct3D)
    {
        return false;
    }
 
    // Direct3D 객체 초기화
    bool result = m_Direct3D->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;
    }
 
    // m_Camera 객체 생성
    m_Camera = new CameraClass;
    if (!m_Camera)
    {
        return false;
    }
 
    // Create the ground model object.
    m_GroundModel = new ModelClass;
    if(!m_GroundModel)
    {
        return false;
    }
 
    // Initialize the ground model object.
    result = m_GroundModel->Initialize(m_Direct3D->GetDevice(), L"../Dx11Demo_29/data/ground01.dds",
                                       "../Dx11Demo_29/data/ground.txt");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the ground model object.", L"Error", MB_OK);
        return false;
    }
 
    // Create the wall model object.
    m_WallModel = new ModelClass;
    if(!m_WallModel)
    {
        return false;
    }
 
    // Initialize the wall model object.
    result = m_WallModel->Initialize(m_Direct3D->GetDevice(), L"../Dx11Demo_29/data/wall01.dds",
                                     "../Dx11Demo_29/data/wall.txt");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the wall model object.", L"Error", MB_OK);
        return false;
    }
 
    // Create the bath model object.
    m_BathModel = new ModelClass;
    if(!m_BathModel)
    {
        return false;
    }
 
    // Initialize the bath model object.
    result = m_BathModel->Initialize(m_Direct3D->GetDevice(), L"../Dx11Demo_29/data/marble01.dds",
                                     "../Dx11Demo_29/data/bath.txt");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the bath model object.", L"Error", MB_OK);
        return false;
    }
 
    // Create the water model object.
    m_WaterModel = new ModelClass;
    if(!m_WaterModel)
    {
        return false;
    }
 
    // Initialize the water model object.
    result = m_WaterModel->Initialize(m_Direct3D->GetDevice(), L"../Dx11Demo_29/data/water01.dds",
                                      "../Dx11Demo_29/data/water.txt");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the water model object.", L"Error", MB_OK);
        return false;
    }
 
    // Create the light object.
    m_Light = new LightClass;
    if(!m_Light)
    {
        return false;
    }
 
    // Initialize the light object.
    m_Light->SetAmbientColor(0.15f, 0.15f, 0.15f, 1.0f);
    m_Light->SetDiffuseColor(1.0f, 1.0f, 1.0f, 1.0f);
    m_Light->SetDirection(0.0f, -1.0f, 0.5f);
 
    // Create the refraction render to texture object.
    m_RefractionTexture = new RenderTextureClass;
    if(!m_RefractionTexture)
    {
        return false;
    }
 
    // Initialize the refraction render to texture object.
    result = m_RefractionTexture->Initialize(m_Direct3D->GetDevice(), screenWidth, screenHeight);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the refraction render to texture object.", L"Error", MB_OK);
        return false;
    }
 
    // Create the reflection render to texture object.
    m_ReflectionTexture = new RenderTextureClass;
    if(!m_ReflectionTexture)
    {
        return false;
    }
 
    // Initialize the reflection render to texture object.
    result = m_ReflectionTexture->Initialize(m_Direct3D->GetDevice(), screenWidth, screenHeight);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the reflection render to texture object.", L"Error", MB_OK);
        return false;
    }
 
    // Create the light shader object.
    m_LightShader = new LightShaderClass;
    if(!m_LightShader)
    {
        return false;
    }
 
    // Initialize the light shader object.
    result = m_LightShader->Initialize(m_Direct3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the light shader object.", L"Error", MB_OK);
        return false;
    }
 
    // Create the refraction shader object.
    m_RefractionShader = new RefractionShaderClass;
    if(!m_RefractionShader)
    {
        return false;
    }
 
    // Initialize the refraction shader object.
    result = m_RefractionShader->Initialize(m_Direct3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the refraction shader object.", L"Error", MB_OK);
        return false;
    }
 
    // Create the water shader object.
    m_WaterShader = new WaterShaderClass;
    if(!m_WaterShader)
    {
        return false;
    }
 
    // Initialize the water shader object.
    result = m_WaterShader->Initialize(m_Direct3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the water shader object.", L"Error", MB_OK);
        return false;
    }
 
    // Set the height of the water.
    m_waterHeight = 2.75f;
 
    // Initialize the position of the water.
    m_waterTranslation = 0.0f;
 
    return true;
}
 
 
void GraphicsClass::Shutdown()
{
    // Release the water shader object.
    if(m_WaterShader)
    {
        m_WaterShader->Shutdown();
        delete m_WaterShader;
        m_WaterShader = 0;
    }
 
    // Release the refraction shader object.
    if(m_RefractionShader)
    {
        m_RefractionShader->Shutdown();
        delete m_RefractionShader;
        m_RefractionShader = 0;
    }
 
    // Release the light shader object.
    if(m_LightShader)
    {
        m_LightShader->Shutdown();
        delete m_LightShader;
        m_LightShader = 0;
    }
 
    // Release the reflection render to texture object.
    if(m_ReflectionTexture)
    {
        m_ReflectionTexture->Shutdown();
        delete m_ReflectionTexture;
        m_ReflectionTexture = 0;
    }
 
    // Release the refraction render to texture object.
    if(m_RefractionTexture)
    {
        m_RefractionTexture->Shutdown();
        delete m_RefractionTexture;
        m_RefractionTexture = 0;
    }
 
    // Release the light object.
    if(m_Light)
    {
        delete m_Light;
        m_Light = 0;
    }
 
    // Release the water model object.
    if(m_WaterModel)
    {
        m_WaterModel->Shutdown();
        delete m_WaterModel;
        m_WaterModel = 0;
    }
 
    // Release the bath model object.
    if(m_BathModel)
    {
        m_BathModel->Shutdown();
        delete m_BathModel;
        m_BathModel = 0;
    }
 
    // Release the wall model object.
    if(m_WallModel)
    {
        m_WallModel->Shutdown();
        delete m_WallModel;
        m_WallModel = 0;
    }
 
    // Release the ground model object.
    if(m_GroundModel)
    {
        m_GroundModel->Shutdown();
        delete m_GroundModel;
        m_GroundModel = 0;
    }
 
    // Release the camera object.
    if(m_Camera)
    {
        delete m_Camera;
        m_Camera = 0;
    }
 
    // Direct3D 객체 반환
    if (m_Direct3D)
    {
        m_Direct3D->Shutdown();
        delete m_Direct3D;
        m_Direct3D = 0;
    }
}
 
 
bool GraphicsClass::Frame()
{
    // Update the position of the water to simulate motion.
    m_waterTranslation += 0.001f;
    if(m_waterTranslation > 1.0f)
    {
        m_waterTranslation -= 1.0f;
    }
 
    // Set the position and rotation of the camera.
    m_Camera->SetPosition(-11.0f, 6.0f, -10.0f);
    m_Camera->SetRotation(0.0f, 45.0f, 0.0f);
 
    return true;
}
 
 
bool GraphicsClass::Render()
{
    bool result;
    static float rotation = 0.0f;
 
    // Render the refraction of the scene to a texture.
    result = RenderRefractionToTexture();
    if(!result)
    {
        return false;
    }
 
    // Render the reflection of the scene to a texture.
    result = RenderReflectionToTexture();
    if(!result)
    {
        return false;
    }
 
    // Render the scene as normal to the back buffer.
    result = RenderScene();
    if(!result)
    {
        return false;
    }
 
    return true;
}
 
 
bool GraphicsClass::RenderRefractionToTexture()
{
    XMMATRIX worldMatrix, viewMatrix, projectionMatrix;
 
    // Setup a clipping plane based on the height of the water to clip everything above it.
    XMFLOAT4 clipPlane = XMFLOAT4(0.0f, -1.0f, 0.0f, m_waterHeight + 0.1f);
        
    // 렌더링 대상을 렌더링에 맞게 설정합니다.
    m_RefractionTexture->SetRenderTarget(m_Direct3D->GetDeviceContext(), m_Direct3D->GetDepthStencilView());
 
    // 렌더링을 텍스처에 지 웁니다.
    m_RefractionTexture->ClearRenderTarget(m_Direct3D->GetDeviceContext(), m_Direct3D->GetDepthStencilView(), 0.0f, 0.0f,
                                           0.0f, 1.0f);
 
    // 카메라의 위치에 따라 뷰 행렬을 생성합니다.
    m_Camera->Render();
    
    // 카메라 및 d3d 객체에서 월드, 뷰 및 투영 행렬을 가져옵니다.
    m_Direct3D->GetWorldMatrix(worldMatrix);
    m_Camera->GetViewMatrix(viewMatrix);
    m_Direct3D->GetProjectionMatrix(projectionMatrix);
 
    // Translate to where the bath model will be rendered.
    worldMatrix = XMMatrixTranslation(0.0f, 2.0f, 0.0f);
 
    // Put the bath model vertex and index buffers on the graphics pipeline to prepare them for drawing.
    m_BathModel->Render(m_Direct3D->GetDeviceContext());
 
    // Render the bath model using the light shader.
    if(!m_RefractionShader->Render(m_Direct3D->GetDeviceContext(), m_BathModel->GetIndexCount(), 
        worldMatrix, viewMatrix, projectionMatrix, m_BathModel->GetTexture(), m_Light->GetDirection(),
        m_Light->GetAmbientColor(), m_Light->GetDiffuseColor(), clipPlane))
    {
        return false;
    }
 
    // Reset the render target back to the original back buffer and not the render to texture anymore.
    m_Direct3D->SetBackBufferRenderTarget();
 
    return true;
}
 
 
bool GraphicsClass::RenderReflectionToTexture()
{
    XMMATRIX reflectionViewMatrix, worldMatrix, projectionMatrix;
 
    // Set the render target to be the reflection render to texture.
    m_ReflectionTexture->SetRenderTarget(m_Direct3D->GetDeviceContext(), m_Direct3D->GetDepthStencilView());
 
    // Clear the reflection render to texture.
    m_ReflectionTexture->ClearRenderTarget(m_Direct3D->GetDeviceContext(), m_Direct3D->GetDepthStencilView(), 0.0f, 0.0f,
                                           0.0f, 1.0f);
 
    // Use the camera to render the reflection and create a reflection view matrix.
    m_Camera->RenderReflection(m_waterHeight);
 
    // Get the camera reflection view matrix instead of the normal view matrix.
    reflectionViewMatrix = m_Camera->GetReflectionViewMatrix();
 
    // Get the world and projection matrices from the d3d object.
    m_Direct3D->GetWorldMatrix(worldMatrix);
    m_Direct3D->GetProjectionMatrix(projectionMatrix);
 
    // Translate to where the wall model will be rendered.
    worldMatrix = XMMatrixTranslation(0.0f, 6.0f, 8.0f);
 
    // Put the wall model vertex and index buffers on the graphics pipeline to prepare them for drawing.
    m_WallModel->Render(m_Direct3D->GetDeviceContext());
 
    // Render the wall model using the light shader and the reflection view matrix.
    if(!m_LightShader->Render(m_Direct3D->GetDeviceContext(), m_WallModel->GetIndexCount(), worldMatrix,
        reflectionViewMatrix, projectionMatrix, m_WallModel->GetTexture(), m_Light->GetDirection(), 
        m_Light->GetAmbientColor(), m_Light->GetDiffuseColor()))
    {
        return false;
    }
 
    // Reset the render target back to the original back buffer and not the render to texture anymore.
    m_Direct3D->SetBackBufferRenderTarget();
 
    return true;
}
 
 
bool GraphicsClass::RenderScene()
{
    XMMATRIX worldMatrix, viewMatrix, projectionMatrix, reflectionMatrix;
 
    // 장면을 시작할 버퍼를 지운다.
    m_Direct3D->BeginScene(0.0f, 0.0f, 0.0f, 1.0f);
 
    // 카메라의 위치에 따라 뷰 행렬을 생성합니다.
    m_Camera->Render();
 
    // 카메라 및 d3d 객체에서 월드, 뷰 및 오쏘 (ortho) 행렬을 가져옵니다.
    m_Direct3D->GetWorldMatrix(worldMatrix);
    m_Camera->GetViewMatrix(viewMatrix);
    m_Direct3D->GetProjectionMatrix(projectionMatrix);
 
    // Translate to where the bath model will be rendered.
    worldMatrix = XMMatrixTranslation(0.0f, 1.0f, 0.0f);
 
    // Put the ground model vertex and index buffers on the graphics pipeline to prepare them for drawing.
    m_GroundModel->Render(m_Direct3D->GetDeviceContext());
 
    // Render the ground model using the light shader.
    bool result = m_LightShader->Render(m_Direct3D->GetDeviceContext(), m_GroundModel->GetIndexCount(), worldMatrix, 
                             viewMatrix, projectionMatrix, m_GroundModel->GetTexture(), m_Light->GetDirection(), 
                             m_Light->GetAmbientColor(), m_Light->GetDiffuseColor());
    if(!result)
    {
        return false;
    }
 
    // Reset the world matrix.
    m_Direct3D->GetWorldMatrix(worldMatrix);
 
    // Translate to where the wall model will be rendered.
    worldMatrix = XMMatrixTranslation(0.0f, 6.0f, 8.0f);
 
    // Put the wall model vertex and index buffers on the graphics pipeline to prepare them for drawing.
    m_WallModel->Render(m_Direct3D->GetDeviceContext());
 
    // Render the wall model using the light shader.
    result = m_LightShader->Render(m_Direct3D->GetDeviceContext(), m_WallModel->GetIndexCount(), worldMatrix, viewMatrix, 
                                   projectionMatrix, m_WallModel->GetTexture(), m_Light->GetDirection(), 
                                   m_Light->GetAmbientColor(), m_Light->GetDiffuseColor());
    if(!result)
    {
        return false;
    }
 
    // Reset the world matrix.
    m_Direct3D->GetWorldMatrix(worldMatrix);
 
    // Translate to where the bath model will be rendered.
    worldMatrix = XMMatrixTranslation(0.0f, 2.0f, 0.0f);
 
    // Put the bath model vertex and index buffers on the graphics pipeline to prepare them for drawing.
    m_BathModel->Render(m_Direct3D->GetDeviceContext());
 
    // Render the bath model using the light shader.
    result = m_LightShader->Render(m_Direct3D->GetDeviceContext(), m_BathModel->GetIndexCount(), worldMatrix, viewMatrix, 
                                   projectionMatrix, m_BathModel->GetTexture(), m_Light->GetDirection(), 
                                   m_Light->GetAmbientColor(), m_Light->GetDiffuseColor());
    if(!result)
    {
        return false;
    }
    
    // Reset the world matrix.
    m_Direct3D->GetWorldMatrix(worldMatrix);
 
    // Get the camera reflection view matrix.
    reflectionMatrix = m_Camera->GetReflectionViewMatrix();
 
    // Translate to where the water model will be rendered.
    worldMatrix = XMMatrixTranslation(0.0f, m_waterHeight, 0.0f);
 
    // Put the water model vertex and index buffers on the graphics pipeline to prepare them for drawing.
    m_WaterModel->Render(m_Direct3D->GetDeviceContext());
 
    // Render the water model using the water shader.
    result = m_WaterShader->Render(m_Direct3D->GetDeviceContext(), m_WaterModel->GetIndexCount(), worldMatrix, viewMatrix, 
                                   projectionMatrix, reflectionMatrix, m_ReflectionTexture->GetShaderResourceView(),
                                   m_RefractionTexture->GetShaderResourceView(), m_WaterModel->GetTexture(), 
                                   m_waterTranslation, 0.01f);
    if(!result)
    {
        return false;
    }
 
    // Present the rendered scene to the screen.
    m_Direct3D->EndScene();
 
    return true;
}

출력 화면

마치면서

반사 및 굴절되는 물에 이동하는 노말맵을 추가하여 매우 사실적인 물 효과를 낼 수 있습니다. 그리고 다른 효과를 낼 때에도 다양하게 확장될 수 있습니다(유리, 얼음 등등).

연습문제

1. 프로그램을 컴파일하여 실행해 보십시오. 반사와 굴절 그리고 움직이는 물을 볼 수 있습니다.

2. color = lerp(reflectionColor, refractionColor, 0.6f)에서 0.6f 값을 조절하여 반사와 굴절이 어떻게 보이는지 확인해 보십시오.

3. reflectRefractScale 값을 수정해 보십시오(m_WaterShader->Render 함수의 마지막 인자)

4. 여러분만의 노말맵을 만들어 다른 물 효과를 내 보십시오.

5. RenderRefractionToTexture() 함수에서 클리핑 평면의 높이를 물의 높이와 동일하게 해 보십시오.

소스코드

소스코드 : Dx11Demo_29.zip