220502_WIN32API_Framework_2_그리기, DeltaTime

* HDC를 통한 그리기 방법 학습

* DeltaTime을 구현하여 프레임 변동해도 일정한 게임 속도 유지시키는 법 학습

 

 

//Class CGameManager
//GameManager.h

#pragma once

#include "GameInfo.h"
#include "SingletonMacro.h"




/*
[프레임과 게임 처리]
내 컴퓨터는 100프레임
PC방 컴퓨터는 200프레임

게임 코드는 1프레임당 한번 게임 로직을 처리
만약 게임 로직이 1프레임에 5씩 캐릭터를 이동시킨다면
내 컴퓨터에서 500 움직일 동안 PC방 컴퓨터는 1000을 움직이게 된다.
아주 심각한 문제

<해결법 - DeltaTime>
* 매 프레임마다 한 프레임을 그리는 데 걸렸던 시간을 변수에 저장한다.
* 그리고 다음 프레임을 그릴때 시간 단위를 위에서 저장한 변수로 처리한다.
* 그러면 프레임 수에 게임 속도가 빨라지거나 느려지는 문제가 발생하지 않는다.
* 그러므로 앞으로 모든 게임 로직 처리 함수에
인자로 DeltaTime을 넣어줄 것.
*/



//윈도우 클래스를 생성하고 전체 게임을 관리하는 클래스
//이 클래스틑 객체를 여러 개 만들 필요가 없으므로 싱글턴 패턴으로 만든다.
class CGameManager
{
//매크로를 활용해 싱글턴 패턴으로 생성
DECLARE_SINGLETON(CGameManager)


private:
	/*
	< 윈도우 핸들 >
	* 일종의 번호로 되어 있음.
		- 이 번호들은 커널 오브젝트에 속함.
	* 커널: 운영체제가 사용하는 특수한 영역 및 핵심 부분. 사용자는 컨트롤 불가능
	* 커널 오브젝트: 커널에 있는 메모리 - 커널에 값을 넣어 놓음
	* 핸들은 각자 자신이 부여받은 번호에 속한 오브젝트들을 컨트롤하는 역할을 한다.
		ex) HWND(윈도우 핸들): 윈도우 창을 컨트롤하기 위한 용도
			HDC: WIN32에서 제공하는 그리기 도구. 윈도우 창의 클라이언트와 연결 됨.
	*/
	HINSTANCE	m_hInst;
	HWND		m_hWnd;

	//HDC는 GetDC 함수에 HWND를 인자로 집어넣어 운영체제로부터 할당받을 수 있다.
	//사용을 다 했으면 ReleaseDC 함수를 통해 할당을 해제해 주어야 한다.
	//DC = Device Context
	HDC			m_hDC;
	static bool	m_Loop;

	//Timer 클래스 전방선언 후 cpp 파일에서 include
	class CTimer* m_Timer;







	//움직여 줄 사각형 구조체
	RECT m_Rect;
	//움직일 방향(충돌시 반대 방향으로 움직이게)
	int m_Dir;

public:
	bool Init(HINSTANCE hInst);

	//Win32API 기본 코드의 메시지 루프 부분을 작동시킬 함수.
	int Run();

private:

	//[게임의 흐름을 구성하는 단계]

	//1. 게임로직을 작성할 함수.
	//이후 인자로 전달해 줄 Deltatime은 여기서 구한다.
	void Logic();

	//2. 사용자의 입력
	void Input(float DeltaTime);

	//3. 입력받은 내용에 대해서 데이터 업데이트
	//	+인공지능들의 데이터 업데이트
	//화면에 표시할 좌표를 만든다던지 하는 로직을 구현할 함수
	void Update(float DeltaTime);

	//4. 업데이트된 데이터를 토대로 충돌을 수행
	//위에서 계산된 로직을 토대로 충돌하는 오브젝트들이 생겼는지 판단
	void Collision(float DeltaTime);

	//4. 출력이 되어야 하는 물체들을 판단.(화면 밖의 오브젝트들)
	//5. 화면에 출력이 되어야 하는 물체들을 출력
	void Render(float DeltaTime);


	


	//윈도우 클래스 구조체를 생성하여 반환한다/
	void Register();
	
	//윈도우 창을 생성한다.
	//WIN32API 기본코드의 Init_Instance 함수와 같은 기능
	bool Create();

	//전역 함수로 선언하여 함수의 주소가 하나만 존재하도록 한다.
	static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

};

//Class CGameManager
//GameManager.cpp


#include "GameManager.h"
#include "resource.h"
#include "Timer.h"

//클래스 바깥에서 정적 변수 초기화
DEFINITION_SINGLETON(CGameManager)
bool CGameManager::m_Loop = true;

CGameManager::CGameManager()
{
    //메모리 릭 체크 함수
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
    //_CrtSetBreakAlloc(100);


}

CGameManager::~CGameManager()
{
    SAFE_DELETE(m_Timer);


    //프로그램이 종료되면 DC를 제거한다.
    //m_hWnd에서 생성된 m_hDC를 삭제하라.
    ReleaseDC(m_hWnd, m_hDC);
}

bool CGameManager::Init(HINSTANCE hInst)
{
	//인자로 들어오는 hInst를 저장하고
	m_hInst = hInst;

    //Register 함수를 통해 윈도우 클래스 구조체를 만들어주고 등록한다.
	Register();

    //윈도우 창을 생성하고 등록한다.
	Create();

    //타이머 생성, 동적할당이므로 소멸자에서 제거 예약
    m_Timer = new CTimer;
    m_Timer->Init();

    //DC를 할당받는다.
    //할당받은 이후에는 반드시 ReleaseDC를 이용해 할당을 해제해 주어야 한다.
    m_hDC = GetDC(m_hWnd);
    



    m_Rect = { 800, 100, 900, 200 };

    m_Dir = 1;



	return true;
}

int CGameManager::Run()
{
    //운영체제가 만들어준 메시지를 얻어오기 위한 구조체이다.
    MSG msg;


    //메시지 루프 반복 여부를 m_Loop 변수로 판단한다.
    while (m_Loop)
    {
        //PeekMessage - 주석 분리하여 블로그에 업로드함
        //메시지 큐가 차있으면 메시지를 가져오고 큐에서 삭제(PM_REMOVE)
        //메시지 큐가 비어있으면 false를 반환.
        if (PeekMessage(&msg, m_hWnd, 0, 0, PM_REMOVE))
        {
            //두 함수는 한 쌍
            //설명 주석은 분리하여 블로그에 따로 업로드하였음.
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        //메시지 큐에 처리할 메시지가 없으면
        //(PeekMessage 함수가 false를 반환하면)
        //여기로 들어와서 게임 로직을 처리한다.
        else
        {
            Logic();
        }
 
    }

    return (int)msg.wParam;
}

void CGameManager::Logic()
{
    //매번 Logic이 실행될 때마다 DeltaTime 갱신
    m_Timer->Update();
    float DeltaTime = m_Timer->GetDelatTime();


    Input(DeltaTime);
    Update(DeltaTime);
    Collision(DeltaTime);
    Render(DeltaTime);


}

void CGameManager::Input(float DeltaTime)
{
}

void CGameManager::Update(float DeltaTime)
{
}

void CGameManager::Collision(float DeltaTime)
{
}

void CGameManager::Render(float DeltaTime)
{
    //fps 출력
    char    FPSText[64] = {};
    sprintf_s(FPSText, "* FPS: %d", (int)m_Timer->GetFPS());
    TextOutA(m_hDC, 1100, 0,FPSText, strlen(FPSText));

    char    DeltaTimeText[64] = {};
    sprintf_s(DeltaTimeText, "* DeltaTime: %.5f", m_Timer->GetDelatTime());
    TextOutA(m_hDC, 1100, 20, DeltaTimeText, strlen(DeltaTimeText));

    static float CurrentTime = 0.f;
    CurrentTime += DeltaTime;
    char    CurrentTimeText[64] = {};
    sprintf_s(CurrentTimeText, "* Time: %.5f", CurrentTime);
    TextOutA(m_hDC, 1100, 40, CurrentTimeText, strlen(CurrentTimeText));


    /*
    < 텍스트 출력 >
    * TextOutA: 멀티바이트 문자열(char 문자열)을 출력하는 함수이다.
    * TextOutW: 유니코드 문자열(wchar_t 문자열)을 출력하는함수이다.
    * TextOut: 현재 프로젝트의 설정에 따라 두 함수 중에서 자동 선택해주는 함수이다.
        #ifdef UNICODE
        #define TextOut  TextOutW
        #else
        #define TextOut  TextOutA
    */
    TextOut(m_hDC, 50, 50, TEXT("텍스트 출력"), lstrlen(TEXT("텍스트 출력")));

    

    //< 도형 출력 >
    //가운데가 흰색으로 칠해져있고, 테두리가 검은색인 사각형을 그린다.
    Rectangle(m_hDC, 100, 100, 200, 200);
    
    //원 출력
    //지정한 사이즈의 사각형 안에 들어가는 원을 그린다.
    Ellipse(m_hDC, 200, 100, 300, 200);

    //점 찍기
    SetPixel(m_hDC, 350, 100, RGB(255, 0, 0));
    SetPixel(m_hDC, 351, 100, RGB(255, 0, 0));
    SetPixel(m_hDC, 350, 101, RGB(255, 0, 0));
    SetPixel(m_hDC, 351, 101, RGB(255, 0, 0));

    //MoveToEx: 선을 그리기 위해서 시작점을 지정한다.
    MoveToEx(m_hDC, 100, 300, nullptr);

    //LineTo: 선의 끝 지점을 지정하고 선을 연결해서 그린다.
    LineTo(m_hDC, 200, 400);

    //LineTo를 계속 써서 선을 계속 이어 그릴수도 있다.
    //새로운 선을 다시 그리고 싶으면 MoveToEx를 사용하면 된다.
    LineTo(m_hDC, 300, 300);

    //RECT 구조체는 Long(=정수) 타입을 저장하므로 소수점 연산이 안 된다.
    //위아래로 움직일 것이므로 Top, Bottom 부분만 Float 타입으로 만들어서
    //프레임이 달라져도 속도가 일정하게 만들어 보자.
    static float Top = (float)m_Rect.top;
    static float Bottom = (float)m_Rect.bottom;

    Rectangle(m_hDC, m_Rect.left, Top, m_Rect.right, Bottom);
    
    Top += m_Dir * 500 * DeltaTime;
    Bottom += m_Dir * 500 * DeltaTime;
    if (Top <= 0)
        m_Dir *= -1;
    else if (Bottom >= 720)
        m_Dir *= -1;

}


void CGameManager::Register()
{
    WNDCLASSEXW wcex;
    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc = WndProc;
    wcex.cbClsExtra = 0;
    wcex.cbWndExtra = 0;
    wcex.hInstance = m_hInst;
    wcex.hIcon = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_ICON1));
    wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_ICON1));
    wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wcex.lpszMenuName = nullptr;
    wcex.lpszClassName = TEXT("GameFramework");
    RegisterClassExW(&wcex);
}

bool CGameManager::Create()
{
    m_hWnd = CreateWindowW(TEXT("GameFramework"), TEXT("GameFramework"), WS_OVERLAPPEDWINDOW,
        100, 0, 0, 0, nullptr, nullptr, m_hInst, nullptr);


    if (!m_hWnd)
    {
        return FALSE;
    }


    RECT rc = { 0, 0, 1280, 720 };
    AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW,FALSE);
    MoveWindow(m_hWnd, 50, 50, rc.right - rc.left,
        rc.bottom - rc.top, TRUE);


    ShowWindow(m_hWnd, SW_SHOW);


    
    UpdateWindow(m_hWnd);

    return TRUE;

}

LRESULT CGameManager::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    //WIN32API 기본 코드에서 가져온 내용
    // 
    //message 큐로부터 받은 message에 따라 어떤 동작을 할지 결정.
    switch (message)
    {
    case WM_DESTROY:
        m_Loop = false;
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

 

 

 

 

 

 

 

 

 

 

 

 

//Class Timer
//Timer.h


#pragma once

#include "GameInfo.h"

/*
* 윈도우는 고해상도 타이머를 내장하고 있고 이 고해상도 타이머의 값을 얻어올 수 있다.
* 프레임과 프레임 사이의 시간을 구하고자 한다면 고해상도 타이머의 값을 얻어와서 구할 수 있다.
*/


class CTimer
{
public:
	CTimer();
	~CTimer();

private:
    //타이머의 1초당 진동수를 저장할 변수
	LARGE_INTEGER m_Second;
	/*
    * LARGE_INTEGER: 공용체(union)
        - 공용체는 메모리 공간을 공유하는 메모리 타입이다.
	typedef union _LARGE_INTEGER {
    struct {
        DWORD LowPart;
        LONG HighPart;
    } DUMMYSTRUCTNAME;
    struct {
        DWORD LowPart;
        LONG HighPart;
    } u;
    LONGLONG QuadPart;
    } LARGE_INTEGER;
	
    * 32비트 기준
        - DWORD LowPart = Unsigned int (4byte)
        - LONG  HighPart= int(4byte)
        - 둘이 합친 공간인 8byte는
        - LONGLONG Quadpart와 공유된다.
	*/

    //타이머의 시간을 저장하기 위한 변수
    LARGE_INTEGER m_Time;

    //한 프레임을 그리는 데 걸리는 시간
    float m_DeltaTime;

    //FPS를 구하기 위한 변수
    int m_FPS;
    int m_Tick;
    float m_FPSTime;

    //프레임 제한을 위한 변수들. 일단 Init 함수에서 할당해놓음.
	float		m_FrameLimitTime;
	float		m_FrameTime;

public:
    void Init();
    void Update();

public:
    float GetDelatTime() const
    {
        return m_DeltaTime;
    }

    int GetFPS() const
    {
        return m_FPS;
    }

};

//Class Timer
//Timer.cpp



#include "Timer.h"

CTimer::CTimer() :
	m_Second{},
	m_Time{},
	m_DeltaTime(0.f),
	m_FPS(0),
	m_FPSTime(0.f),
	m_Tick(0),
	m_FrameTime(0.f)
{
	//프레임 제한을 초당 60프레임으로. 0 = 프레임 무제한
	m_FrameLimitTime = 1.0f / 60.0f;

}

CTimer::~CTimer()
{
}

void CTimer::Init()
{
	//m_Second에 내장 고해상도 타이머의 1초당 진동수를 저장
	QueryPerformanceFrequency(&m_Second);

	//현재 고해상도 타이머 상에서의 시간을 얻어온다.
	QueryPerformanceCounter(&m_Time);
}

void CTimer::Update()
{
	m_DeltaTime = 0.f;
	//프레임 제한을 걸었으면 해당 프레임 제한 시간이 되기 전까지는
	//타이머 안에서 무한루프를 돌면서 대기한다.
    
	//do-while문으로 무조건 1회는 실행시킨다.
    //->프레임 제한을 해제하면 m_FrameLimitTime == 0
	//->while문에 넣으면 아예 코드를 스킵해버려서 문제 발생의 여지가 있으므로
    //do-while문에 넣어준다.
	do
	{
		//매 프레임마다 시간을 한 번씩 기록한다.
		LARGE_INTEGER Time;
		QueryPerformanceCounter(&Time);

		//( 방금 기록한 시간 - 이전 프레임에서 기록한 시간 ) / 초당 진동 수
		//위의 3개 변수 모두 LONG LONG 타입이므로 하나는 형변환을 해 주어야 한다.
		m_FrameTime = (Time.QuadPart - m_Time.QuadPart) / (float)m_Second.QuadPart;

		//이전 타이머 값에 현재 시간을 기록한다.
		m_Time = Time;

		//루프를 돌면서 시간을 더해준다.
		m_DeltaTime += m_FrameTime;
	} while (m_DeltaTime < m_FrameLimitTime);

	

	//FPSTime에 DeltaTime을 누적하여 더하고, 틱도 하나 증가시킨다.
	//FPSTime 동안에 프레임이 몇틱 누적됐는지 확인 ->
	m_FPSTime += m_DeltaTime;
	++m_Tick;

	//초당 한번 프레임 틱을 계산하고 프레임 체크 타이머를 초기화한다.
	if (m_FPSTime > 1.0f)
	{
		m_FPS = m_Tick;
		m_Tick = 0;
		m_FPSTime = 0.0f;
	}



}