[winAPI 07] Scene & Scene Manager

 

 

게임에는 여러가지 씬이 존재한다. 씬은 어떻게 구현될까?

게임 내에는 수 많은 오브젝트가 존재하는데 이를 관리하는 것을 씬이라 볼 수 있다.

 

- 씬 구조 만들기

 여기서 오브젝트를 관리할 것인데 씬도 여러 가지 씬으로 나뉘기에 상속으로 구현된다. 씬에 존재하는 오브젝트를 여러 그룹으로 나눠 구별하기 위해 아래처럼 enum class를 사용한다.

// define.h에 추가

enum class GROUP_TYPE {
	DEFAULT,
	PLAYER,
	MISSTLE,
	MONSTER,

	END = 32,
};

// Scene.h 생성

class Object;	// 전방선언
class Scene {
private:
	vector<Object*> arrObj[(UINT)GROUP_TYPE::END];	
	wstring			strName;

public:
	Scene();
	virtual ~Scene();

	void SetName(const wstring& _strName) { strName = _strName; }
	const wstring& GetName() { return strName; }

	void update();
	void render(HDC _hdc);

	virtual void Enter() = 0;
	virtual void Exit() = 0;

protected:
	void AddObject(Object* obj, GROUP_TYPE type)
	{
		arrObj[(UINT)type].push_back(obj);
	}
};

 

전방선언  : 컴파일 속도에 부담 덜기 위해 사용. 아래에선 Object 헤더 파일 내부 내용이 변경되더라도 Scene 파일은 다시 컴파일 되지 않음.

 

Scene 클래스는 생성되는 모든 씬의 부모 클래스다.

private으로 선언된 arrObj와 strName은 각각 오브젝트를 저장 및 관리할 벡터를 그룹 개수만큼 선언한 변수와 씬 이름을 나타내는 변수이다.

 

 

Object가 포인터로 오는 이유는 자식 클래스 타입들은 부모 포인터 타입으로 가져올 수 있기에 부모 클래스인 Object의 포인터로 가져온 것. 

 

위에서 언급하였 듯이 씬은 여러 개가 존재하기에 이들을 관리하는 Scene Manager가 필요하다.

// SceneManager.h

class Scene;

class SceneManager{
	SINGLE(SceneManager);

private:
	Scene*	arrScene[(UINT)SCENE_TYPE::END];	
	Scene*	currScene;				

public:
	void init();
	void update();
	void render(HDC _hdc);
};

 

이 친구는 여러 씬을 관리하기 때문에 모든 씬의 목록과 현재 어떤 씬인지를 갖고 있어야 한다.

각각 arrScene와 currScene 변수가 이를 의미한다.

 

지금까지 만든 것은 씬의 부모이자 토대가 되는 친구들이다.

만약 게임을 시작하는 Start Scene을 구현해보자.

 

기본 클래스에 Scene을 넣으면 알아서 상속된다

 

// Scene_Start.h

#include "Scene.h"

class Scene_Start : public Scene {
public:
	Scene_Start();
	~Scene_Start();

	virtual void Enter();
	virtual void Exit();
};

Scene_Start::Scene_Start()
{

}

Scene_Start::~Scene_Start()
{
}

void Scene_Start::Enter()
{
	// Object 추가
	Object* obj = new Object;
	obj->setPos(Vec2(640.f, 384.f));
	obj->setScale(Vec2(100.f, 100.f));

	AddObject(obj, GROUP_TYPE::DEFAULT);
}

void Scene_Start::Exit()
{

}

 

 

씬의 Enter함수와 Exit함수에는 각각 씬에 진입할 때와 탈출할 때 해야 하는 작업을 수행해야 한다. 이 Enter()와 Exit()는 모든 씬에 포함되어야 하기에 부모인 씬 클래스 내부에서 가상 함수로 만들어 상속 받고 있는 상속 받는 자식 클래스가 자신만의 버전을 구현하도록 강제해야 한다. ( 즉 Enter과 Exit 함수는 여기서 인터페이스 함수임 )

 

Sence 클래스 내부에 선언된 가상 함수 Enter, Exit

 

그리고 모든 씬은 Scene 클래스를 상속받는데 여기서 중요한 점은 소멸자에 virtual 키워드가 붙어야 한다.
가상 함수가 없었다면 부모 클래스의 소멸자만 호출되고 자식 클래스의 소멸자가 호출되지 않기 때문에, Scene, Object 클래스와 같은 상속이 목적이 되는 클래스는 반드시 소멸자에 virtual을 붙여야 함!

 

Scene_Start class 처럼 가상 함수를 부모 클래스로부터 상속 받는 입장이라면, 굳이 virtual 키워드를 붙일 필요가 없다. 하지만 명시적으로 가상함수임을 표시하기 위해 작성하는 경우가 많다.

 

Enter 함수 내부터에서는 본격적인 오브젝트를 추가하게 되는데 개발자가 동적으로 만드는 애들이기에 소멸시켜 주어야 한다. 어디서? → 상속을 이용하는 이유는 코드의 재사용에 있다. 굳이 이 클래스 내부에서 하나하나 해제하는 것이 아닌 부모 클래스인 Scene 내부에서 지워주면 된다.

// Scene.cpp

Scene::~Scene()
{
	for (UINT i = 0; i < (UINT)GROUP_TYPE::END; ++i)
		for (size_t j = 0; j < arrObj[i].size(); ++j)
			// arrObj[i] 그룹 벡터의 j물체 삭제
			delete arrObj[i][j];
}

 

오브젝트 추가도 아래의 함수를 이용해서 한다.

// Scene.h

protected:
	void AddObject(Object* obj, GROUP_TYPE type)
	{
		arrObj[(UINT)type].push_back(obj);
	}

 

+ 벡터는 데이터를 넣지 않는 이상 메모리 안 먹음 ( 데이터가 삽입되기 전에는 메모리를 거의 사용하지 않음. 벡터 자체의 메타데이터(예: 포인터, 크기, 용량 등)만을 유지하기 위한 약간의 메모리만 사용함 - 벡터 = 동적 배열 )

 

씬에 따라서 업데이트를 하고 그리기 위해서는 기존 Core 코드도 수정할 필요가 있다. 씬 매니저 또한 코어 내부에서 Init함수와 update함수를 불러와야 하고 추가적으로 해당 씬을 그리는 render함수도 추가되어야 한다.

#include "SceneManager.h"	//추가

int Core::Init(HWND _handle, POINT _ptResolution)
{
	//...
    // Manager초기화
	TimeManager::Instance()->Init();
	KeyManager::Instance()->init();
	SceneManager::Instance()->init();	// 추가 - 모든 씬 생성
	
    // ..
}

void Core::Progress()	// 수정
{
	// Manager update
	TimeManager::Instance()->update();
	KeyManager::Instance()->update();

	SceneManager::Instance()->update();

	// Rendering
	// 화면 clear
	Rectangle(mDC, -1, -1, ptResolution.x + 1, ptResolution.y + 1);

	SceneManager::Instance()->render(mDC);

	BitBlt(hDC, 0, 0, ptResolution.x, ptResolution.y, mDC, 0, 0, SRCCOPY); 
}

 

 

씬 매니저 내부에서는 이 각 함수가 어떻게 구현될까?

각 함수가 하는 일과 그 내부 구현은 아래와 같다.

 

#include "pch.h"
#include "SceneManager.h"

#include "Scene_Start.h"

SceneManager::SceneManager()
	:arrScene{}
	,currScene(nullptr)
{

}

SceneManager::~SceneManager()
{
	// 씬 전부 삭제
	for (UINT i = 0; i < (UINT)SCENE_TYPE::END; ++i)
		if (nullptr != arrScene[i])
			delete arrScene[i];
}

void SceneManager::init()
{
	// Scene 생성
	arrScene[(UINT)SCENE_TYPE::START] = new Scene_Start;
	arrScene[(UINT)SCENE_TYPE::START]->SetName(L"Start Scene");
	// arrScene[(UINT)SCENE_TYPE::TOOL] = new Scene_Tool;
	// arrScene[(UINT)SCENE_TYPE::STAGE_01] = new Scene_Stage01;
	// arrScene[(UINT)SCENE_TYPE::STAGE_02] = new Scene_Stage02;

	// 현재 씬 지정
	currScene = arrScene[(UINT)SCENE_TYPE::START];
	currScene->Enter();
}

void SceneManager::update()
{
	// 현재 씬 업데이트
	currScene->update();
}

void SceneManager::render(HDC _hdc)
{
	// 현재 씬 그리기
	currScene->render(_hdc);
}

 

그렇다면 여기서 현재 씬은 Scene 클래스의 포인터임으로 씬 클래스 자체에서도 update함수와 render함수도 구현되어야 한다. 

 

#include "pch.h"
#include "Scene.h"

#include "Object.h"

Scene::Scene()
{

}

Scene::~Scene()
{
	for (UINT i = 0; i < (UINT)GROUP_TYPE::END; ++i)
		for (size_t j = 0; j < arrObj[i].size(); ++j)
			// arrObj[i] 그룹 벡터의 j물체 삭제
			delete arrObj[i][j];
}

void Scene::update()
{
	for (UINT i = 0; i < (UINT)GROUP_TYPE::END; ++i) {
		for (size_t j = 0; j < arrObj[i].size(); ++j) {
			arrObj[i][j]->update();
		}
	}
}

void Scene::render(HDC _hdc)
{
	for (UINT i = 0; i < (UINT)GROUP_TYPE::END; ++i) {
		for (size_t j = 0; j < arrObj[i].size(); ++j) {
			arrObj[i][j]->render(_hdc);
		}
	}
}

 

이러면 각 오브젝트 또한 update와 render함수가 존재해야 하기에 Object 클래스도 아래처럼 변경된다.

 

// Object.h

class Object {
private:
	Vec2	vPos;
	Vec2	vScale;

public:
	Object();
	virtual ~Object();

	void setPos(Vec2 _vPos) { vPos = _vPos; }
	void setScale(Vec2 _vScale) { vScale = _vScale; }

	Vec2 getPos() { return vPos; }
	Vec2 getScale() { return vScale; }

public:
	void update();
	void render(HDC _hdc);
};


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

#include "KeyManager.h"
#include "TimeManager.h"

Object::Object()
	: vPos{}
	, vScale{}
{
}

Object::~Object()
{
}

void Object::update()
{
	if (KeyManager::Instance()->GetKeyState(KEY::W) == KEY_STATE::HOLD) {
		vPos.y -= 200.f * DT;
	}

	if (KeyManager::Instance()->GetKeyState(KEY::S) == KEY_STATE::HOLD) {
		vPos.y += 200.f * DT;
	}

	if (KeyManager::Instance()->GetKeyState(KEY::A) == KEY_STATE::HOLD) {
		vPos.x -= 200.f * DT;
	}

	if (KeyManager::Instance()->GetKeyState(KEY::D) == KEY_STATE::HOLD) {
		vPos.x += 200.f * DT;
	}
}

void Object::render(HDC _hdc)
{
	// 각자 자기가 자기를 그리면 됨
	Rectangle(_hdc, (int)(vPos.x - vScale.x / 2.f), (int)(vPos.y - vScale.y / 2.f),
		(int)(vPos.x + vScale.x / 2.f), (int)(vPos.y + vScale.y / 2.f));
}