DirectX11 Tutorial 26: 투명도

Tutorial 26: Transparency

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

투명도는 말 그대로 텍스쳐가 입혀진 물체를 뚫고 들여다볼 수 있는 효과입니다. 예를 들기 위해 아래 사진을 사용하겠습니다:

이를 반쯤 투명하게 하고 다른 텍스쳐 위에 그려지게 하면 다음과 같은 투명도 효과가 나타납니다:

DirectX 11과 HLSL에서의 투명도는 알파 블렌딩으로 구현되어 있습니다. 각 픽셀에는 알파 성분이 있는데 이 값으로 해당 픽셀의 투명도를 알아냅니다. 예를 들어, 어떤 픽셀의 알파값이 0.5라면 반쯤 투명하게 나타날 것입니다. 많은 텍스쳐들은 알파 성분을 갖고 있어서 어떤 부분은 투명하게 하고 또 다른 부분은 불투명하게 할 수 있습니다.

하지만 이 알파값들이 효과를 발휘하기 위해서는 우선 셰이더에 알파 블렌딩 기능을 켜고 어떻게 색상을 혼합할 지 결정할 블렌딩 공식을 설정해야 합니다. 이 튜토리얼에서는 D3DClass에서 다음과 같이 블렌딩을 설정합니다:

    blendStateDescription.RenderTarget[0].BlendEnable = TRUE;
    blendStateDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
    blendStateDescription.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;

DestBlend는 이미 그 자리에 그려져 있던 목표 픽셀의 색상입니다. 여기에 사용할 블렌딩 함수는 INV_SRC_ALPHA인데, 소스 텍스쳐의 알파를 역전시킨 것입니다. 다시 말해서, 1에서 소스 텍스쳐의 알파만큼 뺀 것입니다. 예를 들자면, 만약 소스의 알파가 0.3이라면 목표의 알파는 0.7로 보고 목표 픽셀의 70%를 사용하게 됩니다.

SrcBlend는 이 튜토리얼의 소스 텍스쳐의 색상을 계산하는데 사용되는 데 사용합니다. 여기서는 SRC_ALPHA를 사용할 것인데, 텍스쳐가 가지고 있는 알파값을 그대로 사용합니다.

소스와 목표값을 더해 최종 픽셀의 색상값을 구하게 됩니다.

프레임워크

이 튜토리얼에는 TransparentShaderClass라는 클래스가 추가되었습니다. 이 클래스는 TextureShaderClass에 알파블렌딩 값을 넣을 수 있게 고친 것입니다.

D3dclass.cpp

앞서 기술했듯이 우선 D3DClass::Initialize함수를 수정하여 텍스쳐의 투명도가 동작하도록 수정합니다. 이 클래스의 변경사항은 그것뿐입니다.

    // 알파블렌드 상태의 descrption을 작성합니다.
    blendStateDescription.RenderTarget[0].BlendEnable = TRUE;
    blendStateDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
    blendStateDescription.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
    blendStateDescription.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
    blendStateDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
    blendStateDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
    blendStateDescription.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
    blendStateDescription.RenderTarget[0].RenderTargetWriteMask = 0x0f;

Transparent.vs

투명 텍스쳐의 정점 셰이더는 일반적인 정점 셰이더와 동일합니다.

////////////////////////////////////////////////////////////////////////////////
// Filename: transparent.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 TransparentVertexShader(VertexInputType input)
{
    PixelInputType output;
    

    // Change the position vector to be 4 units for proper matrix calculations.
    input.position.w = 1.0f;

    // Calculate the position of the vertex against the world, view, and projection matrices.
    output.position = mul(input.position, worldMatrix);
    output.position = mul(output.position, viewMatrix);
    output.position = mul(output.position, projectionMatrix);
    
    // Store the texture coordinates for the pixel shader.
    output.tex = input.tex;

    return output;
}

Transparent.ps

////////////////////////////////////////////////////////////////////////////////
// Filename: transparent.ps
////////////////////////////////////////////////////////////////////////////////


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

blendAmount값을 저장하기 위한 상수 버퍼를 선언합니다. blendAmount는 텍스쳐를 블렌딩할 비율을 저장합니다. 이 값의 범위는 0과 1 사이의 부동소수점 값입니다. 이 튜토리얼에서는 50% 투명도를 만들기 위해 0.5로 세팅할 것입니다.

cbuffer TransparentBuffer
{
    float blendAmount;
};


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


////////////////////////////////////////////////////////////////////////////////
// Pixel Shader
////////////////////////////////////////////////////////////////////////////////
float4 TransparentPixelShader(PixelInputType input) : SV_TARGET
{
    float4 color;
    
    
    // Sample the texture pixel at this location.
    color = shaderTexture.Sample(SampleType, input.tex);

여기서 blendAmount값을 이용하여 텍스쳐의 투명도를 설정합니다. 픽셀의 알파값을 블렌딩할 만큼 설정해 주고 나면 나중에 렌더링이 일어날 때 그 알파값을 사용하게 되므로 투명 효과를 줄 수 있습니다.

    // 픽셀의 알파값을 설정하여 투명 효과가 나타나게 합니다.
    color.a = blendAmount;

    return color;
}

Transparentshaderclass.h

TransparentShaderClass는 TextureShaderClass에 투명도를 설정할 수 있도록 추가한 것입니다.

////////////////////////////////////////////////////////////////////////////////
// Filename: transparentshaderclass.h
////////////////////////////////////////////////////////////////////////////////
#ifndef _TRANSPARENTSHADERCLASS_H_
#define _TRANSPARENTSHADERCLASS_H_


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


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

픽셀 셰이더에 추가한 상수 버퍼에 해당하는 구조체를 선언합니다. CreateBuffer함수가 실패하지 않도록 12바이트의 공백을 더 넣어줍니다.

    struct TransparentBufferType
    {
        float blendAmount;
        D3DXVECTOR3 padding;
    };

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

    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;

픽셀 셰이더에 blendAmount값을 넣어줄 수 있도록 버퍼 변수를 선언합니다.

    ID3D11Buffer* m_transparentBuffer;
};

#endif

Transparentshaderclass.cpp

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


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

생성자에서 투명도 상수 버퍼를 null로 초기화합니다.

    m_transparentBuffer = 0;
}


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


TransparentShaderClass::~TransparentShaderClass()
{
}


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

HLSL 셰이더 파일을 로드합니다.

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

    return true;
}


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

    return;
}

Render 함수는 셰이더에 투명도를 설정할 수 있도록 blend라는 인자가 추가되었습니다.

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


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

    // 셰이더를 이용하여 버퍼에 내용을 그려냅니다.
    RenderShader(deviceContext, indexCount);

    return true;
}


bool TransparentShaderClass::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 transparentBufferDesc;


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

투명도 정점 셰이더를 로드합니다.

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

        return false;
    }

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

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

        return false;
    }

    // 버퍼에서 정점 셰이더를 생성합니다.
    result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, 
                        &m_vertexShader);
    if(FAILED(result))
    {
        return false;
    }

    // 버퍼에서 픽셀 셰이더를 생성합니다.
    result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, 
                       &m_pixelShader);
    if(FAILED(result))
    {
        return false;
    }

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

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

    // 레이아웃에 있는 원소들의 개수를 구합니다.
    numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);

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

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

    pixelShaderBuffer->Release();
    pixelShaderBuffer = 0;

    // 정점 셰이더에 있는 동적 상수 버퍼의 description을 작성합니다.
    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;
    }

상수 버퍼의 인터페이스를 blendAmount값이 있는 TransparentBuffer에 설정합니다.

    // 픽셀 셰이더에 포함된 투명도 동적 상수 버퍼의 description을 작성합니다.
    transparentBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    transparentBufferDesc.ByteWidth = sizeof(TransparentBufferType);
    transparentBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    transparentBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    transparentBufferDesc.MiscFlags = 0;
    transparentBufferDesc.StructureByteStride = 0;

    // 동적 상수 버퍼의 포인터를 생성하여 픽셀 셰이더의 상수 버퍼에 접근할 수 있게 합니다.
    result = device->CreateBuffer(&transparentBufferDesc, NULL, &m_transparentBuffer);
    if(FAILED(result))
    {
        return false;
    }

    return true;
}


void TransparentShaderClass::ShutdownShader()
{

ShutdownShader함수에서 투명도 버퍼를 해제합니다.

    // 투명도 상수 버퍼를 해제합니다.
    if(m_transparentBuffer)
    {
        m_transparentBuffer->Release();
        m_transparentBuffer = 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 TransparentShaderClass::OutputShaderErrorMessage(ID3D10Blob* errorMessage, HWND hwnd, WCHAR* shaderFilename)
{
    char* compileErrors;
    unsigned long bufferSize, i;
    ofstream fout;


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

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

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

    // Write out the error message.
    for(i=0; i<buffersize; i++)="" {="" fout="" <<="" compileerrors[i];="" }="" close="" the="" file.="" fout.close();="" release="" error="" message.="" errormessage-="">Release();
    errorMessage = 0;

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

    return;
}


bool TransparentShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, 
                         D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture, float blend)
{
    HRESULT result;
    D3D11_MAPPED_SUBRESOURCE mappedResource;
    MatrixBufferType* dataPtr;
    unsigned int bufferNumber;
    TransparentBufferType* 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);

렌더링을 하기 전 여기에 blendAmount값을 넣습니다. 투명도 상수 버퍼를 잠근 뒤, 블렌딩할 값을 버퍼에 쓰고 잠금을 해제하고 나면 셰이더가 그 값에 접근할 수 있게 됩니다.

    // 내용을 기록할 수 있도록 투명도 상수 버퍼에 락을 겁니다.
    result = deviceContext->Map(m_transparentBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
    if(FAILED(result))
    {
        return false;
    }

    // 투명도 상수 버퍼 데이터의 포인터를 얻어옵니다.
    dataPtr2 = (TransparentBufferType*)mappedResource.pData;

    // 블렌딩할 값을 투명도 상수 버퍼에 넣습니다.
    dataPtr2->blendAmount = blend;

    // 버퍼의 락을 해제합니다.
    deviceContext->Unmap(m_transparentBuffer, 0);

    // 픽셀 셰이더 안에서의 투명도 상수 버퍼의 위치입니다.
    bufferNumber = 0;

    // 투명도 상수 버퍼를 갱신된 값으로 설정합니다.
    deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_transparentBuffer);

    return true;
}


void TransparentShaderClass::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"
#include "textureshaderclass.h"

TransparentShaderClass의 헤더 파일을 포함시킵니다.

#include "transparentshaderclass.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_Model1;
    ModelClass* m_Model2;
    TextureShaderClass* m_TextureShader;

TransparentShaderClass 객체를 생성합니다.

    TransparentShaderClass* m_TransparentShader;
};

#endif

Graphicsclass.cpp

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

생성자에서 TrandparentShaderClass와 두 모델을 null로 초기화합니다.

GraphicsClass::GraphicsClass()
{
    m_D3D = 0;
    m_Camera = 0;
    m_Model1 = 0;
    m_Model2 = 0;
    m_TextureShader = 0;
    m_TransparentShader = 0;
}


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


GraphicsClass::~GraphicsClass()
{
}


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

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

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

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

흙바닥 텍스쳐가 입혀질 첫번째 모델을 생성하고 초기화합니다.

    // 첫번째 모델 객체를 생성합니다.
    m_Model1 = new ModelClass;
    if(!m_Model1)
    {
        return false;
    }

    // 첫번째 모델을 초기화합니다.
    result = m_Model1->Initialize(m_D3D->GetDevice(), L"../Engine/data/dirt01.dds", "../Engine/data/square.txt");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the first model object.", L"Error", MB_OK);
        return false;
    }

벽돌 텍스쳐가 입혀질 두 번째 모델을 생성하고 초기화합니다.

    // 두 번째 모델 객체를 생성합니다.
    m_Model2 = new ModelClass;
    if(!m_Model2)
    {
        return false;
    }

    // 두 번째 모델을 초기화합니다.
    result = m_Model2->Initialize(m_D3D->GetDevice(), L"../Engine/data/stone01.dds", "../Engine/data/square.txt");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the second model object.", L"Error", MB_OK);
        return false;
    }

    // 텍스쳐 셰이더 객체를 생성합니다.
    m_TextureShader = new TextureShaderClass;
    if(!m_TextureShader)
    {
        return false;
    }

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

TransparentShaderClass 객체를 생성 및 초기화합니다.

    // 투명 셰이더 객체를 생성합니다.
    m_TransparentShader = new TransparentShaderClass;
    if(!m_TransparentShader)
    {
        return false;
    }

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

    return true;
}

Shutdown 함수에서 TransparentShaderClass 객체와 모델 두 개를 해제합니다.

void GraphicsClass::Shutdown()
{
    // 투명 셰이더 객체를 해제합니다.
    if(m_TransparentShader)
    {
        m_TransparentShader->Shutdown();
        delete m_TransparentShader;
        m_TransparentShader = 0;
    }

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

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

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

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

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

    return;
}


bool GraphicsClass::Frame()
{
    // 카메라의 위치를 잡아줍니다.
    m_Camera->SetPosition(0.0f, 0.0f, -5.0f);

    return true;
}


bool GraphicsClass::Render()
{
    D3DXMATRIX worldMatrix, viewMatrix, projectionMatrix;
    bool result;
    float blendAmount;

투명도 셰이더에 들어갈 블렌딩 값을 설정합니다.

    // 50%로 블렌딩 값을 잡습니다.
    blendAmount = 0.5f;

    // 화면을 그리기 전에 버퍼를 깨끗이 합니다.
    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_Model1->Render(m_D3D->GetDeviceContext());

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

이제 돌 텍스쳐를 입힌 모델을 방금 전 텍스쳐의 약간 오른쪽에 덮어 그립니다. 투명도 효과를 주기 위해 TransparentShaderClass와 blendAmount값을 사용하여 그리도록 합니다. 또한 그리기 전에 D3DClass에서 알파블렌딩을 켜 주고 다 끝나면 알파블렌딩을 끄도록 합니다.

    // 오른쪽으로 1만큼, 카메라를 향해 1만큼 이동시킵니다.
    D3DXMatrixTranslation(&worldMatrix, 1.0f, 0.0f, -1.0f);

    // 투명 효과가 동작하게끔 알파블렌딩을 켭니다.
    m_D3D->TurnOnAlphaBlending();

    // 파이프라인에 두 번째 모델을 넣습니다.
    m_Model2->Render(m_D3D->GetDeviceContext());

    // 돌 텍스쳐를 입힌 두 번째 모델을 50% 투명도로 그립니다.
    result = m_TransparentShader->Render(m_D3D->GetDeviceContext(), m_Model2->GetIndexCount(), worldMatrix, viewMatrix,
                         projectionMatrix, m_Model2->GetTexture(), blendAmount);
    if(!result)
    {
        return false;
    }

    // 알파블렌딩을 끕니다.
    m_D3D->TurnOffAlphaBlending();

    // 그려진 장면을 화면에 표시합니다.
    m_D3D->EndScene();

    return true;
}

마치면서

투명도를 이용하면 텍스쳐를 투과해 볼 수 있고 수많은 다른 효과들을 만들어 낼 수 있습니다.

연습문제

1. 프로그램을 다시 컴파일하여 실행해 보십시오. esc키로 종료합니다.
2. GraphicsRender 함수 안의 blendAmount값을 바꾸어 다른 값의 투명도를 확인해 보십시오.

소스코드

Visual Studio 2008 프로젝트: dx11tut26.zip

소스코드만: dx11src26.zip

실행파일만: dx11exe26.zip