DirectX11 Tutorial 11 - Direct Input(개인공부)

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>

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

 

<InputClass.h>

#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_

 

<InputClass.cpp>

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

 

<TextClass.h>

#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_
 

 

<TextClass.cpp>

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

 

<GraphicsClass.h>

#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_

 

<GraphicsClass.cpp>

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

 

<SystemClass.cpp>

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

<결과>

<소스코드>

https://github.com/woonhak-kong/DirectX_11_Tutorial/releases/tag/Tutorial_11