[DirectX 11] Terrain 16 - 호수 효과

)Terrain 16 - 호수 효과

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

 이번 DirectX 11 지형 튜토리얼에서는 HLSL 및 C ++을 사용하여 호수 효과를 구현하는 방법에 대해 설명합니다. 이 듀토리얼의 코드는 이전 지형 듀토리얼을 기반으로 합니다.

호수, 강, 연못, 늪, 큰 파도가 없는 다른 모든 것을 구현하기 위해 우리는 굴절 및 반사 렌더링 시스템을 사용합니다. 우리는 굴절 (물 아래의 모든 것)을 렌더링하고 반사 (물 위의 모든 것)를 렌더링 한 다음 결과를 결합합니다. DirectX Basic 튜토리얼 섹션에서 '[DirectX11] Tutorial 29 - 물'http://copynull.tistory.com/279을 읽었다면 이러한 개념을 이해할 수 있습니다. 튜토리얼을 읽지 않았다면 먼저 여기를 확장하고 더 많은 기능을 추가하기 전에 먼저 검토하기를 권장합니다.

기본적인 지형의 장면부터 시작하겠습니다. 우리는 반사를 위해 하늘과 같은 굴절을 위해 지형을 필요로합니다.

물 파급 효과에 대한 법선도 필요합니다. 가우스 흐린 높이 맵과 Photoshop의 Nvidia 노멀 맵 필터는 다음과 같은 것을 만들 수 있습니다.

그런 다음 물의 면적을 덮을만큼 큰 반경을 가진 단일 쿼드를 만듭니다. 쿼드에 대해 일반 맵 텍스처를 타일링하여 세분화 할 필요가 없습니다.

다음으로 반사 쉐이더를 사용하여 장면을 렌더링하지만 반전된 클립 평면을 사용하여 물 아래의 모든 것을 렌더링하여 굴절을 만듭니다. 이것은 모두 텍스처 렌더링으로 렌더링되므로 카메라의 시점을 기준으로 투영 텍스처를 사용하여 물 쿼드에 적용할 수 있습니다. 우리는 파급 효과를 주기 위해 물 법선 맵에 의한 굴절 텍스처 샘플링을 교란합니다.

우리가 워터 쿼드 위로 노멀 맵을 바둑판 식으로 배열하는 경우에도 서로 다른 텍스처 좌표를 사용하여 두 번 별도로 작업을 수행합니다. 예를 들어 우리는 물 위에 10 배로 타일을 칠한 다음 다시 타일링을하지만 5 번만 타일링 할 수 있습니다. 그런 다음 두 개의 개별적으로 바둑판 식으로 배열된 노멀 맵 결과를 결합하여 단 한번의 회전 텍스처 대신에 잔물결을 애니메이션으로 표현합니다.

그리고 마침내 우리는 잔물결이 있는 깨끗한 물 대신에 착색된 물처럼 보이도록 굴절에 색조를 더합니다. 다음 이미지는 물 굴절이 다음과 같이 보이는 것입니다.

그 시점에서 많은 엔진이 멈추게 됩니다. 우리가 기본적으로 장면을 두 번 렌더링하기 때문에 장면을 텍스처로 렌더링하는 것은 매우 비쌉니다. 이렇게 하면 물을 그릴 때마다 fps가 반으로 줄어 듭니다! 불행하게도 이것을 가속화 할 수 있는 물이 보이지 않을 때 실제로 텍스처에 렌더링하지 않는 것 이외에 많은 기술은 없습니다.

그러나 우리는 그 효과를 더 좋게 보이도록 진행할 것입니다. 우리는 이제 반사 쉐이더를 사용하여 장면을 다시 렌더링하지만 물 위에 있는 모든 것을 렌더링하는 클립면을 사용하여 장면을 반영합니다. 반사를 렌더링하여 텍스처 개체에 렌더링 한 다음 카메라의 시점에서 물 쿼드에 투영합니다. 우리는 또한 물 법선 맵에 의한 텍스처의 렌더링 샘플링을 혼란스럽게 만듭니다. 리플렉션을 렌더링하면 다음과 같이 보입니다.

굴절, 반사 및 일반 3D 장면을 사용하여 이제 프레임당 장면을 세 번 그립니다. 이렇게 하면 원래 속도의 1/3로 fps가 줄어 듭니다. 일부 최적화는 모든 프레임 대신 초당 2 번 반사를 렌더링 할 수 있지만 물 위로 이동하게 될 최대 속도에 따라 달라집니다. 일부 엔진은 결코 변경되지 않는 하늘의 텍스처 하나만 사용합니다. 당신이 할 수 있는 여러 가지가 있지만 그것은 장면에 반사가 얼마나 중요한지에 달려 있습니다.

굴절과 반사를 모두 텍스처로 렌더링하면 이제 이를 결합할 수 있습니다. 두 텍스처를 결합하는 좋은 방법 중 하나는 프레넬 (Fresnel) 요소로 알려진 것을 사용하는 것입니다. 이것은 물에 가까워 질수록 투명해지고 (굴절이 더 많이 표현됨) 더 멀리 떨어지면 반사가 강해지고 더 이상 물을 볼 수 없게 됩니다 (반사가 더 많이 렌더링 됨). ). 이 튜토리얼에서는 높이만을 기준으로한 간단한 프레넬 계수를 만들었습니다. 따라서 물이 더 높을수록 물이 더 많이 반사되고 물에 가까이 갈수록 더 굴절됩니다. 일부 엔진은 훨씬 정교한 frensel 계산을 사용하고 물과의 거리, 각 픽셀에서 물의 깊이 등을 고려합니다.

프레넬 요소와 결합된 결과는 다음과 같습니다.

보시다시피 반사는 결과에 많은 색을 추가했으며 반사된 구름과 지형을 추가했습니다.

수면 효과에 대한 마지막 추가는 태양 빛이 물에서 반사되는 곳의 방향성 반사를 추가하는 것입니다. 우리는 이중 타일된 물 법선 맵에 대한 반사를 계산하여 반사가 물결 무늬를 벗어날 수 있도록 합니다. 이렇게 하면 최종 장면이 생깁니다.

다시 한번 이것은 꽤 비싼 효과입니다. 여러분은 단지 굴절 점에서 멈추고 싶을 것입니다. 그러나 여분의 사이클을 절약할 수 있다면 완전한 효과가 좋습니다.

코드 섹션을 시작하기 위해 수정된 CameraClass를 살펴 보도록 하겠습니다.

CameraClass가 수정되어 이제 반사 뷰 행렬을 생성할 수 있습니다.

Cameraclass.h

#pragma once
 
class CameraClass : public AlignedAllocationPolicy<16>
{
public:
    CameraClass();
    CameraClass(const CameraClass&);
    ~CameraClass();
 
    void SetPosition(XMFLOAT3);
    void SetRotation(XMFLOAT3);
 
    XMFLOAT3 GetPosition();
    XMFLOAT3 GetRotation();
 
    void Render();
    void GetViewMatrix(XMMATRIX&);
 
    void GenerateBaseViewMatrix();
    void GetBaseViewMatrix(XMMATRIX&);
 
    void RenderReflection(float);
    void GetReflectionViewMatrix(XMMATRIX&);
 
private:
    XMFLOAT3 m_position;
    XMFLOAT3 m_rotation;
    XMMATRIX m_viewMatrix;
    XMMATRIX m_baseViewMatrix;
    XMMATRIX m_reflectionViewMatrix;
};

Cameraclass.cpp

#include "stdafx.h"
#include "cameraclass.h"
 
 
CameraClass::CameraClass()
{
    m_position = XMFLOAT3(0.0f, 0.0f, 0.0f);
    m_rotation = XMFLOAT3(0.0f, 0.0f, 0.0f);
}
 
 
CameraClass::CameraClass(const CameraClass& other)
{
}
 
 
CameraClass::~CameraClass()
{
}
 
 
void CameraClass::SetPosition(XMFLOAT3 p)
{
    m_position = p;
}
 
 
void CameraClass::SetRotation(XMFLOAT3 p)
{
    m_rotation = p;
}
 
 
XMFLOAT3 CameraClass::GetPosition()
{
    return m_position;
}
 
 
XMFLOAT3 CameraClass::GetRotation()
{
    return m_rotation;
}
 
 
void CameraClass::Render()
{
    XMFLOAT3 up, position, lookAt;
    XMVECTOR upVector, positionVector, lookAtVector;
 
    // 위쪽을 가리키는 벡터를 설정합니다.
    up.x = 0.0f;
    up.y = 1.0f;
    up.z = 0.0f;
 
    // XMVECTOR 구조체에 로드한다.
    upVector = XMLoadFloat3(&up);
 
    // 3D월드에서 카메라의 위치를 ​​설정합니다.
    position = m_position;
 
    // XMVECTOR 구조체에 로드한다.
    positionVector = XMLoadFloat3(&position);
 
    // 기본적으로 카메라가 찾고있는 위치를 설정합니다.
    lookAt.x = 0.0f;
    lookAt.y = 0.0f;
    lookAt.z = 1.0f;
 
    // XMVECTOR 구조체에 로드한다.
    lookAtVector = XMLoadFloat3(&lookAt);
 
    // yaw (Y 축), pitch (X 축) 및 roll (Z 축)의 회전값을 라디안 단위로 설정합니다.
    float pitch = m_rotation.x * 0.0174532925f;
    float yaw = m_rotation.y * 0.0174532925f;
    float roll = m_rotation.z * 0.0174532925f;
 
    //  yaw, pitch, roll 값을 통해 회전 행렬을 만듭니다.
    XMMATRIX rotationMatrix = XMMatrixRotationRollPitchYaw(pitch, yaw, roll);
 
    // lookAt 및 up 벡터를 회전 행렬로 변형하여 뷰가 원점에서 올바르게 회전되도록 합니다.
    lookAtVector = XMVector3TransformCoord(lookAtVector, rotationMatrix);
    upVector = XMVector3TransformCoord(upVector, rotationMatrix);
 
    // 회전 된 카메라 위치를 뷰어 위치로 변환합니다.
    lookAtVector = XMVectorAdd(positionVector, lookAtVector);
 
    // 마지막으로 세 개의 업데이트 된 벡터에서 뷰 행렬을 만듭니다.
    m_viewMatrix = XMMatrixLookAtLH(positionVector, lookAtVector, upVector);
}
 
 
void CameraClass::GetViewMatrix(XMMATRIX& viewMatrix)
{
    viewMatrix = m_viewMatrix;
}
 
 
void CameraClass::GenerateBaseViewMatrix()
{
    XMFLOAT3 up, position, lookAt;
    XMVECTOR upVector, positionVector, lookAtVector;
 
    // 위쪽을 가리키는 벡터를 설정합니다.
    up.x = 0.0f;
    up.y = 1.0f;
    up.z = 0.0f;
 
    // XMVECTOR 구조체에 로드한다.
    upVector = XMLoadFloat3(&up);
 
    // 3D월드에서 카메라의 위치를 ​​설정합니다.
    position = m_position;
 
    // XMVECTOR 구조체에 로드한다.
    positionVector = XMLoadFloat3(&position);
    
    // 기본적으로 카메라가 찾고있는 위치를 설정합니다.
    lookAt.x = 0.0f;
    lookAt.y = 0.0f;
    lookAt.z = 1.0f;
    
        // XMVECTOR 구조체에 로드한다.
    lookAtVector = XMLoadFloat3(&lookAt);
 
    // yaw (Y 축), pitch (X 축) 및 roll (Z 축)의 회전값을 라디안 단위로 설정합니다.
    float pitch = m_rotation.x * 0.0174532925f;
    float yaw = m_rotation.y * 0.0174532925f;
    float roll = m_rotation.z * 0.0174532925f;
    
    //  yaw, pitch, roll 값을 통해 회전 행렬을 만듭니다.
    XMMATRIX rotationMatrix = XMMatrixRotationRollPitchYaw(pitch, yaw, roll);
    
    // lookAt 및 up 벡터를 회전 행렬로 변형하여 뷰가 원점에서 올바르게 회전되도록 합니다.
    lookAtVector = XMVector3TransformCoord(lookAtVector, rotationMatrix);
    upVector = XMVector3TransformCoord(upVector, rotationMatrix);
 
    // 회전 된 카메라 위치를 뷰어 위치로 변환합니다.
    lookAtVector = XMVectorAdd(positionVector, lookAtVector);
 
    // 마지막으로 세 개의 업데이트 된 벡터에서 뷰 행렬을 만듭니다.
    m_baseViewMatrix = XMMatrixLookAtLH(positionVector, lookAtVector, upVector);
}
 
 
void CameraClass::GetBaseViewMatrix(XMMATRIX& viewMatrix)
{
    viewMatrix = m_baseViewMatrix;
}
 
 
void CameraClass::RenderReflection(float height)
{
    XMFLOAT3 up, position, lookAt;
    XMVECTOR upVector, positionVector, lookAtVector;
 
    // 위쪽을 가리키는 벡터를 설정합니다.
    up.x = 0.0f;
    up.y = 1.0f;
    up.z = 0.0f;
 
    // XMVECTOR 구조체에 로드한다.
    upVector = XMLoadFloat3(&up);
 
    // 3D월드에서 카메라의 위치를 ​​설정합니다.
    position = m_position;
    
    position = m_position;
    position.y = -m_position.y + (height * 2.0f);
 
    // XMVECTOR 구조체에 로드한다.
    positionVector = XMLoadFloat3(&position);
    
    // 기본적으로 카메라가 찾고있는 위치를 설정합니다.
    lookAt.x = 0.0f;
    lookAt.y = 0.0f;
    lookAt.z = 1.0f;
    
        // XMVECTOR 구조체에 로드한다.
    lookAtVector = XMLoadFloat3(&lookAt);
 
    // yaw (Y 축), pitch (X 축) 및 roll (Z 축)의 회전값을 라디안 단위로 설정합니다.
    float pitch = m_rotation.x * 0.0174532925f;
    float yaw = m_rotation.y * 0.0174532925f;
    float roll = m_rotation.z * 0.0174532925f;
    
    //  yaw, pitch, roll 값을 통해 회전 행렬을 만듭니다.
    XMMATRIX rotationMatrix = XMMatrixRotationRollPitchYaw(pitch, yaw, roll);
    
    // lookAt 및 up 벡터를 회전 행렬로 변형하여 뷰가 원점에서 올바르게 회전되도록 합니다.
    lookAtVector = XMVector3TransformCoord(lookAtVector, rotationMatrix);
    upVector = XMVector3TransformCoord(upVector, rotationMatrix);
 
    // 회전 된 카메라 위치를 뷰어 위치로 변환합니다.
    lookAtVector = XMVectorAdd(positionVector, lookAtVector);
 
    // 마지막으로 세 개의 업데이트 된 벡터에서 뷰 행렬을 만듭니다.
    m_reflectionViewMatrix = XMMatrixLookAtLH(positionVector, lookAtVector, upVector);
 
}
 
 
void CameraClass::GetReflectionViewMatrix(XMMATRIX& viewMatrix)
{
    viewMatrix = m_reflectionViewMatrix;
}

반사 HLSL 쉐이더는 클립 평면이 추가 된 지형 HLSL 쉐이더일 뿐입니다. 그렇지 않으면 동일합니다.

Reflection_vs.hlsl

////////////////////////////////////////////////////////////////////////////////
// Filename: reflection_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;
    float3 tangent : TANGENT;
    float3 binormal : BINORMAL;
    float4 color : COLOR;
};
 
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
       float3 normal : NORMAL;
    float3 tangent : TANGENT;
    float3 binormal : BINORMAL;
    float4 color : COLOR;
       float clip : SV_ClipDistance0;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// Vertex Shader
////////////////////////////////////////////////////////////////////////////////
PixelInputType ReflectionVertexShader(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.tangent = mul(input.tangent, (float3x3)worldMatrix);
    output.tangent = normalize(output.tangent);
 
    // 월드 매트릭스에 대해서만 바이 노멀 벡터를 계산 한 다음 최종 값을 정규화합니다.
    output.binormal = mul(input.binormal, (float3x3)worldMatrix);
    output.binormal = normalize(output.binormal);
 
    // 픽셀 쉐이더에 색상 맵 색상을 보냅니다.
    output.color = input.color;
 
    // 클리핑면을 설정합니다.
    output.clip = dot(mul(input.position, worldMatrix), clipPlane);
 
    return output;
}

Reflection_ps.hlsl

////////////////////////////////////////////////////////////////////////////////
// Filename: reflection_ps.hlsl
////////////////////////////////////////////////////////////////////////////////
 
 
//////////////
// TEXTURES //
//////////////
Texture2D colorTexture : register(t0);
Texture2D normalTexture : register(t1);
 
 
//////////////
// SAMPLERS //
//////////////
SamplerState SampleType;
 
 
//////////////////////
// CONSTANT BUFFERS //
//////////////////////
cbuffer LightBuffer
{
    float4 lightDiffuseColor;
    float3 lightDirection;
    float colorTextureBrightness;
};
 
 
//////////////
// TYPEDEFS //
//////////////
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
       float3 normal : NORMAL;
    float3 tangent : TANGENT;
    float3 binormal : BINORMAL;
    float4 color : COLOR;
       float clip : SV_ClipDistance0;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// Pixel Shader
////////////////////////////////////////////////////////////////////////////////
float4 ReflectionPixelShader(PixelInputType input) : SV_TARGET
{
    float3 lightDir;
    float4 textureColor;
    float4 bumpMap;
    float3 bumpNormal;
    float lightIntensity;
    float4 color;
 
 
    // 계산을 위해 빛 방향을 반전시킵니다.
    lightDir = -lightDirection;
 
    // 색상 텍스처를 샘플링합니다.
    textureColor = colorTexture.Sample(SampleType, input.tex);
 
    // 색상 맵 값을 텍스처 색상에 결합합니다.
    textureColor = saturate(input.color * textureColor * colorTextureBrightness);
 
    // 법선 맵을 사용하여 범프 맵을 계산합니다.
    bumpMap = normalTexture.Sample(SampleType, input.tex);
    bumpMap = (bumpMap * 2.0f) - 1.0f;
    bumpNormal = input.normal + bumpMap.x * input.tangent + bumpMap.y * input.binormal;
    bumpNormal = normalize(bumpNormal);
    lightIntensity = saturate(dot(bumpNormal, lightDir));
    
    // 첫 번째 범프 매핑 된 픽셀 색상을 계산합니다.
    color = saturate(lightDiffuseColor * lightIntensity);
    color = color * textureColor;
 
    return color;
}

ReflectionShaderClass는 클립 평면 관련 설정을 제외하고 TerrainShaderClass와 동일합니다.

Reflectionshaderclass.h

#pragma once
 
class ReflectionShaderClass : public AlignedAllocationPolicy<16>
{
private:
    struct MatrixBufferType
    {
        XMMATRIX world;
        XMMATRIX view;
        XMMATRIX projection;
    };
 
    struct ClipPlaneBufferType
    {
        XMFLOAT4 clipPlane;
    };
 
    struct LightBufferType
    {
        XMFLOAT4 lightDiffuseColor;
        XMFLOAT3 lightDirection;
        float colorTextureBrightness;
    };
 
public:
    ReflectionShaderClass();
    ReflectionShaderClass(const ReflectionShaderClass&);
    ~ReflectionShaderClass();
 
    bool Initialize(ID3D11Device*, HWND);
    void Shutdown();
    bool Render(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*,
                XMFLOAT4, XMFLOAT3, float, 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*,
                             ID3D11ShaderResourceView*, XMFLOAT4, XMFLOAT3, float, 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_clipPlaneBuffer = nullptr;
    ID3D11Buffer* m_lightBuffer = nullptr;
};

Reflectionshaderclass.cpp

#include "stdafx.h"
#include "ReflectionShaderClass.h"
 
 
ReflectionShaderClass::ReflectionShaderClass()
{
}
 
 
ReflectionShaderClass::ReflectionShaderClass(const ReflectionShaderClass& other)
{
}
 
 
ReflectionShaderClass::~ReflectionShaderClass()
{
}
 
 
bool ReflectionShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
    // 정점 및 픽셀 쉐이더를 초기화합니다.
    return InitializeShader(device, hwnd, L"../Dx11Terrain_16/reflection_vs.hlsl", L"../Dx11Terrain_16/reflection_ps.hlsl");
}
 
 
void ReflectionShaderClass::Shutdown()
{
    // 버텍스 및 픽셀 쉐이더와 관련된 객체를 종료합니다.
    ShutdownShader();
}
 
 
bool ReflectionShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX worldMatrix, XMMATRIX viewMatrix, 
                                   XMMATRIX projectionMatrix, ID3D11ShaderResourceView* colorTexture,
                                   ID3D11ShaderResourceView* normalTexture, XMFLOAT4 lightDiffuseColor, XMFLOAT3 lightDirection,
                                   float colorTextureBrightness, XMFLOAT4 clipPlane)
{
    // 렌더링에 사용할 셰이더 매개 변수를 설정합니다.
    if (!SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, colorTexture, normalTexture,
                             lightDiffuseColor, lightDirection, colorTextureBrightness, clipPlane))
    {
        return false;
    }
 
    // 설정된 버퍼를 셰이더로 렌더링한다.
    RenderShader(deviceContext, indexCount);
 
    return true;
}
 
 
bool ReflectionShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, const WCHAR* vsFilename, const WCHAR* psFilename)
{
    HRESULT result;
    ID3D10Blob* errorMessage = nullptr;
 
    // 버텍스 쉐이더 코드를 컴파일한다.
    ID3D10Blob* vertexShaderBuffer = nullptr;
    result = D3DCompileFromFile(vsFilename, NULL, NULL, "ReflectionVertexShader", "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, "ReflectionPixelShader", "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[6];
    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;
 
    polygonLayout[3].SemanticName = "TANGENT";
    polygonLayout[3].SemanticIndex = 0;
    polygonLayout[3].Format = DXGI_FORMAT_R32G32B32_FLOAT;
    polygonLayout[3].InputSlot = 0;
    polygonLayout[3].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[3].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[3].InstanceDataStepRate = 0;
 
    polygonLayout[4].SemanticName = "BINORMAL";
    polygonLayout[4].SemanticIndex = 0;
    polygonLayout[4].Format = DXGI_FORMAT_R32G32B32_FLOAT;
    polygonLayout[4].InputSlot = 0;
    polygonLayout[4].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[4].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[4].InstanceDataStepRate = 0;
 
    polygonLayout[5].SemanticName = "COLOR";
    polygonLayout[5].SemanticIndex = 0;
    polygonLayout[5].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
    polygonLayout[5].InputSlot = 0;
    polygonLayout[5].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[5].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[5].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_CLAMP;
    samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
    samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
    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 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;
 
    //이 클래스 내에서 정점 셰이더 상수 버퍼에 액세스 할 수 있도록 상수 버퍼 포인터를 만듭니다.
    result = device->CreateBuffer(&clipPlaneBufferDesc, NULL, &m_clipPlaneBuffer);
    if(FAILED(result))
    {
        return false;
    }
 
    // 픽셀 쉐이더에있는 광원 동적 상수 버퍼의 구조체를 설정합니다.
    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;
    }
 
    return true;
}
 
 
void ReflectionShaderClass::ShutdownShader()
{
    // 조명 상수 버퍼를 해제합니다.
    if(m_lightBuffer)
    {
        m_lightBuffer->Release();
        m_lightBuffer = 0;
    }
 
    // 클립 평면 상수 버퍼를 해제합니다.
    if(m_clipPlaneBuffer)
    {
        m_clipPlaneBuffer->Release();
        m_clipPlaneBuffer = 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 ReflectionShaderClass::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 ReflectionShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, XMMATRIX worldMatrix, XMMATRIX viewMatrix, 
                                                XMMATRIX projectionMatrix, ID3D11ShaderResourceView* colorTexture,
                                                ID3D11ShaderResourceView* normalTexture, XMFLOAT4 lightDiffuseColor,
                                                XMFLOAT3 lightDirection, float colorTextureBrightness, XMFLOAT4 clipPlane)
{
    // 행렬을 transpose하여 셰이더에서 사용할 수 있게 합니다
    worldMatrix = XMMatrixTranspose(worldMatrix);
    viewMatrix = XMMatrixTranspose(viewMatrix);
    projectionMatrix = XMMatrixTranspose(projectionMatrix);
 
    // 상수 버퍼의 내용을 쓸 수 있도록 잠급니다.
    D3D11_MAPPED_SUBRESOURCE mappedResource;
    if (FAILED(deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource)))
    {
        return false;
    }
 
    // 상수 버퍼의 데이터에 대한 포인터를 가져옵니다.
    MatrixBufferType* dataPtr = (MatrixBufferType*)mappedResource.pData;
 
    // 상수 버퍼에 행렬을 복사합니다.
    dataPtr->world = worldMatrix;
    dataPtr->view = viewMatrix;
    dataPtr->projection = projectionMatrix;
 
    // 상수 버퍼의 잠금을 풉니다.
    deviceContext->Unmap(m_matrixBuffer, 0);
 
    // 정점 셰이더에서의 상수 버퍼의 위치를 설정합니다.
    unsigned int bufferNumber = 0;
 
    // 마지막으로 정점 셰이더의 상수 버퍼를 바뀐 값으로 바꿉니다.
    deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer);
 
    // 버퍼에 기록 할 수 있도록 반사 상수 버퍼를 잠급니다.
    if(FAILED(deviceContext->Map(m_clipPlaneBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource)))
    {
        return false;
    }
 
    // 행렬 상수 버퍼의 데이터를 가리키는 포인터를 얻는다.
    ClipPlaneBufferType* dataPtr1 = (ClipPlaneBufferType*)mappedResource.pData;
 
    // 클립 평면을 클립 평면 상수 버퍼에 복사합니다.
    dataPtr1->clipPlane = clipPlane;
 
    // 버퍼를 잠금 해제합니다.
    deviceContext->Unmap(m_clipPlaneBuffer, 0);
 
    // 버텍스 쉐이더에서 클립 평면 상수 버퍼의 위치를 ​​설정합니다.
    bufferNumber = 1;
 
    // 이제 업데이트 된 값으로 버텍스 쉐이더에서 클립 평면 상수 버퍼를 설정합니다.
    deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_clipPlaneBuffer);
    
    // 조명 상수 버퍼를 잠글 수 있도록 기록한다.
    if(FAILED(deviceContext->Map(m_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource)))
    {
        return false;
    }
 
    // 상수 버퍼의 데이터에 대한 포인터를 가져옵니다.
    LightBufferType* dataPtr2 = (LightBufferType*)mappedResource.pData;
 
    // 조명 변수를 상수 버퍼에 복사합니다.
    dataPtr2->lightDiffuseColor = lightDiffuseColor;
    dataPtr2->lightDirection = lightDirection;
    dataPtr2->colorTextureBrightness = colorTextureBrightness;
 
    // 상수 버퍼의 잠금을 해제합니다.
    deviceContext->Unmap(m_lightBuffer, 0);
 
    // 픽셀 쉐이더에서 광원 상수 버퍼의 위치를 ​​설정합니다.
    bufferNumber = 0;
 
    // 마지막으로 업데이트 된 값으로 픽셀 쉐이더에서 광원 상수 버퍼를 설정합니다.
    deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_lightBuffer);
 
    // 픽셀 쉐이더에서 텍스처 리소스를 설정합니다.
    deviceContext->PSSetShaderResources(0, 1, &colorTexture);
    deviceContext->PSSetShaderResources(1, 1, &normalTexture);
 
    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);
}

WaterClass는 물 쿼드 및 셰이더 관련 설정 및 파일의 지오메트리를 유지하는데 사용되는 새로운 클래스입니다.

Waterclass.h

#pragma once
 
 
class TextureClass;
 
 
class WaterClass
{
private:
    struct VertexType
    {
        XMFLOAT3 position;
        XMFLOAT2 texture;
    };
 
public:
    WaterClass();
    WaterClass(const WaterClass&);
    ~WaterClass();
 
    bool Initialize(ID3D11Device*, const WCHAR*, float, float);
    void Shutdown();
    void Frame();
    void Render(ID3D11DeviceContext*);
 
    int GetIndexCount();
    ID3D11ShaderResourceView* GetTexture();
    
    float GetWaterHeight();
    XMFLOAT2 GetNormalMapTiling();
    float GetWaterTranslation();
    float GetReflectRefractScale();
    XMFLOAT4 GetRefractionTint();
    float GetSpecularShininess();
 
private:
    bool InitializeBuffers(ID3D11Device*, float);
    void ShutdownBuffers();
    void RenderBuffers(ID3D11DeviceContext*);
 
    bool LoadTexture(ID3D11Device*, const WCHAR*);
    void ReleaseTexture();
 
private:
    float m_waterHeight = 0.0f;
    ID3D11Buffer *m_vertexBuffer = nullptr;
    ID3D11Buffer *m_indexBuffer = nullptr;
    int m_vertexCount = 0;
    int m_indexCount = 0;
    TextureClass* m_Texture = nullptr;
    XMFLOAT2 m_normalMapTiling;
    float m_waterTranslation = 0.0f;
    float m_reflectRefractScale = 0.0f;
    XMFLOAT4 m_refractionTint;
    float m_specularShininess = 0.0f;
};

Waterclass.cpp

#include "stdafx.h"
#include "TextureClass.h"
#include "waterclass.h"
 
 
WaterClass::WaterClass()
{
}
 
 
WaterClass::WaterClass(const WaterClass& other)
{
}
 
 
WaterClass::~WaterClass()
{
}
 
 
bool WaterClass::Initialize(ID3D11Device* device, const WCHAR* textureFilename, float waterHeight, float waterRadius)
{
    // 수위를 저장합니다.
    m_waterHeight = waterHeight;
 
    // 삼각형의 지오메트리를 유지하는 꼭지점과 인덱스 버퍼를 초기화합니다.
    if(!InitializeBuffers(device, waterRadius))
    {
        return false;
    }
 
    //이 모델의 텍스처를 로드합니다.
    if(!LoadTexture(device, textureFilename))
    {
        return false;
    }
 
    // 물 법선 맵의 타일링을 설정합니다.
    m_normalMapTiling.x = 0.01f;  // 쿼드에 10 번 타일을 붙입니다.
    m_normalMapTiling.y = 0.02f;  // 쿼드에 5 번 타일을 붙입니다.
 
    // 수질 변환을 0으로 초기화합니다.
    m_waterTranslation = 0.0f;
 
    // 물 법선 맵의 스케일링 값을 설정합니다.
    m_reflectRefractScale = 0.03f;
 
    // 굴절의 색조를 설정합니다.
    m_refractionTint = XMFLOAT4(0.0f, 0.8f, 1.0f, 1.0f);
 
    // specular shininess를 설정합니다.
    m_specularShininess = 200.0f;
 
    return true;
}
 
 
void WaterClass::Shutdown()
{
    // 모델 텍스처를 릴리즈한다.
    ReleaseTexture();
 
    // 버텍스와 인덱스 버퍼를 해제한다.
    ShutdownBuffers();
}
 
 
void WaterClass::Frame()
{
    // 모션을 시뮬레이트 하기 위해 물의 위치를 ​​업데이트 합니다.
    m_waterTranslation += 0.003f;
    if(m_waterTranslation > 1.0f)
    {
        m_waterTranslation -= 1.0f;
    }
}
 
 
void WaterClass::Render(ID3D11DeviceContext* deviceContext)
{
    // 그리기를 준비하기 위해 그래픽 파이프 라인에 꼭지점과 인덱스 버퍼를 놓습니다.
    RenderBuffers(deviceContext);
}
 
 
int WaterClass::GetIndexCount()
{
    return m_indexCount;
}
 
 
ID3D11ShaderResourceView* WaterClass::GetTexture()
{
    return m_Texture->GetTexture();
}
 
 
float WaterClass::GetWaterHeight()
{
    return m_waterHeight;
}
 
 
XMFLOAT2 WaterClass::GetNormalMapTiling()
{
    return m_normalMapTiling;
}
 
 
float WaterClass::GetWaterTranslation()
{
    return m_waterTranslation;
}
 
 
float WaterClass::GetReflectRefractScale()
{
    return m_reflectRefractScale;
}
 
 
XMFLOAT4 WaterClass::GetRefractionTint()
{
    return m_refractionTint;
}
 
 
float WaterClass::GetSpecularShininess()
{
    return m_specularShininess;
}
 
 
bool WaterClass::InitializeBuffers(ID3D11Device* device, float waterRadius)
{
    // 정점 배열의 정점 수를 설정합니다.
    m_vertexCount = 6;
 
    // 인덱스 배열의 인덱스 수를 설정합니다.
    m_indexCount = 6;
 
    // 정점 배열을 만듭니다.
    VertexType* vertices = new VertexType[m_vertexCount];
    if(!vertices)
    {
        return false;
    }
 
    // 인덱스 배열을 만듭니다.
    ULONG* indices = new unsigned long[m_indexCount];
    if(!indices)
    {
        return false;
    }
 
    // 정점 배열에 데이터를 로드합니다.
    vertices[0].position = XMFLOAT3(-waterRadius, 0.0f, waterRadius);  // 왼쪽 위.
    vertices[0].texture = XMFLOAT2(0.0f, 0.0f);
 
    vertices[1].position = XMFLOAT3(waterRadius, 0.0f, waterRadius);  // 오른쪽 위.
    vertices[1].texture = XMFLOAT2(1.0f, 0.0f);
    
    vertices[2].position = XMFLOAT3(-waterRadius, 0.0f, -waterRadius);  // 왼쪽 아래.
    vertices[2].texture = XMFLOAT2(0.0f, 1.0f);
 
    vertices[3].position = XMFLOAT3(-waterRadius, 0.0f, -waterRadius);  // 왼쪽 아래.
    vertices[3].texture = XMFLOAT2(0.0f, 1.0f);
 
    vertices[4].position = XMFLOAT3(waterRadius, 0.0f, waterRadius);  // 오른쪽 위.
    vertices[4].texture = XMFLOAT2(1.0f, 0.0f);
 
    vertices[5].position = XMFLOAT3(waterRadius, 0.0f, -waterRadius);  // 오른쪽 아래.
    vertices[5].texture = XMFLOAT2(1.0f, 1.0f);
 
    // 데이터로 인덱스 배열을 로드합니다.
    indices[0] = 0;
    indices[1] = 1;
    indices[2] = 2;
    indices[3] = 3;
    indices[4] = 4;
    indices[5] = 5;
 
    // 정점 버퍼의 구조체를 설정합니다.
    D3D11_BUFFER_DESC vertexBufferDesc;
    vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_vertexCount;
    vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vertexBufferDesc.CPUAccessFlags = 0;
    vertexBufferDesc.MiscFlags = 0;
    vertexBufferDesc.StructureByteStride = 0;
 
    // subresource 구조에 정점 데이터에 대한 포인터를 제공합니다.
    D3D11_SUBRESOURCE_DATA vertexData;
    vertexData.pSysMem = vertices;
    vertexData.SysMemPitch = 0;
    vertexData.SysMemSlicePitch = 0;
 
    // 이제 마침내 정점 버퍼를 만듭니다.
    if(FAILED(device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer)))
    {
        return false;
    }
 
    // 인덱스 버퍼의 설명을 설정합니다.
    D3D11_BUFFER_DESC indexBufferDesc;
    indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    indexBufferDesc.ByteWidth = sizeof(unsigned long) * m_indexCount;
    indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
    indexBufferDesc.CPUAccessFlags = 0;
    indexBufferDesc.MiscFlags = 0;
    indexBufferDesc.StructureByteStride = 0;
 
    // 하위 리소스 구조에 인덱스 데이터에 대한 포인터를 제공합니다.
    D3D11_SUBRESOURCE_DATA indexData;
    indexData.pSysMem = indices;
    indexData.SysMemPitch = 0;
    indexData.SysMemSlicePitch = 0;
 
    // 인덱스 버퍼를 만듭니다.
    if(FAILED(device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer)))
    {
        return false;
    }
 
    // 이제 버텍스와 인덱스 버퍼가 생성되고로드 된 배열을 해제하십시오.
    delete [] vertices;
    vertices = 0;
 
    delete [] indices;
    indices = 0;
 
    return true;
}
 
 
void WaterClass::ShutdownBuffers()
{
    // 인덱스 버퍼를 해제합니다.
    if(m_indexBuffer)
    {
        m_indexBuffer->Release();
        m_indexBuffer = 0;
    }
 
    // 버텍스 버퍼를 해제합니다.
    if(m_vertexBuffer)
    {
        m_vertexBuffer->Release();
        m_vertexBuffer = 0;
    }
}
 
 
void WaterClass::RenderBuffers(ID3D11DeviceContext* deviceContext)
{
    // 정점 버퍼 보폭 및 오프셋을 설정합니다.
    unsigned int stride = sizeof(VertexType); 
    unsigned int offset = 0;
    
    // 렌더링 할 수 있도록 입력 어셈블러에서 정점 버퍼를 활성으로 설정합니다.
    deviceContext->IASetVertexBuffers(0, 1, &m_vertexBuffer, &stride, &offset);
 
    // 렌더링 할 수 있도록 입력 어셈블러에서 인덱스 버퍼를 활성으로 설정합니다.
    deviceContext->IASetIndexBuffer(m_indexBuffer, DXGI_FORMAT_R32_UINT, 0);
 
    // 이 꼭지점 버퍼에서 렌더링되어야하는 프리미티브 유형을 설정합니다.이 경우에는 삼각형입니다.
    deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
}
 
 
bool WaterClass::LoadTexture(ID3D11Device* device, const WCHAR* filename)
{
    // 텍스처 오브젝트를 생성한다.
    m_Texture = new TextureClass;
    if(!m_Texture)
    {
        return false;
    }
 
    // 텍스처 오브젝트를 초기화한다.
    return m_Texture->Initialize(device, filename);
}
 
 
void WaterClass::ReleaseTexture()
{
    // 텍스처 오브젝트를 릴리즈한다.
    if(m_Texture)
    {
        m_Texture->Shutdown();
        delete m_Texture;
        m_Texture = 0;
    }
}

여기에 있는 HLSL 워터 셰이더는 DirectX 튜토리얼 섹션의 HLSL 워터 셰이더와 매우 비슷합니다. 우리가 한 모든 것은 추가적인 효과를 추가하는 것입니다.

Water_vs.hlsl

////////////////////////////////////////////////////////////////////////////////
// Filename: water_vs.hlsl
////////////////////////////////////////////////////////////////////////////////
 
 
/////////////
// GLOBALS //
/////////////
cbuffer MatrixBuffer
{
    matrix worldMatrix;
    matrix viewMatrix;
    matrix projectionMatrix;
    matrix reflectionMatrix;
};
 
cbuffer CamNormBuffer
{
    float3 cameraPosition;
    float padding1;
    float2 normalMapTiling;
    float2 padding2;
};
 
 
//////////////
// TYPEDEFS //
//////////////
struct VertexInputType
{
    float4 position : POSITION;
    float2 tex : TEXCOORD0;
};
 
struct PixelInputType
{
    float4 position : SV_POSITION;
    float4 reflectionPosition : TEXCOORD0;
    float4 refractionPosition : TEXCOORD1;
    float3 viewDirection : TEXCOORD2;
    float2 tex1 : TEXCOORD3;
    float2 tex2 : TEXCOORD4;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// Vertex Shader
////////////////////////////////////////////////////////////////////////////////
PixelInputType WaterVertexShader(VertexInputType input)
{
    PixelInputType output;
    matrix reflectProjectWorld;
    matrix viewProjectWorld;
    float4 worldPosition;
 
    
    // 적절한 행렬 계산을 위해 위치 벡터를 4 단위로 변경합니다.
    input.position.w = 1.0f;
 
    // 월드, 뷰 및 투영 행렬에 대한 정점의 위치를 ​​계산합니다.
    output.position = mul(input.position, worldMatrix);
    output.position = mul(output.position, viewMatrix);
    output.position = mul(output.position, projectionMatrix);
    
    // 반사 투영 세계 행렬을 만듭니다.
    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);
    
     // 세계의 정점 위치를 계산합니다.
    worldPosition = mul(input.position, worldMatrix);
 
    // 카메라의 위치와 세계의 정점 위치를 기준으로 보기 방향을 결정합니다.
    output.viewDirection = cameraPosition.xyz - worldPosition.xyz;
 
    // 뷰 방향 벡터를 표준화합니다.
    output.viewDirection = normalize(output.viewDirection);
 
    // 수질 쿼드 위에 수차 법 맵을 여러 번 타일링하기 위해 두 개의 다른 텍스처 샘플 좌표를 만듭니다.
    output.tex1 = input.tex / normalMapTiling.x;
    output.tex2 = input.tex / normalMapTiling.y;
 
    return output;
}

Water_ps.hlsl

////////////////////////////////////////////////////////////////////////////////
// Filename: water_ps.hlsl
////////////////////////////////////////////////////////////////////////////////
 
 
/////////////
// GLOBALS //
/////////////
SamplerState SampleType;
Texture2D refractionTexture : register(t0);
Texture2D reflectionTexture : register(t1);
Texture2D normalTexture : register(t2);
 
cbuffer WaterBuffer
{
    float4 refractionTint;
    float3 lightDirection;
    float waterTranslation;
    float reflectRefractScale;
    float specularShininess;
    float2 padding;
};
 
 
//////////////
// TYPEDEFS //
//////////////
struct PixelInputType
{
    float4 position : SV_POSITION;
    float4 reflectionPosition : TEXCOORD0;
    float4 refractionPosition : TEXCOORD1;
    float3 viewDirection : TEXCOORD2;
    float2 tex1 : TEXCOORD3;
    float2 tex2 : TEXCOORD4;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// Pixel Shader
////////////////////////////////////////////////////////////////////////////////
float4 WaterPixelShader(PixelInputType input) : SV_TARGET
{
    float4 normalMap1;
    float4 normalMap2;
    float3 normal1;
    float3 normal2;
    float3 normal;
    float2 refractTexCoord;
    float2 reflectTexCoord;
    float4 reflectionColor;
    float4 refractionColor;
    float3 heightView;
    float r;
    float fresnelFactor;
    float4 color;
    float3 reflection;
    float specular;
 
 
    // 움직이는 물을 시뮬레이트하기 위해 물 수직선을 샘플링 한 위치를 이동합니다.    
    input.tex1.y += waterTranslation;
    input.tex2.y += waterTranslation;
 
    // 두 개의 서로 다른 바둑판 식 좌표와 변환 된 좌표를 사용하여 노멀 맵 텍스처로부터 법선을 샘플링합니다.
    normalMap1 = normalTexture.Sample(SampleType, input.tex1);
    normalMap2 = normalTexture.Sample(SampleType, input.tex2);
    
    // 법선의 범위를 (0,1)에서 (-1, + 1)로 확장합니다.
    normal1 = (normalMap1.rgb * 2.0f) - 1.0f;
    normal2 = (normalMap2.rgb * 2.0f) - 1.0f;
 
    // 법선을 결합하여 법선 맵을 함께 추가합니다.
    normal = normalize(normal1 + normal2);
        
    // 투영된 굴절 텍스처 좌표를 계산합니다.
    refractTexCoord.x = input.refractionPosition.x / input.refractionPosition.w / 2.0f + 0.5f;
    refractTexCoord.y = -input.refractionPosition.y / input.refractionPosition.w / 2.0f + 0.5f;
    
    // 투사 된 반사 텍스처 좌표를 계산합니다.
    reflectTexCoord.x = input.reflectionPosition.x / input.reflectionPosition.w / 2.0f + 0.5f;
    reflectTexCoord.y = -input.reflectionPosition.y / input.reflectionPosition.w / 2.0f + 0.5f;
        
    // 스케일 된 노멀 맵 값으로 텍스처 좌표 샘플링 위치의 위치를 ​​변경하여 졸졸 물결 효과를 시뮬레이트 합니다.
    reflectTexCoord = reflectTexCoord + (normal.xy * reflectRefractScale);
    refractTexCoord = refractTexCoord + (normal.xy * reflectRefractScale);
    
    // 업데이트 된 텍스처 좌표를 사용하여 텍스처에서 텍스처 픽셀을 샘플링합니다.
    reflectionColor = reflectionTexture.Sample(SampleType, reflectTexCoord);
    refractionColor = refractionTexture.Sample(SampleType, refractTexCoord);
 
    // 색조를 굴절 색상과 결합합니다.
    refractionColor = saturate(refractionColor * refractionTint);
 
    // 높이만 고려한 카메라의 수정된 보기 방향을 가져옵니다.
    heightView.x = input.viewDirection.y;
    heightView.y = input.viewDirection.y;
    heightView.z = input.viewDirection.y;
 
    // 이제 높이만을 기준으로 프레넬 기간을 계산합니다.
    r = (1.2f - 1.0f) / (1.2f + 1.0f);
    fresnelFactor = max(0.0f, min(1.0f, r + (1.0f - r) * pow(1.0f - dot(normal, heightView), 2)));
 
    // fresnel 인수를 사용하여 최종 색상의 반사 및 굴절 결과를 결합합니다.
    color = lerp(reflectionColor, refractionColor, fresnelFactor);
 
    // 법선과 빛의 방향을 사용하여 반사 벡터를 계산합니다.
    reflection = -reflect(normalize(lightDirection), normal);
    
    // 반사 및 카메라 위치를 기반으로 반사 조명을 계산합니다.
    specular = dot(normalize(reflection), normalize(input.viewDirection));
 
    // 물에 검은 반점이 없도록 반사가 양수인지 확인하십시오.
    if(specular > 0.0f)
    {
        // 반사율을 shininess 값만큼 증가시킵니다.
        specular = pow(specular, specularShininess);
 
        // 최종 색상에 반사를 추가합니다.
        color = saturate(color + specular);
    }
 
    return color;
}

WaterShaderClass는 specular, texture tiling 및 refraction tint와 같은 새로운 설정을 위한 변수를 포함한다는 점을 제외하고는 DirectX 물 듀토리얼과 동일합니다.

Watershaderclass.h

#pragma once
 
class WaterShaderClass
{
private:
    struct MatrixBufferType
    {
        XMMATRIX world;
        XMMATRIX view;
        XMMATRIX projection;
        XMMATRIX reflection;
    };
 
    struct CamNormBufferType
    {
        XMFLOAT3 cameraPosition;
        float padding1;
        XMFLOAT2 normalMapTiling;
        XMFLOAT2 padding2;
    };
 
    struct WaterBufferType
    {
        XMFLOAT4 refractionTint;
        XMFLOAT3 lightDirection;
        float waterTranslation;
        float reflectRefractScale;
        float specularShininess;
        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*, XMFLOAT3, XMFLOAT2, float, float, XMFLOAT4, XMFLOAT3,
                float);
 
private:
    bool InitializeShader(ID3D11Device*, HWND, const WCHAR*, const WCHAR*);
    void ShutdownShader();
    void OutputShaderErrorMessage(ID3D10Blob*, HWND, const WCHAR*);
 
    bool SetShaderParameters(ID3D11DeviceContext*, XMMATRIX, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*,
                             ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, XMFLOAT3, XMFLOAT2, float, float, XMFLOAT4,
                             XMFLOAT3, 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_camNormBuffer = 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"../Dx11Terrain_16/water_vs.hlsl", L"../Dx11Terrain_16/water_ps.hlsl");
}
 
 
void WaterShaderClass::Shutdown()
{
    // 버텍스 및 픽셀 쉐이더와 관련된 객체를 종료합니다.
    ShutdownShader();
}
 
 
bool WaterShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX worldMatrix, XMMATRIX viewMatrix, 
                        XMMATRIX projectionMatrix, XMMATRIX reflectionMatrix, ID3D11ShaderResourceView* refractionTexture, 
                        ID3D11ShaderResourceView* reflectionTexture, ID3D11ShaderResourceView* normalTexture,
                        XMFLOAT3 cameraPosition, XMFLOAT2 normalMapTiling, float waterTranslation, float reflectRefractScale,
                        XMFLOAT4 refractionTint, XMFLOAT3 lightDirection, float specularShininess)
{
    // 렌더링에 사용할 셰이더 매개 변수를 설정합니다.
    if (!SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, reflectionMatrix, refractionTexture,
                             reflectionTexture, normalTexture, cameraPosition, normalMapTiling, waterTranslation,
                             reflectRefractScale, refractionTint, lightDirection, specularShininess))
    {
        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 camNormBufferDesc;
    camNormBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    camNormBufferDesc.ByteWidth = sizeof(CamNormBufferType);
    camNormBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    camNormBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    camNormBufferDesc.MiscFlags = 0;
    camNormBufferDesc.StructureByteStride = 0;
 
    // 이 클래스 내에서 정점 셰이더 상수 버퍼에 액세스 할 수 있도록 상수 버퍼 포인터를 만듭니다.
    result = device->CreateBuffer(&camNormBufferDesc, NULL, &m_camNormBuffer);
    if(FAILED(result))
    {
        return false;
    }
 
    // 픽셀 쉐이더에있는 물 동적 상수 버퍼의 설명을 설정합니다.
    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;
 
    // 이 클래스 내에서 픽셀 쉐이더 상수 버퍼에 액세스 할 수 있도록 상수 버퍼 포인터를 만듭니다.
    result = device->CreateBuffer(&waterBufferDesc, NULL, &m_waterBuffer);
    if(FAILED(result))
    {
        return false;
    }    
 
    return true;
}
 
 
void WaterShaderClass::ShutdownShader()
{
    // 물 상수 버퍼를 해제합니다.
    if(m_waterBuffer)
    {
        m_waterBuffer->Release();
        m_waterBuffer = 0;
    }
 
    // 카메라와 일반 타일링 상수 버퍼를 해제합니다.
    if(m_camNormBuffer)
    {
        m_camNormBuffer->Release();
        m_camNormBuffer = 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* refractionTexture,
                         ID3D11ShaderResourceView* reflectionTexture, ID3D11ShaderResourceView* normalTexture, 
                         XMFLOAT3 cameraPosition, XMFLOAT2 normalMapTiling, float waterTranslation, float reflectRefractScale,
                         XMFLOAT4 refractionTint, XMFLOAT3 lightDirection, float specularShininess)
{
    // 행렬을 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;
    dataPtr->reflection = reflectionMatrix;
    
    // 상수 버퍼의 잠금을 풉니다.
    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_camNormBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource)))
    {
        return false;
    }
 
    // 상수 버퍼의 데이터에 대한 포인터를 가져옵니다.
    CamNormBufferType* dataPtr2 = (CamNormBufferType*)mappedResource.pData;
 
    // Copy the data into the constant buffer.
    dataPtr2->cameraPosition = cameraPosition;
    dataPtr2->padding1 = 0.0f;
    dataPtr2->normalMapTiling = normalMapTiling;
    dataPtr2->padding2 = XMFLOAT2(0.0f, 0.0f);
 
    // 행렬 상수 버퍼의 잠금을 해제합니다.
    deviceContext->Unmap(m_camNormBuffer, 0);
 
    // 픽셀 쉐이더에서 광원 상수 버퍼의 위치를 ??설정합니다.
    bufferNumber = 1;
 
    // 업데이트 된 값으로 버텍스 쉐이더에 상수 버퍼를 설정합니다.
    deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_camNormBuffer);
 
    // 픽셀 쉐이더에서 텍스처 리소스를 설정합니다.
    deviceContext->PSSetShaderResources(0, 1, &refractionTexture);
    deviceContext->PSSetShaderResources(1, 1, &reflectionTexture);
    deviceContext->PSSetShaderResources(2, 1, &normalTexture);
 
    // 쓸 수 있도록 물 상수 버퍼를 잠급니다.
    if(FAILED(deviceContext->Map(m_waterBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource)))
    {
        return false;
    }
 
    // 상수 버퍼의 데이터에 대한 포인터를 가져옵니다.
    WaterBufferType* dataPtr3 = (WaterBufferType*)mappedResource.pData;
 
    // 물 데이터를 상수 버퍼에 복사합니다.
    dataPtr3->waterTranslation = waterTranslation;
    dataPtr3->reflectRefractScale = reflectRefractScale;
    dataPtr3->refractionTint = refractionTint;
    dataPtr3->lightDirection = lightDirection;
    dataPtr3->specularShininess = specularShininess;
    dataPtr3->padding = XMFLOAT2(0.0f, 0.0f);
 
    // 상수 버퍼의 잠금을 해제합니다.
    deviceContext->Unmap(m_waterBuffer, 0);
 
    // 픽셀 셰이더에서 물 상수 버퍼의 위치를 ​​설정합니다.
    bufferNumber = 0;
 
    // 마지막으로 업데이트 된 값으로 픽셀 쉐이더에 물 상수 버퍼를 설정합니다.
    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);
}

Applicationclass.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 InputClass;
class D3DClass;
class TimerClass;
class PositionClass;
class CameraClass;
class LightClass;
class TerrainClass;
class TerrainShaderClass;
class SkyDomeClass;
class SkyDomeShaderClass;
class SkyPlaneClass;
class SkyPlaneShaderClass;
class FpsClass;
class CpuClass;
class FontShaderClass;
class TextClass;
class RenderTextureClass;
class ReflectionShaderClass;
class WaterClass;
class WaterShaderClass;
 
 
class ApplicationClass
{
public:
    ApplicationClass();
    ApplicationClass(const ApplicationClass&);
    ~ApplicationClass();
 
    bool Initialize(HINSTANCE, HWND, int, int);
    void Shutdown();
    bool Frame();
 
private:
    bool HandleMovementInput(float);
    void RenderRefractionToTexture();
    void RenderReflectionToTexture();
    bool Render();
 
private:
    InputClass* m_Input = nullptr;
    D3DClass* m_Direct3D = nullptr;
    TimerClass* m_Timer = nullptr;
    PositionClass* m_Position = nullptr;
    CameraClass* m_Camera = nullptr;
    LightClass* m_Light = nullptr;
    TerrainClass* m_Terrain = nullptr;
    TerrainShaderClass* m_TerrainShader = nullptr;
    SkyDomeClass* m_SkyDome = nullptr;
    SkyDomeShaderClass* m_SkyDomeShader = nullptr;
    SkyPlaneClass *m_SkyPlane = nullptr;
    SkyPlaneShaderClass* m_SkyPlaneShader = nullptr;
    FpsClass* m_Fps = nullptr;
    CpuClass* m_Cpu = nullptr;
    FontShaderClass* m_FontShader = nullptr;
    TextClass* m_Text = nullptr;
    RenderTextureClass *m_RefractionTexture = nullptr;
    RenderTextureClass *m_ReflectionTexture = nullptr;
    ReflectionShaderClass* m_ReflectionShader = nullptr;
    WaterClass* m_Water = nullptr;
    WaterShaderClass* m_WaterShader = nullptr;
};

Applicationclass.cpp

#include "stdafx.h"
#include "inputclass.h"
#include "d3dclass.h"
#include "timerclass.h"
#include "positionclass.h"
#include "cameraclass.h"
#include "lightclass.h"
#include "terrainclass.h"
#include "terrainshaderclass.h"
#include "skydomeclass.h"
#include "skydomeshaderclass.h"
#include "skyplaneclass.h"
#include "skyplaneshaderclass.h"
#include "fpsclass.h"
#include "cpuclass.h"
#include "fontshaderclass.h"
#include "textclass.h"
#include "rendertextureclass.h"
#include "reflectionshaderclass.h"
#include "waterclass.h"
#include "watershaderclass.h"
#include "ApplicationClass.h"
 
 
ApplicationClass::ApplicationClass()
{
}
 
 
ApplicationClass::ApplicationClass(const ApplicationClass& other)
{
}
 
 
ApplicationClass::~ApplicationClass()
{
}
 
 
bool ApplicationClass::Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int screenHeight)
{
    // 입력 개체를 생성합니다.
    m_Input = new InputClass;
    if(!m_Input)
    {
        return false;
    }
 
    // 입력 개체를 초기화 합니다.
    bool result = m_Input->Initialize(hinstance, hwnd, screenWidth, screenHeight);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the input object.", L"Error", MB_OK);
        return false;
    }
 
    // Direct3D 개체를 생성합니다.
    m_Direct3D = new D3DClass;
    if(!m_Direct3D)
    {
        return false;
    }
 
    // Direct3D 개체를 초기화 합니다.
    result = m_Direct3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize DirectX 11.", L"Error", MB_OK);
        return false;
    }
 
    // 비디오 카드 정보를 가져옵니다.
    char videoCard[128] = { 0, };
    int videoMemory = 0;
    m_Direct3D->GetVideoCardInfo(videoCard, videoMemory);
 
    // 타이머 객체를 생성합니다.
    m_Timer = new TimerClass;
    if(!m_Timer)
    {
        return false;
    }
 
    // 타이머 객체를 초기화 합니다.
    result = m_Timer->Initialize();
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the timer object.", L"Error", MB_OK);
        return false;
    }
 
    // 위치 개체를 생성합니다.
    m_Position = new PositionClass;
    if(!m_Position)
    {
        return false;
    }
 
    // 뷰어의 초기 위치와 회전을 설정합니다.
    m_Position->SetPosition(XMFLOAT3(280.379f, 24.5225f, 367.018f));
    m_Position->SetRotation(XMFLOAT3(19.6834f, 222.013f, 0.0f));
    
    // 카메라 객체를 생성합니다.
    m_Camera = new CameraClass;
    if(!m_Camera)
    {
        return false;
    }
 
    // 2D 사용자 인터페이스 렌더링을 위해 카메라로 기본 뷰 행렬을 초기화 합니다.
    XMMATRIX baseViewMatrix;
    m_Camera->SetPosition(XMFLOAT3(0.0f, 0.0f, -10.0f));
    m_Camera->GenerateBaseViewMatrix();
    m_Camera->GetBaseViewMatrix(baseViewMatrix);
 
    // 조명 객체를 생성합니다.
    m_Light = new LightClass;
    if(!m_Light)
    {
        return false;
    }
 
    // 조명 객체를 초기화 합니다.
    m_Light->SetDiffuseColor(XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f));
    m_Light->SetDirection(XMFLOAT3(0.5f, -0.75f, 0.25f));
    
    // 지형 객체를 생성합니다.
    m_Terrain = new TerrainClass;
    if(!m_Terrain)
    {
        return false;
    }
 
    // 지형 객체를 초기화 합니다.
    result = m_Terrain->Initialize(m_Direct3D->GetDevice(), "../Dx11Terrain_16/data/hm.bmp",
                                                            "../Dx11Terrain_16/data/cm.bmp", 20.0f,
                                                           L"../Dx11Terrain_16/data/dirt.dds", 
                                                           L"../Dx11Terrain_16/data/normal.dds");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the terrain object.", L"Error", MB_OK);
        return false;
    }
 
    // 지형 쉐이더 객체를 생성합니다.
    m_TerrainShader = new TerrainShaderClass;
    if(!m_TerrainShader)
    {
        return false;
    }
 
    // 지형 쉐이더 객체를 초기화 합니다.
    result = m_TerrainShader->Initialize(m_Direct3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the terrain shader object.", L"Error", MB_OK);
        return false;
    }
 
    // sky dome 객체를 생성합니다.
    m_SkyDome = new SkyDomeClass;
    if(!m_SkyDome)
    {
        return false;
    }
 
    // sky dome 객체를 초기화 합니다.
    result = m_SkyDome->Initialize(m_Direct3D->GetDevice());
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the sky dome object.", L"Error", MB_OK);
        return false;
    }
 
    // sky dome shader 객체를 생성합니다.
    m_SkyDomeShader = new SkyDomeShaderClass;
    if(!m_SkyDomeShader)
    {
        return false;
    }
 
    // sky dome shader 객체를 초기화 합니다.
    result = m_SkyDomeShader->Initialize(m_Direct3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the sky dome shader object.", L"Error", MB_OK);
        return false;
    }
 
    // 하늘 평면 객체를 생성합니다.
    m_SkyPlane = new SkyPlaneClass;
    if(!m_SkyPlane)
    {
        return false;
    }
 
    // 하늘 평면 객체를 초기화 합니다.
    result = m_SkyPlane->Initialize(m_Direct3D->GetDevice(), L"../Dx11Terrain_16/data/cloud001.dds",
                                                             L"../Dx11Terrain_16/data/perturb001.dds");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the sky plane object.", L"Error", MB_OK);
        return false;
    }
 
    // sky plane shader 객체를 생성합니다.
    m_SkyPlaneShader = new SkyPlaneShaderClass;
    if(!m_SkyPlaneShader)
    {
        return false;
    }
 
    // sky plane shader 객체를 초기화 합니다.
    result = m_SkyPlaneShader->Initialize(m_Direct3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the sky plane shader object.", L"Error", MB_OK);
        return false;
    }
    
    // fps 객체를 생성합니다.
    m_Fps = new FpsClass;
    if(!m_Fps)
    {
        return false;
    }
 
    // fps 객체를 초기화 합니다.
    m_Fps->Initialize();
 
    // cpu 객체를 생성합니다.
    m_Cpu = new CpuClass;
    if(!m_Cpu)
    {
        return false;
    }
 
    // cpu 객체를 초기화 합니다.
    m_Cpu->Initialize();
 
    // 폰트 셰이더 객체를 생성합니다.
    m_FontShader = new FontShaderClass;
    if(!m_FontShader)
    {
        return false;
    }
 
    // 폰트 셰이더 객체를 초기화 합니다.
    result = m_FontShader->Initialize(m_Direct3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the font shader object.", L"Error", MB_OK);
        return false;
    }
 
    // 텍스트 객체를 생성합니다.
    m_Text = new TextClass;
    if(!m_Text)
    {
        return false;
    }
 
    // 텍스트 객체를 초기화 합니다.
    result = m_Text->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), hwnd, screenWidth, screenHeight,
                                baseViewMatrix);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the text object.", L"Error", MB_OK);
        return false;
    }
 
    // 텍스트 객체에 비디오 카드 정보를 설정합니다.
    result = m_Text->SetVideoCardInfo(videoCard, videoMemory, m_Direct3D->GetDeviceContext());
    if(!result)
    {
        MessageBox(hwnd, L"Could not set video card info in the text object.", L"Error", MB_OK);
        return false;
    }
 
    // 텍스처 오브젝트에 굴절 렌더링을 생성합니다.
    m_RefractionTexture = new RenderTextureClass;
    if(!m_RefractionTexture)
    {
        return false;
    }
 
    // 텍스처 오브젝트에 굴절 렌더링을 초기화한다.
    result = m_RefractionTexture->Initialize(m_Direct3D->GetDevice(), screenWidth, screenHeight, SCREEN_DEPTH, SCREEN_NEAR);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the refraction render to texture object.", L"Error", MB_OK);
        return false;
    }
 
    // 텍스처 객체에 반사 렌더링을 생성합니다.
    m_ReflectionTexture = new RenderTextureClass;
    if(!m_ReflectionTexture)
    {
        return false;
    }
 
    // 반사 렌더링을 텍스처 오브젝트로 초기화 합니다.
    result = m_ReflectionTexture->Initialize(m_Direct3D->GetDevice(), screenWidth, screenHeight, SCREEN_DEPTH, SCREEN_NEAR);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the reflection render to texture object.", L"Error", MB_OK);
        return false;
    }
 
    // 반사 셰이더 개체를 생성합니다.
    m_ReflectionShader = new ReflectionShaderClass;
    if(!m_ReflectionShader)
    {
        return false;
    }
 
    // 반사 쉐이더 객체를 초기화 합니다.
    result = m_ReflectionShader->Initialize(m_Direct3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the reflection shader object.", L"Error", MB_OK);
        return false;
    }
 
    // 물 객체를 생성합니다.
    m_Water = new WaterClass;
    if(!m_Water)
    {
        return false;
    }
 
    // 물 객체를 초기화 합니다.
    result = m_Water->Initialize(m_Direct3D->GetDevice(), L"../Dx11Terrain_16/data/waternormal.dds", 3.75f, 110.0f);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the water object.", L"Error", MB_OK);
        return false;
    }
 
    // 워터 셰이더 객체를 생성합니다.
    m_WaterShader = new WaterShaderClass;
    if(!m_WaterShader)
    {
        return false;
    }
 
    // 워터 셰이더 개체를 초기화 합니다.
    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;
    }
 
    return true;
}
 
 
void ApplicationClass::Shutdown()
{
    // 물 셰이더 객체를 해제합니다.
    if(m_WaterShader)
    {
        m_WaterShader->Shutdown();
        delete m_WaterShader;
        m_WaterShader = 0;
    }
 
    // 물 객체를 해제합니다.
    if(m_Water)
    {
        m_Water->Shutdown();
        delete m_Water;
        m_Water = 0;
    }
 
    // 반사 쉐이더 객체를 해제합니다.
    if(m_ReflectionShader)
    {
        m_ReflectionShader->Shutdown();
        delete m_ReflectionShader;
        m_ReflectionShader = 0;
    }
 
    // 반사 텍스처 객체를 해제합니다.
    if(m_ReflectionTexture)
    {
        m_ReflectionTexture->Shutdown();
        delete m_ReflectionTexture;
        m_ReflectionTexture = 0;
    }
 
    // 굴절 텍스처 객체를 해제합니다.
    if(m_RefractionTexture)
    {
        m_RefractionTexture->Shutdown();
        delete m_RefractionTexture;
        m_RefractionTexture = 0;
    }
 
    // 텍스트 객체를 해제합니다.
    if(m_Text)
    {
        m_Text->Shutdown();
        delete m_Text;
        m_Text = 0;
    }
 
    // 폰트 쉐이더 객체를 해제합니다.
    if(m_FontShader)
    {
        m_FontShader->Shutdown();
        delete m_FontShader;
        m_FontShader = 0;
    }
 
    // cpu 객체를 해제합니다.
    if(m_Cpu)
    {
        m_Cpu->Shutdown();
        delete m_Cpu;
        m_Cpu = 0;
    }
 
    // fps 객체를 해제합니다.
    if(m_Fps)
    {
        delete m_Fps;
        m_Fps = 0;
    }
        
    // 하늘 평면 쉐이더 객체를 해제합니다.
    if(m_SkyPlaneShader)
    {
        m_SkyPlaneShader->Shutdown();
        delete m_SkyPlaneShader;
        m_SkyPlaneShader = 0;
    }
 
    // 하늘 평면 객체를 해제합니다.
    if(m_SkyPlane)
    {
        m_SkyPlane->Shutdown();
        delete m_SkyPlane;
        m_SkyPlane = 0;
    }
 
    // sky dome shader 객체를 해제합니다.
    if(m_SkyDomeShader)
    {
        m_SkyDomeShader->Shutdown();
        delete m_SkyDomeShader;
        m_SkyDomeShader = 0;
    }
 
    // 하늘 돔 객체를 해제합니다.
    if(m_SkyDome)
    {
        m_SkyDome->Shutdown();
        delete m_SkyDome;
        m_SkyDome = 0;
    }
 
    // 지형 셰이더 객체를 해제합니다.
    if(m_TerrainShader)
    {
        m_TerrainShader->Shutdown();
        delete m_TerrainShader;
        m_TerrainShader = 0;
    }
 
    // 지형 객체를 해제합니다.
    if(m_Terrain)
    {
        m_Terrain->Shutdown();
        delete m_Terrain;
        m_Terrain = 0;
    }
    
    // 조명 객체를 해제합니다.
    if(m_Light)
    {
        delete m_Light;
        m_Light = 0;
    }
 
    // 카메라 객체를 해제합니다.
    if(m_Camera)
    {
        delete m_Camera;
        m_Camera = 0;
    }
    
    // 위치 객체를 해제합니다.
    if(m_Position)
    {
        delete m_Position;
        m_Position = 0;
    }
 
    // 타이머 객체를 해제합니다.
    if(m_Timer)
    {
        delete m_Timer;
        m_Timer = 0;
    }
 
    // Direct3D 객체를 해제합니다.
    if(m_Direct3D)
    {
        m_Direct3D->Shutdown();
        delete m_Direct3D;
        m_Direct3D = 0;
    }
 
    // 입력 객체를 해제합니다.
    if(m_Input)
    {
        m_Input->Shutdown();
        delete m_Input;
        m_Input = 0;
    }
}
 
 
bool ApplicationClass::Frame()
{
    // 시스템 통계를 업데이트 합니다.
    m_Timer->Frame();
    m_Fps->Frame();
    m_Cpu->Frame();
 
    // 사용자 입력을 읽습니다.
    bool result = m_Input->Frame();
    if(!result)
    {
        return false;
    }
    
    // 사용자가 ESC를 눌렀을 때 응용 프로그램을 종료 할 것인지 확인합니다.
    if(m_Input->IsEscapePressed() == true)
    {
        return false;
    }
 
    // 프레임 입력 처리를 수행합니다.
    result = HandleMovementInput(m_Timer->GetTime());
    if(!result)
    {
        return false;
    }
 
    // 텍스트 개체에서 FPS 값을 업데이트합니다.
    result = m_Text->SetFps(m_Fps->GetFps(), m_Direct3D->GetDeviceContext());
    if(!result)
    {
        return false;
    }
    
    // 텍스트 개체의 CPU 사용 값을 업데이트합니다.
    result = m_Text->SetCpu(m_Cpu->GetCpuPercentage(), m_Direct3D->GetDeviceContext());
    if(!result)
    {
        return false;
    }
 
    // 물 프레임 처리를 수행합니다.
    m_Water->Frame();
 
    // 하늘 평면 프레임 처리를 수행합니다.
    m_SkyPlane->Frame();
 
    // 장면의 굴절을 텍스처에 렌더링합니다.
    RenderRefractionToTexture();
 
    // 장면의 반사를 텍스처에 렌더링합니다.
    RenderReflectionToTexture();
 
    // 그래픽을 렌더링합니다.
    return Render();
}
 
 
bool ApplicationClass::HandleMovementInput(float frameTime)
{
    XMFLOAT3 pos = XMFLOAT3(0.0f, 0.0f, 0.0f);
    XMFLOAT3 rot = XMFLOAT3(0.0f, 0.0f, 0.0f);
 
    // 갱신된 위치를 계산하기 위한 프레임 시간을 설정합니다.
    m_Position->SetFrameTime(frameTime);
 
    // 입력을 처리합니다.
    m_Position->TurnLeft(m_Input->IsLeftPressed());
    m_Position->TurnRight(m_Input->IsRightPressed());
    m_Position->MoveForward(m_Input->IsUpPressed());
    m_Position->MoveBackward(m_Input->IsDownPressed());
    m_Position->MoveUpward(m_Input->IsAPressed());
    m_Position->MoveDownward(m_Input->IsZPressed());
    m_Position->LookUpward(m_Input->IsPgUpPressed());
    m_Position->LookDownward(m_Input->IsPgDownPressed());
    
    // 시점 위치 / 회전을 가져옵니다.
    m_Position->GetPosition(pos);
    m_Position->GetRotation(rot);
 
    // 카메라의 위치를 ​​설정합니다.
    m_Camera->SetPosition(pos);
    m_Camera->SetRotation(rot);
 
    // 텍스트 개체의 위치 값을 업데이트 합니다.
    if(!m_Text->SetCameraPosition(pos, m_Direct3D->GetDeviceContext()))
    {
        return false;
    }
 
    // 텍스트 객체의 회전 값을 업데이트 합니다.
    return m_Text->SetCameraRotation(rot, m_Direct3D->GetDeviceContext());
}
 
 
void ApplicationClass::RenderRefractionToTexture()
{
    XMMATRIX worldMatrix, viewMatrix, projectionMatrix;
 
    // 물 위 높이에 따라 클리핑면을 설정하여 굴절을 만들기 위해 위의 모든 것을 클립합니다.
    XMFLOAT4 clipPlane = XMFLOAT4(0.0f, -1.0f, 0.0f, m_Water->GetWaterHeight() + 0.1f);
 
    // 렌더 타겟을 텍스쳐의 굴절 렌더링으로 설정합니다.
    m_RefractionTexture->SetRenderTarget(m_Direct3D->GetDeviceContext());
 
    // 텍스처에 굴절 렌더링을 지운다.
    m_RefractionTexture->ClearRenderTarget(m_Direct3D->GetDeviceContext(), 0.0f, 0.0f, 0.0f, 1.0f);
 
    // 카메라의 위치에 따라 뷰 행렬을 생성합니다.
    m_Camera->Render();
 
    // 카메라와 d3d 객체로부터 행렬을 얻는다.
    m_Direct3D->GetWorldMatrix(worldMatrix);
    m_Camera->GetViewMatrix(viewMatrix);
    m_Direct3D->GetProjectionMatrix(projectionMatrix);
 
    // 반사 쉐이더와 굴절 클립면을 사용하여 지형을 렌더링하여 굴절 효과를 만듭니다.
    m_Terrain->Render(m_Direct3D->GetDeviceContext());
    m_ReflectionShader->Render(m_Direct3D->GetDeviceContext(), m_Terrain->GetIndexCount(), worldMatrix, viewMatrix,
                               projectionMatrix, m_Terrain->GetColorTexture(), m_Terrain->GetNormalTexture(),
                               m_Light->GetDiffuseColor(), m_Light->GetDirection(), 2.0f, clipPlane);
    
    // 렌더링 대상을 원래의 백 버퍼로 다시 설정하고 렌더링에 대한 렌더링을 더 이상 다시 설정하지 않습니다.
    m_Direct3D->SetBackBufferRenderTarget();
 
    // 뷰포트를 원본으로 다시 설정합니다.
    m_Direct3D->ResetViewport();
}
 
 
void ApplicationClass::RenderReflectionToTexture()
{
    XMMATRIX reflectionViewMatrix, worldMatrix, projectionMatrix;
 
    // 물밑에 있는 물체의 높이를 기준으로 클리핑면을 설정합니다.
    XMFLOAT4 clipPlane = XMFLOAT4(0.0f, 1.0f, 0.0f, -m_Water->GetWaterHeight());
    
    // 렌더 타겟을 텍스처에 대한 반사 렌더링으로 설정합니다.
    m_ReflectionTexture->SetRenderTarget(m_Direct3D->GetDeviceContext());
 
    // 텍스처에 반사 렌더링을 지운다.
    m_ReflectionTexture->ClearRenderTarget(m_Direct3D->GetDeviceContext(), 0.0f, 0.0f, 0.0f, 1.0f);
 
    // 카메라를 사용하여 반사를 렌더링하고 반사보기 행렬을 만듭니다.
    m_Camera->RenderReflection(m_Water->GetWaterHeight());
 
    // 일반 뷰 매트릭스 대신 카메라 반사 뷰 매트릭스를 가져옵니다.
    m_Camera->GetReflectionViewMatrix(reflectionViewMatrix);
 
    // d3d 객체에서 월드 및 투영 행렬을 가져옵니다.
    m_Direct3D->GetWorldMatrix(worldMatrix);
    m_Direct3D->GetProjectionMatrix(projectionMatrix);
 
    // 카메라 위치를 얻는다.
    XMFLOAT3 cameraPosition = m_Camera->GetPosition();
 
    // 반사 된 카메라 위치의 수면 평면 주위로 카메라의 Y 좌표를 뒤집습니다.
    cameraPosition.y = -cameraPosition.y + (m_Water->GetWaterHeight() * 2.0f);
 
    // 반사 된 카메라 위치를 중심으로 하늘 돔과 하늘 평면을 번역합니다.
    worldMatrix = XMMatrixTranslation(cameraPosition.x, cameraPosition.y, cameraPosition.z);
 
    // 뒷면 제거 및 Z 버퍼를 끕니다.
    m_Direct3D->TurnOffCulling();
    m_Direct3D->TurnZBufferOff();
 
    // 반사 뷰 매트릭스를 사용하여 스카이 돔을 렌더링합니다.
    m_SkyDome->Render(m_Direct3D->GetDeviceContext());
    m_SkyDomeShader->Render(m_Direct3D->GetDeviceContext(), m_SkyDome->GetIndexCount(), worldMatrix, reflectionViewMatrix,
                            projectionMatrix, m_SkyDome->GetApexColor(), m_SkyDome->GetCenterColor());
 
    // 뒷면 컬링을 사용합니다.
    m_Direct3D->TurnOnCulling();
 
    // 구름이 sky dome color와 혼합되도록 첨가물 블렌딩을 가능하게합니다.
    m_Direct3D->EnableSecondBlendState();
 
    // 하늘 평면 쉐이더를 사용하여 하늘 평면을 렌더링합니다.
    m_SkyPlane->Render(m_Direct3D->GetDeviceContext());
    m_SkyPlaneShader->Render(m_Direct3D->GetDeviceContext(), m_SkyPlane->GetIndexCount(), worldMatrix, reflectionViewMatrix,
                             projectionMatrix, m_SkyPlane->GetCloudTexture(), m_SkyPlane->GetPerturbTexture(),
                             m_SkyPlane->GetTranslation(), m_SkyPlane->GetScale(), m_SkyPlane->GetBrightness());
 
    // 혼합을 해제하고 Z 버퍼를 다시 활성화합니다.
    m_Direct3D->TurnOffAlphaBlending();
    m_Direct3D->TurnZBufferOn();
 
    // 월드 행렬을 재설정합니다.
    m_Direct3D->GetWorldMatrix(worldMatrix);
 
    // 반사 뷰 행렬과 반사 클립 평면을 사용하여 지형을 렌더링합니다.
    m_Terrain->Render(m_Direct3D->GetDeviceContext());
    m_ReflectionShader->Render(m_Direct3D->GetDeviceContext(), m_Terrain->GetIndexCount(), worldMatrix, reflectionViewMatrix,
                               projectionMatrix, m_Terrain->GetColorTexture(), m_Terrain->GetNormalTexture(),
                               m_Light->GetDiffuseColor(), m_Light->GetDirection(), 2.0f, clipPlane);
 
    // 렌더링 대상을 원래의 백 버퍼로 다시 설정하고 렌더링에 대한 렌더링을 더 이상 다시 설정하지 않습니다.
    m_Direct3D->SetBackBufferRenderTarget();
 
    // 뷰포트를 원본으로 다시 설정합니다.
    m_Direct3D->ResetViewport();
}
 
 
bool ApplicationClass::Render()
{
    XMMATRIX worldMatrix, viewMatrix, projectionMatrix, orthoMatrix, baseViewMatrix, reflectionViewMatrix;
 
    // 장면을 지웁니다.
    m_Direct3D->BeginScene(0.0f, 0.0f, 0.0f, 1.0f);
 
    // 카메라의 위치에 따라 뷰 행렬을 생성합니다.
    m_Camera->Render();
 
    // 카메라의 위치와 물의 높이를 기반으로 반사 행렬을 생성합니다.
    m_Camera->RenderReflection(m_Water->GetWaterHeight());
 
    // 카메라, Direct3D 객체로부터 월드, 뷰, 프로젝션, 오쏘,베이스 뷰 매트릭스를 가져옵니다.
    m_Direct3D->GetWorldMatrix(worldMatrix);
    m_Camera->GetViewMatrix(viewMatrix);
    m_Direct3D->GetProjectionMatrix(projectionMatrix);
    m_Direct3D->GetOrthoMatrix(orthoMatrix);
    m_Camera->GetBaseViewMatrix(baseViewMatrix);
    m_Camera->GetReflectionViewMatrix(reflectionViewMatrix);
 
    // 카메라 위치를 얻는다.
    XMFLOAT3 cameraPosition = m_Camera->GetPosition();
 
    // 스카이 돔을 카메라 위치를 중심으로 변환합니다.
    worldMatrix = XMMatrixTranslation(cameraPosition.x, cameraPosition.y, cameraPosition.z);
 
    // 뒷면 제거 및 Z 버퍼를 끕니다.
    m_Direct3D->TurnOffCulling();
    m_Direct3D->TurnZBufferOff();
 
    // 하늘 돔 셰이더를 사용하여 하늘 돔을 렌더링합니다.
    m_SkyDome->Render(m_Direct3D->GetDeviceContext());
    m_SkyDomeShader->Render(m_Direct3D->GetDeviceContext(), m_SkyDome->GetIndexCount(), worldMatrix, viewMatrix,
                            projectionMatrix, m_SkyDome->GetApexColor(), m_SkyDome->GetCenterColor());
 
    // 다시 얼굴 컬링을 되돌립니다.
    m_Direct3D->TurnOnCulling();
 
    // 구름이 sky dome color와 혼합되도록 첨가물 블렌딩을 가능하게합니다.
    m_Direct3D->EnableSecondBlendState();
 
    // 하늘 평면 쉐이더를 사용하여 하늘 평면을 렌더링합니다.
    m_SkyPlane->Render(m_Direct3D->GetDeviceContext());
    m_SkyPlaneShader->Render(m_Direct3D->GetDeviceContext(), m_SkyPlane->GetIndexCount(), worldMatrix, viewMatrix,
                             projectionMatrix, m_SkyPlane->GetCloudTexture(), m_SkyPlane->GetPerturbTexture(),
                             m_SkyPlane->GetTranslation(), m_SkyPlane->GetScale(), m_SkyPlane->GetBrightness());
 
    // 블렌드를 끕니다.
    m_Direct3D->TurnOffAlphaBlending();
 
    // Z 버퍼를 다시 켭니다.
    m_Direct3D->TurnZBufferOn();
 
    // 월드 행렬을 재설정합니다.
    m_Direct3D->GetWorldMatrix(worldMatrix);
 
    // 지형 셰이더를 사용하여 지형을 렌더링합니다.
    m_Terrain->Render(m_Direct3D->GetDeviceContext());
    
    if(!m_TerrainShader->Render(m_Direct3D->GetDeviceContext(), m_Terrain->GetIndexCount(), worldMatrix, viewMatrix,
                                projectionMatrix, m_Terrain->GetColorTexture(), m_Terrain->GetNormalTexture(),
                                m_Light->GetDiffuseColor(), m_Light->GetDirection(), 2.0f))
    {
        return false;
    }
 
    // 물의 위치로 번역하고 렌더링합니다.
    worldMatrix = XMMatrixTranslation(240.0f, m_Water->GetWaterHeight(), 250.0f);
    m_Water->Render(m_Direct3D->GetDeviceContext());
 
    m_WaterShader->Render(m_Direct3D->GetDeviceContext(), m_Water->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix,
                          reflectionViewMatrix, m_RefractionTexture->GetShaderResourceView(),
                          m_ReflectionTexture->GetShaderResourceView(), m_Water->GetTexture(), m_Camera->GetPosition(),
                          m_Water->GetNormalMapTiling(), m_Water->GetWaterTranslation(), m_Water->GetReflectRefractScale(),
                          m_Water->GetRefractionTint(), m_Light->GetDirection(), m_Water->GetSpecularShininess());
 
    // 월드 행렬을 재설정합니다.
    m_Direct3D->GetWorldMatrix(worldMatrix);
 
    // 모든 2D 렌더링을 시작하려면 Z 버퍼를 끕니다.
    m_Direct3D->TurnZBufferOff();
        
    // 텍스트를 렌더링하기 전에 알파 블렌딩을 켭니다.
    m_Direct3D->TurnOnAlphaBlending();
 
    // 텍스트 사용자 인터페이스 요소를 렌더링 합니다.
    if(!m_Text->Render(m_Direct3D->GetDeviceContext(), m_FontShader, worldMatrix, orthoMatrix))
    {
        return false;
    }
 
    // 텍스트를 렌더링 한 후 알파 블렌딩을 끕니다.
    m_Direct3D->TurnOffAlphaBlending();
 
    // 모든 2D 렌더링이 완료되었으므로 Z 버퍼를 다시 켭니다.
    m_Direct3D->TurnZBufferOn();
 
    // 렌더링 된 장면을 화면에 표시합니다.
    m_Direct3D->EndScene();
 
    return true;
}

출력 화면

마치면서

우리는 큰 파도가 필요없는 작은 물결 모양의 현실적인 물 효과를 나타낼 수 있습니다.

연습문제

1. 프로그램을 컴파일하고 실행하십시오. 화살표 키 A, Z, PgUp 및 PgDn을 사용하여 주위를 이동하십시오. 종료하려면 ESC 키를 누릅니다.

2. 쉐이더 입력값 (예 : 굴절 농도)을 수정하여 물 효과를 변경하는 방법을 확인합니다.

3. 워터 셰이더를 수정하여 각각의 효과 출력을 확인하십시오. 예를 들어 굴절 색상만 반환한 다음 반사 색상만 반환합니다.

4. 설명된 방법 중 하나를 사용하여 반사 부분을 최적화 합니다 (예 : 1 초에 한 번 반사 반영).

5. 이 튜토리얼을 Glass and Ice DirectX 튜토리얼과 결합하십시오. 눈이 많이 내리는 지형을 렌더링하고 대신 물이 얼음이 되도록 변경하십시오.

소스코드

소스코드 : Dx11Terrain_16.zip