begin adding SceneManager

CMakeLists.txt

@@ -12,8 +12,10 @@ project(engine LANGUAGES CXX
 set(SRC_FILES
 	"src/engine.cpp"
 	"src/window.cpp"
-	"src/input.cpp"
+	"src/input_manager.cpp"
+	"src/scene_manager.cpp"
 	"src/gfx_device_vulkan.cpp"
+
 	"src/util/files.cpp"
 )
 
@@ -26,7 +28,8 @@ set(INCLUDE_FILES
 	"include/window.hpp"
 	"include/inputs/keyboard.hpp"
 	"include/inputs/mouse.hpp"
-	"include/input.hpp"
+	"include/input_manager.hpp"
+	"include/scene_manager.hpp"
 	"include/gfx.hpp"
 	"include/gfx_device.hpp"
 	"include/util/files.hpp"

include/engine.hpp

@@ -1,30 +1,36 @@
 #pragma once
 
+#include <memory>
+
 namespace engine {
 
 	class Window;
 	class GFXDevice;
-	class Input;
+	class InputManager;
+	class SceneManager;
 
 	class Application {
+
 	public:
 		Application(const char* appName, const char* appVersion);
-
+		~Application();
 		Application(const Application&) = delete;
 		Application& operator=(const Application&) = delete;
 
-		~Application();
+		/* methods */
-
 		void gameLoop();
 
-		Window* window() { return m_win; }
+		/* getters */
-		GFXDevice* gfx() { return m_gfx; }
+		Window* window() { return m_window.get(); }
-		Input* input() { return m_input; }
+		GFXDevice* gfx() { return m_gfx.get(); }
+		InputManager* inputManager() { return m_inputManager.get(); }
+		SceneManager* sceneManager() { return m_sceneManager.get(); }
 
 	private:
-		Window* m_win;
+		std::unique_ptr<Window> m_window;
-		GFXDevice* m_gfx;
+		std::unique_ptr<GFXDevice> m_gfx;
-		Input* m_input;
+		std::unique_ptr<InputManager> m_inputManager;
+		std::unique_ptr<SceneManager> m_sceneManager;
 
 	};
 

include/input_manager.hpp

@@ -21,15 +21,15 @@ namespace engine {
 	};
 
 	// This class should be used to get platform/input-device independent input
-	class ENGINE_API Input {
+	class ENGINE_API InputManager {
 
 	public:
 
 		// requires a window reference to get input from
-		Input(const Window& win);
+		InputManager(const Window* win);
-		Input(const Input&) = delete;
+		InputManager(const InputManager&) = delete;
-		Input& operator=(const Input&) = delete;
+		InputManager& operator=(const InputManager&) = delete;
-		~Input();
+		~InputManager();
 
 		// Add a mouse input
 		void addInputButton(const std::string& name, inputs::MouseButton button);
@@ -68,7 +68,7 @@ namespace engine {
 			int low;
 		};
 
-		const Window& m_win;
+		const Window* const m_win;
 
 		std::vector<struct ButtonEntry> m_buttonEntries;
 		std::vector<struct AxisEntry> m_axisEntries;

include/scene_manager.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+namespace engine {
+
+	class SceneManager {
+
+	public:
+		SceneManager();
+		~SceneManager();
+		SceneManager(const SceneManager&) = delete;
+		SceneManager& operator=(const SceneManager&) = delete;
+
+	private:
+
+	};
+
+}

src/engine.cpp

@@ -4,7 +4,8 @@
 
 #include "window.hpp"
 #include "gfx_device.hpp"
-#include "input.hpp"
+#include "input_manager.hpp"
+#include "scene_manager.hpp"
 
 // To allow the FPS-limiter to put the thread to sleep
 #include <thread>
@@ -13,17 +14,13 @@ namespace engine {
 
 	Application::Application(const char* appName, const char* appVersion)
 	{
-		m_win = new Window(appName, true, true);
+		m_window = std::make_unique<Window>(appName, true, true);
-		m_gfx = new GFXDevice(appName, appVersion, m_win->getHandle());
+		m_gfx = std::make_unique<GFXDevice>(appName, appVersion, m_window->getHandle());
-		m_input = new Input(*m_win);
+		m_inputManager = std::make_unique<InputManager>(window());
+		m_sceneManager = std::make_unique<SceneManager>();
 	}
 
-	Application::~Application()
+	Application::~Application() {}
-	{
-		delete m_input;
-		delete m_gfx;
-		delete m_win;
-	}
 
 	void Application::gameLoop()
 	{
@@ -35,7 +32,7 @@ namespace engine {
 		auto endFrame = beginFrame + FRAMETIME_LIMIT;
 
 		// single-threaded game loop
-		while (m_win->isRunning()) {
+		while (m_window->isRunning()) {
 
 			/* logic */
 
@@ -43,7 +40,7 @@ namespace engine {
 			m_gfx->renderFrame();
 
 			/* poll events */
-			m_win->getInputAndEvents();
+			m_window->getInputAndEvents();
 
 			/* fps limiter */
 			std::this_thread::sleep_until(endFrame);

src/input_manager.cpp

@@ -1,4 +1,4 @@
-#include "input.hpp"
+#include "input_manager.hpp"
 
 #include "window.hpp"
 
@@ -7,30 +7,30 @@
 
 namespace engine {
 
-	Input::Input(const Window& win) : m_win(win)
+	InputManager::InputManager(const Window* win) : m_win(win)
 	{
 		m_enabledDevices.fill(true);
 	}
 
-	Input::~Input()
+	InputManager::~InputManager()
 	{
 	}
 
 	// private methods
 
-	float Input::getDeviceAxis(enum InputDevice device, int axis) const
+	float InputManager::getDeviceAxis(enum InputDevice device, int axis) const
 	{
 		switch (device) {
 		case InputDevice::MOUSE:
 			switch (static_cast<inputs::MouseAxis>(axis)) {
 			case inputs::MouseAxis::X:
-				return static_cast<float>(m_win.getMouseDX());
+				return static_cast<float>(m_win->getMouseDX());
 			case inputs::MouseAxis::Y:
-				return static_cast<float>(m_win.getMouseDY());
+				return static_cast<float>(m_win->getMouseDY());
 			case inputs::MouseAxis::X_SCR:
-				return m_win.getMouseScrollX();
+				return m_win->getMouseScrollX();
 			case inputs::MouseAxis::Y_SCR:
-				return m_win.getMouseScrollY();
+				return m_win->getMouseScrollY();
 			default: break;
 			}
 			break;
@@ -43,13 +43,13 @@ namespace engine {
 		throw std::runtime_error("Error getting device axis");
 	}
 
-	bool Input::getDeviceButton(enum InputDevice device, int button) const
+	bool InputManager::getDeviceButton(enum InputDevice device, int button) const
 	{
 		switch (device) {
 		case InputDevice::MOUSE:
-			return m_win.getButton(static_cast<inputs::MouseButton>(button));
+			return m_win->getButton(static_cast<inputs::MouseButton>(button));
 		case InputDevice::KEYBOARD:
-			return m_win.getKey(static_cast<inputs::Key>(button));
+			return m_win->getKey(static_cast<inputs::Key>(button));
 		case InputDevice::CONTROLLER:
 			break;
 		default: break;
@@ -57,13 +57,13 @@ namespace engine {
 		throw std::runtime_error("Error getting device button");
 	}
 
-	bool Input::getDeviceButtonDown(enum InputDevice device, int button) const
+	bool InputManager::getDeviceButtonDown(enum InputDevice device, int button) const
 	{
 		switch (device) {
 		case InputDevice::MOUSE:
-			return m_win.getButtonPress(static_cast<enum inputs::MouseButton>(button));
+			return m_win->getButtonPress(static_cast<enum inputs::MouseButton>(button));
 		case InputDevice::KEYBOARD:
-			return m_win.getKeyPress(static_cast<enum inputs::Key>(button));
+			return m_win->getKeyPress(static_cast<enum inputs::Key>(button));
 		case InputDevice::CONTROLLER:
 			break;
 		default: break;
@@ -71,13 +71,13 @@ namespace engine {
 		throw std::runtime_error("Error getting device button");
 	}
 
-	bool Input::getDeviceButtonUp(enum InputDevice device, int button) const
+	bool InputManager::getDeviceButtonUp(enum InputDevice device, int button) const
 	{
 		switch (device) {
 		case InputDevice::MOUSE:
-			return m_win.getButtonRelease(static_cast<enum inputs::MouseButton>(button));
+			return m_win->getButtonRelease(static_cast<enum inputs::MouseButton>(button));
 		case InputDevice::KEYBOARD:
-			return m_win.getKeyRelease(static_cast<enum inputs::Key>(button));
+			return m_win->getKeyRelease(static_cast<enum inputs::Key>(button));
 		case InputDevice::CONTROLLER:
 			break;
 		default: break;
@@ -85,7 +85,7 @@ namespace engine {
 		throw std::runtime_error("Error getting device button");
 	}
 
-	float Input::getButtonAxis(enum InputDevice device, int high, int low) const
+	float InputManager::getButtonAxis(enum InputDevice device, int high, int low) const
 	{
 		float value = 0.0f;
 		if (getDeviceButton(device, high)) value += 1.0f;
@@ -97,17 +97,17 @@ namespace engine {
 
 	// public methods
 
-	void Input::addInputButton(const std::string& name, InputDevice device, int button)
+	void InputManager::addInputButton(const std::string& name, InputDevice device, int button)
 	{
 		m_buttonEntries.push_back({ name, device, button });
 	}
 
-	void Input::addInputAxis(const std::string& name, InputDevice device, int axis)
+	void InputManager::addInputAxis(const std::string& name, InputDevice device, int axis)
 	{
 		m_axisEntries.push_back({ name, device, axis, false, 0, 0 });
 	}
 
-	void Input::addInputButtonAsAxis(const std::string& name, InputDevice device, int high, int low)
+	void InputManager::addInputButtonAsAxis(const std::string& name, InputDevice device, int high, int low)
 	{
 		m_axisEntries.push_back({ name, device, 0, true, high, low });
 	}
@@ -115,56 +115,56 @@ namespace engine {
 	// OVERLOADS:
 
 	// Add a mouse input
-	void Input::addInputButton(const std::string& name, inputs::MouseButton button)
+	void InputManager::addInputButton(const std::string& name, inputs::MouseButton button)
 	{
 		addInputButton(name, InputDevice::MOUSE, static_cast<int>(button));
 	}
 
-	void Input::addInputAxis(const std::string& name, inputs::MouseAxis axis)
+	void InputManager::addInputAxis(const std::string& name, inputs::MouseAxis axis)
 	{
 		addInputAxis(name, InputDevice::MOUSE, static_cast<int>(axis));
 	}
 
-	void Input::addInputButtonAsAxis(const std::string& name, inputs::MouseButton high, inputs::MouseButton low)
+	void InputManager::addInputButtonAsAxis(const std::string& name, inputs::MouseButton high, inputs::MouseButton low)
 	{
 		addInputButtonAsAxis(name, InputDevice::MOUSE, static_cast<int>(high), static_cast<int>(low));
 	}
 
-	void Input::addInputButton(const std::string& name, inputs::Key button)
+	void InputManager::addInputButton(const std::string& name, inputs::Key button)
 	{
 		addInputButton(name, InputDevice::KEYBOARD, static_cast<int>(button));
 	}
 
-	void Input::addInputButtonAsAxis(const std::string& name, inputs::Key high, inputs::Key low)
+	void InputManager::addInputButtonAsAxis(const std::string& name, inputs::Key high, inputs::Key low)
 	{
 		addInputButtonAsAxis(name, InputDevice::KEYBOARD, static_cast<int>(high), static_cast<int>(low));
 	}
 
-	void Input::delInputButton(int index)
+	void InputManager::delInputButton(int index)
 	{
 		std::vector<struct ButtonEntry>::iterator it = m_buttonEntries.begin();
 		std::advance(it, index);
 		m_buttonEntries.erase(it);
 	}
 
-	void Input::delInputAxis(int index)
+	void InputManager::delInputAxis(int index)
 	{
 		std::vector<struct AxisEntry>::iterator it = m_axisEntries.begin();
 		std::advance(it, index);
 		m_axisEntries.erase(it);
 	}
 
-	void Input::setDeviceActive(enum InputDevice device, bool active)
+	void InputManager::setDeviceActive(enum InputDevice device, bool active)
 	{
 		m_enabledDevices[static_cast<int>(device)] = active;
 	}
 
-	bool Input::getDeviceActive(enum InputDevice device) const
+	bool InputManager::getDeviceActive(enum InputDevice device) const
 	{
 		return m_enabledDevices[static_cast<int>(device)];
 	}
 
-	float Input::getAxis(const std::string& axisName) const
+	float InputManager::getAxis(const std::string& axisName) const
 	{
 		for (const AxisEntry& e : m_axisEntries) {
 			if (e.name == axisName) {
@@ -182,7 +182,7 @@ namespace engine {
 	//	throw std::runtime_error("Unable to find mapping in input table");
 	}
 
-	bool Input::getButton(const std::string& buttonName) const
+	bool InputManager::getButton(const std::string& buttonName) const
 	{
 		bool isDown = false;
 
@@ -199,7 +199,7 @@ namespace engine {
 		return isDown;
 	}
 
-	bool Input::getButtonPress(const std::string& buttonName) const
+	bool InputManager::getButtonPress(const std::string& buttonName) const
 	{
 		bool isPressed = false;
 
@@ -216,7 +216,7 @@ namespace engine {
 		return isPressed;
 	}
 
-	bool Input::getButtonRelease(const std::string& buttonName) const
+	bool InputManager::getButtonRelease(const std::string& buttonName) const
 	{
 		bool isReleased = false;
 

src/scene_manager.cpp

@@ -0,0 +1,15 @@
+#include "scene_manager.hpp"
+
+namespace engine {
+
+	SceneManager::SceneManager()
+	{
+
+	}
+
+	SceneManager::~SceneManager()
+	{
+
+	}
+
+}