[winAPI 03] Core class & Singleton

🧐 Study/winAPI

[winAPI 03] Core class & Singleton

GAMEMING 2024. 4. 8. 05:26

코어(Core)는 말그대로 중심이라는 의미로 주요한 기능을 제공하고 전반적인 프로그램 구조를 정의하며 싱글톤(singleton)은 클래스의 인스턴스가 단 하나만 생성되도록 보장하는 소프트웨어 패턴이다. 우리가 프로그램을 만들 때 코어 클래스의 객체가 중심이 될 것이기에 이 객체는 여러 개일 수가 없어 싱글톤 패턴으로 구현하고자 한다.

- Core class ( 동적할당 Heap 영역 사용 )

// Core.h
class Core {
private:  
	static Core* pInst;  
	
	Core();
	~Core();

public:
	static Core* Instance()   
	{
		if (pInst == nullptr) {
			return new Core; 
		}
		return pInst; 
	}

	static void Release()
	{
		if (pInst != nullptr) {
			delete pInst;
			pInst = nullptr;
		}
	}

};


// Core.cpp
#include "Core.h"

Core* Core::pInst = nullptr; 


// main.cpp - wWinMain
 Core* pCore = Core::Instance();

우선 객체의 생성을 하나로 제한하려면 어떻게 해야 하는가?

→ 생성자와 소멸자는 private으로 선언해주면 된다. 오로직 멤버 함수로만 만들고 지우고 생성될 수 있게 한다.

어디서든 쉽게 접근하려면?

→ 자기 자신의 포인터를 반환하는 함수로 만들면 된다. 다만, 생성자와 소멸자가 private으로 선언될 경우 외부에서 객체를 만들 수 없게 된다(프라이빗이라 생성자로 접근이 불가능함). 객체가 없는데 멤버 함수와 멤버 변수에 접근이 가능한가?

→ No. 누가 함수를 호출했는지 알 수 없어(this가 없음) 접근이 불가능하다.

→ 멤버 없이 호출하려면 static(정적)으로 선언할 필요가 있다

→ 정적 멤버 함수는 내부 정적 멤버로만 접근할 수 있다.

정적(static) 변수 선언에 대하여

1. 함수 안에 선언 → data 영역 (함수가 종료되더라도 할당된 공간에 남아있음 -> 해당 함수에서만 접근 가능)
2. 파일 안에 선언 → data영역, 파일 안에서만 접근이 가능
3. 클래스 안에 선언 → data영역 / 클래스의 사이즈(크기)와는 상관 없게 , 클래스 내부에서만 접근 가능

→ 어디서든 만들더라도 데이터 영역에 있는 것

* 정적멤버는 무조건 클래스 외부에서 초기화 해줘야함 → 안하면 링크 오류

Core 클래스의 멤버 함수로 두 가지를 만들자

1. 인스턴스를 얻는 함수 ( static Core* Instance() )

자기 자신의 포인터형을 반환하는 Instance함수를 만든다

→ 최초 호출되는 경우 (pInst가 nullptr인 경우) : 동적으로 Core 객체 하나를 만들어 그 주소를 반환한다.

→ 2번 이상 호출인 경우 아무 것도 하지 않는다.

2. 해제하는 함수 ( static void Release() )

동적으로 사용한 객체는 해제가 필요하다. pInst가 nullptr이 아니라면(객체가 있다면) 메모리를 해제하고 그 공간은 nullptr로 바꾼다.

pInst는 Core.cpp에서 무조건 초기화한다.

- Core class ( Data영역 사용 )

class Core {
private:
	Core();                
	~Core();

public:
	static Core* Instance() {
		static Core core;
		return &core;
	}
};

간단하다. Core의 주소를 얻어서 접근하면 되는데 해제 할 필요가 없고 간단하다는 장점이 있지만, 단점으로는 프로그램 중간에 지울 수 없다는 사실이다. 보통 Manager에서 쓰이며 굳이 지울 필요 없을 때 많이 사용된다.

자주 사용하는 것들은 매크로로 정해두면 좋다우선 그 전에 미리 만들고 다시 살펴볼 경우가 없는 것들을 모아 pch.h로 만들고, 미리 컴파일 된 헤더로 만들어 놓자.미리 컴파일 된 헤더는 모든 cpp파일에 존재해야 하며 이를 사용하면 컴파일 속도를 올릴 수 있다.

// pch.h

#pragma once
#include <windows.h>

#include "define.h"

* 프로젝트의 속성 → C/C++ → 미리 컴파일된 헤더 → 맨 위의 설정 만들기 + 두 번째 헤더 파일 이름 설정

define.h 내부에 Core 클래스의 instance부분을 매크로로 지정한다.

#include "pch.h"

# define SINGLE(type) public:\
		static Core* Instance()\
		{\
		static Core mgr;\
		return &mgr;\
		}

여기서 백슬래쉬(\)는 매크로 내에서 한 줄 띄우는 것을 의미한다. public도 잊지말자.모든 cpp 파일 내에 pch.h를 추가했다면,위의 Core 클래스 파일에 아래와 같이 쓸 수 있다.

#pragma once
class Core {
	SINGLE(Core);
private:
	Core();                
	~Core();

public:
};

- Core class를 이용해서 해상도 설정과 사각형 그리기

본격적으로 Core class를 이용해 만들어보자.

// Core.class

class Core {
	SINGLE(Core);
private:
	HWND    handle;         
	POINT   ptResolution; 
	HDC     hDC;          

	Core();                
	~Core();

public:
	int Init(HWND _hWnd, POINT _ptResolution);
	void Progress();
};

Core 클래스 내부에 창 핸들을 받을 변수(handle)와, 해상도를 받을 변수(ptResolution)을 만든다, hDC는 그리기 위한 변수로 조금 이따가 밑에서 설명하겠다.

이 변수들은 모두 private으로 이 값들을 가지고 설정하기 위한 함수들은 public으로 설정한다.

#include "pch.h"
#include "Core.h"

Core::Core()
	:handle(0)
	, ptResolution{}
	, hDC(0)
{

}

Core::~Core()
{
	ReleaseDC(handle, hDC);
}

int Core::Init(HWND _handle, POINT _ptResolution)
{  
	handle = _handle;
	ptResolution = _ptResolution;

	RECT rt = {0, 0 , ptResolution.x, ptResolution.y };  
	AdjustWindowRect(&rt, WS_OVERLAPPEDWINDOW, true);
	SetWindowPos(handle, nullptr, 100, 100, rt.right - rt.left, rt.bottom - rt.top, 0);

	return S_OK;
}

void Core::Progress()
{

}

Core.cpp을 살펴보겠다. 우선 생성자에선 각 변수에 대한 초기화를, 소멸자에선 추후에 쓸 hDC를 해제하는 부분을 써준다.

Init()함수는 class 객체가 시작할 때 초기화해야 하는 부분을 넣은 함수다. 핸들 값(_handle)과 설정할 해상도 값(_ptResolution)을 매개변수로 받는다.

각 매개변수 값을 멤버 변수 handle와 ptResolution에 넣는다.

AdjustWindowRect() 함수는 윈도우가 실제로 그릴 수 있는 영역을 계산하는데, 메뉴바나 윈도우 창 주변으로 생겨있는 테두리 영역(8pixel 정도)를 제외한 영역을 의미한다. 각 매개변수의 의미는 다음과 같다.

IpRect : 윈도우의 크기와 위치를 지정하는 RECT 구조체에 대한 포인터
dwStyle : 윈도우의 스타일 (모양과 동작 - 테두리, 제목 표시줄, 크기 조정이 가능한지 등)
bMenu : 메뉴바

현재 RECT 구조체를 이용해서 윈도우 크기를 조정하며 SetWindowPos() 함수를 사용해 윈도우의 위치와 크기를 설정한다.

rt-right - rt.left 와 rt.bottom - rt.top은 각각 윈도우의 너비와 높이를 의미한다.

hWnd: 윈도우 핸들
hWndInsertAfter: 새로운 Z 순서를 설정
X: 윈도우의 x 좌표
Y: 윈도우의 y 좌표
cx: 윈도우의 너비
cy: 윈도우의 높이
uFlags: 윈도우 위치와 크기를 설정하는 데 사용되는 플래그

다음은 main을 수정해 반영해주어야 한다.

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);


    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_WINDOWSPROJECT, szWindowClass, MAX_LOADSTRING);
   
    MyRegisterClass(hInstance);


    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    if (FAILED(Core::Instance()->Init(hWnd, POINT{ 1280, 768 }))) { 
        MessageBox(nullptr, L"Core 객체 초기화 실패", L"ERROR", MB_OK);   
        return FALSE;
    }

    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_WINDOWSPROJECT));

    MSG msg;

    while (true){
        if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE)) {
            if (WM_QUIT == msg.message)
                break;

            if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
        }
        else{
            Core::Instance()->Progress();
        }
    }

    return (int) msg.wParam;
}

앞서 다루었듯이 Core 객체는 Instance()를 이용해 생성해서 접근해야 한다.

이를 이용해 초기화 작업을 실행하자.

현재 우리가 다루고 있던 창의 handle 값과 1280, 768을 해상도 값으로 전달하겠다.

만약 이 작업을 실패하면 FALED 값이 true가 되어 메세지 박스를 생성하고 종료하도록 하자.

이제 사각형을 그려보자.

이제는 Core class 내부의 Progress() 함수 내부에 계속 실행되는 부분을 여기에 코딩할 것이다.

그리기 작업 또한 여기서 진행할 수 있는데 메세지에서 처리했던 것과 똑같이 DC가 필요하다. 따라서 클래스 내부에 HDC 멤버 변수를 하나 만들어 준 것.

이를 이용해서 클래스 내부 함수에서 어떻게 그릴 것인가?

Object 클래스를 하나 만들겠다

// Object.h
#pragma once

class Object {
public:
	POINT	ptPos;
	POINT	ptScale;

public:
	Object();
	~Object();
};


// Object.cpp
#include "pch.h"
#include "Object.h"

Object::Object()
	: ptPos{}
	, ptScale{}
{
}

Object::~Object()
{
}

앞으로 이 Object class를 이용해 게임에 존재하는 물체를 만들 것이다. 보통 현재 멤버 변수들은 private을 이용해 만드는 것이 옳지만, public으로 일단 설정하겠다.

// Core.cpp
#include "Object.h"

Object obj;

//  ...

int Core::Init(HWND _handle, POINT _ptResolution)
{
	// ...
	hDC = GetDC(handle);

	obj.ptPos = POINT{ ptResolution.x, ptResolution.y };
	obj.ptScale = POINT{ 100,100 };
    
	return S_OK;
}

void Core::Progress()
{
	Rectangle(hDC, 10, 10, 110, 110);
}

hDC 변수에 handle 값을 이용해 DC를 가져오고, 사각형을 그릴 때 필요한 값들을 구조체에 전달해주도록 한다.

이후 Progress() 함수 내에서 사각형을 그려주면 된다.

메세지 방식이 아니라 계속해서 갱신하는 방법으로 사각형을 그린 것이다.

(실제 게임은 각 장면을 다시 그린다. 이를 렌더링이라 하고 1초 60번 해야 자연스럽게 보임 )

다음은 키 입력을 받아서 사각형을 이동시켜보자

- 키 입력해서 사각형 이동하기 (Update합수와 Render함수)

// Core.h
class Core {
	SINGLE(Core);
private:
	HWND    handle;       
	POINT   ptResolution; 
	HDC		hDC;         

	Core();
	~Core();

private:
	void Update();  // 추가
	void Render();  // 추가

public:
	int Init(HWND _hWnd, POINT _ptResolution);
	void Progress();
};


// Core.cpp

// Init 함수 
	obj.ptPos = POINT{ ptResolution.x / 2, ptResolution.y / 2 };  // 수정
    
oid Core::Progress()
{
	Update();
	Render();
}


void Core::Update()   
{
	// 키입력..
	if (GetAsyncKeyState(VK_LEFT) & 0x8000) {  

		obj.ptPos.x -= 1;
	}
	if (GetAsyncKeyState(VK_RIGHT) & 0x8000) { 

		obj.ptPos.x += 1;
	}
}

void Core::Render() 
{
	Rectangle(hDC,
		obj.ptPos.x - obj.ptScale.x / 2,
		obj.ptPos.y - obj.ptScale.y / 2, 
		obj.ptPos.x + obj.ptScale.x / 2,
		obj.ptPos.y + obj.ptScale.y / 2);
}

Update() 함수는 물체의 변경된 좌표를 추적하고 업데이트하는 함수며, Render()은 이 정보를 토대로 그리는 기능을 수행하는 함수다.

GetAsyncKeyState() 함수를 이용하면 비트를 통해 여러 정보를 가져올 수 있는데 0x8000과 비트연산 해주면 키가 눌렸는지를 확인할 수 있다. 키가 눌렸을 때 해당 좌표를 늘리고 줄이는 코드다.

결과를 봐보자

키보드 오른쪽 방향키를 누르면 이렇게 된다

잘못된게 아니라 현재 코드에서 Progress()함수가 1초에 4만번 정도가 돌아가서(너무 빨라서) 생기는 문제다

이를 해결하기 위한 방안은 다음 시간에..

728x90