Thinking Different




Terrain 08 - 지형 미니맵



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



 미니맵은 사용자 인터페이스의 작은 2D 맵으로 사용자가 지형에서 현재 위치를 쉽게 찾을 수 있도록 도와줍니다. 지형에 사용되는 컬러맵을 기본 배경으로 초록색의 작은 점으로 위치가 표시 됩니다. 이전 튜토리얼은 컬러맵을 다루었으므로 이 튜토리얼은 해당 정보를 바탕으로 작성되었습니다. 이전 튜토리얼의 컬러맵을 사용하여 이를 사용자 인터페이스의 일부로 2D로 렌더링할 비트맵으로 사용합니다. 또한 3x3 녹색 픽셀 비트 맵을 사용하여 현재 사용자가 미니맵에 있는 위치를 나타냅니다. 그리고 미니맵 주위에 흰 테두리를 그려 더 돋보이게 하도록 하겠습니다.


이 듀토리얼의 코드에는 DirectX 11 듀토리얼의 TextureShaderClass 및 BitmapClass가 포함되어 미니맵 렌더링을 처리하게 합니다. 미니맵 기능을 처리하는 새로운 클래스를 MiniMapClass 라고 합니다.


먼저 MiniMapClass 코드부터 보도록 하겠습니다.


Minimapclass.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
#pragma once
 
 
class BitmapClass;
class TextureShaderClass;
 
 
class MiniMapClass
{
public:
    MiniMapClass();
    MiniMapClass(const MiniMapClass&);
    ~MiniMapClass();
 
    bool Initialize(ID3D11Device*, HWND, intint, XMMATRIX, floatfloat);
    void Shutdown();
    bool Render(ID3D11DeviceContext*, XMMATRIX, XMMATRIX, TextureShaderClass*);
    
    void PositionUpdate(floatfloat);
 
private:
    int m_mapLocationX = 0;
    int m_mapLocationY = 0;
    int m_pointLocationX = 0;
    int m_pointLocationY = 0;
    float m_mapSizeX = 0;
    float m_mapSizeY = 0;
    float m_terrainWidth = 0;
    float m_terrainHeight = 0;
    XMMATRIX m_viewMatrix;
    BitmapClass *m_MiniMapBitmap = nullptr;
    BitmapClass *m_Border = nullptr;
    BitmapClass *m_Point = nullptr;
};
cs



Minimapclass.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
#include "stdafx.h"
#include "bitmapclass.h"
#include "textureshaderclass.h"
#include "minimapclass.h"
 
 
MiniMapClass::MiniMapClass()
{
}
 
 
MiniMapClass::MiniMapClass(const MiniMapClass& other)
{
}
 
 
MiniMapClass::~MiniMapClass()
{
}
 
 
bool MiniMapClass::Initialize(ID3D11Device* device, HWND hwnd, int screenWidth, int screenHeight, XMMATRIX viewMatrix,
 float terrainWidth, float terrainHeight)
{
    // 화면에서 미니 맵의 위치를 ​​초기화합니다.
    m_mapLocationX = 150;
    m_mapLocationY = 75;
 
    // 미니 맵의 크기를 설정합니다.
    m_mapSizeX = 150.0f;
    m_mapSizeY = 150.0f;
 
    // 기본 뷰 매트릭스를 저장합니다.
    m_viewMatrix = viewMatrix;
 
    // 지형 크기를 저장합니다.
    m_terrainWidth = terrainWidth;
    m_terrainHeight = terrainHeight;
 
    // 미니 맵 비트 맵 객체를 만듭니다.
    m_MiniMapBitmap = new BitmapClass;
    if(!m_MiniMapBitmap)
    {
        return false;
    }
 
    // 미니 맵 비트 맵 객체를 초기화합니다.
    bool result = m_MiniMapBitmap->Initialize(device, screenWidth, screenHeight, L"../Dx11Terrain_08/data/colorm01.dds",
 150150);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the mini-map object.", L"Error", MB_OK);
        return false;
    }
 
    // 테두리 비트 맵 객체를 만듭니다.
    m_Border = new BitmapClass;
    if(!m_Border)
    {
        return false;
    }
 
    // 테두리 비트 맵 객체를 초기화합니다.
    result = m_Border->Initialize(device, screenWidth, screenHeight, L"../Dx11Terrain_08/data/border01.dds"154154);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the border object.", L"Error", MB_OK);
        return false;
    }
 
    // 포인트 비트 맵 객체를 만듭니다.
    m_Point = new BitmapClass;
    if(!m_Point)
    {
        return false;
    }
 
    // 포인트 비트 맵 객체를 초기화합니다.
    result = m_Point->Initialize(device, screenWidth, screenHeight, L"../Dx11Terrain_08/data/point01.dds"33);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the point object.", L"Error", MB_OK);
        return false;
    }
 
    return true;
}
 
 
void MiniMapClass::Shutdown()
{
    // 포인트 비트 맵 객체를 해제합니다.
    if(m_Point)
    {
        m_Point->Shutdown();
        delete m_Point;
        m_Point = 0;
    }
 
    // 테두리 비트 맵 객체를 해제합니다.
    if(m_Border)
    {
        m_Border->Shutdown();
        delete m_Border;
        m_Border = 0;
    }
 
    // 미니 맵 비트 맵 객체를 해제합니다.
    if(m_MiniMapBitmap)
    {
        m_MiniMapBitmap->Shutdown();
        delete m_MiniMapBitmap;
        m_MiniMapBitmap = 0;
    }
}
 
 
bool MiniMapClass::Render(ID3D11DeviceContext* deviceContext, XMMATRIX worldMatrix, XMMATRIX orthoMatrix,
 TextureShaderClass* textureShader)
{
    // 테두리 비트 맵 버텍스와 인덱스 버퍼를 그래픽 파이프 라인에 배치하여 그리기를 준비합니다.
    bool result = m_Border->Render(deviceContext, (m_mapLocationX - 2), (m_mapLocationY - 2));
    if(!result)
    {
        return false;
    }
 
    // 텍스처 셰이더를 사용하여 테두리 비트 맵을 렌더링합니다.
    textureShader->Render(deviceContext, m_Border->GetIndexCount(), worldMatrix, m_viewMatrix, orthoMatrix,
 m_Border->GetTexture());
 
    // 미니 맵 비트 맵 버텍스와 인덱스 버퍼를 그래픽 파이프 라인에 배치하여 그리기를 준비합니다.
    result = m_MiniMapBitmap->Render(deviceContext, m_mapLocationX, m_mapLocationY);
    if(!result)
    {
        return false;
    }
 
    // 텍스처 셰이더를 사용하여 미니 맵 비트 맵을 렌더링합니다.
    textureShader->Render(deviceContext, m_MiniMapBitmap->GetIndexCount(), worldMatrix, m_viewMatrix, orthoMatrix,
 m_MiniMapBitmap->GetTexture());
 
    // 포인트 비트 맵 버텍스와 인덱스 버퍼를 그래픽 파이프 라인에 배치하여 그리기를 준비합니다.
    result = m_Point->Render(deviceContext, m_pointLocationX, m_pointLocationY);
    if(!result)
    {
        return false;
    }
 
    // 텍스처 셰이더를 사용하여 포인트 비트 맵을 렌더링합니다.
    textureShader->Render(deviceContext, m_Point->GetIndexCount(), worldMatrix, m_viewMatrix, orthoMatrix,
 m_Point->GetTexture());
 
    return true;
}
 
 
void MiniMapClass::PositionUpdate(float positionX, float positionZ)
{
    // 카메라가 지형 경계선을 지나쳐도 포인트가 미니 맵 테두리를 떠나지 않는지 확인합니다.
    if(positionX < 0)
    {
        positionX = 0;
    }
 
    if(positionZ < 0)
    {
        positionZ = 0;
    }
 
    if(positionX > m_terrainWidth)
    {
        positionX = m_terrainWidth;
    }
 
    if(positionZ > m_terrainHeight)
    {
        positionZ = m_terrainHeight;
    }
 
    // 미니 맵에서 카메라의 위치를 ​​백분율로 계산합니다.
    float percentX = positionX / m_terrainWidth;
    float percentY = 1.0f - (positionZ / m_terrainHeight);
 
    // 미니 맵에서 포인트의 픽셀 위치를 결정합니다.
    m_pointLocationX = m_mapLocationX + (int)(percentX * m_mapSizeX);
    m_pointLocationY = m_mapLocationY + (int)(percentY * m_mapSizeY);
 
    // 3x3 포인트 픽셀 이미지 크기에 따라 미니 맵에서 포인트의 중심에 위치에서 1을 뺍니다.
    m_pointLocationX = m_pointLocationX - 1;
    m_pointLocationY = m_pointLocationY - 1;
}
cs



TerrainClass는 미니 맵 기능을 보조하기 위해 약간 수정되었습니다.


Terrainclass.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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
#pragma once
 
 
 
/////////////
// GLOBALS //
/////////////
const int TEXTURE_REPEAT = 8;
 
class TextureClass;
 
 
class TerrainClass
{
private:
    struct VertexType
    {
        XMFLOAT3 position;
        XMFLOAT2 texture;
        XMFLOAT3 normal;
        XMFLOAT4 color;
    };
 
    struct HeightMapType 
    { 
        float x, y, z;
        float tu, tv;
        float nx, ny, nz;
        float r, g, b;
    };
 
    struct VectorType 
    { 
        float x, y, z;
    };
 
public:
    TerrainClass();
    TerrainClass(const TerrainClass&);
    ~TerrainClass();
 
    bool Initialize(ID3D11Device*const char*const WCHAR*const char*);
    void Shutdown();
    void Render(ID3D11DeviceContext*);
 
    int GetIndexCount();
    ID3D11ShaderResourceView* GetTexture();
    void GetTerrainSize(int&int&);
 
private:
    bool LoadHeightMap(const char*);
    void NormalizeHeightMap();
    bool CalculateNormals();
    void ShutdownHeightMap();
 
    void CalculateTextureCoordinates();
    bool LoadTexture(ID3D11Device*const WCHAR*);
    void ReleaseTexture();
 
    bool LoadColorMap(const char*);
 
    bool InitializeBuffers(ID3D11Device*);
    void ShutdownBuffers();
    void RenderBuffers(ID3D11DeviceContext*);
    
private:
    int m_terrainWidth = 0;
    int m_terrainHeight = 0;
    int m_vertexCount = 0;
    int m_indexCount = 0;
    ID3D11Buffer* m_vertexBuffer = nullptr;
    ID3D11Buffer* m_indexBuffer = nullptr;
    HeightMapType* m_heightMap = nullptr;
    TextureClass* m_Texture = nullptr;
};
cs



Terrainclass.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
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
#include "stdafx.h"
#include "textureclass.h"
#include "terrainclass.h"
#include <stdio.h>
 
 
TerrainClass::TerrainClass()
{
}
 
 
TerrainClass::TerrainClass(const TerrainClass& other)
{
}
 
 
TerrainClass::~TerrainClass()
{
}
 
 
bool TerrainClass::Initialize(ID3D11Device* device, const char* heightMapFilename, const WCHAR* textureFilename,
 const char* colorMapFilename)
{
    // 지형의 높이 맵을 로드합니다.
    if(!LoadHeightMap(heightMapFilename))
    {
        return false;
    }
 
    // 높이 맵의 높이를 표준화합니다.
    NormalizeHeightMap();
 
    // 지형 데이터의 법선을 계산합니다.
    if(!CalculateNormals())
    {
        return false;
    }
 
    // 텍스처 좌표를 계산합니다.
    CalculateTextureCoordinates();
 
    // 텍스처를 로드합니다.
    if(!LoadTexture(device, textureFilename))
    {
        return false;
    }
 
    // 컬러 맵을 지형에 로드합니다.
    if(!LoadColorMap(colorMapFilename))
    {
        return false;
    }
 
    // 지형에 대한 지오 메트릭을 포함하는 정점 및 인덱스 버퍼를 초기화합니다.
    return InitializeBuffers(device);
}
 
 
void TerrainClass::Shutdown()
{
    // 텍스처를 해제합니다.
    ReleaseTexture();
 
    // 버텍스와 인덱스 버퍼를 해제합니다.
    ShutdownBuffers();
 
    // 높이맵 데이터를 해제합니다.
    ShutdownHeightMap();
}
 
 
void TerrainClass::Render(ID3D11DeviceContext* deviceContext)
{
    // 그리기를 준비하기 위해 그래픽 파이프 라인에 꼭지점과 인덱스 버퍼를 놓습니다.
    RenderBuffers(deviceContext);
}
 
 
int TerrainClass::GetIndexCount()
{
    return m_indexCount;
}
 
 
ID3D11ShaderResourceView* TerrainClass::GetTexture()
{
    return m_Texture->GetTexture();
}
 
 
bool TerrainClass::LoadHeightMap(const char* filename)
{
    // 바이너리 모드로 높이맵 파일을 엽니다.
    FILE* filePtr = nullptr;
    if(fopen_s(&filePtr, filename, "rb"!= 0)
    {
        return false;
    }
 
    // 파일 헤더를 읽습니다.
    BITMAPFILEHEADER bitmapFileHeader;
    if(fread(&bitmapFileHeader, sizeof(BITMAPFILEHEADER), 1, filePtr) != 1)
    {
        return false;
    }
 
    // 비트맵 정보 헤더를 읽습니다.
    BITMAPINFOHEADER bitmapInfoHeader;
    if(fread(&bitmapInfoHeader, sizeof(BITMAPINFOHEADER), 1, filePtr) != 1)
    {
        return false;
    }
 
    // 지형의 크기를 저장합니다.
    m_terrainWidth = bitmapInfoHeader.biWidth;
    m_terrainHeight = bitmapInfoHeader.biHeight;
 
    // 비트맵 이미지 데이터의 크기를 계산합니다.
    int imageSize = m_terrainWidth * m_terrainHeight * 3;
 
    // 비트맵 이미지 데이터에 메모리를 할당합니다.
    unsigned char* bitmapImage = new unsigned char[imageSize];
    if(!bitmapImage)
    {
        return false;
    }
 
    // 비트맵 데이터의 시작 부분으로 이동합니다.
    fseek(filePtr, bitmapFileHeader.bfOffBits, SEEK_SET);
 
    // 비트맵 이미지 데이터를 읽습니다.
    if(fread(bitmapImage, 1, imageSize, filePtr) != imageSize)
    {
        return false;
    }
 
    // 파일을 닫습니다.
    if(fclose(filePtr) != 0)
    {
        return false;
    }
 
    // 높이 맵 데이터를 저장할 구조체를 만듭니다.
    m_heightMap = new HeightMapType[m_terrainWidth * m_terrainHeight];
    if(!m_heightMap)
    {
        return false;
    }
 
    // 이미지 데이터 버퍼의 위치를 ​​초기화합니다.
    int k = 0;
 
    // 이미지 데이터를 높이 맵으로 읽어들입니다.
    for(int j=0; j<m_terrainHeight; j++)
    {
        for(int i=0; i<m_terrainWidth; i++)
        {
            unsigned char height = bitmapImage[k];
            
            int index = (m_terrainHeight * j) + i;
 
            m_heightMap[index].x = (float)i;
            m_heightMap[index].y = (float)height;
            m_heightMap[index].z = (float)j;
 
            k+=3;
        }
    }
 
    // 비트맵 이미지 데이터를 해제합니다.
    delete [] bitmapImage;
    bitmapImage = 0;
 
    return true;
}
 
 
void TerrainClass::NormalizeHeightMap()
{
    for(int j=0; j<m_terrainHeight; j++)
    {
        for(int i=0; i<m_terrainWidth; i++)
        {
            m_heightMap[(m_terrainHeight * j) + i].y /= 15.0f;
        }
    }
}
 
 
bool TerrainClass::CalculateNormals()
{
    int index1 = 0;
    int index2 = 0;
    int index3 = 0;
    int index = 0;
    int count = 0;
    float vertex1[3= { 0.f, 0.f, 0.f };
    float vertex2[3= { 0.f, 0.f, 0.f };
    float vertex3[3= { 0.f, 0.f, 0.f };
    float vector1[3= { 0.f, 0.f, 0.f };
    float vector2[3= { 0.f, 0.f, 0.f };
    float sum[3= { 0.f, 0.f, 0.f };
    float length = 0.0f;
 
 
    // 정규화되지 않은 법선 벡터를 저장할 임시 배열을 만듭니다.
    VectorType* normals = new VectorType[(m_terrainHeight-1* (m_terrainWidth-1)];
    if(!normals)
    {
        return false;
    }
 
    // 메쉬의 모든면을 살펴보고 법선을 계산합니다.
    for(int j=0; j<(m_terrainHeight-1); j++)
    {
        for(int i=0; i<(m_terrainWidth-1); i++)
        {
            index1 = (j * m_terrainHeight) + i;
            index2 = (j * m_terrainHeight) + (i+1);
            index3 = ((j+1* m_terrainHeight) + i;
 
            // 표면에서 세 개의 꼭지점을 가져옵니다.
            vertex1[0= m_heightMap[index1].x;
            vertex1[1= m_heightMap[index1].y;
            vertex1[2= m_heightMap[index1].z;
        
            vertex2[0= m_heightMap[index2].x;
            vertex2[1= m_heightMap[index2].y;
            vertex2[2= m_heightMap[index2].z;
        
            vertex3[0= m_heightMap[index3].x;
            vertex3[1= m_heightMap[index3].y;
            vertex3[2= m_heightMap[index3].z;
 
            // 표면의 두 벡터를 계산합니다.
            vector1[0= vertex1[0- vertex3[0];
            vector1[1= vertex1[1- vertex3[1];
            vector1[2= vertex1[2- vertex3[2];
            vector2[0= vertex3[0- vertex2[0];
            vector2[1= vertex3[1- vertex2[1];
            vector2[2= vertex3[2- vertex2[2];
 
            index = (j * (m_terrainHeight-1)) + i;
 
            // 이 두 법선에 대한 정규화되지 않은 값을 얻기 위해 두 벡터의 외적을 계산합니다.
            normals[index].x = (vector1[1* vector2[2]) - (vector1[2* vector2[1]);
            normals[index].y = (vector1[2* vector2[0]) - (vector1[0* vector2[2]);
            normals[index].z = (vector1[0* vector2[1]) - (vector1[1* vector2[0]);
        }
    }
 
    // 이제 모든 정점을 살펴보고 각면의 평균을 취합니다.     
    // 정점이 닿아 그 정점에 대한 평균 평균값을 얻는다.
    for(int j=0; j<m_terrainHeight; j++)
    {
        for(int i=0; i<m_terrainWidth; i++)
        {
            // 합계를 초기화합니다.
            sum[0= 0.0f;
            sum[1= 0.0f;
            sum[2= 0.0f;
 
            // 카운트를 초기화합니다.
            count = 0;
 
            // 왼쪽 아래면.
            if(((i-1>= 0&& ((j-1>= 0))
            {
                index = ((j-1* (m_terrainHeight-1)) + (i-1);
 
                sum[0+= normals[index].x;
                sum[1+= normals[index].y;
                sum[2+= normals[index].z;
                count++;
            }
 
            // 오른쪽 아래 면.
            if((i < (m_terrainWidth-1)) && ((j-1>= 0))
            {
                index = ((j-1* (m_terrainHeight-1)) + i;
 
                sum[0+= normals[index].x;
                sum[1+= normals[index].y;
                sum[2+= normals[index].z;
                count++;
            }
 
            // 왼쪽 위 면.
            if(((i-1>= 0&& (j < (m_terrainHeight-1)))
            {
                index = (j * (m_terrainHeight-1)) + (i-1);
 
                sum[0+= normals[index].x;
                sum[1+= normals[index].y;
                sum[2+= normals[index].z;
                count++;
            }
 
            // 오른쪽 위 면.
            if((i < (m_terrainWidth-1)) && (j < (m_terrainHeight-1)))
            {
                index = (j * (m_terrainHeight-1)) + i;
 
                sum[0+= normals[index].x;
                sum[1+= normals[index].y;
                sum[2+= normals[index].z;
                count++;
            }
            
            // 이 정점에 닿는면의 평균을 취합니다.
            sum[0= (sum[0/ (float)count);
            sum[1= (sum[1/ (float)count);
            sum[2= (sum[2/ (float)count);
 
            // 이 법선의 길이를 계산합니다.
            length = (float)sqrt((sum[0* sum[0]) + (sum[1* sum[1]) + (sum[2* sum[2]));
            
            // 높이 맵 배열의 정점 위치에 대한 인덱스를 가져옵니다.
            index = (j * m_terrainHeight) + i;
 
            // 이 정점의 최종 공유 법선을 표준화하여 높이 맵 배열에 저장합니다.
            m_heightMap[index].nx = (sum[0/ length);
            m_heightMap[index].ny = (sum[1/ length);
            m_heightMap[index].nz = (sum[2/ length);
        }
    }
 
    // 임시 법선을 해제합니다.
    delete [] normals;
    normals = 0;
 
    return true;
}
 
 
void TerrainClass::ShutdownHeightMap()
{
    if(m_heightMap)
    {
        delete [] m_heightMap;
        m_heightMap = 0;
    }
}
 
 
void TerrainClass::CalculateTextureCoordinates()
{
    // 텍스처 좌표를 얼마나 많이 증가 시킬지 계산합니다.
    float incrementValue = (float)TEXTURE_REPEAT / (float)m_terrainWidth;
 
    // 텍스처를 반복 할 횟수를 계산합니다.
    int incrementCount = m_terrainWidth / TEXTURE_REPEAT;
 
    // tu 및 tv 좌표 값을 초기화합니다.
    float tuCoordinate = 0.0f;
    float tvCoordinate = 1.0f;
 
    //  tu 및 tv 좌표 인덱스를 초기화합니다.
    int tuCount = 0;
    int tvCount = 0;
 
    // 전체 높이 맵을 반복하고 각 꼭지점의 tu 및 tv 텍스처 좌표를 계산합니다.
    for(int j=0; j<m_terrainHeight; j++)
    {
        for(int i=0; i<m_terrainWidth; i++)
        {
            // 높이 맵에 텍스처 좌표를 저장한다.
            m_heightMap[(m_terrainHeight * j) + i].tu = tuCoordinate;
            m_heightMap[(m_terrainHeight * j) + i].tv = tvCoordinate;
 
            // tu 텍스처 좌표를 증가 값만큼 증가시키고 인덱스를 1 씩 증가시킨다.
            tuCoordinate += incrementValue;
            tuCount++;
 
            // 텍스처의 오른쪽 끝에 있는지 확인하고, 그렇다면 처음부터 다시 시작하십시오.
            if(tuCount == incrementCount)
            {
                tuCoordinate = 0.0f;
                tuCount = 0;
            }
        }
 
        // tv 텍스처 좌표를 증가 값만큼 증가시키고 인덱스를 1 씩 증가시킵니다.
        tvCoordinate -= incrementValue;
        tvCount++;
 
        // 텍스처의 상단에 있는지 확인하고, 그렇다면 하단에서 다시 시작합니다.
        if(tvCount == incrementCount)
        {
            tvCoordinate = 1.0f;
            tvCount = 0;
        }
    }
}
 
 
bool TerrainClass::LoadTexture(ID3D11Device* device, const WCHAR* filename)
{
    // 텍스처 객체를 생성합니다.
    m_Texture = new TextureClass;
    if(!m_Texture)
    {
        return false;
    }
 
    // 텍스처 오브젝트를 초기화한다.
    return m_Texture->Initialize(device, filename);
}
 
 
void TerrainClass::ReleaseTexture()
{
    //텍스처 객체를 해제합니다.
    if(m_Texture)
    {
        m_Texture->Shutdown();
        delete m_Texture;
        m_Texture = 0;
    }
}
 
 
bool TerrainClass::LoadColorMap(const char* filename)
{
    FILE* filePtr = nullptr;
 
    // 바이너리로 컬러 맵 파일을 엽니다.
    if(fopen_s(&filePtr, filename, "rb"!= 0)
    {
        return false;
    }
 
    // 파일 헤더를 읽습니다.
    BITMAPFILEHEADER bitmapFileHeader;
    if(fread(&bitmapFileHeader, sizeof(BITMAPFILEHEADER), 1, filePtr) != 1)
    {
        return false;
    }
 
    // 비트맵 정보 헤더를 읽습니다.
    BITMAPINFOHEADER bitmapInfoHeader;
    if(fread(&bitmapInfoHeader, sizeof(BITMAPINFOHEADER), 1, filePtr) != 1)
    {
        return false;
    }
 
    // 컬러 맵 치수가 쉬운 1 : 1 매핑을위한 지형 치수와 동일한지 확인하십시오.
    int colorMapWidth = bitmapInfoHeader.biWidth;
    int colorMapHeight = bitmapInfoHeader.biHeight;
 
    if((colorMapWidth != m_terrainWidth) || (colorMapHeight != m_terrainHeight))
    {
        return false;
    }
 
    // 비트맵 이미지 데이터의 크기를 계산합니다.
    int imageSize = colorMapWidth * colorMapHeight * 3;
 
    // 비트맵 이미지 데이터에 메모리를 할당합니다.
    unsigned char* bitmapImage = new unsigned char[imageSize];
    if(!bitmapImage)
    {
        return false;
    }
 
    // 비트맵 데이터의 시작 부분으로 이동합니다.
    fseek(filePtr, bitmapFileHeader.bfOffBits, SEEK_SET);
 
    // 비트맵 이미지 데이터를 읽습니다.
    if(fread(bitmapImage, 1, imageSize, filePtr) != imageSize)
    {
        return false;
    }
 
    // 파일을 닫습니다.
    if(fclose(filePtr) != 0)
    {
        return false;
    }
 
    // 이미지 데이터 버퍼의 위치를 ​​초기화합니다.
    int k=0;
 
    // 이미지 데이터를 높이 맵 구조의 색상 맵 부분으로 읽습니다.
    for(int j=0; j<colorMapHeight; j++)
    {
        for(int i=0; i<colorMapWidth; i++)
        {
            int index = (colorMapHeight * j) + i;
 
            m_heightMap[index].b = (float)bitmapImage[k]   / 255.0f;
            m_heightMap[index].g = (float)bitmapImage[k+1/ 255.0f;
            m_heightMap[index].r = (float)bitmapImage[k+2/ 255.0f;
 
            k+=3;
        }
    }
 
    // 비트맵 이미지 데이터를 해제합니다.
    delete [] bitmapImage;
    bitmapImage = 0;
 
    return true;
}
 
 
bool TerrainClass::InitializeBuffers(ID3D11Device* device)
{
    float tu = 0.0f;
    float tv = 0.0f;
 
    // 지형 메쉬의 정점 수를 계산합니다.
    m_vertexCount = (m_terrainWidth - 1* (m_terrainHeight - 1* 6;
 
    // 인덱스 수를 꼭지점 수와 같게 설정합니다.
    m_indexCount = m_vertexCount;
 
    // 정점 배열을 만듭니다.
    VertexType* vertices = new VertexType[m_vertexCount];
    if(!vertices)
    {
        return false;
    }
 
    // 인덱스 배열을 만듭니다.
    unsigned long* indices = new unsigned long[m_indexCount];
    if(!indices)
    {
        return false;
    }
 
    // 정점 배열에 대한 인덱스를 초기화합니다.
    int index = 0;
 
    // 지형 데이터로 정점 및 인덱스 배열을 로드합니다.
    for(int j=0; j<(m_terrainHeight-1); j++)
    {
        for(int i=0; i<(m_terrainWidth-1); i++)
        {
            int index1 = (m_terrainHeight * j) + i;          // 왼쪽 아래.
            int index2 = (m_terrainHeight * j) + (i+1);      // 오른쪽 아래.
            int index3 = (m_terrainHeight * (j+1)) + i;      // 왼쪽 위.
            int index4 = (m_terrainHeight * (j+1)) + (i+1);  // 오른쪽 위.
 
            // 왼쪽 위.
            tv = m_heightMap[index3].tv;
 
            // 상단 가장자리를 덮도록 텍스처 좌표를 수정합니다.
            if(tv == 1.0f) { tv = 0.0f; }
 
            vertices[index].position = XMFLOAT3(m_heightMap[index3].x, m_heightMap[index3].y, m_heightMap[index3].z);
            vertices[index].texture = XMFLOAT2(m_heightMap[index3].tu, tv);
            vertices[index].normal = XMFLOAT3(m_heightMap[index3].nx, m_heightMap[index3].ny, m_heightMap[index3].nz);
            vertices[index].color = XMFLOAT4(m_heightMap[index3].r, m_heightMap[index3].g, m_heightMap[index3].b, 1.0f);
            indices[index] = index;
            index++;
 
            // 오른쪽 위.
            tu = m_heightMap[index4].tu;
            tv = m_heightMap[index4].tv;
 
            // 위쪽과 오른쪽 가장자리를 덮도록 텍스처 좌표를 수정합니다.
            if(tu == 0.0f) { tu = 1.0f; }
            if(tv == 1.0f) { tv = 0.0f; }
 
            vertices[index].position = XMFLOAT3(m_heightMap[index4].x, m_heightMap[index4].y, m_heightMap[index4].z);
            vertices[index].texture = XMFLOAT2(tu, tv);
            vertices[index].normal = XMFLOAT3(m_heightMap[index4].nx, m_heightMap[index4].ny, m_heightMap[index4].nz);
            vertices[index].color = XMFLOAT4(m_heightMap[index4].r, m_heightMap[index4].g, m_heightMap[index4].b, 1.0f);
            indices[index] = index;
            index++;
 
            // 왼쪽 아래.
            vertices[index].position = XMFLOAT3(m_heightMap[index1].x, m_heightMap[index1].y, m_heightMap[index1].z);
            vertices[index].texture = XMFLOAT2(m_heightMap[index1].tu, m_heightMap[index1].tv);
            vertices[index].normal = XMFLOAT3(m_heightMap[index1].nx, m_heightMap[index1].ny, m_heightMap[index1].nz);
            vertices[index].color = XMFLOAT4(m_heightMap[index1].r, m_heightMap[index1].g, m_heightMap[index1].b, 1.0f);
            indices[index] = index;
            index++;
 
            // 왼쪽 아래.
            vertices[index].position = XMFLOAT3(m_heightMap[index1].x, m_heightMap[index1].y, m_heightMap[index1].z);
            vertices[index].texture = XMFLOAT2(m_heightMap[index1].tu, m_heightMap[index1].tv);
            vertices[index].normal = XMFLOAT3(m_heightMap[index1].nx, m_heightMap[index1].ny, m_heightMap[index1].nz);
            vertices[index].color = XMFLOAT4(m_heightMap[index1].r, m_heightMap[index1].g, m_heightMap[index1].b, 1.0f);
            indices[index] = index;
            index++;
 
            // 오른쪽 위.
            tu = m_heightMap[index4].tu;
            tv = m_heightMap[index4].tv;
 
            // 위쪽과 오른쪽 가장자리를 덮도록 텍스처 좌표를 수정합니다.
            if(tu == 0.0f) { tu = 1.0f; }
            if(tv == 1.0f) { tv = 0.0f; }
 
            vertices[index].position = XMFLOAT3(m_heightMap[index4].x, m_heightMap[index4].y, m_heightMap[index4].z);
            vertices[index].texture = XMFLOAT2(tu, tv);
            vertices[index].normal = XMFLOAT3(m_heightMap[index4].nx, m_heightMap[index4].ny, m_heightMap[index4].nz);
            vertices[index].color = XMFLOAT4(m_heightMap[index4].r, m_heightMap[index4].g, m_heightMap[index4].b, 1.0f);
            indices[index] = index;
            index++;
 
            // 오른쪽 아래.
            tu = m_heightMap[index2].tu;
 
            // 오른쪽 가장자리를 덮도록 텍스처 좌표를 수정합니다.
            if(tu == 0.0f) { tu = 1.0f; }
 
            vertices[index].position = XMFLOAT3(m_heightMap[index2].x, m_heightMap[index2].y, m_heightMap[index2].z);
            vertices[index].texture = XMFLOAT2(tu, m_heightMap[index2].tv);
            vertices[index].normal = XMFLOAT3(m_heightMap[index2].nx, m_heightMap[index2].ny, m_heightMap[index2].nz);
            vertices[index].color = XMFLOAT4(m_heightMap[index2].r, m_heightMap[index2].g, m_heightMap[index2].b, 1.0f);
            indices[index] = index;
            index++;            
        }
    }
 
    // 정적 정점 버퍼의 구조체를 설정한다.
    D3D11_BUFFER_DESC vertexBufferDesc;
    vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_vertexCount;
    vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vertexBufferDesc.CPUAccessFlags = 0;
    vertexBufferDesc.MiscFlags = 0;
    vertexBufferDesc.StructureByteStride = 0;
 
    // subresource 구조에 정점 데이터에 대한 포인터를 제공합니다.
    D3D11_SUBRESOURCE_DATA vertexData;
    vertexData.pSysMem = vertices;
    vertexData.SysMemPitch = 0;
    vertexData.SysMemSlicePitch = 0;
 
    // 이제 정점 버퍼를 만듭니다.
    if(FAILED(device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer)))
    {
        return false;
    }
 
    // 정적 인덱스 버퍼의 구조체를 설정합니다.
    D3D11_BUFFER_DESC indexBufferDesc;
    indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    indexBufferDesc.ByteWidth = sizeof(unsigned long* m_indexCount;
    indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
    indexBufferDesc.CPUAccessFlags = 0;
    indexBufferDesc.MiscFlags = 0;
    indexBufferDesc.StructureByteStride = 0;
 
    // 하위 리소스 구조에 인덱스 데이터에 대한 포인터를 제공합니다.
    D3D11_SUBRESOURCE_DATA indexData;
    indexData.pSysMem = indices;
    indexData.SysMemPitch = 0;
    indexData.SysMemSlicePitch = 0;
 
    // 인덱스 버퍼를 만듭니다.
    if(FAILED(device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer)))
    {
        return false;
    }
 
    // 이제 버퍼가 생성되고 로드된 배열을 해제하십시오.
    delete [] vertices;
    vertices = 0;
 
    delete [] indices;
    indices = 0;
 
    return true;
}
 
 
void TerrainClass::ShutdownBuffers()
{
    // 인덱스 버퍼를 해제합니다.
    if(m_indexBuffer)
    {
        m_indexBuffer->Release();
        m_indexBuffer = 0;
    }
 
    // 버텍스 버퍼를 해제합니다.
    if(m_vertexBuffer)
    {
        m_vertexBuffer->Release();
        m_vertexBuffer = 0;
    }
}
 
 
void TerrainClass::RenderBuffers(ID3D11DeviceContext* deviceContext)
{
    // 정점 버퍼 보폭 및 오프셋을 설정합니다.
    unsigned int stride = sizeof(VertexType); 
    unsigned int offset = 0;
    
    // 렌더링 할 수 있도록 입력 어셈블러에서 정점 버퍼를 활성으로 설정합니다.
    deviceContext->IASetVertexBuffers(01&m_vertexBuffer, &stride, &offset);
 
    // 렌더링 할 수 있도록 입력 어셈블러에서 인덱스 버퍼를 활성으로 설정합니다.
    deviceContext->IASetIndexBuffer(m_indexBuffer, DXGI_FORMAT_R32_UINT, 0);
 
    // 이 꼭지점 버퍼에서 렌더링 되어야 하는 프리미티브 유형을 설정합니다. 이 경우에는 삼각형입니다.
    deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
}
 
 
void TerrainClass::GetTerrainSize(int& width, int& height)
{
    // 지형 사이즈를 반환합니다.
    width = m_terrainWidth;
    height = m_terrainHeight;
}
cs




Applicationclass.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
55
56
57
58
59
#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 InputClass;
class CameraClass;
class TerrainClass;
 
class TimerClass;
class PositionClass;
class FpsClass;
class CpuClass;
class FontShaderClass;
class TextClass;
class TerrainShaderClass;
class LightClass;
class TextureShaderClass;
class MiniMapClass;
 
 
class ApplicationClass
{
public:
    ApplicationClass();
    ApplicationClass(const ApplicationClass&);
    ~ApplicationClass();
 
    bool Initialize(HINSTANCE, HWND, intint);
    void Shutdown();
    bool Frame();
 
private:
    bool HandleInput(float);
    bool RenderGraphics();
 
private:
    InputClass* m_Input = nullptr;
    D3DClass* m_Direct3D = nullptr;
    CameraClass* m_Camera = nullptr;
    TerrainClass* m_Terrain = nullptr;
    TimerClass* m_Timer = nullptr;
    PositionClass* m_Position = nullptr;
    FpsClass* m_Fps = nullptr;
    CpuClass* m_Cpu = nullptr;
    FontShaderClass* m_FontShader = nullptr;
    TextClass* m_Text = nullptr;
    TerrainShaderClass* m_TerrainShader = nullptr;
    LightClass* m_Light = nullptr;
    TextureShaderClass* m_TextureShader = nullptr;
    MiniMapClass* m_MiniMap = nullptr;
};
cs



Applicationclass.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
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
#include "stdafx.h"
#include "inputclass.h"
#include "d3dclass.h"
#include "cameraclass.h"
#include "terrainclass.h"
#include "timerclass.h"
#include "positionclass.h"
#include "fpsclass.h"
#include "cpuclass.h"
#include "fontshaderclass.h"
#include "textclass.h"
#include "terrainshaderclass.h"
#include "lightclass.h"
#include "textureshaderclass.h"
#include "minimapclass.h"
#include "ApplicationClass.h"
 
 
ApplicationClass::ApplicationClass()
{
}
 
 
ApplicationClass::ApplicationClass(const ApplicationClass& other)
{
}
 
 
ApplicationClass::~ApplicationClass()
{
}
 
 
bool ApplicationClass::Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int screenHeight)
{
    // 입력 개체를 생성합니다.
    m_Input = new InputClass;
    if(!m_Input)
    {
        return false;
    }
 
    // 입력 개체를 초기화 합니다.
    bool result = m_Input->Initialize(hinstance, hwnd, screenWidth, screenHeight);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the input object.", L"Error", MB_OK);
        return false;
    }
 
    // Direct3D 개체를 생성합니다.
    m_Direct3D = new D3DClass;
    if(!m_Direct3D)
    {
        return false;
    }
 
    // Direct3D 개체를 초기화 합니다.
    result = m_Direct3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize DirectX 11.", L"Error", MB_OK);
        return false;
    }
 
    // 카메라 객체를 생성합니다.
    m_Camera = new CameraClass;
    if(!m_Camera)
    {
        return false;
    }
 
    // 2D 사용자 인터페이스 렌더링을 위해 카메라로 기본 뷰 행렬을 초기화 합니다.
    XMMATRIX baseViewMatrix;
    m_Camera->SetPosition(XMFLOAT3(0.0f, 0.0f, -1.0f));
    m_Camera->Render();
    m_Camera->GetViewMatrix(baseViewMatrix);
 
    // 카메라의 초기 위치를 설정합니다.
    XMFLOAT3 camera = XMFLOAT3(50.0f, 2.0f, -7.0f);
    m_Camera->SetPosition(camera);
 
    // 지형 객체를 생성합니다.
    m_Terrain = new TerrainClass;
    if(!m_Terrain)
    {
        return false;
    }
 
    // 지형 객체를 초기화 합니다.
    result = m_Terrain->Initialize(m_Direct3D->GetDevice(), "../Dx11Terrain_08/data/heightmap01.bmp",
 L"../Dx11Terrain_08/data/dirt01.dds",
 "../Dx11Terrain_08/data/colorm01.bmp");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the terrain object.", L"Error", MB_OK);
        return false;
    }
 
    // 타이머 객체를 생성합니다.
    m_Timer = new TimerClass;
    if(!m_Timer)
    {
        return false;
    }
 
    // 타이머 객체를 초기화 합니다.
    result = m_Timer->Initialize();
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the timer object.", L"Error", MB_OK);
        return false;
    }
 
    // 위치 개체를 생성합니다.
    m_Position = new PositionClass;
    if(!m_Position)
    {
        return false;
    }
 
    // 뷰어의 초기 위치를 초기 카메라 위치와 동일하게 설정합니다.
    m_Position->SetPosition(camera);
 
    // fps 객체를 생성합니다.
    m_Fps = new FpsClass;
    if(!m_Fps)
    {
        return false;
    }
 
    // fps 객체를 초기화 합니다.
    m_Fps->Initialize();
 
    // cpu 객체를 생성합니다.
    m_Cpu = new CpuClass;
    if(!m_Cpu)
    {
        return false;
    }
 
    // cpu 객체를 초기화 합니다.
    m_Cpu->Initialize();
 
    // 폰트 셰이더 객체를 생성합니다.
    m_FontShader = new FontShaderClass;
    if(!m_FontShader)
    {
        return false;
    }
 
    // 폰트 셰이더 객체를 초기화 합니다.
    result = m_FontShader->Initialize(m_Direct3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the font shader object.", L"Error", MB_OK);
        return false;
    }
 
    // 텍스트 객체를 생성합니다.
    m_Text = new TextClass;
    if(!m_Text)
    {
        return false;
    }
 
    // 텍스트 객체를 초기화 합니다.
    result = m_Text->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), hwnd, screenWidth, screenHeight,
 baseViewMatrix);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the text object.", L"Error", MB_OK);
        return false;
    }
 
    // 비디오 카드 정보를 가져옵니다.
    char videoCard[128= { 0, };
    int videoMemory = 0;
    m_Direct3D->GetVideoCardInfo(videoCard, videoMemory);
 
    // 텍스트 객체에 비디오 카드 정보를 설정합니다.
    result = m_Text->SetVideoCardInfo(videoCard, videoMemory, m_Direct3D->GetDeviceContext());
    if(!result)
    {
        MessageBox(hwnd, L"Could not set video card info in the text object.", L"Error", MB_OK);
        return false;
    }
 
    // 지형 쉐이더 객체를 생성합니다.
    m_TerrainShader = new TerrainShaderClass;
    if(!m_TerrainShader)
    {
        return false;
    }
 
    // 지형 쉐이더 객체를 초기화 합니다.
    result = m_TerrainShader->Initialize(m_Direct3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the terrain shader object.", L"Error", MB_OK);
        return false;
    }
 
    // 조명 객체를 생성합니다.
    m_Light = new LightClass;
    if(!m_Light)
    {
        return false;
    }
 
    // 조명 객체를 초기화 합니다.
    m_Light->SetAmbientColor(XMFLOAT4(0.05f, 0.05f, 0.05f, 1.0f));
    m_Light->SetDiffuseColor(XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f));
    m_Light->SetDirection(XMFLOAT3(-0.5f, -1.0f, 0.0f));
 
    // 텍스처 쉐이더 객체를 생성합니다.
    m_TextureShader = new TextureShaderClass;
    if(!m_TextureShader)
    {
        return false;
    }
 
    // 텍스처 쉐이더 객체를 초기화 합니다.
    result = m_TextureShader->Initialize(m_Direct3D->GetDevice(), hwnd);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the texture shader object.", L"Error", MB_OK);
        return false;
    }
 
    // 미니맵에서 이 정보가 필요하기 때문에 지형의 크기를 가져옵니다.
    int terrainWidth = 0;
    int terrainHeight = 0;
    m_Terrain->GetTerrainSize(terrainWidth, terrainHeight);
 
    // 미니맵 객체를 생성합니다.
    m_MiniMap = new MiniMapClass;
    if(!m_MiniMap)
    {
        return false;
    }
 
    // 미니맵 객체를 초기화 합니다.
    result = m_MiniMap->Initialize(m_Direct3D->GetDevice(), hwnd, screenWidth, screenHeight, baseViewMatrix,
 (float)(terrainWidth - 1), (float)(terrainHeight - 1));
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the mini map object.", L"Error", MB_OK);
        return false;
    }
 
    return true;
}
 
 
void ApplicationClass::Shutdown()
{
    // 미니맵 객체를 해제합니다.
    if(m_MiniMap)
    {
        m_MiniMap->Shutdown();
        delete m_MiniMap;
        m_MiniMap = 0;
    }
 
    // 텍스처 쉐이더를 해제합니다.
    if(m_TextureShader)
    {
        m_TextureShader->Shutdown();
        delete m_TextureShader;
        m_TextureShader = 0;
    }
 
    // 조명 객체를 해제합니다.
    if(m_Light)
    {
        delete m_Light;
        m_Light = 0;
    }
 
    // 지형 쉐이더 객체를 해제합니다.
    if(m_TerrainShader)
    {
        m_TerrainShader->Shutdown();
        delete m_TerrainShader;
        m_TerrainShader = 0;
    }
 
    // 텍스트 객체를 해제합니다.
    if(m_Text)
    {
        m_Text->Shutdown();
        delete m_Text;
        m_Text = 0;
    }
 
    // 폰트 쉐이더 객체를 해제합니다..
    if(m_FontShader)
    {
        m_FontShader->Shutdown();
        delete m_FontShader;
        m_FontShader = 0;
    }
 
    // cpu 객체를 해제합니다.
    if(m_Cpu)
    {
        m_Cpu->Shutdown();
        delete m_Cpu;
        m_Cpu = 0;
    }
 
    // fps 객체를 해제합니다.
    if(m_Fps)
    {
        delete m_Fps;
        m_Fps = 0;
    }
 
    // 위치 객체를 해제합니다.
    if(m_Position)
    {
        delete m_Position;
        m_Position = 0;
    }
 
    // 타이머 객체를 해제합니다.
    if(m_Timer)
    {
        delete m_Timer;
        m_Timer = 0;
    }
 
    // 지형 객체를 해제합니다.
    if(m_Terrain)
    {
        m_Terrain->Shutdown();
        delete m_Terrain;
        m_Terrain = 0;
    }
 
    // 카메라 객체를 해제합니다.
    if(m_Camera)
    {
        delete m_Camera;
        m_Camera = 0;
    }
 
    // D3D 객체를 해제합니다.
    if (m_Direct3D)
    {
        m_Direct3D->Shutdown();
        delete m_Direct3D;
        m_Direct3D = 0;
    }
 
    // 입력 객체를 해제합니다.
    if(m_Input)
    {
        m_Input->Shutdown();
        delete m_Input;
        m_Input = 0;
    }
}
 
 
bool ApplicationClass::Frame()
{
    // 사용자 입력을 읽습니다.
    bool result = m_Input->Frame();
    if(!result)
    {
        return false;
    }
    
    // 사용자가 ESC를 눌렀을 때 응용 프로그램을 종료 할 것인지 확인합니다.
    if(m_Input->IsEscapePressed() == true)
    {
        return false;
    }
 
    // 시스템 통계를 업데이트 합니다.
    m_Timer->Frame();
    m_Fps->Frame();
    m_Cpu->Frame();
 
    // 텍스트 개체에서 FPS 값을 업데이트 합니다.
    result = m_Text->SetFps(m_Fps->GetFps(), m_Direct3D->GetDeviceContext());
    if(!result)
    {
        return false;
    }
    
    // 텍스트 개체의 CPU 사용값을 업데이트 합니다.
    result = m_Text->SetCpu(m_Cpu->GetCpuPercentage(), m_Direct3D->GetDeviceContext());
    if(!result)
    {
        return false;
    }
 
    // 프레임 입력 처리를 수행합니다.
    result = HandleInput(m_Timer->GetTime());
    if(!result)
    {
        return false;
    }
 
    // 그래픽을 렌더링 합니다.
    result = RenderGraphics();
    if(!result)
    {
        return false;
    }
 
    return result;
}
 
 
bool ApplicationClass::HandleInput(float frameTime)
{
    XMFLOAT3 pos = XMFLOAT3(0.0f, 0.0f, 0.0f);
    XMFLOAT3 rot = XMFLOAT3(0.0f, 0.0f, 0.0f);
 
 
    // 갱신된 위치를 계산하기 위한 프레임 시간을 설정합니다.
    m_Position->SetFrameTime(frameTime);
 
    // 입력을 처리합니다.
    m_Position->TurnLeft(m_Input->IsLeftPressed());
    m_Position->TurnRight(m_Input->IsRightPressed());
    m_Position->MoveForward(m_Input->IsUpPressed());
    m_Position->MoveBackward(m_Input->IsDownPressed());
    m_Position->MoveUpward(m_Input->IsAPressed());
    m_Position->MoveDownward(m_Input->IsZPressed());
    m_Position->LookUpward(m_Input->IsPgUpPressed());
    m_Position->LookDownward(m_Input->IsPgDownPressed());
    
    // 시점 위치 / 회전을 가져옵니다.
    m_Position->GetPosition(pos);
    m_Position->GetRotation(rot);
 
    // 카메라의 위치를 ​​설정합니다.
    m_Camera->SetPosition(pos);
    m_Camera->SetRotation(rot);
 
    // 텍스트 개체의 위치 값을 업데이트 합니다.
    if(!m_Text->SetCameraPosition(pos, m_Direct3D->GetDeviceContext()))
    {
        return false;
    }
 
    // 텍스트 객체의 회전 값을 업데이트 합니다.
    if(!m_Text->SetCameraRotation(rot, m_Direct3D->GetDeviceContext()))
    {
        return false;
    }
 
    // 미니 맵에서 카메라의 위치를 ​​업데이트 합니다.
    m_MiniMap->PositionUpdate(pos.x, pos.z);
 
    return true;
}
 
 
bool ApplicationClass::RenderGraphics()
{
    XMMATRIX worldMatrix, viewMatrix, projectionMatrix, orthoMatrix;
 
    // 장면을 지웁니다.
    m_Direct3D->BeginScene(0.0f, 0.0f, 0.0f, 1.0f);
 
    // 카메라의 위치에 따라 뷰 행렬을 생성합니다.
    m_Camera->Render();
 
    // 카메라 및 Direct3D 객체에서 월드, 뷰, 투영 및 ortho 행렬을 가져옵니다.
    m_Direct3D->GetWorldMatrix(worldMatrix);
    m_Camera->GetViewMatrix(viewMatrix);
    m_Direct3D->GetProjectionMatrix(projectionMatrix);
    m_Direct3D->GetOrthoMatrix(orthoMatrix);
 
    // 지형 버퍼를 렌더링 합니다.
    m_Terrain->Render(m_Direct3D->GetDeviceContext());
 
    // 지형 쉐이더를 사용하여 모델을 렌더링 합니다.
    if(!m_TerrainShader->Render(m_Direct3D->GetDeviceContext(), m_Terrain->GetIndexCount(), worldMatrix, viewMatrix,
 projectionMatrix, m_Light->GetAmbientColor(), m_Light->GetDiffuseColor(),
 m_Light->GetDirection(), m_Terrain->GetTexture()))
    {
        return false;
    }
 
    // 모든 2D 렌더링을 시작하려면 Z 버퍼를 끕니다.
    m_Direct3D->TurnZBufferOff();
    
    // 미니맵을 렌더링 합니다.
    if(!m_MiniMap->Render(m_Direct3D->GetDeviceContext(), worldMatrix, orthoMatrix, m_TextureShader))
    {
        return false;
    }
 
    // 텍스트를 렌더링하기 전에 알파 블렌딩을 켭니다.
    m_Direct3D->TurnOnAlphaBlending();
 
    // 텍스트 사용자 인터페이스 요소를 렌더링 합니다.
    if(!m_Text->Render(m_Direct3D->GetDeviceContext(), m_FontShader, worldMatrix, orthoMatrix))
    {
        return false;
    }
 
    // 텍스트를 렌더링 한 후 알파 블렌딩을 끕니다.
    m_Direct3D->TurnOffAlphaBlending();
 
    // 모든 2D 렌더링이 완료되었으므로 Z 버퍼를 다시 켭니다.
    m_Direct3D->TurnZBufferOn();
 
    // 렌더링 된 장면을 화면에 표시합니다.
    m_Direct3D->EndScene();
 
    return true;
}
cs



출력 화면




마치면서


우리는 이제 3D 지형에서 사용자의 현재 위치를 나타내는 녹색 픽셀을 가진 미니 맵을 갖게 되었습니다.


연습문제


1. 프로그램을 컴파일하고 실행하십시오. 지형을 따라 이동하면 초록색 픽셀이 미니 맵에서 현재 위치를 표시합니다.


2. 미니 맵 2D 렌더링을 화면의 다른 위치로 이동하십시오.


3. 미니 맵에 대한 경계와 표시기를 만듭니다.



소스코드


소스코드 : Dx11Terrain_08.zip