3D게임아키텍처응용

기초 구조 실습

구조

FileManager

파일 로딩 전용 객체를 통한 텍스쳐 및 obj 파일 로딩 담당한다. 로딩된 데이터는 Object를 통해 관리된다.

Object

로딩된 파일 정보를 관리한다.

Renderer

Object의 정보를 이용하여 화면에 출력하는 기능을 담당한다.

의사코드

int main()
{
	파일매니저 객체 생성
	오브젝트객체 cube 생성
	오브젝트객체 human 생성
	오브젝트 cube 객체에 파일매니저를 통해 로딩된 obj 파일 등의 정보 설정
	오브젝트 human 객체에 파일매니저를 통해 로딩된 obj 파일 등의 정보 설정

	렌더러 객체 생성

	반복
		렌더러 객체를 통해 cube draw
		렌더러 객체를 통해 human draw	
}

좌표설정이 가능하도록 구현(카메라 시점, 오브젝트 위치, 객체들마다 별도로.)

내가 작성한 코드

int main()
{
  FileManager* filemgr = FileManager::instance(); //파일매니저 객체 생성

  RenderableObject* cube = new RenderableObject(); //오브젝트객체 cube 생성

  RenderableObject* human= new RenderableObject(); //오브젝트객체 human 생성

  filemgr->loadOBJ(		
		cube,					
                "cube.obj",			
		"uvtemplate.DDS",		
		"20161676_vs.shader",			
		"20161676_fs.shader"			
		); //오브젝트 cube 객체에 파일매니저를 통해 로딩된 obj 파일 등의 정보 설정

  filemgr->loadOBJ(		
		human,					
                "human.obj",			
		"uvtemplate.DDS",		
		"20161676_vs.shader",			
		"20161676_fs.shader"			
		); //오브젝트 human 객체에 파일매니저를 통해 로딩된 obj 파일 등의 정보 설정

 glm::mat4 ModelMatrix_Human = glm::mat4(1.0);	
 ModelMatrix_Human = glm::translate(ModelMatrix_Human, glm::vec3(3.0f, 0.0f, 0.0f)); //코드에선 Sphere로 했지만 여기선 Human으로 작성
 
 glm::mat4 ModelMatrix_Cube = glm::mat4(1.0);
 ModelMatrix_Cube = glm::translate(ModelMatrix_Cube, glm::vec3(0.0f, 3.0f, 0.0f)); 
 // 오브젝트 위치를 바꾸는 것 때문에 작성했던 코드 Main문에서 왜 사용했을까 바보같은 생각이었던 것 같다.

  while(true)
 {                                                               
  renderer->render(sphere, ModelMatrix_Human); //렌더러 객체를 통해 human draw		
  renderer->render(cube, ModelMatrix_Cube); //렌더러 객체를 통해 cube draw
 }
 
 ...
}

클래스 구조 추가

1. 공통적으로 사용되는 함수들의 인터페이스화

공통적으로 사용되는 함수들이 있을 수 있음.

같은 기능을 수행하는 함수들의 이름이 달라지지 않을 수 있도록 억제하는 효과.

C++에서는 인터페이스를 문법적으로 지원하지 않으므로, 추상 클래스를 상속하는 방법을 사용한다.

class ICleanUp
{
public :
	virtual void shutDown() = 0;
};

class Object : public ICleanUp
{
public :
	virtual void shutDown() override
	{
		//  Object 정리 코드.
	}
};

class Renderer: public ICleanUp
{
public :
	virtual void shutDown() override
	{
		// renderer 정리 코드.
	}
};

2. 기능 구분을 위한 상속

예시 - 화면에 그려지지 않는 Object 기능 추가.

현재의 구조에서 Object는 무조건 화면에 보여진다고 가정됨.

화면에 보여지지 않을 수 있는 Object를 효과적으로 만들 수 없는 구조.

그려지는 Object, 그려지지 않는 Object는 상속 관계를 추가하여 효과적으로 구현이 가능.

render, update 부분을 인터페이스화 시킴.

class IRender
{
public:
	virtual void render() = 0;
};

class IUpdate
{
public:
	virtual void update() = 0;
};

화면에 보여지지 않는 Object 클래스.

class NonRenderableObject : public Object , public IUpdate
{	

 public:	
    virtual void shutDown() override;	   
   
};	

구 출력용 클래스.

class Sphere : public RenderableObject
{	
  public:
	Sphere(FileManager* filepath);
	virtual void shutDown() override;
	virtual	void setPosition(float x, float y, float z);
};

이런식으로 구성

비렌더링 오브젝트 로직

화면에 렌더링 되지 않는 오브젝트의 로직이 처리될 수 있어야 함.

현재는 오브젝트의 생성만 가능할 뿐 렌더링 되지 않는 오브젝트의 코드가 작동하지 않음.

프레임 별 코드 처리

화면에 그려지지 않는 객체도 매 프레임 처리되어야 할 코드가 존재할 수 있다.

이러한 코드를 작동시키기 위해 렌더링과 별개로 Update를 수행하는 부분이 필요.

NonRenderableObject* non_render_obj = new NonRenderableObject();

while (true)
{
	renderer->update(sphere);
}

오브젝트 렌더링 처리 방법 개선 및 공통함수 처리 방법 개선

생성한 모든 객체들에 대해 모두 render()를 호출해주는 것은 버그 발생 가능성이 농후함.

실수로 작성해주지 않으면 해당 오브젝트는 렌더링 되지 않을 것.

렌더링을 담당하는 객체가 책임지고 렌더링을 해주는 것이 좋음.

'렌더링'만 담당해준다.

객체의 생성과 소멸까지 담당은 클래스의 역할을 오버하게 됨.

객체가 사용한 데이터의 '정리'는 담당해주어도 문제 없을 것.

렌더링에 관련된 내용에 한하여.

RenderableObject* cube = new RenderableObject();
renderer->addObject(cube);

Sphere* sphere = new Sphere();
renderer->addObject(sphere);

while (true)
{
		renderer->render();
}

내가 작성한 코드

int main()
{	
		FileManager* filemgr = FileManager::instance();

			renderer->init();


			RenderableObject* cube = new RenderableObject();
			renderer->addObject(cube);


			filemgr->loadObJ(
				cube,
					"cube.obj",
				"uvtemplate.DDS",
					"20161676_vs.shader",
					"20161676_fs.shader"
				);

	//cube는 RenderableObject 에서 관리하기때문에 filemgr를 통해 가져와줘야함.

	Sphere* sphere = new Sphere(filemgr);
	renderer->addObject(sphere);

	//sphere는 sphere 자체에서 모든것을 관리함.

	RenderableObject* cube1 = new RenderableObject();
	renderer->addObject(cube1);

	filemgr->loadObJ(
		cube1,
		"cube.obj",
		"uvtemplate.DDS",
		"20161676_vs.shader",
		"20161676_fs.shader"
	);

	Sphere* sphere1 = new Sphere(filemgr);
	renderer->addObject(sphere1);


	Sphere* sphere = new Sphere();		
        sphere->setPosition(-2.0f, 2.0f, 0.0f);
	sphere1->setPosition(2.0f, -2.0f, 0.0f);
	cube->setPosition(2.0f, 2.0f, 0.0f);
	cube1->setPosition(-2.0f, -2.0f, 0.0f);

	NonRenderableObject* non_render_obj = new NonRenderableObject();


while (true)
{
	renderer->Clear();

        renderer->render();
		
	renderer->update(non_render_obj);


	renderer->Out();
}
	cube->shutDown();
	sphere->shutDown();
	renderer->shutDown();
		
	delete cube;
	delete sphere;
	delete non_render_obj;


			return 0;
} 

중간

main문

int main()
{	
	FileManager* filemgr = FileManager::instance();
	Renderer* renderer = Renderer::instance();
	renderer->init();


	RenderableObject* ground = new RenderableObject();
	renderer->addObject(ground);


	filemgr->loadObJ(
		ground,
		"ground.obj",
		"skin.BMP",
		"20161676_vs.shader",
		"20161676_fs.shader"
		);


	Sphere* sun = new Sphere(filemgr);

	renderer->addObject(sun);
	
        RenderableObject* earth = new RenderableObject();
	renderer->addObject(earth);


	filemgr->loadObJ(
		earth,
		"orb.obj",
		"8k_earth.BMP",
		"20161676_vs.shader",
		"20161676_fs.shader"
		);


		RenderableObject* moon = new RenderableObject();
		renderer->addObject(moon);


		filemgr->loadObJ(
			moon,
			"orb.obj",
			"8k_moon.BMP",
		        "20161676_vs.shader",
		        "20161676_fs.shader"
	);


	sun->setPosition(-2.0f, 5.0f, 0.0f);
	earth->setPosition(2.0f, 5.0f, 0.0f);
	moon->setPosition(0.0f, 3.0f, 0.0f);
	ground->setPosition(0.0f, -10.0f, 0.0f);

	sun->setMoving(true);
	earth->setMoving(true);
	moon->setMoving(true);
	ground->setMoving(false);


	NonRenderableObject* non_render_obj = new NonRenderableObject();

        renderer->setCameraPos(0, 5, 13);	


	while (true)
	{
          renderer->Clear();
          renderer->update(non_render_obj);
          renderer->render();
	  renderer->Out();
	}
		
	sun->shutDown();
	renderer->shutDown();
	moon->shutDown();
	earth->shutDown();


	delete moon;
	delete earth;
	delete sun;
        delete non_render_obj;

	return 0;
}

우선적으로 밑에 그라운드 객체를 생성후 moon, earth, sun을 그려주고 객체들의 이동을 가능하게 했습니다. setMoving이라는 함수를 통해서 움직입니다. 그리고 키입력과 마우스입력을 통해 마우스를 통해 카메라의 시점을 바꿀수있게 만들었습니다.

키입력 부분

KeyInput::instance()->horizontalAngle += KeyInput::instance()->mouseSpeed * float(1024 / 2 - xpos);
glm::mat4 ProjectionMatrix = KeyInput::instance()->getProjectionMatrix();
glm::mat4 ViewMatrix = KeyInput::instance()->getViewMatrix();
glm::mat4 ModelMatrix = glm::mat4(1.0);
ModelMatrix = getPosition(ModelMatrix, src_obj);
glm::mat4 Projection = glm::perspective(glm::radians(FoV), 4.0f / 3.0f, 0.1f, 100.0f); //마우스 시점변환부분
glm::vec3 direction(
cos(KeyInput::instance()->verticalAngle) * sin(KeyInput::instance()->horizontalAngle),
sin(KeyInput::instance()->verticalAngle),
cos(KeyInput::instance()->verticalAngle) * cos(KeyInput::instance()->horizontalAngle)
);
glm::vec3 right = glm::vec3(
sin(KeyInput::instance()->horizontalAngle - 3.14f / 2.0f),
0,
cos(KeyInput::instance()->horizontalAngle - 3.14f / 2.0f)
);
glm::vec3 position = glm::vec3(0, 0, 5);
glm::mat4 To_World = glm::mat4(1.0f);
glm::mat4 MVP;
if (src_obj->getMoving() == true)
{
MVP = ProjectionMatrix * moveCameraPos * ViewMatrix * moveObjPos * ModelMatrix;
}
else
{
MVP = Projection * moveCameraPos * View * moveObjPos * To_World;
}

//getmoving 이 true이면 키보드 입력을 받음 main문에서 setmoving으로 true,false 지정해주면됨.

고정, 가변 프레임

가변 프레임

컴퓨터의 성능이나 기타 필요에 따라 프레임이 변경되는 것을 의미한다.

게임의 모든 코드가 가변 프레임이면 빠른 컴퓨터와 느린 컴퓨터에서의 게임 진행 속도가 달라질 수 있다.

고정 프레임

프레임을 1초에 N회로 고정하는 것을 의미한다.

물리나 서버, 게임로직 등의 특정 시스템 부분은 컴퓨터에 성능과 상관없이 동일하게 수행될 수 있어야 하므로 고정하는 편.

##Time부분

Time::Time()
{
	frame = 60;
	count = 0;
	QueryPerformanceFrequency(&_frameInfo);
	QueryPerformanceCounter(&_prevFrameCounter);

	// fps 60 = 1초.
	_perFrame = (double)_frameInfo.QuadPart / frame;
	std::cout << _perFrame << std::endl;
}

bool Time::IsFixedRendering()
{
	QueryPerformanceCounter(&_nowFrameCounter);
	double time_distance = (double)_nowFrameCounter.QuadPart - (double)_prevFrameCounter.QuadPart;
	if (time_distance > _perFrame)
	{
		_prevFrameCounter = _nowFrameCounter;

		count++;
		if(frame == count)
		{
			std::cout << "1SECOND" << std::endl;	
			count = 0;
		}

		return true;
	}
	std::cout<<"Dis:"<<time_distance<<" Fps:" <<1/ (time_distance / (double)_frameInfo.QuadPart) << std::endl;
	return false;
} 

main문에는

while(true)
{
   renderer->Clear();

   if (time->IsFixedRendering())
		{
			renderer->update(earth);
			renderer->update(moon);
			renderer->update(non_render_obj);
		}

   renderer->render();
}//이렇게 추가해줌

오브젝트 구조에 template을 적용.

그려지는 오브젝트, 그려지지 않는 오브젝트 모두 포함.

template 함수

오브젝트 초기화를 위한 template

예: init()

오브젝트 렌더링을 위함.

예: render()

오브젝트의 업데이트를 위함.

예: update()

오브젝트의 소멸처리를 위함.

예: shutDown()

Init

class IInit
{
public:
	virtual void init() = 0;
};

Render

class IRender
{
public:
	virtual void render() = 0;
};

Update

class IUpdate
{
public:
	virtual void update() = 0;
};

Shutdown

class ICleanUp
{
public:
	virtual void shutDown() = 0;
};

Renderer쪽 iterator를 사용해 바꿔주기

void Renderer::addRenderObject(RenderableObject* obj)
{
	renderObjList.push_back(obj);
}

void Renderer::addNonRenderObject(NonRenderableObject* obj)
{
	nonrenderObjList.push_back(obj);
}

int Renderer::init()
{
	if (!glfwInit())
	{
		fprintf(stderr, "Failed to initialize GLFW\n");
		getchar();
		return -1;
	}

	glfwWindowHint(GLFW_SAMPLES, 4);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	window = glfwCreateWindow(1024, 768, "20161676 Choi_Won_Jun", NULL, NULL);
	if (window == NULL) {
		fprintf(stderr, "Failed to open GLFW window. If you have an Intel GPU, they are not 3.3 compatible. Try the 2.1 version of the tutorials.\n");
		getchar();
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(window);

	glewExperimental = true;

	if (glewInit() != GLEW_OK) {
		fprintf(stderr, "Failed to initialize GLEW\n");
		getchar();
		glfwTerminate();
		return -1;
	}

	glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);

	glClearColor(0.0f, 0.0f, 0.4f, 0.0f);

	// depth test
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LESS);

	for (std::vector<RenderableObject*>::iterator it = renderObjList.begin(); it != renderObjList.end(); it++)
	{
		(*it)->init();
	}

	for (std::vector<NonRenderableObject*>::iterator it = nonrenderObjList.begin(); it != nonrenderObjList.end(); it++)
	{
		(*it)->init();
	}

}

void Renderer::render()
{
	for (std::vector<RenderableObject*>::iterator it = renderObjList.begin(); it != renderObjList.end(); it++)
	{
		(*it)->render();
	}

	for (std::vector<NonRenderableObject*>::iterator it = nonrenderObjList.begin(); it != nonrenderObjList.end(); it++)
	{
		(*it)->render();
	}
}

void Renderer::shutDown()
{
	glfwTerminate();
	for (std::vector<RenderableObject*>::iterator it = renderObjList.begin(); it != renderObjList.end(); it++)
	{
		(*it)->shutDown();
	}

	for (std::vector<NonRenderableObject*>::iterator it = nonrenderObjList.begin(); it != nonrenderObjList.end(); it++)
	{
		(*it)->shutDown();
	}
}

void Renderer::update()
{
	for (std::vector<RenderableObject*>::iterator it = renderObjList.begin(); it != renderObjList.end(); it++)
	{
		(*it)->update();
	}

	for (std::vector<NonRenderableObject*>::iterator it = nonrenderObjList.begin(); it != nonrenderObjList.end(); it++)
	{
		(*it)->update();
	}
}


void Renderer::Clear()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}

void Renderer::Out()
{
	if (glfwGetKey(window , GLFW_KEY_ESCAPE) == GLFW_PRESS)
	{
		exit(0);
	}
	glfwSwapBuffers(window);
	glfwPollEvents();
}

깔끔하게 변한 main문

int main()
{
	FileManager* filemgr = FileManager::instance();

	Time* time = Time::instance();
	Renderer* renderer = Renderer::instance();

	RenderableObject* render_obj = new RenderableObject();
	NonRenderableObject* non_render_obj = new NonRenderableObject();

	Sun* sun = new Sun();

	renderer->init();

	while (true)
	{
		renderer->Clear();

		if (time->IsFixedRendering())
		{
			renderer->update();
		}

		renderer->render();

		renderer->Out();
	}


	renderer->shutDown();


	delete sun;
	delete non_render_obj;

	return 0;
}

처음에는 코드가 정말 난잡하고 어떻게 해야할지 몰랐지만 하나씩 천천히 해보니까 완성되었음.

게임은 떨어지는 공피하기 게임을 만들예정