Visual Studio 2022에서 작성하였습니다.
해당글은 다음 블로그를 참조하였습니다.
http://www.rastertek.com/tutdx11.html
https://ppparkje.tistory.com/category/%EA%B0%95%EC%A2%8C%EB%B2%88%EC%97%AD/DirectX%2011?page=2
https://copynull.tistory.com/category/DirectX%2011/Basic
Tutorial-10 에 이어서 작성하였음.
<DxDefine.h>
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
#pragma once
// 라이브러리 링크
#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "dxgi.lib")
#pragma comment(lib, "d3dcompiler.lib")
#pragma comment(lib, "dinput8.lib")
// include
#include <d3d11.h>
#include <d3dcompiler.h>
#include <directxmath.h>
#include <dinput.h>
using namespace DirectX;
|
cs |
<InputClass.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
|
#pragma once
#ifndef _INPUTCLASS_H_
#define _INPUTCLASS_H_
class InputClass
{
public:
InputClass();
InputClass(const InputClass& other);
~InputClass();
bool Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int screenHeight);
void Shutdown();
bool Frame();
bool IsEscapePressed();
void GetMouseLocation(int& mouseX, int& mouseY);
private:
bool ReadKeyboard();
bool ReadMouse();
void ProcessInput();
private:
IDirectInput8* m_directInput = nullptr;
IDirectInputDevice8* m_keyboard = nullptr;
IDirectInputDevice8* m_mouse = nullptr;
unsigned char m_keyboardState[256] = { 0, };
DIMOUSESTATE m_mouseState;
int m_screenWidth = 0;
int m_screenHeight = 0;
int m_mouseX = 0;
int m_mouseY = 0;
};
#endif // _INPUTCLASS_H_
|
cs |
<InputClass.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
|
#include "stdafx.h"
#include "inputclass.h"
InputClass::InputClass()
{
}
InputClass::InputClass(const InputClass& other)
{
}
InputClass::~InputClass()
{
}
bool InputClass::Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int screenHeight)
{
// 마우스 커서의 위치 지정에 사용될 화면 크기를 설정한다.
m_screenWidth = screenWidth;
m_screenHeight = screenHeight;
// Direct Input 인터페이스를 초기화 합니다.
HRESULT result = DirectInput8Create(hinstance, DIRECTINPUT_VERSION, IID_IDirectInput8, reinterpret_cast<void**>(&m_directInput), nullptr);
if (FAILED(result))
{
return false;
}
// 키보드의 Direct Input 인터페이스를 생성한다.
result = m_directInput->CreateDevice(GUID_SysKeyboard, &m_keyboard, nullptr);
if (FAILED(result))
{
return false;
}
// 데이터 형식을 설정한다. 이 경우 키보드이므로 사전 정의된 데이터 형식을 사용 할 수 있다.
result = m_keyboard->SetDataFormat(&c_dfDIKeyboard);
if (FAILED(result))
{
return false;
}
// 다른 프로그램과 공유 할 수 있도록 키보드의 협력 수준을 설정한다.
result = m_keyboard->SetCooperativeLevel(hwnd, DISCL_FOREGROUND | DISCL_EXCLUSIVE);
if (FAILED(result))
{
return false;
}
// 키보드를 할당 받는다.
result = m_keyboard->Acquire();
if (FAILED(result))
{
return false;
}
// 마우스 Direct Input 인터페이스를 생성한다.
result = m_directInput->CreateDevice(GUID_SysMouse, &m_mouse, nullptr);
if (FAILED(result))
{
return false;
}
// 미리 정의된 마우스 데이터 형식을 사용하여 마우스의 데이터 형식을 설정한다.
result = m_mouse->SetDataFormat(&c_dfDIMouse);
if (FAILED(result))
{
return false;
}
// 다른 프로그램과 공유 할 수 있도록 마우스의 협력 수준을 설정한다.
result = m_mouse->SetCooperativeLevel(hwnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
if (FAILED(result))
{
return false;
}
// 마우스를 할당받는다.
result = m_mouse->Acquire();
if (FAILED(result))
{
return false;
}
return true;
}
void InputClass::Shutdown()
{
// 마우스 반환
if (m_mouse)
{
m_mouse->Unacquire();
m_mouse->Release();
m_mouse = nullptr;
}
// 키보드 반환
if (m_keyboard)
{
m_keyboard->Unacquire();
m_keyboard->Release();
m_keyboard = nullptr;
}
// m_directInput 객체 반환
if (m_directInput)
{
m_directInput->Release();
m_directInput = nullptr;
}
}
bool InputClass::Frame()
{
// 키보드의 현재 상태를 읽는다.
if (!ReadKeyboard())
{
return false;
}
// 마우스의 현재 상태를 읽는다.
if (!ReadMouse())
{
return false;
}
// 키보드와 마우스의 변경상태를 처리한다.
ProcessInput();
return true;
}
bool InputClass::IsEscapePressed()
{
// escape 키가 현재 눌려지고 있는지 bit값을 계산하여 확인한다.
if (m_keyboardState[DIK_ESCAPE] & 0x80)
{
return true;
}
return false;
}
void InputClass::GetMouseLocation(int& mouseX, int& mouseY)
{
mouseX = m_mouseX;
mouseY = m_mouseY;
}
bool InputClass::ReadKeyboard()
{
// 키보드 디바이스를 얻는다.
HRESULT result = m_keyboard->GetDeviceState(sizeof(m_keyboardState), reinterpret_cast<LPVOID>(&m_keyboardState));
if (FAILED(result))
{
// 키보드가 포커스를 잃었거나 획득되지 않은 경우 컨트롤을 다시 가져온다.
if ((result == DIERR_INPUTLOST) || (result == DIERR_NOTACQUIRED))
{
m_keyboard->Acquire();
}
else
{
return false;
}
}
return true;
}
bool InputClass::ReadMouse()
{
// 마우스 디바이스를 얻는다.
HRESULT result = m_mouse->GetDeviceState(sizeof(DIMOUSESTATE), reinterpret_cast<LPVOID>(&m_mouseState));
if (FAILED(result))
{
// 마우스가 포커스를 잃었거나 획득되지 않은 경우 컨트롤을 다시 가져온다.
if ((result == DIERR_INPUTLOST) || (result == DIERR_NOTACQUIRED))
{
m_mouse->Acquire();
}
else
{
return false;
}
}
return true;
}
void InputClass::ProcessInput()
{
// 프레임 동안 마우스 위치의 변경을 기반으로 마우스 커서의 위치를 업데이트 한다.
m_mouseX += m_mouseState.lX;
m_mouseY += m_mouseState.lY;
// 마우스 위치가 화면 너비 또는 높이를 초과하지 않는지 확인한다.
if (m_mouseX < 0)
{
m_mouseX = 0;
}
if (m_mouseY < 0)
{
m_mouseY = 0;
}
if (m_mouseX > m_screenWidth)
{
m_mouseX = m_screenWidth;
}
if (m_mouseY > m_screenHeight)
{
m_mouseY = m_screenHeight;
}
}
|
cs |
<TextClass.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
42
43
44
45
46
47
48
49
50
51
52
53
54
|
#pragma once
#ifndef _TEXTCLASS_H_
#define _TEXTCLASS_H_
class FontClass;
class FontShaderClass;
class TextClass
{
private:
struct SentenceType
{
ID3D11Buffer* vertexBuffer, * indexBuffer;
int vertexCount, indexCount, maxLength;
float red, green, blue;
};
struct VertexType
{
XMFLOAT3 position;
XMFLOAT2 texture;
};
public:
TextClass();
TextClass(const TextClass& other);
~TextClass();
bool Initialize(ID3D11Device* device, ID3D11DeviceContext* deviceContext, HWND hwnd, int screenWidth, int screenHeight, XMMATRIX baseViewMatrix);
void Shutdown();
bool Render(ID3D11DeviceContext* deviceContext, XMMATRIX worldMatrix, XMMATRIX orthoMatrix);
bool SetMousePosition(int mouseX, int mouseY, ID3D11DeviceContext* deviceContext);
private:
bool InitializeSentence(SentenceType** sentence, int maxLength, ID3D11Device* device);
bool UpdateSentence(SentenceType* sentence, const char* text, int positionX, int positionY, float red, float green, float blue, ID3D11DeviceContext* deviceContext);
void ReleaseSentence(SentenceType** sentence);
bool RenderSentence(ID3D11DeviceContext* deviceContext, SentenceType* sentence, XMMATRIX worldMatrix, XMMATRIX orthoMatrix);
private:
FontClass* m_Font = nullptr;
FontShaderClass* m_FontShader = nullptr;
int m_screenWidth = 0;
int m_screenHeight = 0;
XMMATRIX m_baseViewMatrix;
SentenceType* m_sentence1 = nullptr;
SentenceType* m_sentence2 = nullptr;
};
#endif // _TEXTCLASS_H_
|
cs |
<TextClass.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
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
|
#include "stdafx.h"
#include "TextClass.h"
#include "FontClass.h"
#include "FontShaderClass.h"
TextClass::TextClass()
{
}
TextClass::TextClass(const TextClass& other)
{
}
TextClass::~TextClass()
{
}
bool TextClass::Initialize(ID3D11Device* device, ID3D11DeviceContext* deviceContext, HWND hwnd, int screenWidth, int screenHeight, XMMATRIX baseViewMatrix)
{
// 화면 너비 높이 값 저장.
m_screenWidth = screenWidth;
m_screenHeight = screenHeight;
// baseViewMatrix 저장.
m_baseViewMatrix = baseViewMatrix;
// Font 객체 생성
m_Font = new FontClass;
if (!m_Font)
{
return false;
}
// Font 객체 초기화
if (!(m_Font->Initialize(device, "./fontdata.txt", L"./Textures/font.dds")))
{
MessageBox(hwnd, L"Could not initialize the font object", L"Error", MB_OK);
return false;
}
// 폰트 쉐이더 객체 생성
m_FontShader = new FontShaderClass;
if (!m_FontShader)
{
return false;
}
// 폰트쉐이더 객체 초기화
if (!(m_FontShader->Initialize(device, hwnd)))
{
MessageBox(hwnd, L"Could not initialize the font shader object", L"Error", MB_OK);
return false;
}
// 첫번째 문장 초기화
if (!(InitializeSentence(&m_sentence1, 16, device)))
{
return false;
}
// 이젠 Sentence Vertex Buffer를 문장으로 업데이트 한다.
if (!(UpdateSentence(m_sentence1, "Hello", 100, 100, 1.0f, 1.0f, 1.0f, deviceContext)))
{
return false;
}
// 두번째 문장 초기화
if (!(InitializeSentence(&m_sentence2, 16, device)))
{
return false;
}
// 이젠 Sentence Vertex Buffer를 문장으로 업데이트 한다.
if (!(UpdateSentence(m_sentence2, "Goodbye", 100, 200, 1.0f, 1.0f, 0.0f, deviceContext)))
{
return false;
}
return true;
}
void TextClass::Shutdown()
{
// 문장 객체 해제
ReleaseSentence(&m_sentence1);
ReleaseSentence(&m_sentence2);
// 폰트쉐이더 객체 해제
if (m_FontShader)
{
m_FontShader->Shutdown();
delete m_FontShader;
m_FontShader = nullptr;
}
// 폰트 객체 해제
if (m_Font)
{
m_Font->Shutdown();
delete m_Font;
m_Font = nullptr;
}
}
bool TextClass::Render(ID3D11DeviceContext* deviceContext, XMMATRIX worldMatrix, XMMATRIX orthoMatrix)
{
bool result;
// 첫번째 문자 그리기
result = RenderSentence(deviceContext, m_sentence1, worldMatrix, orthoMatrix);
if (!result)
{
return false;
}
// 두번째 문자 그리기
result = RenderSentence(deviceContext, m_sentence2, worldMatrix, orthoMatrix);
if (!result)
{
return false;
}
return true;
}
bool TextClass::SetMousePosition(int mouseX, int mouseY, ID3D11DeviceContext* deviceContext)
{
char tempString[16];
char mouseString[16];
bool result;
// 마우스X 위치 정수를 문자열로 변경.
_itoa_s(mouseX, tempString, 10);
// 마우스X 문자열 만들기
strcpy_s(mouseString, "Mouse X: ");
strcpy_s(mouseString, tempString);
// Sentence 를 새로운 문자열로 업데이트한다.
result = UpdateSentence(m_sentence1, mouseString, 20, 20, 1.0f, 1.0f, 1.0f, deviceContext);
if (!result)
{
return false;
}
// 마우스Y 위치 정수를 문자열로 변경.
_itoa_s(mouseY, tempString, 10);
// 마우스Y 문자열 만들기
strcpy_s(mouseString, "Mouse Y: ");
strcpy_s(mouseString, tempString);
// Sentence2 를 새로운 문자열로 업데이트한다.
result = UpdateSentence(m_sentence2, mouseString, 20, 40, 1.0f, 1.0f, 1.0f, deviceContext);
if (!result)
{
return false;
}
return true;
}
bool TextClass::InitializeSentence(SentenceType** sentence, int maxLength, ID3D11Device* device)
{
// SentenceType 객체 생성
*sentence = new SentenceType;
if (!*sentence)
{
return false;
}
// 센텐스 버퍼를 null로 초기화
(*sentence)->vertexBuffer = nullptr;
(*sentence)->indexBuffer = nullptr;
// 최대 길이 초기화
(*sentence)->maxLength = maxLength;
// 정점수 초기화
(*sentence)->vertexCount = 6 * maxLength; // 한글자에 6정점 필요(삼각형 2개)
// 인덱스의 수 초기화
(*sentence)->indexCount = (*sentence)->vertexCount;
// 버텍스 배열 생성
VertexType* vertices = new VertexType[(*sentence)->vertexCount];
if (!vertices)
{
return false;
}
// 인덱스 배열 생성
unsigned long* indices = new unsigned long[(*sentence)->indexCount];
if (!indices)
{
return false;
}
// 버텍스 어레이 0으로 초기화
memset(vertices, 0, (sizeof(VertexType) * (*sentence)->vertexCount));
// 인덱스 어레이 초기화
for (int i = 0; i < (*sentence)->indexCount; i++)
{
indices[i] = i;
}
// 동적 정점 버퍼 디스크립션 설정
D3D11_BUFFER_DESC vertexBufferDesc;
vertexBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
vertexBufferDesc.ByteWidth = sizeof(VertexType) * (*sentence)->vertexCount;
vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
vertexBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
vertexBufferDesc.MiscFlags = 0;
vertexBufferDesc.StructureByteStride = 0;
// Subresource 구조체에 버텍스 데이터 포인터를 할당.
D3D11_SUBRESOURCE_DATA vertexData;
vertexData.pSysMem = vertices;
vertexData.SysMemPitch = 0;
vertexData.SysMemSlicePitch = 0;
// 버텍스 버퍼 생성
auto result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &(*sentence)->vertexBuffer);
if (FAILED(result))
{
return false;
}
// 정적 인덱스 버퍼의 디스크립션 작성
D3D11_BUFFER_DESC indexBufferDesc;
indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
indexBufferDesc.ByteWidth = sizeof(unsigned long) * (*sentence)->indexCount;
indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
indexBufferDesc.CPUAccessFlags = 0;
indexBufferDesc.MiscFlags = 0;
indexBufferDesc.StructureByteStride = 0;
// Subresource 구조체에 인덱스 데이타 포인터 할당
D3D11_SUBRESOURCE_DATA indexData;
indexData.pSysMem = indices;
indexData.SysMemPitch = 0;
indexData.SysMemSlicePitch = 0;
// 인덱스 버퍼 생성
result = device->CreateBuffer(&indexBufferDesc, &indexData, &(*sentence)->indexBuffer);
if (FAILED(result))
{
return false;
}
// 더이상 사용하지 않는 버텍스, 인덱스 배열 할당 해제
delete[] vertices;
vertices = nullptr;
delete[] indices;
indices = nullptr;
return true;
}
bool TextClass::UpdateSentence(SentenceType* sentence, const char* text, int positionX, int positionY, float red, float green, float blue , ID3D11DeviceContext* deviceContext)
{
// 문장의 색상 저장
sentence->red = red;
sentence->green = green;
sentence->blue = blue;
// 문장의 길이 가져오기
auto numLetters = static_cast<int>(strlen(text));
// 버퍼의 오버플로우 확인
if (numLetters > sentence->maxLength)
{
return false;
}
// 버텍스 어레이 생성
auto vertices = new VertexType[sentence->vertexCount];
if (!vertices)
{
return false;
}
// 버텍스 어레이 0으로 초기화
memset(vertices, 0, sizeof(VertexType) * sentence->vertexCount);
// X와 Y의 픽셀위치를 계산한다.
auto drawX = static_cast<float>(((m_screenWidth / 2) * -1) + positionX);
auto drawY = static_cast<float>((m_screenHeight / 2) - positionY);
// 문장 텍스트와 문자 그리는 위치를 사용하여 버텍스 어레이를 빌드하기위해 폰트 클래스를 사용한다.
m_Font->BuildVertexArray(reinterpret_cast<void*>(vertices), text, drawX, drawY);
// 버텍스 버퍼를 쓰기 위해 잠근다.
D3D11_MAPPED_SUBRESOURCE mappedResource;
HRESULT result = deviceContext->Map(sentence->vertexBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
return false;
}
// 버텍스 버퍼의 데이터를 가르키는 포인터를 가져온다.
auto verticesPtr = reinterpret_cast<VertexType*>(mappedResource.pData);
// 데이타를 버텍스 버퍼로 복사한다.
memcpy(verticesPtr, reinterpret_cast<void*>(vertices), sizeof(VertexType) * sentence->vertexCount);
// 버텍스 버퍼의 잠금해제 한다.
deviceContext->Unmap(sentence->vertexBuffer, 0);
// 더이상 사용하지 않는 버텍스 어레이 할당해제
delete[] vertices;
vertices = nullptr;
return true;
}
void TextClass::ReleaseSentence(SentenceType** sentence)
{
if (*sentence)
{
// 문장 버텍스 버퍼 해제
if ((*sentence)->vertexBuffer)
{
(*sentence)->vertexBuffer->Release();
(*sentence)->vertexBuffer = nullptr;
}
// 문장 인덱스 버퍼 해제
if (((*sentence)->indexBuffer))
{
(*sentence)->indexBuffer->Release();
(*sentence)->indexBuffer = nullptr;
}
// sentence 해제
delete* sentence;
*sentence = nullptr;
}
}
bool TextClass::RenderSentence(ID3D11DeviceContext* deviceContext, SentenceType* sentence, XMMATRIX worldMatrix, XMMATRIX orthoMatrix)
{
// 버텍스 버퍼의 스트라이드와 오프셋을 설정
unsigned int stride = sizeof(VertexType);
unsigned int offset = 0;
// 랜더될수 있도록 인풋 어셈블러에서 버텍스 버퍼가 활성화 되도록 설정한다.
deviceContext->IASetVertexBuffers(0, 1, &sentence->vertexBuffer, &stride, &offset);
// 인덱스 버퍼 활성화
deviceContext->IASetIndexBuffer(sentence->indexBuffer, DXGI_FORMAT_R32_UINT, 0);
// primitive 타입 설정, 여기서는 삼각형
deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
// 픽셀 생상 벡터를 인풋된 문장 색상으로 만든다.
auto pixelColor = XMFLOAT4(sentence->red, sentence->green, sentence->blue, 1.0f);
// 폰트쉐이더를 이용하여 텍스트를 랜더한다.
bool result = m_FontShader->Render(deviceContext, sentence->indexCount, worldMatrix, m_baseViewMatrix, orthoMatrix,
m_Font->GetTexture(), pixelColor);
if (!result)
{
return false;
}
return true;
}
|
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
42
43
44
45
46
47
48
49
|
#pragma once
#ifndef _GRAPHICSCLASS_H_
#define _GRAPHICSCLASS_H_
// 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 CameraClass;
//class ModelClass;
//class ColorShaderClass;
class TextureShaderClass;
class BitmapClass;
class LightShaderClass;
class LightClass;
class TextClass;
class GraphicsClass
{
public:
GraphicsClass();
GraphicsClass(const GraphicsClass& other);
~GraphicsClass();
bool Initialize(int screenWidth, int screenHeight, HWND hwnd);
void Shutdown();
bool Frame(int mouseX, int mouseY);
bool Render();
private:
D3DClass* m_D3D = nullptr;
CameraClass* m_Camera = nullptr;
//ModelClass* m_Model = nullptr;
//TextureShaderClass* m_TextureShader = nullptr;
//BitmapClass* m_Bitmap = nullptr;
//ColorShaderClass* m_ColorShader = nullptr;
//LightShaderClass* m_LightShader = nullptr;
//LightClass* m_Light = nullptr;
TextClass* m_Text = nullptr;
};
#endif // _GRAPHICSCLASS_H_
|
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
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
|
#include "stdafx.h"
#include "graphicsclass.h"
#include "BitmapClass.h"
#include "D3dclass.h"
#include "CameraClass.h"
#include "ModelClass.h"
#include "LightShaderClass.h"
#include "LightClass.h"
#include "TextClass.h"
#include "TextureShaderClass.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 객체를 초기화 한다.
if (!m_D3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR))
{
MessageBox(hwnd, L"Could not initialize Direct3D.", L"Error", MB_OK);
return false;
}
// m_Camera 객체 생성
m_Camera = new CameraClass;
if (!m_Camera)
{
return false;
}
// 카메라 포지션 설정
XMMATRIX baseViewMatrix;
m_Camera->SetPosition(0.0f, 0.0f, -5.0f);
m_Camera->Render();
m_Camera->GetViewMatrix(baseViewMatrix);
// 텍스트 객체 생성
m_Text = new TextClass;
if (!m_Text)
{
return false;
}
// 텍스트 객체 초기화
if (!m_Text->Initialize(m_D3D->GetDevice(), m_D3D->GetDeviceContext(), hwnd, screenWidth, screenHeight,baseViewMatrix))
{
MessageBox(hwnd, L"Could not initialize the Text object.", L"Error", MB_OK);
return false;
}
//// m_Model 객체 생성
//m_Model = new ModelClass;
//if (!m_Model)
//{
// return false;
//}
//// m_Model 초기화
//if (!m_Model->Initialize(m_D3D->GetDevice(), "./cube.txt", L"./Textures/WoodCrate01.dds"))
//{
// MessageBox(hwnd, L"Could not initialize the model object.", L"Error", MB_OK);
//}
// 텍스쳐 쉐이더 객체 생성
//m_TextureShader = new TextureShaderClass;
//if (!m_TextureShader)
//{
// return false;
//}
//// 텍스터 쉐이더 객테 초기화
//if (!m_TextureShader->Initialize(m_D3D->GetDevice(), hwnd))
//{
// MessageBox(hwnd, L"Could not initialize texture shader object.", L"Error", MB_OK);
// return false;
//}
//// LightShaderClass 객체 생성
//m_LightShader = new LightShaderClass;
//if (!m_LightShader)
//{
// return false;
//}
//// LightShader 객체를 초기화한다.
//if (!m_LightShader->Initialize(m_D3D->GetDevice(), hwnd))
//{
// MessageBox(hwnd, L"Could not initialize the light shader object.", L"Error", MB_OK);
// return false;
//}
//// LightClass 객체 생성
//m_Light = new LightClass;
//if (!m_Light)
//{
// return false;
//}
//// Light 객체 초기화
//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(1.0f, 0.0f, 1.0f);
//m_Light->SetSpecularColor(1.0f, 1.0f, 1.0f, 1.0f);
//m_Light->SetSpecularPower(32.0f);
// 비트맵 객체 생성
//m_Bitmap = new BitmapClass;
//if (!m_Bitmap)
//{
// return false;
//}
// 비트맵 객체 초기화
//if (!m_Bitmap->Initialize(m_D3D->GetDevice(), screenWidth, screenHeight, L"./Textures/WoodCrate01.dds",
// 512, 512))
//{
// MessageBox(hwnd, L"Could not initialize the bitmap object.", L"Error", MB_OK);
// return false;
//}
return true;
}
void GraphicsClass::Shutdown()
{
// 텍스트 객체 해제
if (m_Text)
{
m_Text->Shutdown();
delete m_Text;
m_Text = nullptr;
}
// 비트맵 객체 해제
//if (m_Bitmap)
//{
// m_Bitmap->Shutdown();
// delete m_Bitmap;
// m_Bitmap = nullptr;
//}
//// light 객체 해제
//if (m_Light)
//{
// delete m_Light;
// m_Light = nullptr;
//}
//// LightShader 객체 해제
//if (m_LightShader)
//{
// m_LightShader->Shutdown();
// delete m_LightShader;
// m_LightShader = nullptr;
//}
// m_TextureShader 객체 반환
//if (m_TextureShader)
//{
// m_TextureShader->Shutdown();
// delete m_TextureShader;
// m_TextureShader = nullptr;
//}
//// m_Model 객체 반환
//if (m_Model)
//{
// m_Model->Shutdown();
// delete m_Model;
// m_Model = nullptr;
//}
// m_Camera 객체 반환
if (m_Camera)
{
delete m_Camera;
m_Camera = nullptr;
}
// D3D 객체를 반환합니다.
if (m_D3D)
{
m_D3D->Shutdown();
delete m_D3D;
m_D3D = nullptr;
}
}
bool GraphicsClass::Frame(int mouseX, int mouseY)
{
bool result;
// 마우스 위치 세팅
result = m_Text->SetMousePosition(mouseX, mouseY, m_D3D->GetDeviceContext());
if (!result)
{
return false;
}
// 카메라 위치 세팅
//m_Camera->SetPosition(0.0f, 0.0f, -10.0f);
return true;
}
bool GraphicsClass::Render()
{
// 씬 그리기를 시작하기 위해 버퍼의 내용을 지웁니다.
m_D3D->BeginScene(0.0f, 0.0f, 0.0f, 1.0f);
// 카메라의 위치에 따라 뷰 행렬을 생성한다.
m_Camera->Render();
// 카메라 및 d3d 객체에서 월드, 뷰 및 투영 행렬을 가져온다.
XMMATRIX worldMatrix, viewMatrix, projectionMatrix, orthoMatrix;
m_D3D->GetWorldMatrix(worldMatrix);
m_Camera->GetViewMatrix(viewMatrix);
m_D3D->GetProjectionMatrix(projectionMatrix);
m_D3D->GetOrthoMatrix(orthoMatrix);
// 2D 렌더링을 시작하기 위해 Z버퍼를 끈다.
m_D3D->TurnZBufferOff();
// 알파 블렌딩을 켠다.
m_D3D->TurnOnAlphaBlending();
// 비트맵 버텍스와 인덱스 버퍼를 그래픽 파이프 라인에 배치하여 그리기를 준비한다.
//if (!m_Bitmap->Render(m_D3D->GetDeviceContext(), 100, 100))
//{
// return false;
//}
// 도형이 회전 할 수 있도록 회전 값으로 월드 행렬을 회전한다.
// = XMMatrixRotationY(rotation);
// 모델 버텍스와 인덱스 버퍼를 그래픽 파이프 라인에 배치하여 드로잉을 준비한다.
//m_Model->Render(m_D3D->GetDeviceContext());
// Light 쉐이더를 사용하여 모델을 렌더링 한다.
//if (!m_LightShader->Render(m_D3D->GetDeviceContext(), m_Model->GetIndexCount(), worldMatrix,
// viewMatrix, projectionMatrix, m_Model->GetTexture(), m_Light->GetDirection(), m_Light->GetAmbientColor(), m_Light->GetDiffuseColor()
// , m_Camera->GetPosition(), m_Light->GetSpecularColor(), m_Light->GetSpecularPower()))
//{
// return false;
//}
// 텍스트 문자열을 렌더한다.
if (!m_Text->Render(m_D3D->GetDeviceContext(), worldMatrix, orthoMatrix))
{
return false;
}
// 텍스처 쉐이더를 사용하여 모델을 랜더링 한다.
//if (!m_TextureShader->Render(m_D3D->GetDeviceContext(), m_Bitmap->GetIndexCount(), worldMatrix, viewMatrix, orthoMatrix,
// m_Bitmap->GetTexture()))
//{
// return false;
//}
// 모든2D 렌더링이 완료되었으므로 Z버퍼를 다시 켠다.
m_D3D->TurnZBufferOn();
// 버퍼에 그려진 씬을 화면에 표시합니다.
m_D3D->EndScene();
return true;
}
|
cs |
<SystemClass.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
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
|
#include "stdafx.h"
#include "systemclass.h"
SystemClass* SystemClass::ApplicationHandle = nullptr;
SystemClass::SystemClass()
{
}
SystemClass::SystemClass(const SystemClass&)
{
}
SystemClass::~SystemClass()
{
}
bool SystemClass::Initialize()
{
int screenWidth, screenHeight;
bool result;
// 함수에 높이와 너비를 전달하기 전에 변수를 0으로 초기화한다.
screenWidth = 0;
screenHeight = 0;
// 윈도우즈 api를 사용하여 초기화한다.
InitializeWindows(screenWidth, screenHeight);
// input 객체를 생성한다.
// 이 객체는 유저로부터 들어오는 키보드 입력을 처리하기위해 사용된다.
m_Input = new InputClass;
if (!m_Input)
{
return false;
}
// Input 객체를 초기화한다.
result = m_Input->Initialize(m_hinstance, m_hwnd, screenWidth, screenHeight);
if (!result)
{
MessageBox(m_hwnd, L"Could not initialize the input object.", L"Error", MB_OK);
return false;
}
// graphics 객체를 생성한다.
// 이 객체는 이 어플리케이션의 모든 그래픽 요소를 그리는 일을 한다.
m_Graphics = new GraphicsClass;
if (!m_Graphics)
{
return false;
}
// graphics 객체를 초기화 한다.
result = m_Graphics->Initialize(screenWidth, screenHeight, m_hwnd);
if (!result)
{
return false;
}
return true;
}
void SystemClass::Shutdown()
{
// Graphics 객체를 반환합니다.
if (m_Graphics)
{
m_Graphics->Shutdown();
delete m_Graphics;
m_Graphics = nullptr;
}
// Input 객체를 반환합니다.
if (m_Input)
{
m_Input->Shutdown();
delete m_Input;
m_Input = nullptr;
}
// 창을 종료시킵니다.
ShutdownWindows();
return;
}
void SystemClass::Run()
{
MSG msg;
bool done, result;
// 메세지 구조체를 초기화합니다.
ZeroMemory(&msg, sizeof(MSG));
// 유저로부터 종료 메시지를 받을 때까지 루프를 돈다.
done = false;
while (!done)
{
// 윈도우 메시지를 처리합니다.
if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
// 윈도우에서 어플리케이션의 종료를 요청하는 경우 빠져나갑니다.
if (msg.message == WM_QUIT)
{
done = true;
}
else
{
// 그 외에는 Frame 함수를 처리합니다.
result = Frame();
if (!result)
{
MessageBox(m_hwnd, L"Frame processing Failed", L"Error", MB_OK);
done = true;
}
}
// 유저가 Escape 키를 눌렀는지 확인한다.
if (m_Input->IsEscapePressed())
{
done = true;
}
}
}
HWND& SystemClass::GetHWND()
{
return m_hwnd;
}
LRESULT SystemClass::MessageHandler(HWND hwnd, UINT umsg, WPARAM wparam, LPARAM lparam)
{
return DefWindowProc(hwnd, umsg, wparam, lparam);
}
bool SystemClass::Frame()
{
bool result;
int mouseX, mouseY;
// 입력 프레임 절차
result = m_Input->Frame();
if (!result)
{
return false;
}
// 마우스 위치를 가져온다.
m_Input->GetMouseLocation(mouseX, mouseY);
// graphics 객체의 작업을 처리합니다. 마우스 위치값을 매개변수로
result = m_Graphics->Frame(mouseX, mouseY);
if (!result)
{
return false;
}
// 렌더한다.
result = m_Graphics->Render();
if (!result)
{
return false;
}
return true;
}
void SystemClass::InitializeWindows(int& screenWidth, int& screenHeight)
{
WNDCLASSEX wc;
DEVMODE dmScreenSettings;
int posX, posY;
// 외부 포인터를 이 객체로 설정
ApplicationHandle = this;
// 이 어플리케이션의 인스턴스 가져오기.
m_hinstance = GetModuleHandle(nullptr);
// 엎플리케이션의 이름 설정
m_applicationName = L"Engine";
// 윈도우 클래스를 기본 설정으로 설정.
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = m_hinstance;
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
wc.hIconSm = wc.hIcon;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
wc.lpszMenuName = NULL;
wc.lpszClassName = m_applicationName;
wc.cbSize = sizeof(WNDCLASSEX);
// 윈도우 클래스 등록
RegisterClassEx(&wc);
// 모니터 화면의 해상도 가져오기
screenWidth = GetSystemMetrics(SM_CXSCREEN);
screenHeight = GetSystemMetrics(SM_CYSCREEN);
if (FULL_SCREEN)
{
memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
dmScreenSettings.dmSize = sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = static_cast<unsigned long>(screenWidth);
dmScreenSettings.dmPelsHeight = static_cast<unsigned long>(screenHeight);
dmScreenSettings.dmBitsPerPel = 32;
dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
// 풀스크린에 맞는 디스플레이 설정을 합니다.
ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN);
// 윈도우의 위치를 화면의 왼쪽 위로 맞춥니다.
posX = posY = 0;
}
else
{
// 윈도우 모드라면 800X600으로 크기 설정
screenWidth = 800;
screenHeight = 600;
// 창을 모니터의 중앙에 오도록 설정
posX = (GetSystemMetrics(SM_CXSCREEN) - screenWidth) / 2;
posY = (GetSystemMetrics(SM_CYSCREEN) - screenHeight) / 2;
}
// 설정한 것을 가지고 창을 만들고 그 핸들을 가져옵니다.
m_hwnd = CreateWindowEx(WS_EX_APPWINDOW, m_applicationName, m_applicationName,
WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_POPUP,
posX, posY, screenWidth, screenHeight, nullptr, nullptr, m_hinstance, nullptr);
// 윈도우를 화면에 표시하고 포커스를 줍니다.
ShowWindow(m_hwnd, SW_SHOW);
SetForegroundWindow(m_hwnd);
SetFocus(m_hwnd);
// 마우스 커서 표시설정
ShowCursor(true);
return;
}
void SystemClass::ShutdownWindows()
{
// 마우스 커서를 표시합니다.
ShowCursor(true);
// 풀스크린 모드를 빠져나올 때 디스플레이 설정을 바꿉니다.
if (FULL_SCREEN)
{
ChangeDisplaySettings(nullptr, 0);
}
// 창을 제거합니다.
DestroyWindow(m_hwnd);
m_hwnd = nullptr;
// 어플리케이션 인스턴스를 제거한다.
UnregisterClass(m_applicationName, m_hinstance);
m_hinstance = nullptr;
// 이 클래스에 대한 외부포인터 참조를 제거
ApplicationHandle = nullptr;
}
LRESULT WndProc(HWND hwnd, UINT umessage, WPARAM wparam, LPARAM lparam)
{
switch (umessage)
{
// 윈도우가 제거되었는지 확인
case WM_DESTROY:
{
PostQuitMessage(0);
return 0;
}
// 윈도우가 닫히는지 확인한다.
case WM_CLOSE:
{
PostQuitMessage(0);
}
// 다른 모든 메세지들은 system 클래스의 메세지 처리기에 전달합니다.
default:
{
return SystemClass::ApplicationHandle->MessageHandler(hwnd, umessage, wparam, lparam);
}
}
}
|
cs |
<결과>
<소스코드>
https://github.com/woonhak-kong/DirectX_11_Tutorial/releases/tag/Tutorial_11
'DirectX 11' 카테고리의 다른 글
| DirectX11 Tutorial 10 - 글꼴 엔진(개인공부) (0) | 2022.07.07 |
|---|---|
| DirectX11 Tutorial 9- 2D 렌더링(개인공부) (0) | 2022.07.03 |
| DirectX11 Tutorial 8 - 정반사광(Specular Lighting)(개인공부) (0) | 2022.06.20 |
| DirectX11 Tutorial 7 - 주변광(AmbientLight)(개인공부) (0) | 2022.06.20 |
| DirectX11 Tutorial 6 - 3D 모델 렌더링(개인공부) (0) | 2022.06.17 |
