Thinking Different :: [DirectX11] Tutorial 45

[DirectX11] Tutorial 45 - 쉐이더 관리자

DirectX 11/Basic2018. 1. 19. 21:31

뷰어
댓글로
이전글
다음글

Tutorial 45 - 쉐이더 관리자

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

여러 개의 셰이더를 사용하는 그래픽 응용 프로그램에서 발생하는 문제 중 하나는 이를 빠르게 관리하는 방법입니다. DirectX 11 튜토리얼 시리즈에서는 일반적으로 튜토리얼의 초점을 맞추지 않고 이해하기가 더 어렵기 때문에 어떻게 관리하는지 보여주지 않습니다. 그래서 이 튜토리얼 에서는 여러 쉐이더를 관리하는 더 간단한 방법 중 하나를 제시할 것입니다.

이 듀토리얼에서는 ShaderManagerClass라는 새로운 클래스를 사용합니다. 이 클래스는 응용 프로그램에 필요한 모든 쉐이더의 로드, 언로드 및 사용법을 캡슐화합니다. 여기에서는 디자인 패턴중에 하나인 파사드 패턴을 사용하여 코드량이 큰 부분을 단순화하여 인터페이스를 캡슐화하도록 하였습니다.

이 듀토리얼에서는 ShaderManager 클래스에 텍스처, 조명 및 범프 맵 쉐이더 객체가 포함됩니다. 그것들을 모두 로드 및 언로드 할 것이고 객체를 렌더링하게 하는 인터페이스도 제공 할 것입니다. 이를 통해 ShaderManagerClass 객체 하나만 생성 한 다음 응용 프로그램 주변의 클래스 객체에 단일 포인터를 전달하여 렌더링 객체가 객체 포인터를 사용하는 단일 함수 호출이 되도록 합니다. 이것은 이전 튜토리얼에서 D3DClass가 사용 된 방법과 유사합니다.

다음 이미지는 ShaderManagerClass를 사용하여 동시에 텍스처 쉐이더, 라이트 쉐이더 및 범프 맵 쉐이더로 렌더링되는 큐브를 보여줍니다.

Shadermanagerclass.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#pragma once
 
class TextureShaderClass;
class LightShaderClass;
class BumpMapShaderClass;
 
class ShaderManagerClass
{
public:
    ShaderManagerClass();
    ShaderManagerClass(const ShaderManagerClass&);
    ~ShaderManagerClass();
 
    bool Initialize(ID3D11Device*, HWND);
    void Shutdown();
 
    bool RenderTextureShader(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*);
 
    bool RenderLightShader(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*,
                           XMFLOAT3, XMFLOAT4, XMFLOAT4, XMFLOAT3, XMFLOAT4, float);
 
    bool RenderBumpMapShader(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*,
                             ID3D11ShaderResourceView*, XMFLOAT3, XMFLOAT4);
 
private:
    TextureShaderClass* m_TextureShader = nullptr;
    LightShaderClass* m_LightShader = nullptr;
    BumpMapShaderClass* m_BumpMapShader = nullptr;
};
Colored by Color Scripter
cs

Shadermanagerclass.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
#include "stdafx.h"
#include "textureshaderclass.h"
#include "lightshaderclass.h"
#include "bumpmapshaderclass.h"
#include "shadermanagerclass.h"
 
 
ShaderManagerClass::ShaderManagerClass()
{
    m_TextureShader = 0;
    m_LightShader = 0;
    m_BumpMapShader = 0;
}
 
 
ShaderManagerClass::ShaderManagerClass(const ShaderManagerClass& other)
{
}
 
 
ShaderManagerClass::~ShaderManagerClass()
{
}
 
 
bool ShaderManagerClass::Initialize(ID3D11Device* device, HWND hwnd)
{
    // 텍스처 쉐이더 객체를 생성한다.
    m_TextureShader = new TextureShaderClass;
    if(!m_TextureShader)
    {
        return false;
    }
 
    // 텍스처 쉐이더 객체를 초기화한다.
    bool result = m_TextureShader->Initialize(device, hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the texture shader object.", L"Error", MB_OK);
        return false;
    }
 
    // 라이트 쉐이더 객체를 만듭니다.
    m_LightShader = new LightShaderClass;
    if(!m_LightShader)
    {
        return false;
    }
 
    // 라이트 쉐이더 객체를 초기화합니다.
    result = m_LightShader->Initialize(device, hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the light shader object.", L"Error", MB_OK);
        return false;
    }
 
    // 범프 맵 쉐이더 객체를 생성합니다.
    m_BumpMapShader = new BumpMapShaderClass;
    if(!m_BumpMapShader)
    {
        return false;
    }
 
    // 범프 맵 쉐이더 객체를 초기화한다.
    result = m_BumpMapShader->Initialize(device, hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the bump map shader object.", L"Error", MB_OK);
        return false;
    }
 
    return true;
}
 
 
void ShaderManagerClass::Shutdown()
{
    // 범프 맵 쉐이더 객체를 해제한다.
    if(m_BumpMapShader)
    {
        m_BumpMapShader->Shutdown();
        delete m_BumpMapShader;
        m_BumpMapShader = 0;
    }
 
    // 라이트 쉐이더 객체를 해제합니다.
    if(m_LightShader)
    {
        m_LightShader->Shutdown();
        delete m_LightShader;
        m_LightShader = 0;
    }
 
    // 텍스처 쉐이더 객체를 해제한다.
    if(m_TextureShader)
    {
        m_TextureShader->Shutdown();
        delete m_TextureShader;
        m_TextureShader = 0;
    }
}
 
 
bool ShaderManagerClass::RenderTextureShader(ID3D11DeviceContext* device, int indexCount, XMMATRIX worldMatrix,
                                             XMMATRIX viewMatrix, XMMATRIX projectionMatrix,
                                             ID3D11ShaderResourceView* texture)
{
    // 텍스처 셰이더를 사용하여 모델을 렌더링합니다.
    return m_TextureShader->Render(device, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture);
}
 
 
bool ShaderManagerClass::RenderLightShader(ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX worldMatrix,
                                    XMMATRIX viewMatrix, XMMATRIX projectionMatrix, ID3D11ShaderResourceView* texture,
                                    XMFLOAT3 lightDirection, XMFLOAT4 ambient, XMFLOAT4 diffuse, XMFLOAT3 cameraPosition,
                                    XMFLOAT4 specular, float specularPower)
{
    // 라이트 쉐이더를 사용하여 모델을 렌더링합니다.
    return m_LightShader->Render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture,
                                 lightDirection, ambient, diffuse, cameraPosition, specular, specularPower);
}
 
 
bool ShaderManagerClass::RenderBumpMapShader(ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX worldMatrix,
                                     XMMATRIX viewMatrix, XMMATRIX projectionMatrix, ID3D11ShaderResourceView* colorTexture,
                                     ID3D11ShaderResourceView* normalTexture, XMFLOAT3 lightDirection, XMFLOAT4 diffuse)
{
    // 범프 맵 셰이더를 사용하여 모델을 렌더링합니다.
    return m_BumpMapShader->Render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, colorTexture,
                                   normalTexture, lightDirection, diffuse);
}
Colored by Color Scripter
cs

Graphicsclass.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#pragma once
 
/////////////
// GLOBALS //
/////////////
const bool FULL_SCREEN = false;
const bool VSYNC_ENABLED = true;
const float SCREEN_DEPTH = 1000.0f;
const float SCREEN_NEAR = 0.1f;
 
 
class D3DClass;
class ShaderManagerClass;
class CameraClass;
class ModelClass;
class LightClass;
class BumpModelClass;
 
class GraphicsClass
{
public:
    GraphicsClass();
    GraphicsClass(const GraphicsClass&);
    ~GraphicsClass();
 
    bool Initialize(int, int, HWND);
    void Shutdown();
    bool Frame();
 
private:
    bool Render(float);
 
private:
    D3DClass* m_D3D = nullptr;
    ShaderManagerClass* m_ShaderManager = nullptr;
    CameraClass* m_Camera = nullptr;
    LightClass* m_Light = nullptr;
    ModelClass *m_Model1 = nullptr;
    ModelClass *m_Model2 = nullptr;
    BumpModelClass* m_Model3 = nullptr;
};
Colored by Color Scripter
cs

Graphicsclass.cpp

#include "stdafx.h"
#include "d3dclass.h"
#include "shadermanagerclass.h"
#include "cameraclass.h"
#include "lightclass.h"
#include "modelclass.h"
#include "bumpmodelclass.h"
#include "graphicsclass.h"
 
 
GraphicsClass::GraphicsClass()
{
}
 
 
GraphicsClass::GraphicsClass(const GraphicsClass& other)
{
}
 
 
GraphicsClass::~GraphicsClass()
{
}
 
 
bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
{
    // Direct3D 객체 생성
    m_D3D = new D3DClass;
    if(!m_D3D)
    {
        return false;
    }
 
    // Direct3D 객체 초기화
    bool 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_ShaderManager = new ShaderManagerClass;
    if(!m_ShaderManager)
    {
        return false;
    }
 
    // 셰이더 관리자 객체를 초기화합니다.
    result = m_ShaderManager->Initialize(m_D3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the shader manager object.", L"Error", MB_OK);
        return false;
    }
 
    // 카메라 객체를 만듭니다.
    m_Camera = new CameraClass;
    if(!m_Camera)
    {
        return false;
    }
 
    // 카메라의 초기 위치를 설정합니다.
    m_Camera->SetPosition(XMFLOAT3(0.0f, 0.0f, -10.0f));
    
    // light 객체를 만듭니다.
    m_Light = new LightClass;
    if(!m_Light)
    {
        return false;
    }
 
    // 조명 객체를 초기화합니다.
    m_Light->SetAmbientColor(0.15f, 0.15f, 0.15f, 1.0f);
    m_Light->SetDiffuseColor(1.0f, 1.0f, 1.0f, 1.0f);
    m_Light->SetDirection(0.0f, 0.0f, 1.0f);
    m_Light->SetSpecularColor(1.0f, 1.0f, 1.0f, 1.0f);
    m_Light->SetSpecularPower(64.0f);
 
    // 모델 객체를 만듭니다.
    m_Model1 = new ModelClass;
    if(!m_Model1)
    {
        return false;
    }
 
    // 모델 객체를 초기화합니다.
    result = m_Model1->Initialize(m_D3D->GetDevice(), "../Dx11Demo_45/data/cube.txt", L"../Dx11Demo_45/data/marble.dds");
    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(), "../Dx11Demo_45/data/cube.txt", L"../Dx11Demo_45/data/metal.dds");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the second model object.", L"Error", MB_OK);
        return false;
    }
 
    // 법선 맵과 관련 벡터가있는 모델에 대해 세 번째 범프 모델 객체를 만듭니다.
    m_Model3 = new BumpModelClass;
    if(!m_Model3)
    {
        return false;
    }
 
    // 범프 모델 객체를 초기화합니다.
    result = m_Model3->Initialize(m_D3D->GetDevice(), "../Dx11Demo_45/data/cube.txt", L"../Dx11Demo_45/data/stone.dds", 
                                  L"../Dx11Demo_45/data/normal.dds");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the third model object.", L"Error", MB_OK);
        return false;
    }
 
    return true;
}
 
 
void GraphicsClass::Shutdown()
{
    // 모델 객체를 해제합니다.
    if(m_Model1)
    {
        m_Model1->Shutdown();
        delete m_Model1;
        m_Model1 = 0;
    }
 
    if(m_Model2)
    {
        m_Model2->Shutdown();
        delete m_Model2;
        m_Model2 = 0;
    }
 
    if(m_Model3)
    {
        m_Model3->Shutdown();
        delete m_Model3;
        m_Model3 = 0;
    }
 
    // light 오브젝트를 해제한다.
    if(m_Light)
    {
        delete m_Light;
        m_Light = 0;
    }
 
    // 카메라 객체를 해제합니다.
    if(m_Camera)
    {
        delete m_Camera;
        m_Camera = 0;
    }
 
    // 셰이더 관리자 객체를 해제합니다.
    if(m_ShaderManager)
    {
        m_ShaderManager->Shutdown();
        delete m_ShaderManager;
        m_ShaderManager = 0;
    }
 
    // D3D 객체를 해제합니다.
    if(m_D3D)
    {
        m_D3D->Shutdown();
        delete m_D3D;
        m_D3D = 0;
    }
}
 
 
bool GraphicsClass::Frame()
{
    static float rotation = 0.0f;
 
    // 각 프레임의 rotation 변수를 업데이트합니다.
    rotation += (float)XM_PI * 0.005f;
    if(rotation > 360.0f)
    {
        rotation -= 360.0f;
    }
    
    // 그래픽 장면을 렌더링합니다.
    return Render(rotation);
}
 
 
bool GraphicsClass::Render(float rotation)
{
    XMMATRIX worldMatrix, viewMatrix, projectionMatrix, translateMatrix;
    
    // 씬을 그리기 위해 버퍼를 지웁니다
    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);
 
    // 첫 번째 모델의 회전 및 평행 이동을 설정합니다.
    worldMatrix = XMMatrixRotationY(rotation);
    translateMatrix = XMMatrixTranslation(-3.5f, 0.0f, 0.0f);
    worldMatrix = XMMatrixMultiply(worldMatrix, translateMatrix);
 
    // 텍스처 셰이더를 사용하여 첫 번째 모델을 렌더링합니다.
    m_Model1->Render(m_D3D->GetDeviceContext());
 
    if(!m_ShaderManager->RenderTextureShader(m_D3D->GetDeviceContext(), m_Model1->GetIndexCount(), worldMatrix, viewMatrix,
                                             projectionMatrix,
        m_Model1->GetTexture()))
    {
        return false;
    }
 
    // 두 번째 모델의 회전 및 평행 이동을 설정합니다.
    m_D3D->GetWorldMatrix(worldMatrix);
    worldMatrix = XMMatrixRotationY(rotation);
    translateMatrix = XMMatrixTranslation(0.0f, 0.0f, 0.0f);
    worldMatrix = XMMatrixMultiply(worldMatrix, translateMatrix);
 
    // 라이트 쉐이더를 사용하여 두 번째 모델을 렌더링합니다.
    m_Model2->Render(m_D3D->GetDeviceContext());
    
    if(!m_ShaderManager->RenderLightShader(m_D3D->GetDeviceContext(), m_Model2->GetIndexCount(), worldMatrix, viewMatrix,
                                           projectionMatrix, m_Model2->GetTexture(), m_Light->GetDirection(),
                                           m_Light->GetAmbientColor(), m_Light->GetDiffuseColor(), m_Camera->GetPosition(),
                                           m_Light->GetSpecularColor(), m_Light->GetSpecularPower()))
    {
        return false;
    }
 
    // 셋째 모델의 회전 및 평행 이동을 설정합니다.
    m_D3D->GetWorldMatrix(worldMatrix);
    worldMatrix = XMMatrixRotationY(rotation);
    translateMatrix = XMMatrixTranslation(3.5f, 0.0f, 0.0f);
    worldMatrix = XMMatrixMultiply(worldMatrix, translateMatrix);
 
    // 범프 맵 셰이더를 사용하여 세 번째 모델을 렌더링합니다.
    m_Model3->Render(m_D3D->GetDeviceContext());
    
    if(!m_ShaderManager->RenderBumpMapShader(m_D3D->GetDeviceContext(), m_Model3->GetIndexCount(), worldMatrix, viewMatrix,
                                             projectionMatrix, m_Model3->GetColorTexture(), m_Model3->GetNormalMapTexture(),
                                             m_Light->GetDirection(),
        m_Light->GetDiffuseColor()))
    {
        return false;
    }
                               
    // 렌더링 된 장면을 화면에 표시합니다.
    m_D3D->EndScene();
 
    return true;
}

Colored by Color Scripter

출력 화면

마치면서

이제 하나의 클래스를 통해서 여러 쉐이더를 관리하는 기능을 캡슐화하여 사용할 수 있게 되었습니다.

연습문제

1. 코드를 컴파일하고 실행하십시오. 다른 셰이더로 음영 처리 된 세 개의 큐브가 나타납니다. 종료하려면 ESC 키를 누릅니다.

2. 다른 셰이더를 ShaderManager 클래스에 추가하고 해당 셰이더를 사용하여 네 번째 큐브를 렌더링합니다.

3. ShaderManager 클래스에 지능을 추가하여 필요에 따라 셰이더를로드 및 언로드합니다.

소스코드

소스코드 : Dx11Demo_45.zip

저작자표시 비영리 동일조건

'DirectX 11 > Basic' 카테고리의 다른 글

[DirectX11] Tutorial 47 - 피킹 (0)	2018.01.26
[DirectX11] Tutorial 46 - 광선 효과 (0)	2018.01.22
[DirectX11] Tutorial 44 - 투영 라이트 맵 (0)	2018.01.18
[DirectX11] Tutorial 43 - 투영 텍스처 (0)	2018.01.17
[DirectX11] Tutorial 42 - 부드러운 그림자 (0)	2018.01.16

Thinking Different

[DirectX11] Tutorial 45 - 쉐이더 관리자

'DirectX 11 > Basic' 카테고리의 다른 글

최근에 올라온 글

최근에 달린 댓글

링크

블로그 방문자 수

티스토리툴바

« 2024/11 »
일	월	화	수	목	금	토
					1	2
3	4	5	6	7	8	9
10	11	12	13	14	15	16
17	18	19	20	21	22	23
24	25	26	27	28	29	30