outsourced application handling

CMakeLists.txt

@@ -16,5 +16,6 @@ else (SDL2_FOUND)
 	set (SDL2_LIBRARIES SDL2-static SDL2main)
 endif (SDL2_FOUND)
 
-# Include sub-projects.
+# Include sub-projects
+add_subdirectory ("lib")
 add_subdirectory ("src")

lib/CMakeLists.txt

@@ -0,0 +1,11 @@
+
+add_library(nm_utils STATIC
+	"Window.cpp"
+)
+
+target_include_directories(nm_utils PUBLIC ${SDL2_INCLUDE_DIRS} ${CMAKE_CURRENT_SOURCE_DIR})
+target_link_libraries(nm_utils PUBLIC ${SDL2_LIBRARIES})
+
+if(MSVC)
+	target_compile_definitions(nm_utils PUBLIC _CRT_SECURE_NO_WARNINGS)
+endif()

lib/Window.cpp

@@ -0,0 +1,150 @@
+#include "Window.hpp"
+
+#include <iostream>
+#include <SDL.h>
+
+void Window::Launch()
+{
+	SDL_ShowWindow(window);
+
+	while (!shouldClose)
+	{
+		HandleEvents();
+		Update();
+		Render();
+	}
+
+	SDL_HideWindow(window);
+}
+
+Window::Window(int width, int height, const std::string& title)
+{
+	window = nullptr;
+	renderer = nullptr;
+
+	window = SDL_CreateWindow(
+		title.c_str(),
+		SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+		width, height,
+		SDL_WINDOW_HIDDEN
+	);
+	if (window == nullptr)
+	{
+		char errbuf[512];
+		SDL_GetErrorMsg(errbuf, 512);
+
+		std::cerr << "Failed to create SDL Window: " << std::endl
+			<< errbuf << std::endl;
+
+		return;
+	}
+
+	renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
+	if (renderer == nullptr)
+	{
+		char errbuf[512];
+		SDL_GetErrorMsg(errbuf, 512);
+
+		std::cerr << "Failed to create SDL Renderer: " << std::endl
+			<< errbuf << std::endl;
+
+		return;
+	}
+
+	SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
+
+	startOfLastFrame = std::chrono::steady_clock::now();
+}
+
+Window::Window(const Window& other)
+{
+	*this = other;
+}
+
+Window& Window::operator=(const Window& other)
+{
+	const char* title = SDL_GetWindowTitle(other.window);
+	int width, height;
+	SDL_GetWindowSize(other.window, &width, &height);
+
+	window = SDL_CreateWindow(
+		title,
+		SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+		width, height,
+		SDL_WINDOW_HIDDEN
+	);
+
+	if (window == nullptr)
+	{
+		char errbuf[512];
+		SDL_GetErrorMsg(errbuf, 512);
+
+		std::cerr << "Failed to create SDL Window: " << std::endl
+			<< errbuf << std::endl;
+
+		throw std::runtime_error("");
+	}
+
+	renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
+	if (renderer == nullptr)
+	{
+		char errbuf[512];
+		SDL_GetErrorMsg(errbuf, 512);
+
+		std::cerr << "Failed to create SDL Renderer: " << std::endl
+			<< errbuf << std::endl;
+
+		throw std::runtime_error("");
+	}
+
+	startOfLastFrame = std::chrono::steady_clock::now();
+
+	return *this;
+}
+
+Window::~Window()
+{
+	SDL_DestroyRenderer(renderer);
+	SDL_DestroyWindow(window);
+}
+
+void Window::HandleEvents()
+{
+	SDL_Event event;
+	while (SDL_PollEvent(&event))
+	{
+		switch (event.type)
+		{
+		case SDL_WINDOWEVENT:
+		{
+			switch (event.window.event)
+			{
+			case SDL_WINDOWEVENT_CLOSE:
+				shouldClose = true;
+				break;
+			}
+		} break;
+		}
+	}
+}
+
+void Window::Update()
+{
+	double dt = std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::steady_clock::now() - startOfLastFrame).count();
+	startOfLastFrame = std::chrono::steady_clock::now();
+
+	OnUpdate(dt);
+}
+
+void Window::Render()
+{
+	SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
+	SDL_RenderClear(renderer);
+
+	OnRender(renderer);
+
+	if (renderer == nullptr)
+		throw std::runtime_error("Client window left renderer in an invalid state");
+	
+	SDL_RenderPresent(renderer);
+}

lib/Window.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <string>
+#include <chrono>
+
+struct SDL_Renderer;
+struct SDL_Window;
+
+class Window
+{
+public:
+	void Launch();
+
+protected:
+	Window(int width, int height, const std::string& title);
+	Window(const Window& other);
+	Window& operator=(const Window& other);
+	~Window();
+
+
+	virtual void OnUpdate(double dt) {}
+	virtual void OnRender(SDL_Renderer* renderer) {}
+
+private:
+	void HandleEvents();
+	void Update();
+	void Render();
+
+protected:
+	SDL_Window* window;
+
+private:
+	SDL_Renderer* renderer;
+
+	bool shouldClose = false;
+	std::chrono::steady_clock::time_point startOfLastFrame;
+};

src/EulerFluid/Application.cpp

@@ -1,103 +0,0 @@
-#include "Application.hpp"
-
-#include <iostream>
-#include <SDL.h>
-
-Application::Application(int width, int height, const char* title)
-{
-	window = SDL_CreateWindow(
-		title, 
-		SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 
-		width, height, 
-		SDL_WINDOW_SHOWN
-	);
-	if (window == nullptr)
-	{
-		char errbuf[512];
-		SDL_GetErrorMsg(errbuf, 512);
-
-		std::cerr << "Failed to create SDL Window: " << std::endl
-			<< errbuf << std::endl;
-
-		return;
-	}
-
-	// Let's just pretend we're the first application in this program to create a renderer :) what could go wrong
-	renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
-	if (renderer == nullptr)
-	{
-		char errbuf[512];
-		SDL_GetErrorMsg(errbuf, 512);
-
-		std::cerr << "Failed to create SDL Renderer: " << std::endl
-			<< errbuf << std::endl;
-
-		return;
-	}
-
-	SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
-
-	field = new FluidField(60);
-	before = std::chrono::steady_clock::now();
-}
-
-Application::~Application()
-{
-	delete field;
-
-	SDL_DestroyRenderer(renderer);	// Let's just destroy this renderer regardless of other applications in this program :) what could go wrong
-	SDL_DestroyWindow(window);
-}
-
-void Application::Launch()
-{
-	if (renderer == nullptr || window == nullptr)
-	{
-		throw std::runtime_error("Can't launch application. Window or Renderer is in invalid state.");
-	}
-
-	while (!shouldClose)
-	{
-		HandleEvents();
-		Update();
-		Render();
-	}
-}
-
-void Application::HandleEvents()
-{
-	static SDL_Event event;
-
-	while (SDL_PollEvent(&event))
-	{
-		if (event.type == SDL_WINDOWEVENT)
-		{
-			switch (event.window.event)
-			{
-			case SDL_WINDOWEVENT_CLOSE:
-				shouldClose = true;
-				break;
-			}
-		}
-	}
-}
-
-void Application::Update()
-{
-	double frametime = std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::steady_clock::now() - before).count();
-	before = std::chrono::steady_clock::now();
-
-	field->VelocityStep(0.002, frametime);
-	field->DensityStep(0.0005, frametime);
-}
-
-void Application::Render()
-{
-	SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
-	SDL_RenderClear(renderer);
-
-
-	field->Draw(renderer, {0, 0, 1000, 1000});
-
-	SDL_RenderPresent(renderer);
-}

src/EulerFluid/Application.hpp

@@ -1,32 +0,0 @@
-#pragma once 
-
-#include <chrono>
-#include "FluidField.hpp"
-
-// Forward Declarations
-struct SDL_Window;
-struct SDL_Renderer;
-
-// Should be a singleton but who cares
-class Application
-{
-public:
-	Application(int width, int height, const char* title);
-	~Application();
-
-	void Launch();
-
-private:
-	void HandleEvents();
-	void Update();
-	void Render();
-
-private:
-	SDL_Window* window = nullptr;
-	SDL_Renderer* renderer = nullptr;
-
-	std::chrono::steady_clock::time_point before;
-	bool shouldClose = false;
-
-	FluidField* field;
-};

src/EulerFluid/CMakeLists.txt

@@ -4,10 +4,10 @@
 cmake_minimum_required (VERSION 3.8)
 
 # Add source to this project's executable.
-add_executable (EulerFluid "main.cpp" "Application.hpp" "Application.cpp" "VectorField.hpp" "VectorField.cpp" "FluidField.hpp" "FluidField.cpp")
+add_executable (EulerFluid "main.cpp" "EulerFluid.hpp" "EulerFluid.cpp" "VectorField.hpp" "VectorField.cpp" "FluidField.hpp" "FluidField.cpp")
 
-target_include_directories(EulerFluid PUBLIC ${SDL2_INCLUDE_DIRS})
+target_include_directories(EulerFluid PUBLIC nm_utils)
-target_link_libraries(EulerFluid PUBLIC ${SDL2_LIBRARIES})
+target_link_libraries(EulerFluid PRIVATE nm_utils)
 
 if(MSVC)
 target_compile_definitions(EulerFluid PUBLIC _CRT_SECURE_NO_WARNINGS)

src/EulerFluid/EulerFluid.cpp

@@ -0,0 +1,26 @@
+#include "EulerFluid.hpp"
+
+#include <iostream>
+#include <SDL.h>
+
+EulerFluid::EulerFluid(int width, int height, const char* title) :
+	Window::Window(width, height, title)
+{
+	field = new FluidField(60);
+}
+
+EulerFluid::~EulerFluid()
+{
+	delete field;
+}
+
+void EulerFluid::OnUpdate(double dt)
+{
+	field->VelocityStep(0.002, dt);
+	field->DensityStep(0.0005, dt);
+}
+
+void EulerFluid::OnRender(SDL_Renderer* renderer)
+{
+	field->Draw(renderer, {0, 0, 1000, 1000});
+}

src/EulerFluid/EulerFluid.hpp

@@ -0,0 +1,18 @@
+#pragma once 
+
+#include "Window.hpp"
+#include "FluidField.hpp"
+
+class EulerFluid : public Window
+{
+public:
+	EulerFluid(int width, int height, const char* title);
+	~EulerFluid();
+
+private:
+	void OnUpdate(double dt) override;
+	void OnRender(SDL_Renderer* renderer) override;
+
+private:
+	FluidField* field;
+};

src/EulerFluid/main.cpp

@@ -1,8 +1,10 @@
-#include "Application.hpp"
+#include "EulerFluid.hpp"
+
+#include <thread>
 
 int main(int argc, char** argv)
 {
-	Application* app = new Application(1000, 1000, "Euler Fluid Simulation");
+	EulerFluid* app = new EulerFluid(1000, 1000, "Euler Fluid Simulation");
 	app->Launch();
 
 	delete app;