Thinking Different




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;
};
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);
}
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(intint, 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;
};
cs





Graphicsclass.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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
#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;
}
cs



출력 화면




마치면서


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



연습문제


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


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


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



소스코드


소스코드 : Dx11Demo_45.zip