[DirectX 11] Terrain 08 - 지형 미니맵

Terrain 08 - 지형 미니맵

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

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

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

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

Minimapclass.h

#pragma once
 
 
class BitmapClass;
class TextureShaderClass;
 
 
class MiniMapClass
{
public:
    MiniMapClass();
    MiniMapClass(const MiniMapClass&);
    ~MiniMapClass();
 
    bool Initialize(ID3D11Device*, HWND, int, int, XMMATRIX, float, float);
    void Shutdown();
    bool Render(ID3D11DeviceContext*, XMMATRIX, XMMATRIX, TextureShaderClass*);
    
    void PositionUpdate(float, float);
 
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;
};

Minimapclass.cpp

#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",
                                              150, 150);
    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", 154, 154);
    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", 3, 3);
    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;
}

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

Terrainclass.h

#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;
};

Terrainclass.cpp

#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(0, 1, &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;
}

Applicationclass.h

#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, int, int);
    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;
};

Applicationclass.cpp

#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;
}

출력 화면

마치면서

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

연습문제

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

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

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

소스코드

소스코드 : Dx11Terrain_08.zip