DirectX11 Tutorial 25: 텍스쳐 이동

Tutorial 25: Texture Translation

원문: http://rastertek.com/dx11tut25.html

텍스쳐 이동(Texture transition)은 다각형 평면에 텍스쳐가 이동하는 듯한 애니메이션 효과를 주는 데 사용됩니다. 이 튜토리얼에서는 DirectX 11과 HLSL을 이용하여 텍스쳐 이동을 구현하는 내용을 다룹니다. 예제 코드는 이전 튜토리얼에서 이어집니다.

텍스쳐링 튜토리얼에서 다루었었듯이 도형에 텍스쳐를 입힐 때 UV 좌표계를 사용합니다. UV 좌표는 각각 X와 Y좌표로 변환되어 X는 도형의 가로로, Y는 세로로 대응하게 됩니다. 텍스쳐 이동을 구현하기 위해서는 픽셀 셰이더에서 텍스쳐의 X와 Y의 값을 바꿀 수 있어야 합니다. 단순히 0과 1 사이의 값을 X또는 Y에 더하거나 빼는 것으로도 텍스쳐 이동을 만들 수 있습니다.

예를 들어 다음과 같은 텍스쳐가 입혀진 도형이 있다고 합시다:

그리고 픽셀 셰이더 안에서 X좌표에 0.5를 더하면 텍스쳐가 아래 그림처럼 절반 정도 이동하게 됩니다:

프레임워크

프레임워크에는 TranslateShaderClass라는 클래스가 추가되었습니다.

Translate.vs

정점 셰이더는 기존 텍스쳐 정점 셰이더와 같습니다.

////////////////////////////////////////////////////////////////////////////////
// Filename: translate.vs
////////////////////////////////////////////////////////////////////////////////


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


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

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


////////////////////////////////////////////////////////////////////////////////
// Vertex Shader
////////////////////////////////////////////////////////////////////////////////
PixelInputType TranslateVertexShader(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;

    return output;
}

Translate.ps

////////////////////////////////////////////////////////////////////////////////
// Filename: translate.ps
////////////////////////////////////////////////////////////////////////////////


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

부동소수점 값을 저장하는 textureTranslation이라는 버퍼를 추가했습니다. 이 값은 *graphicsclass.cpp*에서 Render 함수가 불렸을 때 텍스쳐를 이동할 위치를 갱신하기 위해 세팅합니다. 이 값은 0과 1사이의 값을 가져야 합니다.

cbuffer TranslationBuffer
{
    float textureTranslation;
};


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

픽셀 셰이더에서 실제로 텍스쳐 좌표를 textureTranslation만큼 이동시킵니다. 입력으로 텍스쳐 좌표를 받은 뒤 매 픽셀 셰이더 호출이 있을 때마다 좌표에 그 값만큼 더합니다. 도형 표면 전체에 걸쳐 동일한 양만큼 이동하게 됩니다.

////////////////////////////////////////////////////////////////////////////////
// Pixel Shader
////////////////////////////////////////////////////////////////////////////////
float4 TranslatePixelShader(PixelInputType input) : SV_TARGET
{
    // 픽셀을 샘플링한 곳에서 더 이동시킨 위치로 저장합니다.
    input.tex.x += textureTranslation;

    return shaderTexture.Sample(SampleType, input.tex);
}

Translateshaderclass.h

TranslateShaderClass는 TextureShaderClass에 텍스쳐 이동 기능이 추가된 것입니다.

////////////////////////////////////////////////////////////////////////////////
// Filename: translateshaderclass.h
////////////////////////////////////////////////////////////////////////////////
#ifndef _TRANSLATESHADERCLASS_H_
#define _TRANSLATESHADERCLASS_H_


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


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

아래는 텍스쳐 이동 버퍼를 위한 구조체입니다. padding을 추가해 구조체 크기가 16의 배수가 되게 합니다.

    struct TranslateBufferType
    {
        float translation;
        D3DXVECTOR3 padding;
    };

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

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

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

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

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

텍스쳐 이동 버퍼를 위한 새로운 버퍼 포인터를 선언합니다.

    ID3D11Buffer* m_translateBuffer;
};

#endif

Translateshaderclass.cpp

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


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

생성자에서 텍스쳐 이동 버퍼를 NULL로 초기화합니다.

    m_translateBuffer = 0;
}


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


TranslateShaderClass::~TranslateShaderClass()
{
}


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

텍스쳐 이동 HLSL 파일을 불러옵니다.

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

    return true;
}


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

    return;
}

Render 함수에 인자를 추가하여 픽셀 셰이더에 텍스쳐 이동 값을 받도록 합니다. 이 인자는 SetShaderParameters 함수를 통하여 렌더링이 일어나기 전에 셰이더에 전달됩니다.

bool TranslateShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, D3DXMATRIX worldMatrix, 
                  D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture, 
                  float translation)
{
    bool result;


    // 렌더링에 사용할 셰이더 인자들을 넘겨줍니다.
    result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, translation);
    if(!result)
    {
        return false;
    }

    // 셰이더를 사용하여 준비된 버퍼를 그립니다.
    RenderShader(deviceContext, indexCount);

    return true;
}


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


    // 선언한 포인터들을 null로 초기화합니다.
    errorMessage = 0;
    vertexShaderBuffer = 0;
    pixelShaderBuffer = 0;

텍스쳐 이동 셰이더를 불러옵니다.

    // 정점 셰이더를 컴파일합니다.
    result = D3DX11CompileFromFile(vsFilename, NULL, NULL, "TranslateVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 
                       0, NULL, &vertexShaderBuffer, &errorMessage, NULL);
    if(FAILED(result))
    {
        // 셰이더 컴파일이 실패한 경우 에러 메세지를 저장하게끔 합니다.
        if(errorMessage)
        {
            OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
        }
        // 에러메세지가 없는 경우 그냥 셰이더 파일 자체를 찾지 못한 경우입니다.
        else
        {
            MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
        }

        return false;
    }

텍스쳐 이동 픽셀 셰이더를 불러옵니다.

    // 픽셀 셰이더를 컴파일합니다.
    result = D3DX11CompileFromFile(psFilename, NULL, NULL, "TranslatePixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 
                       0, NULL, &pixelShaderBuffer, &errorMessage, NULL);
    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;
    }

    // 정점 입력 레이아웃 description을 작성합니다.
    // ModelClass에 있는 VertexType과 형식이 동일하게 만들어야 합니다.
    polygonLayout[0].SemanticName = "POSITION";
    polygonLayout[0].SemanticIndex = 0;
    polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
    polygonLayout[0].InputSlot = 0;
    polygonLayout[0].AlignedByteOffset = 0;
    polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[0].InstanceDataStepRate = 0;

    polygonLayout[1].SemanticName = "TEXCOORD";
    polygonLayout[1].SemanticIndex = 0;
    polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
    polygonLayout[1].InputSlot = 0;
    polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[1].InstanceDataStepRate = 0;

    // 레이아웃에 들어간 원소의 수를 계산합니다.
    numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);

    // 정점 입력 레이아웃을 생성합니다.
    result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), 
                       vertexShaderBuffer->GetBufferSize(), &m_layout);
    if(FAILED(result))
    {
        return false;
    }

    // 더 이상 사용하지 않는 정점 및 픽셀 셰이더 버퍼를 해제합니다.
    vertexShaderBuffer->Release();
    vertexShaderBuffer = 0;

    pixelShaderBuffer->Release();
    pixelShaderBuffer = 0;

    // 정점 셰이더에서 사용하는 동적 상수 버퍼를 설정합니다.
    matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
    matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    matrixBufferDesc.MiscFlags = 0;
    matrixBufferDesc.StructureByteStride = 0;

    // 정점 셰이더에서 동적 상수 버퍼에 접근할 수 있도록 생성해 둡니다.
    result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
    if(FAILED(result))
    {
        return false;
    }

    // 텍스쳐 샘플러 description을 작성합니다.
    samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
    samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.MipLODBias = 0.0f;
    samplerDesc.MaxAnisotropy = 1;
    samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
    samplerDesc.BorderColor[0] = 0;
    samplerDesc.BorderColor[1] = 0;
    samplerDesc.BorderColor[2] = 0;
    samplerDesc.BorderColor[3] = 0;
    samplerDesc.MinLOD = 0;
    samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;

    // 텍스쳐 샘플러를 생성합니다.
    result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
    if(FAILED(result))
    {
        return false;
    }

이동 버퍼를 생성하여 픽셀 셰이더에서 얼마만큼 텍스쳐를 이동시킬지 접근할 수 있게 합니다.

    // 픽셀 셰이더에 있는 텍스쳐 이동을 위한 동적 상수 버퍼의 description을 작성합니다.
    translateBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    translateBufferDesc.ByteWidth = sizeof(TranslateBufferType);
    translateBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    translateBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    translateBufferDesc.MiscFlags = 0;
    translateBufferDesc.StructureByteStride = 0;

    // 상수 버퍼 포인터를 만들어 픽셀 셰이더에서 접근할 수 있도록 합니다.
    result = device->CreateBuffer(&translateBufferDesc, NULL, &m_translateBuffer);
    if(FAILED(result))
    {
        return false;
    }

    return true;
}


void TranslateShaderClass::ShutdownShader()
{

ShutdownShader함수에서 만들었던 이동 버퍼를 해제합니다.

    // 텍스쳐 이동 상수 버퍼를 해제합니다.
    if(m_translateBuffer)
    {
        m_translateBuffer->Release();
        m_translateBuffer = 0;
    }

    // 샘플러를 해제합니다.
    if(m_sampleState)
    {
        m_sampleState->Release();
        m_sampleState = 0;
    }

    // 행렬 상수 버퍼를 해제합니다.
    if(m_matrixBuffer)
    {
        m_matrixBuffer->Release();
        m_matrixBuffer = 0;
    }

    // 레이아웃을 해제합니다.
    if(m_layout)
    {
        m_layout->Release();
        m_layout = 0;
    }

    // 픽셀 셰이더를 해제합니다.
    if(m_pixelShader)
    {
        m_pixelShader->Release();
        m_pixelShader = 0;
    }

    // 정점 셰이더를 해제합니다.
    if(m_vertexShader)
    {
        m_vertexShader->Release();
        m_vertexShader = 0;
    }

    return;
}


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


    // 에러 메세지의 버퍼 포인터를 얻어돕니다.
    compileErrors = (char*)(errorMessage->GetBufferPointer());

    // 메세지의 길이를 구합니다.
    bufferSize = errorMessage->GetBufferSize();

    // 에러 메세지를 기록할 파일을 엽니다.
    fout.open("shader-error.txt");

    // 에러 메세지를 파일에 씁니다.
    for(i=0; i<buffersize; i++)
    {
        fout <<= compileerrors[i];
    }
    
    // 파일을 닫습니다.
    fout.close();

    // 에러 메세지를 해제합니다.
    errormessage->Release();
    errorMessage = 0;

    // 유저가 텍스트파일을 확인해 볼 수 있도록 에러메세지를 팝업으로 표시합니다.
    MessageBox(hwnd, L"Error compiling shader.  Check shader-error.txt for message.", shaderFilename, MB_OK);

    return;
}


bool TranslateShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, 
                           D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture, 
                           float translation)
{
    HRESULT result;
    D3D11_MAPPED_SUBRESOURCE mappedResource;
    MatrixBufferType* dataPtr;
    unsigned int bufferNumber;
    TranslateBufferType* dataPtr2;


    // 셰이더에서 사용할 수 있도록 행렬을 변환시켜 놓습니다.
    D3DXMatrixTranspose(&amp;worldMatrix, &amp;worldMatrix);
    D3DXMatrixTranspose(&amp;viewMatrix, &amp;viewMatrix);
    D3DXMatrixTranspose(&amp;projectionMatrix, &amp;projectionMatrix);

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

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

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

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

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

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

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

여기서 픽셀 셰이더에 텍스쳐 이동값을 넣어줍니다. 우선 텍스쳐 이동 상수 버퍼를 잠그고 이동시킬 값을 버퍼에 써 넣습니다. 그리고 나서 버퍼를 해제하고 픽셀 셰이더에서 그 버퍼를 사용하게 합니다.

    // 쓰기 작업을 할 수 있도록 텍스쳐 이동 상수 버퍼를 잠급니다.
    result = deviceContext->Map(m_translateBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
    if(FAILED(result))
    {
        return false;
    }

    // 텍스쳐 이동 상수 버퍼에 접근하기 위해 데이터의 포인터를 얻어옵니다.
    dataPtr2 = (TranslateBufferType*)mappedResource.pData;

    // 상수 버퍼에 텍스쳐 이동 값을 복사해 넣습니다.
    dataPtr2->translation = translation;
    
    // 버퍼의 잠금을 해제합니다.
    deviceContext->Unmap(m_translateBuffer, 0);

    // 픽셀 셰이더에 텍스쳐 이동 버퍼의 값을 설정합니다.
    bufferNumber = 0;

    // 픽셀 셰이더에서 상수 버퍼를 최신의 값으로 설정합니다.
    deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_translateBuffer);

    return true;
}


void TranslateShaderClass::RenderShader(ID3D11DeviceContext* deviceContext, int indexCount)
{
    // 정점 입력 레이아웃을 설정합니다.
    deviceContext->IASetInputLayout(m_layout);

    // 삼각형을 그리는 데 사용할 정점 및 픽셀 셰이더를 설정합니다.
    deviceContext->VSSetShader(m_vertexShader, NULL, 0);
    deviceContext->PSSetShader(m_pixelShader, NULL, 0);

    // 픽셀 셰이더에 샘플러를 설정합니다.
    deviceContext->PSSetSamplers(0, 1, &m_sampleState);

    // 삼각형을 그립니다.
    deviceContext->DrawIndexed(indexCount, 0, 0);

    return;
}

Graphicsclass.h

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


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


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

TranslateShaderClass의 헤더를 추가합니다.

#include "translateshaderclass.h"


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

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

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

TranslateShaderClass 객체를 생성합니다.

    TranslateShaderClass* m_TranslateShader;
};

#endif

Graphicsclass.cpp

이전 튜토리얼에서 바뀐 것 위주로 다루겠습니다.

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


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

생성자에서 TranslateShaderClass 객체를 null로 초기화합니다.

    m_TranslateShader = 0;
}


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


    // Direct3D 객체를 생성합니다.
    m_D3D = new D3DClass;
    if(!m_D3D)
    {
        return false;
    }

    // Direct3D 객체를 초기화합니다.
    result = m_D3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize Direct3D.", L"Error", MB_OK);
        return false;
    }

    // 카메라를 생성합니다.
    m_Camera = new CameraClass;
    if(!m_Camera)
    {
        return false;
    }

    // 모델을 생성합니다.
    m_Model = new ModelClass;
    if(!m_Model)
    {
        return false;
    }

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

TranslateShaderClass 객체를 생성하고 초기화합니다.

    // 텍스쳐 이동 셰이더를 생성합니다.
    m_TranslateShader = new TranslateShaderClass;
    if(!m_TranslateShader)
    {
        return false;
    }

    // 텍스쳐 이동 셰이더 객체를 초기화합니다.
    result = m_TranslateShader->Initialize(m_D3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the texture translation shader object.", L"Error", MB_OK);
        return false;
    }

    return true;
}


void GraphicsClass::Shutdown()
{

Shutdown 함수에서 TranslateShaderClass 객체를 해제합니다.

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

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

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

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

    return;
}


bool GraphicsClass::Render()
{
    D3DXMATRIX worldMatrix, viewMatrix, projectionMatrix;
    bool result;
    static float textureTranslation = 0.0f;

여기서 매 프레임마다 텍스쳐 이동값을 조금씩 증가하게 합니다. 값이 1.0을 넘어가면 0.0에서 다시 시작하게 합니다.

    // 텍스쳐 이동값을 증가시킵니다.
    textureTranslation += 0.01f;
    if(textureTranslation > 1.0f)
    {
        textureTranslation -= 1.0f;
    }

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

    // 카메라 위치를 이용하여 뷰 행렬을 생성합니다.
    m_Camera->Render();
    
    // 카메라 및 d3d객체를 이용하여 월드, 뷰, 프로젝션 행렬을 구합니다.
    m_D3D->GetWorldMatrix(worldMatrix);
    m_Camera->GetViewMatrix(viewMatrix);
    m_D3D->GetProjectionMatrix(projectionMatrix);

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

그리고 나서 TranslateShaderClass에 텍스쳐 이동값을 넣고 모델을 그립니다.

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

    // 화면에 렌더링된 장면을 출력합니다.
    m_D3D->EndScene();

    return true;
}

마치면서

정말 간단한 픽셀 셰이더이지만 쓸모 있는 효과를 낼 수 있습니다. 이를 좀 더 고쳐 표면에 텍스쳐가 어떻게 나오는지 알게 되고 간단한 수학을 이용하여 다양한 효과를 내게 할 수 있습니다.

연습문제

1. 코드를 다시 빌드하고 해답인지 체크합니다.
2. 픽셀 셰이더의 효과가 X축이 아니라 Y축을 따라 일어나게 해 보십시오.
3. 픽셀 셰이더를 고쳐 X축 및 Y축 모두 반응하도록 해 보십시오.

소스 코드

비주얼 스튜디오 2008 프로젝트: dx11tut25.zip

소스코드만: dx11src25.zip

실행파일만: dx11exe25.zip