[winAPI 04] Timer

 

 

 

저번 시간에 작성했던 프로그램을 토대로 게임을 만든다고 했을 때  두 가지 문제가 있을 수 있다

 

 

1. 컴퓨터가 느린 사람과 빠른 사람의 이동 속도가 달라질 수 있다. 즉 CPU의 속도에 따라 처리 속도가 달라져 1초 당 이동 거리 속도가 다른 문제가 발생한다.

 

2. 정수 단위로 이동하고 있어서 1초에 엄청나게 많은 거리를 이동하고 있다.

 

우선 실수 단위로 이동 시켜 보도록 하자

기존 Object class에서 POINT 객체로 되어 있던 것을 vec2 라는 객체로 만들겠다. 여기서 vec2는 우리가 아는 수학적 2차원 개념이다.

 

// new header file : struct.h

#pragma once
struct Vec2 {
	float x;
	float y;

	Vec2()
		:x(0.f)
		,y(0.f)
	{}

	Vec2(float _x, float _y)
		:x(_x)
		,y(_y)
	{}

	Vec2(int _x, int _y)
		:x((float)_x)
		,y((float)_y)
	{}
};



// pch.h -> struct.h를 미리 컴파일된 헤더로 추가.

#pragma once
#include <windows.h>
#include <iostream>

#include "define.h"
#include "struct.h"



// Object.h 수정

class Object {
private:
	Vec2	vPos;
	Vec2	vScale;

public:
	Object();
	~Object();

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

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

};



// Object.cpp 수정

#include "pch.h"
#include "Object.h"

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

Object::~Object()
{
}



// Core.cpp 수정

// Init() 함수
	obj.setPos(Vec2((float)(ptResolution.x / 2), (float)(ptResolution.y / 2)));
	obj.setScale( Vec2(100, 100 ));
    
    
// Update() 함수
void Core::Update()   
{
	Vec2 vPos = obj.getPos();

	if (GetAsyncKeyState(VK_LEFT) & 0x8000) {   
		vPos.x -= 0.01f  
	}
	if (GetAsyncKeyState(VK_RIGHT) & 0x8000) {   
		vPos.x += 0.01f
	}

	obj.setPos(vPos);
}



// Render() 함수
void Core::Render() 
{
	Vec2 vPos = obj.getPos();
	Vec2 vScale = obj.getScale();

	Rectangle(hDC,    //rectangle은 정수를 요구함
		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));

}

 

 

 

우선 기존 Object의 좌표와 크기 변수가 public에서 private로 선언 됨에 따라 이에 접근할 수 있는 Set함수와 Get함수가 필요하다. Set()은 매개변수 값을 통해 값을 설정할 수 있는 함수고, Get()은 각 변수의 값을 얻어올 수 있는 함수다. 이런 함수들을 보통 인터페이스 함수라고 한다.

 

위의 코드를 적용하면 아래와 같이 저번 시간과는 다르게 눈으로 확인할 수 있을 정도의 움직임을 볼 수 있다. 이전 것을 무효화하는 작업을 아직 하지 않아서 아래와 같이 나온다. 무효화 작업은 뒤에서 하겠다.

 

 

 

 

 

자 근데 정수에서 실수로 바꾸었다고 해서 아까 언급했던 1번 문제는 없어지지 않는다. 이는 게임과 같은 프로그램에서 게임의 밸런스와 공정성을 깰 수 있는 부분임으로 현실 시간을 반영하여 1초에 어느 정도 이동할 것인지는 반영해주어야 한다. 

 

앞으로 시간을 관리하는 TimeManager Class를 만들어보자.

 

// TimeManager.h

#pragma once
class TimeManager{
	SINGLE(TimeManager);
private:
	LARGE_INTEGER curCount;
	LARGE_INTEGER prevCount;
	LARGE_INTEGER prequency;

	double        dDT; 
	double        dAcc; 
	UINT          iCallCount; 
	UINT          iFPS;       

public:
	void Init();
	void update();
	double getDT() { return dDT; }
	float  getfDT() { return (float)dDT; }
};


// TimeManager.cpp

#include "pch.h"
#include "TimeManager.h"

#include "Core.h"

TimeManager::TimeManager()
	:curCount{}
	,prevCount{}
	,prequency{}
	,dDT(0.)
	,dAcc(0.)
	,iCallCount(0)
{

}

TimeManager::~TimeManager()
{

}

void TimeManager::Init()
{
	QueryPerformanceCounter(&prevCount);
	QueryPerformanceFrequency(&prequency); 
}

void TimeManager::update()
{
	QueryPerformanceCounter(&curCount);
	dDT = (double) (curCount.QuadPart - prevCount.QuadPart) / (double)prequency.QuadPart;

	prevCount = curCount;

	++iCallCount;
	dAcc += dDT; 

	if (dAcc >= 1.) {
		iFPS = iCallCount;
		dAcc = 0.;
		iCallCount = 0;

		wchar_t szBuffer[255] = {};
		swprintf_s(szBuffer,L"FPS : %d, DT : %f", iFPS, dDT);
		SetWindowText(Core::Instance()->getMainHandle(), szBuffer);
	}	
}

 

 

 

보통 게임에서의 시간은 FPS로 많이 표현된다. 

 

1초에 2프레임이라고 하면, 1프레임 당 0.5초

1초에 10프레임이라 하면, 1프레임 당 0.1초

 

→ 즉 프레임의 역수는 한 프레임 당 걸리는 시간을 의미한다.

 

 

TimeManager.h

 

LARGE_INTEGER : 시간을 측정하기 위한 값

→ curCount :  현재 시간 / prevCount : 이전 시간 / prequency : 성능 카운터가 초당 몇 번 진행되는지 저장

 

dDT : 두 프레임 사이의 시간 값으로 현재 시간과 이전 시간의 차이를 구한 후 시스템 성능 카운터의 주파수로 나눠 계산됨

dAcc : 누적 경과 시간으로 1초를 초과하면 FPS 계산하고 초기화

iCallCount : Update 함수 호출 횟수 저장

iFPS : 프레임 속도로 1초당 Update호출 횟수

 

 

 

Init() 함수

→ QueryPerformanceCounter() : prevCount 변수에 현재 카운트를 저장함.

→ QueryPerformanceFrequency() : prequency 변수에 1초당 카운트 횟수를 저장함.

 

QueryPerformanceCounter() 
: 현재 시간을 측정하기 위해 사용되며 시스템의 성능 카운터 값을 가져와서 현재 시간을 나타냄

QueryPerformanceFrequency() 
: 성능 카운터의 주파수(초당 클럭 틱의 수)를 측정하는 데 사용, 이 값을 이용해 성능 카운터 값의 단위를 시간 단위로 변환 가능함.

 

 

 

 

 

Update() 함수

→ curCount 변수에 현재 카운트를 저장함. → dDT 변수에 이전 프레임의 카운팅과 현재 프레임 카운팅 값의 차이에 주파수 값을 나눠 두 프레임 간의 시간 값을 저장함 → prevCount 변수에 이전 카운트 값을 현재 값으로 갱신하여 저장함 (다음 계산을 위) → Update함수가 호출되었음으로 iCallCount 횟수를 하나 높여 저장함 → dAcc 변수에 dDT을 누적 해서 저장하여 흐른 시간을 나타냄.

→ dAcc 변수의 값이 1 이상이면 아래 작업들을 수행함.

 

 

 

 

- 시간 적용해서 사각형 이동하기

// Core.cpp 추가

#include "TimeManager.h"

// Init() 함수 추가

	// Manager초기화
	TimeManager::Instance()->Init();
    
    
// Progress() 함수 추가

	// Manager update
	TimeManager::Instance()->update();
    
    
// Update() 함수 수정

void Core::Update()   
{
	Vec2 vPos = obj.getPos();

	if (GetAsyncKeyState(VK_LEFT) & 0x8000) {   
		vPos.x -= 200.f * TimeManager::Instance()->getfDT();   
	}
	if (GetAsyncKeyState(VK_RIGHT) & 0x8000) {   
		vPos.x += 200.f * TimeManager::Instance()->getfDT();
	}

	obj.setPos(vPos);
}

 

 

 

상단바에 FPS와 DT 값을 출력된다. DT(두 프레임 사이의) 값을 이용해서 1초에 이동해야 하는 거리를 계산한다. 이것은 CPU 성능과는 상관없이 현실 시간에 맞춰 진행되도록 한다.

 

 

 

앞으로 시간을 이용해서 게임을 구현해야 하기 때문에 자주 사용할 것임으로 아래처럼 매크로로 지정해두자. 저번 시간에 만들어 놓았던 define.h 파일에 추가 해주면 된다.