// Инициализируем SDL2 один раз за время работы программы.
SDL_Init(SDL_INIT_EVERYTHING);

// Специальное значение SDL_WINDOWPOS_CENTERED для x и y заставит SDL2
// разместить окно в центре монитора по осям x и y.
// Здесь для примера используется 0, т.е. окно появится в левом верхнем углу экрана.
// Для использования OpenGL вы ДОЛЖНЫ указать флаг SDL_WINDOW_OPENGL.
SDL_Window *window = SDL_CreateWindow(
    "SDL2/OpenGL Demo", 0, 0, 640, 480, SDL_WINDOW_OPENGL);

// Создаём контекст OpenGL, связанный с окном.
SDL_GLContext glcontext = SDL_GL_CreateContext(window);
// Теперь мы можем очистить область окна средствами OpenGL
glClearColor(0,0,0,1);
glClear(GL_COLOR_BUFFER_BIT);
// В конце - вывод нарисованного кадра в окно на экране
SDL_GL_SwapWindow(window);

// После окончания работы программы, SDL_GLContext должен быть удалён
SDL_GL_DeleteContext(glcontext);

SDL_Event event;
bool running = true;
while (running)
{
    while (SDL_PollEvent(&event) != 0)
    {
        if (event.type == SDL_QUIT)
        {
            running = false;
        }
    }
    // Заливка кадра чёрным цветом средствами OpenGL
    glClearColor(0,0,0,1);
    glClear(GL_COLOR_BUFFER_BIT);
    // Обновление и рисование сцены
    UpdateCurrentScene();
    DrawCurrentScene();
    // В конце - вывод нарисованного кадра в окно на экране
    SDL_GL_SwapWindow(window);
}

// Через системные часы получаем объект типа time_point.
auto lastTimePoint = std::chrono::system_clock::now();

while (running)
{
    // ... выполняем предшествующие обновлению операции

    // Получаем второй момент времени (после итерации).
    auto newTimePoint = std::chrono::system_clock::now();
    auto dtMsec = std::chrono::duration_cast<std::chrono::milliseconds>(newTimePoint - lastTimePoint);
    lastTimePoint = newTimePoint;
    float dtSeconds = 0.001f * float(dtMsec.count());

    // Обновление и рисование сцены
    UpdateCurrentScene(dtSeconds);
    DrawCurrentScene();
    // В конце - вывод нарисованного кадра в окно на экране
    SDL_GL_SwapWindow(window);
}

#include <glm/vec2.hpp>

void ShowWindow(glm::vec2 const& size)
{
    // Реализация показа окна.
}

// Используем unique_ptr с явно заданной функцией удаления вместо delete.
using SDLWindowPtr = std::unique_ptr<SDL_Window, void(*)(SDL_Window*)>;
using SDLGLContextPtr = std::unique_ptr<void, void(*)(SDL_GLContext)>;

void foo()
{
	SDLWindowPtr pWindow(nullptr, SDL_DestroyWindow);
	SDLGLContextPtr pGLContext(nullptr, SDL_GL_DeleteContext);

	pWindow.reset(/*...create window...*/);
	pGLContext.reset(/*...create GL context...*/);
}

namespace detail
{
struct SDLWindowDeleter
{
	void operator()(SDL_Window *ptr)
	{
		SDL_DestroyWindow(ptr);
	}
};
struct SDLGLContextDeleter
{
	void operator()(SDL_GLContext ptr)
	{
		SDL_GL_DeleteContext(ptr);
	}
};
}

// Используем unique_ptr с явно заданным функтором удаления вместо delete.
using SDLWindowPtr = std::unique_ptr<SDL_Window, detail::SDLWindowDeleter>;

// Используем unique_ptr с явно заданным функтором удаления вместо delete.
using SDLGLContextPtr = std::unique_ptr<void, detail::SDLGLContextDeleter>;

class CUtils
{
public:
	CUtils() = delete;

	static void InitOnceSDL2();
	static void ValidateSDL2Errors();
};

class CChronometer
{
public:
	CChronometer();
	float GrabDeltaTime();

private:
	std::chrono::system_clock::time_point m_lastTime;
};

#include "stdafx.h"
#include "Utils.h"
#include <SDL2/SDL.h>
#include <iostream>

// Вызывает инициализацию SDL2 только один раз за время работы приложения.
// (в многопоточной среде нам потребуется std::call_once вместо static bool)
void CUtils::InitOnceSDL2()
{
	static bool didInit = false;

	if (!didInit)
	{
		if (0 != SDL_Init(SDL_INIT_EVERYTHING))
		{
			std::cerr << "SDL2 initialization failed: " << SDL_GetError() << std::endl;
			std::abort();
		}
	}
}

void CUtils::ValidateSDL2Errors()
{
	std::string message = SDL_GetError();
	if (!message.empty())
	{
		std::cerr << "SDL2 error: " << message << std::endl;
		std::abort();
	}
}

CChronometer::CChronometer()
	: m_lastTime(std::chrono::system_clock::now())
{
}

float CChronometer::GrabDeltaTime()
{
	auto newTime = std::chrono::system_clock::now();
	auto timePassed = std::chrono::duration_cast<std::chrono::milliseconds>(newTime - m_lastTime);
	m_lastTime = newTime;
	return 0.001f * float(timePassed.count());
};

#pragma once

#include <memory>
#include <boost/noncopyable.hpp>
#include <glm/fwd.hpp>
#include <SDL2/SDL_events.h>

class CAbstractWindow : private boost::noncopyable
{
public:
    CAbstractWindow();
    virtual ~CAbstractWindow();

    void ShowFixedSize(glm::ivec2 const& size);
    void DoGameLoop();

protected:
    void SetBackgroundColor(glm::vec4 const& color);

    virtual void OnWindowEvent(const SDL_Event &event) = 0;
    virtual void OnUpdateWindow(float deltaSeconds) = 0;
    virtual void OnDrawWindow() = 0;

private:
    class Impl;
    std::unique_ptr<Impl> m_pImpl;
};

#include "stdafx.h"
#include "AbstractWindow.h"
#include "Utils.h"

namespace
{
const char WINDOW_TITLE[] = "SDL2+OpenGL Demo (press R, G, B to change window color)";
}

class CAbstractWindow::Impl
{
public:
    void ShowFixedSize(glm::ivec2 const& size)
	{
		CUtils::InitOnceSDL2();

        // Специальное значение SDL_WINDOWPOS_CENTERED вместо x и y заставит SDL2
        // разместить окно в центре монитора по осям x и y.
        // Для использования OpenGL вы ДОЛЖНЫ указать флаг SDL_WINDOW_OPENGL.
        m_pWindow.reset(SDL_CreateWindow(WINDOW_TITLE, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
                                         size.x, size.y, SDL_WINDOW_OPENGL));

        // Создаём контекст OpenGL, связанный с окном.
        m_pGLContext.reset(SDL_GL_CreateContext(m_pWindow.get()));
        if (!m_pGLContext)
        {
			CUtils::ValidateSDL2Errors();
        }
    }

    void SetBackgroundColor(const glm::vec4 &color)
    {
        m_clearColor = color;
    }

    void Clear()const
    {
        // Заливка кадра цветом фона средствами OpenGL
        glClearColor(m_clearColor.x, m_clearColor.y, m_clearColor.z, m_clearColor.w);
        glClear(GL_COLOR_BUFFER_BIT);
    }

    void SwapBuffers()
    {
        // Вывод нарисованного кадра в окно на экране.
        // При этом система отдаёт старый буфер для рисования нового кадра.
        // Обмен двух буферов вместо создания новых позволяет не тратить ресурсы впустую.
        SDL_GL_SwapWindow(m_pWindow.get());
    }

private:
    SDLWindowPtr m_pWindow;
    SDLGLContextPtr m_pGLContext;
    glm::vec4 m_clearColor;
};

CAbstractWindow::CAbstractWindow()
    : m_pImpl(new Impl)
{
}

CAbstractWindow::~CAbstractWindow()
{
}

void CAbstractWindow::ShowFixedSize(const glm::ivec2 &size)
{
    m_pImpl->ShowFixedSize(size);
}

void CAbstractWindow::DoGameLoop()
{
    SDL_Event event;
    CChronometer chronometer;
    bool running = true;
    while (running)
    {
        while (SDL_PollEvent(&event) != 0)
        {
            if (event.type == SDL_QUIT)
            {
                running = false;
            }
            else
            {
                OnWindowEvent(event);
            }
        }
        // Очистка буфера кадра, обновление и рисование сцены, вывод буфера кадра.
        if (running)
        {
            m_pImpl->Clear();
            const float deltaSeconds = chronometer.GrabDeltaTime();
            OnUpdateWindow(deltaSeconds);
            OnDrawWindow();
            m_pImpl->SwapBuffers();
        }
    }
}

void CAbstractWindow::SetBackgroundColor(const glm::vec4 &color)
{
    m_pImpl->SetBackgroundColor(color);
}

#include "stdafx.h"
#include "AbstractWindow.h"
#include <SDL2/SDL.h>

// Выключаем макроподмену main на SDL_main,
// т.к. приложение собирается c SUBSYSTEM:CONSOLE
#ifdef _WIN32
#undef main
#endif

class CWindow : public CAbstractWindow
{
protected:
    void OnWindowEvent(const SDL_Event &event) override
    {
        if (event.type == SDL_KEYDOWN)
        {
            switch (event.key.keysym.sym)
            {
            case SDLK_r:
                SetBackgroundColor({1, 0, 0, 1});
                break;
            case SDLK_g:
                SetBackgroundColor({0, 1, 0, 1});
                break;
            case SDLK_b:
                SetBackgroundColor({0, 0, 1, 1});
                break;
            }
        }
    }

    void OnUpdateWindow(float deltaSeconds) override
    {
        (void)deltaSeconds;
    }

    void OnDrawWindow() override
    {
    }
};

int main()
{
    CWindow window;
    window.ShowFixedSize({800, 600});
    window.DoGameLoop();

    return 0;
}