From 80c74b90a3e44e25a4fa9fdd25bf0aa9efbaf6fd Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Mon, 11 Nov 2024 16:12:09 +0100
Subject: interfaces working but unsubscribe broken

---
 src/crepe/api/CMakeLists.txt | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'src/crepe/api/CMakeLists.txt')

diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt
index 87cbb09..4e8f8a0 100644
--- a/src/crepe/api/CMakeLists.txt
+++ b/src/crepe/api/CMakeLists.txt
@@ -18,6 +18,10 @@ target_sources(crepe PUBLIC
 	Vector2.cpp
 	Camera.cpp
 	Animator.cpp
+	EventManager.cpp
+	EventHandler.cpp
+	IKeyListener.cpp
+	IMouseListener.cpp
 )
 
 target_sources(crepe PUBLIC FILE_SET HEADERS FILES
@@ -42,4 +46,9 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	SceneManager.hpp
 	Camera.h
 	Animator.h
+	EventManager.h
+	EventHandler.h
+	Event.h
+	IKeyListener.h
+	IMouseListener.h
 )
-- 
cgit v1.2.3


From cab672ce6258aec563e7f0e0549281156c0c8d21 Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Fri, 15 Nov 2024 12:43:38 +0100
Subject: feedback

---
 src/crepe/api/CMakeLists.txt     |  14 ++++
 src/crepe/api/Event.h            |  13 ++--
 src/crepe/api/EventHandler.h     |   1 +
 src/crepe/api/EventManager.cpp   |   3 +
 src/crepe/api/EventManager.h     | 142 ++-------------------------------------
 src/crepe/api/EventManager.hpp   | 140 ++++++++++++++++++++++++++++++++++++++
 src/crepe/api/IKeyListener.cpp   |   4 +-
 src/crepe/api/IMouseListener.cpp |  10 ++-
 src/crepe/api/KeyCodes.h         |   1 -
 src/example/events.cpp           |  10 ++-
 10 files changed, 187 insertions(+), 151 deletions(-)
 create mode 100644 src/crepe/api/EventManager.hpp

(limited to 'src/crepe/api/CMakeLists.txt')

diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt
index 87cbb09..53b3041 100644
--- a/src/crepe/api/CMakeLists.txt
+++ b/src/crepe/api/CMakeLists.txt
@@ -18,6 +18,12 @@ target_sources(crepe PUBLIC
 	Vector2.cpp
 	Camera.cpp
 	Animator.cpp
+	EventManager.cpp
+	EventHandler.cpp
+	IKeyListener.cpp
+	IMouseListener.cpp
+	LoopManager.cpp
+	LoopTimer.cpp
 )
 
 target_sources(crepe PUBLIC FILE_SET HEADERS FILES
@@ -42,4 +48,12 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	SceneManager.hpp
 	Camera.h
 	Animator.h
+	EventManager.h
+	EventManager.hpp
+	EventHandler.h
+	Event.h
+	IKeyListener.h
+	IMouseListener.h
+	LoopManager.h
+	LoopTimer.h
 )
diff --git a/src/crepe/api/Event.h b/src/crepe/api/Event.h
index cffa5da..701ecdf 100644
--- a/src/crepe/api/Event.h
+++ b/src/crepe/api/Event.h
@@ -6,38 +6,37 @@
 
 class Event {
 public:
-	bool handled = false;
 };
 
 class KeyPressEvent : public Event {
 public:
 	int repeat = 0;
-	Keycode key = Keycode::None;
+	Keycode key = Keycode::NONE;
 };
 
 class KeyReleaseEvent : public Event {
 public:
-	Keycode key = Keycode::None;
+	Keycode key = Keycode::NONE;
 };
 
 class MousePressEvent : public Event {
 public:
 	int mouse_x = 0;
 	int mouse_y = 0;
-	MouseButton button;
+	MouseButton button = MouseButton::NONE;
 };
 
 class MouseClickEvent : public Event {
 public:
 	int mouse_x = 0;
 	int mouse_y = 0;
-	MouseButton button;
+	MouseButton button = MouseButton::NONE;
 };
 class MouseReleaseEvent : public Event {
 public:
 	int mouse_x = 0;
 	int mouse_y = 0;
-	MouseButton button = MouseButton::None;
+	MouseButton button = MouseButton::NONE;
 };
 class MouseMoveEvent : public Event {
 public:
@@ -50,7 +49,7 @@ public:
 };
 class TextSubmitEvent : public Event {
 public:
-	std::string text;
+	std::string text = "";
 };
 class ShutDownEvent : public Event {
 public:
diff --git a/src/crepe/api/EventHandler.h b/src/crepe/api/EventHandler.h
index 46c6c7b..0ab90de 100644
--- a/src/crepe/api/EventHandler.h
+++ b/src/crepe/api/EventHandler.h
@@ -12,6 +12,7 @@
  * 
  * \tparam EventType The type of event this handler will handle.
  */
+// TODO: typedef
 template <typename EventType>
 using EventHandler = std::function<bool(const EventType & e)>;
 
diff --git a/src/crepe/api/EventManager.cpp b/src/crepe/api/EventManager.cpp
index 72cfd74..e881d49 100644
--- a/src/crepe/api/EventManager.cpp
+++ b/src/crepe/api/EventManager.cpp
@@ -1,5 +1,7 @@
 #include "EventManager.h"
 
+using namespace crepe;
+
 EventManager & EventManager::get_instance() {
 	static EventManager instance;
 	return instance;
@@ -62,6 +64,7 @@ void EventManager::dispatch_events() {
 						 iterator handler_it
 					 = handlers.begin();
 					 handler_it != handlers.end(); ++handler_it) {
+					// remove event from queue since and continue when callback returns true
 					if ((*handler_it)->exec(*event)) {
 						event_it = this->events_queue.erase(event_it);
 						event_handled = true;
diff --git a/src/crepe/api/EventManager.h b/src/crepe/api/EventManager.h
index e2665bd..38d2e64 100644
--- a/src/crepe/api/EventManager.h
+++ b/src/crepe/api/EventManager.h
@@ -10,6 +10,8 @@
 #include "Event.h"
 #include "EventHandler.h"
 
+
+namespace crepe {
 /**
  * \class EventManager
  * \brief The EventManager class is responsible for managing the subscription, triggering, 
@@ -115,142 +117,6 @@ private:
 						   std::vector<std::unique_ptr<IEventHandlerWrapper>>>>
 		subscribers_by_event_id;
 };
-template <typename EventType>
-void EventManager::subscribe(EventHandler<EventType> && callback, int channel) {
-	std::type_index event_type = typeid(EventType);
-	std::unique_ptr<EventHandlerWrapper<EventType>> handler
-		= std::make_unique<EventHandlerWrapper<EventType>>(callback);
-
-	if (channel) {
-		std::unordered_map<int,
-						   std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
-			handlers_map
-			= this->subscribers_by_event_id[event_type];
-		std::unordered_map<
-			int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
-			handlers
-			= handlers_map.find(channel);
-		if (handlers != handlers_map.end()) {
-			handlers->second.emplace_back(std::move(handler));
-		} else {
-			handlers_map[channel].emplace_back(std::move(handler));
-		}
-	} else {
-		std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
-			= this->subscribers[event_type];
-		handlers.emplace_back(std::move(handler));
-	}
-}
-
-template <typename EventType>
-void EventManager::queue_event(EventType && event, int channel) {
-	std::type_index event_type = std::type_index(typeid(EventType));
-
-	std::unique_ptr<EventType> event_ptr
-		= std::make_unique<EventType>(std::forward<EventType>(event));
-
-	std::tuple<std::unique_ptr<Event>, int, std::type_index> tuple(
-		std::move(event_ptr), channel, event_type);
-	this->events_queue.push_back(std::move(tuple));
-}
-
-template <typename EventType>
-void EventManager::trigger_event(const EventType & event, int channel) {
-	std::type_index event_type = std::type_index(typeid(EventType));
-
-	if (channel > 0) {
-		std::unordered_map<int,
-						   std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
-			handlers_map
-			= this->subscribers_by_event_id[event_type];
-		std::unordered_map<
-			int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
-			handlers_it
-			= handlers_map.find(channel);
-
-		if (handlers_it != handlers_map.end()) {
-			std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
-				= handlers_it->second;
-			for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
-				 = handlers.begin();
-				 it != handlers.end();) {
-				// erases callback if callback function returns true
-				if ((*it)->exec(event)) {
-					it = handlers.erase(it);
-				} else {
-					++it;
-				}
-			}
-		}
-	} else {
-		std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
-			= this->subscribers[event_type];
-		for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
-			 = handlers.begin();
-			 it != handlers.end();) {
-			// erases callback if callback function returns true
-			if ((*it)->exec(event)) {
-				it = handlers.erase(it);
-			} else {
-				++it;
-			}
-		}
-	}
-}
-
-template <typename EventType>
-void EventManager::unsubscribe(const EventHandler<EventType> & callback,
-							   int channel) {
-	std::type_index event_type(typeid(EventType));
-	std::string handler_name = callback.target_type().name();
 
-	if (channel) {
-		std::unordered_map<
-			std::type_index,
-			std::unordered_map<
-				int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::
-			iterator subscriber_list
-			= this->subscribers_by_event_id.find(event_type);
-		if (subscriber_list != this->subscribers_by_event_id.end()) {
-			std::unordered_map<
-				int, std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
-				handlers_map
-				= subscriber_list->second;
-			std::unordered_map<
-				int,
-				std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
-				handlers
-				= handlers_map.find(channel);
-			if (handlers != handlers_map.end()) {
-				std::vector<std::unique_ptr<IEventHandlerWrapper>> & callbacks
-					= handlers->second;
-				for (std::vector<
-						 std::unique_ptr<IEventHandlerWrapper>>::iterator it
-					 = callbacks.begin();
-					 it != callbacks.end(); ++it) {
-					if ((*it)->get_type() == handler_name) {
-						it = callbacks.erase(it);
-						return;
-					}
-				}
-			}
-		}
-	} else {
-		std::unordered_map<std::type_index,
-						   std::vector<std::unique_ptr<IEventHandlerWrapper>>>::
-			iterator handlers_it
-			= this->subscribers.find(event_type);
-		if (handlers_it != this->subscribers.end()) {
-			std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
-				= handlers_it->second;
-			for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
-				 = handlers.begin();
-				 it != handlers.end(); ++it) {
-				if ((*it)->get_type() == handler_name) {
-					it = handlers.erase(it);
-					return;
-				}
-			}
-		}
-	}
-}
+} // namespace crepe
+#include "EventManager.hpp"
diff --git a/src/crepe/api/EventManager.hpp b/src/crepe/api/EventManager.hpp
new file mode 100644
index 0000000..b509097
--- /dev/null
+++ b/src/crepe/api/EventManager.hpp
@@ -0,0 +1,140 @@
+#include "EventManager.h"
+namespace crepe {
+
+template <typename EventType>
+void EventManager::subscribe(EventHandler<EventType> && callback, int channel) {
+	std::type_index event_type = typeid(EventType);
+	std::unique_ptr<EventHandlerWrapper<EventType>> handler
+		= std::make_unique<EventHandlerWrapper<EventType>>(callback);
+
+	if (channel) {
+		std::unordered_map<int,
+						   std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
+			handlers_map
+			= this->subscribers_by_event_id[event_type];
+		std::unordered_map<
+			int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
+			handlers
+			= handlers_map.find(channel);
+		if (handlers != handlers_map.end()) {
+			handlers->second.emplace_back(std::move(handler));
+		} else {
+			handlers_map[channel].emplace_back(std::move(handler));
+		}
+	} else {
+		std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
+			= this->subscribers[event_type];
+		handlers.emplace_back(std::move(handler));
+	}
+}
+
+template <typename EventType>
+void EventManager::queue_event(EventType && event, int channel) {
+	std::type_index event_type = std::type_index(typeid(EventType));
+
+	std::unique_ptr<EventType> event_ptr
+		= std::make_unique<EventType>(std::forward<EventType>(event));
+
+	std::tuple<std::unique_ptr<Event>, int, std::type_index> tuple(
+		std::move(event_ptr), channel, event_type);
+	this->events_queue.push_back(std::move(tuple));
+}
+
+template <typename EventType>
+void EventManager::trigger_event(const EventType & event, int channel) {
+	std::type_index event_type = std::type_index(typeid(EventType));
+
+	if (channel > 0) {
+		std::unordered_map<int,
+						   std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
+			handlers_map
+			= this->subscribers_by_event_id[event_type];
+		std::unordered_map<
+			int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
+			handlers_it
+			= handlers_map.find(channel);
+
+		if (handlers_it != handlers_map.end()) {
+			std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
+				= handlers_it->second;
+			for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
+				 = handlers.begin();
+				 it != handlers.end();++it) {
+				// stops when callback returns true
+				if((*it)->exec(event)){
+					break;
+				}
+			}
+		}
+	} else {
+		std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
+			= this->subscribers[event_type];
+		for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
+			 = handlers.begin();
+			 it != handlers.end();++it) {
+			// stops when callback returns true
+			if((*it)->exec(event)){
+					break;
+				}
+		}
+	}
+}
+
+template <typename EventType>
+void EventManager::unsubscribe(const EventHandler<EventType> & callback,
+							   int channel) {
+	std::type_index event_type(typeid(EventType));
+	std::string handler_name = callback.target_type().name();
+
+	if (channel) {
+		std::unordered_map<
+			std::type_index,
+			std::unordered_map<
+				int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::
+			iterator subscriber_list
+			= this->subscribers_by_event_id.find(event_type);
+		if (subscriber_list != this->subscribers_by_event_id.end()) {
+			std::unordered_map<
+				int, std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
+				handlers_map
+				= subscriber_list->second;
+			std::unordered_map<
+				int,
+				std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
+				handlers
+				= handlers_map.find(channel);
+			if (handlers != handlers_map.end()) {
+				std::vector<std::unique_ptr<IEventHandlerWrapper>> & callbacks
+					= handlers->second;
+				for (std::vector<
+						 std::unique_ptr<IEventHandlerWrapper>>::iterator it
+					 = callbacks.begin();
+					 it != callbacks.end(); ++it) {
+					if ((*it)->get_type() == handler_name) {
+						it = callbacks.erase(it);
+						return;
+					}
+				}
+			}
+		}
+	} else {
+		std::unordered_map<std::type_index,
+						   std::vector<std::unique_ptr<IEventHandlerWrapper>>>::
+			iterator handlers_it
+			= this->subscribers.find(event_type);
+		if (handlers_it != this->subscribers.end()) {
+			std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
+				= handlers_it->second;
+			for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
+				 = handlers.begin();
+				 it != handlers.end(); ++it) {
+				if ((*it)->get_type() == handler_name) {
+					it = handlers.erase(it);
+					return;
+				}
+			}
+		}
+	}
+}
+
+}
diff --git a/src/crepe/api/IKeyListener.cpp b/src/crepe/api/IKeyListener.cpp
index eb8f9af..4fd9855 100644
--- a/src/crepe/api/IKeyListener.cpp
+++ b/src/crepe/api/IKeyListener.cpp
@@ -1,5 +1,7 @@
 #include "IKeyListener.h"
-#include <iostream>
+
+using namespace crepe;
+
 IKeyListener::IKeyListener() {
 	this->channel = channel;
 	this->subscribe_events();
diff --git a/src/crepe/api/IMouseListener.cpp b/src/crepe/api/IMouseListener.cpp
index 683632c..489e55b 100644
--- a/src/crepe/api/IMouseListener.cpp
+++ b/src/crepe/api/IMouseListener.cpp
@@ -1,6 +1,11 @@
 #include "IMouseListener.h"
+
+using namespace crepe;
+
 IMouseListener::IMouseListener(int channel) { this->channel = channel; }
+
 IMouseListener::IMouseListener() { this->subscribe_events(); }
+
 IMouseListener::~IMouseListener() { this->unsubscribe_events(); }
 
 void IMouseListener::subscribe_events() {
@@ -26,7 +31,7 @@ void IMouseListener::subscribe_events() {
 	EventManager::get_instance().subscribe<MouseMoveEvent>(
 		std::move(this->mouse_move_handler), this->channel);
 }
-
+// TODO: reference voor singleton
 void IMouseListener::unsubscribe_events() {
 	EventManager::get_instance().unsubscribe<MouseClickEvent>(
 		this->mouse_click_handler, this->channel);
@@ -37,18 +42,21 @@ void IMouseListener::unsubscribe_events() {
 	EventManager::get_instance().unsubscribe<MouseMoveEvent>(
 		this->mouse_move_handler, this->channel);
 }
+
 void IMouseListener::activate_mouse() {
 	if (this->active) {
 		return;
 	}
 	this->subscribe_events();
 }
+
 void IMouseListener::deactivate_mouse() {
 	if (!this->active) {
 		return;
 	}
 	this->unsubscribe_events();
 }
+
 void IMouseListener::set_channel(int channel) {
 	this->unsubscribe_events();
 	this->channel = channel;
diff --git a/src/crepe/api/KeyCodes.h b/src/crepe/api/KeyCodes.h
index 1cb1a8a..e5a91fc 100644
--- a/src/crepe/api/KeyCodes.h
+++ b/src/crepe/api/KeyCodes.h
@@ -12,7 +12,6 @@ enum class MouseButton {
 };
 
 enum class Keycode : int {
-	// From glfw3.h
 	NONE = 0,
 	SPACE = 32,
 	APOSTROPHE = 39, /* ' */
diff --git a/src/example/events.cpp b/src/example/events.cpp
index 51c9a37..9c59bb7 100644
--- a/src/example/events.cpp
+++ b/src/example/events.cpp
@@ -70,7 +70,7 @@ int main() {
 	key_press.key = Keycode::A;
 	key_press.repeat = 0;
 	MouseClickEvent click_event;
-	click_event.button = MouseButton::Left_Mouse;
+	click_event.button = MouseButton::LEFT_MOUSE;
 	click_event.mouse_x = 100;
 	click_event.mouse_y = 200;
 	// queue events to test queue
@@ -89,8 +89,12 @@ int main() {
 
 		// Trigger the events while `testListener` is in scope
 		EventManager::get_instance().trigger_event<KeyPressEvent>(key_press, 1);
-		EventManager::get_instance().trigger_event<MouseClickEvent>(click_event,
-																	1);
+		// EventManager::get_instance().trigger_event<MouseClickEvent>(MouseClickEvent{
+		// 	.button = MouseButton::LEFT_MOUSE,
+		// 	.mouse_y = 100,
+		// 	.mouse_x = 100,
+			
+		// },1);
 	}
 	// custom lambda event handler
 	EventHandler<KeyPressEvent> event_handler = [](const KeyPressEvent & e) {
-- 
cgit v1.2.3


From 6e7003c73110cf9ad7e4c72de703dfdc2292d8ca Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Sat, 16 Nov 2024 13:55:47 +0100
Subject: added hpp files and auto

---
 src/crepe/api/CMakeLists.txt   |  3 +-
 src/crepe/api/Event.h          | 94 ++++++++++++++++++++++++++++++++++--------
 src/crepe/api/EventHandler.cpp |  8 +++-
 src/crepe/api/EventHandler.h   | 53 +++++++++++++-----------
 src/crepe/api/EventHandler.hpp | 25 +++++++++++
 src/crepe/api/EventManager.hpp | 42 +++++--------------
 src/crepe/api/IKeyListener.h   |  3 ++
 src/crepe/api/IMouseListener.h |  3 ++
 8 files changed, 155 insertions(+), 76 deletions(-)
 create mode 100644 src/crepe/api/EventHandler.hpp

(limited to 'src/crepe/api/CMakeLists.txt')

diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt
index 53b3041..edf4250 100644
--- a/src/crepe/api/CMakeLists.txt
+++ b/src/crepe/api/CMakeLists.txt
@@ -19,11 +19,11 @@ target_sources(crepe PUBLIC
 	Camera.cpp
 	Animator.cpp
 	EventManager.cpp
-	EventHandler.cpp
 	IKeyListener.cpp
 	IMouseListener.cpp
 	LoopManager.cpp
 	LoopTimer.cpp
+	EventHandler.cpp
 )
 
 target_sources(crepe PUBLIC FILE_SET HEADERS FILES
@@ -51,6 +51,7 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	EventManager.h
 	EventManager.hpp
 	EventHandler.h
+	EventHandler.hpp
 	Event.h
 	IKeyListener.h
 	IMouseListener.h
diff --git a/src/crepe/api/Event.h b/src/crepe/api/Event.h
index 701ecdf..e7cac25 100644
--- a/src/crepe/api/Event.h
+++ b/src/crepe/api/Event.h
@@ -1,56 +1,116 @@
 #pragma once
-#include "KeyCodes.h"
+
 #include <iostream>
 #include <string>
 #include <typeindex>
 
+#include "KeyCodes.h"
+/**
+ * \brief Base class for all event types in the system.
+ */
 class Event {
 public:
 };
 
+/**
+ * \brief Event triggered when a key is pressed.
+ */
 class KeyPressEvent : public Event {
 public:
-	int repeat = 0;
-	Keycode key = Keycode::NONE;
+    //! Number of times the key press is repeated (e.g., for long presses).
+    int repeat = 0;
+
+    //! The key that was pressed.
+    Keycode key = Keycode::NONE;
 };
 
+/**
+ * \brief Event triggered when a key is released.
+ */
 class KeyReleaseEvent : public Event {
 public:
-	Keycode key = Keycode::NONE;
+    //! The key that was released.
+    Keycode key = Keycode::NONE;
 };
 
+/**
+ * \brief Event triggered when a mouse button is pressed.
+ */
 class MousePressEvent : public Event {
 public:
-	int mouse_x = 0;
-	int mouse_y = 0;
-	MouseButton button = MouseButton::NONE;
+    //! X-coordinate of the mouse position at the time of the event.
+    int mouse_x = 0;
+
+    //! Y-coordinate of the mouse position at the time of the event.
+    int mouse_y = 0;
+
+    //! The mouse button that was pressed.
+    MouseButton button = MouseButton::NONE;
 };
 
+/**
+ * \brief Event triggered when a mouse button is clicked (press and release).
+ */
 class MouseClickEvent : public Event {
 public:
-	int mouse_x = 0;
-	int mouse_y = 0;
-	MouseButton button = MouseButton::NONE;
+    //! X-coordinate of the mouse position at the time of the event.
+    int mouse_x = 0;
+
+    //! Y-coordinate of the mouse position at the time of the event.
+    int mouse_y = 0;
+
+    //! The mouse button that was clicked.
+    MouseButton button = MouseButton::NONE;
 };
+
+/**
+ * \brief Event triggered when a mouse button is released.
+ */
 class MouseReleaseEvent : public Event {
 public:
-	int mouse_x = 0;
-	int mouse_y = 0;
-	MouseButton button = MouseButton::NONE;
+    //! X-coordinate of the mouse position at the time of the event.
+    int mouse_x = 0;
+
+    //! Y-coordinate of the mouse position at the time of the event.
+    int mouse_y = 0;
+
+    //! The mouse button that was released.
+    MouseButton button = MouseButton::NONE;
 };
+
+/**
+ * \brief Event triggered when the mouse is moved.
+ */
 class MouseMoveEvent : public Event {
 public:
-	int mouse_x = 0;
-	int mouse_y = 0;
+    //! X-coordinate of the mouse position at the time of the event.
+    int mouse_x = 0;
+
+    //! Y-coordinate of the mouse position at the time of the event.
+    int mouse_y = 0;
 };
+
+/**
+ * \brief Event triggered during a collision between objects.
+ */
 class CollisionEvent : public Event {
 public:
-	//Collision collisionData;
+    //! Data describing the collision (currently not implemented).
+    // Collision collisionData;
 };
+
+/**
+ * \brief Event triggered when text is submitted, e.g., from a text input.
+ */
 class TextSubmitEvent : public Event {
 public:
-	std::string text = "";
+    //! The submitted text.
+    std::string text = "";
 };
+
+/**
+ * \brief Event triggered to indicate the application is shutting down.
+ */
 class ShutDownEvent : public Event {
 public:
 };
diff --git a/src/crepe/api/EventHandler.cpp b/src/crepe/api/EventHandler.cpp
index 93a116a..d90d765 100644
--- a/src/crepe/api/EventHandler.cpp
+++ b/src/crepe/api/EventHandler.cpp
@@ -1,2 +1,8 @@
 #include "EventHandler.h"
-bool IEventHandlerWrapper::exec(const Event & e) { return call(e); }
+
+using namespace crepe;
+
+// Implementation of IEventHandlerWrapper::exec
+bool IEventHandlerWrapper::exec(const Event & e) {
+    return call(e);
+}
diff --git a/src/crepe/api/EventHandler.h b/src/crepe/api/EventHandler.h
index 0ab90de..2a684c0 100644
--- a/src/crepe/api/EventHandler.h
+++ b/src/crepe/api/EventHandler.h
@@ -1,9 +1,11 @@
 #pragma once
-#include "Event.h"
+
 #include <functional>
-#include <iostream>
-#include <typeindex>
+#include <string>
+
+#include "Event.h"
 
+namespace crepe {
 /**
  * \brief A type alias for an event handler function.
  * 
@@ -12,7 +14,6 @@
  * 
  * \tparam EventType The type of event this handler will handle.
  */
-// TODO: typedef
 template <typename EventType>
 using EventHandler = std::function<bool(const EventType & e)>;
 
@@ -25,12 +26,12 @@ using EventHandler = std::function<bool(const EventType & e)>;
  */
 class IEventHandlerWrapper {
 public:
-	/**
+    /**
      * \brief Virtual destructor for IEventHandlerWrapper.
      */
-	virtual ~IEventHandlerWrapper() = default;
+    virtual ~IEventHandlerWrapper() = default;
 
-	/**
+    /**
      * \brief Executes the handler with the given event.
      * 
      * This method calls the `call()` method of the derived class, passing the event to the handler.
@@ -38,19 +39,19 @@ public:
      * \param e The event to be processed.
      * \return A boolean value indicating whether the event is handled.
      */
-	bool exec(const Event & e);
+    bool exec(const Event & e);
 
-	/**
+    /**
      * \brief Get the type of the event handler.
      * 
      * This method returns the type of the event handler as a string.
      * 
      * \return A string representing the handler's type.
      */
-	virtual std::string get_type() const = 0;
+    virtual std::string get_type() const = 0;
 
 private:
-	/**
+    /**
      * \brief The method responsible for handling the event.
      * 
      * This method is implemented by derived classes to process the event.
@@ -58,7 +59,7 @@ private:
      * \param e The event to be processed.
      * \return A boolean value indicating whether the event is handled.
      */
-	virtual bool call(const Event & e) = 0;
+    virtual bool call(const Event & e) = 0;
 };
 
 /**
@@ -74,18 +75,17 @@ private:
 template <typename EventType>
 class EventHandlerWrapper : public IEventHandlerWrapper {
 public:
-	/**
+    /**
      * \brief Constructs an EventHandlerWrapper with a given handler.
      * 
      * The constructor takes an event handler function and stores it in the wrapper.
      * 
      * \param handler The event handler function.
      */
-	explicit EventHandlerWrapper(const EventHandler<EventType> & handler)
-		: m_handler(handler), m_handler_type(m_handler.target_type().name()) {}
+    explicit EventHandlerWrapper(const EventHandler<EventType> & handler);
 
 private:
-	/**
+    /**
      * \brief Calls the stored event handler with the event.
      * 
      * This method casts the event to the appropriate type and calls the handler.
@@ -93,20 +93,23 @@ private:
      * \param e The event to be handled.
      * \return A boolean value indicating whether the event is handled.
      */
-	bool call(const Event & e) override {
-		return m_handler(static_cast<const EventType &>(e));
-	}
+    bool call(const Event & e) override;
 
-	/**
+    /**
      * \brief Returns the type of the handler.
      * 
      * This method returns a string representing the type of the event handler.
      * 
      * \return The handler type as a string.
      */
-	std::string get_type() const override { return m_handler_type; }
-	//! The event handler function.
-	EventHandler<EventType> m_handler;
-	//! The type name of the handler function.
-	const std::string m_handler_type;
+    std::string get_type() const override;
+
+    //! The event handler function.
+    EventHandler<EventType> m_handler;
+    //! The type name of the handler function.
+    const std::string m_handler_type;
 };
+
+} // namespace crepe
+
+#include "EventHandler.hpp"
diff --git a/src/crepe/api/EventHandler.hpp b/src/crepe/api/EventHandler.hpp
new file mode 100644
index 0000000..1b5702e
--- /dev/null
+++ b/src/crepe/api/EventHandler.hpp
@@ -0,0 +1,25 @@
+
+#include <typeindex>
+
+#include "EventHandler.h"
+
+namespace crepe {
+
+// Implementation of EventHandlerWrapper constructor
+template <typename EventType>
+EventHandlerWrapper<EventType>::EventHandlerWrapper(const EventHandler<EventType> & handler)
+    : m_handler(handler), m_handler_type(m_handler.target_type().name()) {}
+
+// Implementation of EventHandlerWrapper::call
+template <typename EventType>
+bool EventHandlerWrapper<EventType>::call(const Event & e) {
+    return m_handler(static_cast<const EventType &>(e));
+}
+
+// Implementation of EventHandlerWrapper::get_type
+template <typename EventType>
+std::string EventHandlerWrapper<EventType>::get_type() const {
+    return m_handler_type;
+}
+
+} //namespace crepe
diff --git a/src/crepe/api/EventManager.hpp b/src/crepe/api/EventManager.hpp
index b509097..70f0a31 100644
--- a/src/crepe/api/EventManager.hpp
+++ b/src/crepe/api/EventManager.hpp
@@ -12,10 +12,7 @@ void EventManager::subscribe(EventHandler<EventType> && callback, int channel) {
 						   std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
 			handlers_map
 			= this->subscribers_by_event_id[event_type];
-		std::unordered_map<
-			int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
-			handlers
-			= handlers_map.find(channel);
+		auto handlers = handlers_map.find(channel);
 		if (handlers != handlers_map.end()) {
 			handlers->second.emplace_back(std::move(handler));
 		} else {
@@ -49,16 +46,12 @@ void EventManager::trigger_event(const EventType & event, int channel) {
 						   std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
 			handlers_map
 			= this->subscribers_by_event_id[event_type];
-		std::unordered_map<
-			int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
-			handlers_it
-			= handlers_map.find(channel);
+		auto handlers_it = handlers_map.find(channel);
 
 		if (handlers_it != handlers_map.end()) {
 			std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
 				= handlers_it->second;
-			for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
-				 = handlers.begin();
+			for (auto it = handlers.begin();
 				 it != handlers.end();++it) {
 				// stops when callback returns true
 				if((*it)->exec(event)){
@@ -69,7 +62,7 @@ void EventManager::trigger_event(const EventType & event, int channel) {
 	} else {
 		std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
 			= this->subscribers[event_type];
-		for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
+		for (auto it
 			 = handlers.begin();
 			 it != handlers.end();++it) {
 			// stops when callback returns true
@@ -87,28 +80,17 @@ void EventManager::unsubscribe(const EventHandler<EventType> & callback,
 	std::string handler_name = callback.target_type().name();
 
 	if (channel) {
-		std::unordered_map<
-			std::type_index,
-			std::unordered_map<
-				int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::
-			iterator subscriber_list
-			= this->subscribers_by_event_id.find(event_type);
+		auto subscriber_list = this->subscribers_by_event_id.find(event_type);
 		if (subscriber_list != this->subscribers_by_event_id.end()) {
 			std::unordered_map<
 				int, std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
 				handlers_map
 				= subscriber_list->second;
-			std::unordered_map<
-				int,
-				std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
-				handlers
-				= handlers_map.find(channel);
+				auto handlers = handlers_map.find(channel);
 			if (handlers != handlers_map.end()) {
 				std::vector<std::unique_ptr<IEventHandlerWrapper>> & callbacks
 					= handlers->second;
-				for (std::vector<
-						 std::unique_ptr<IEventHandlerWrapper>>::iterator it
-					 = callbacks.begin();
+				for (auto it = callbacks.begin();
 					 it != callbacks.end(); ++it) {
 					if ((*it)->get_type() == handler_name) {
 						it = callbacks.erase(it);
@@ -118,15 +100,11 @@ void EventManager::unsubscribe(const EventHandler<EventType> & callback,
 			}
 		}
 	} else {
-		std::unordered_map<std::type_index,
-						   std::vector<std::unique_ptr<IEventHandlerWrapper>>>::
-			iterator handlers_it
-			= this->subscribers.find(event_type);
+		auto handlers_it = this->subscribers.find(event_type);
 		if (handlers_it != this->subscribers.end()) {
 			std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
 				= handlers_it->second;
-			for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
-				 = handlers.begin();
+			for (auto it = handlers.begin();
 				 it != handlers.end(); ++it) {
 				if ((*it)->get_type() == handler_name) {
 					it = handlers.erase(it);
@@ -137,4 +115,4 @@ void EventManager::unsubscribe(const EventHandler<EventType> & callback,
 	}
 }
 
-}
+} // namespace crepe
diff --git a/src/crepe/api/IKeyListener.h b/src/crepe/api/IKeyListener.h
index 839acbf..5a2cafa 100644
--- a/src/crepe/api/IKeyListener.h
+++ b/src/crepe/api/IKeyListener.h
@@ -3,6 +3,7 @@
 #include "EventHandler.h"
 #include "EventManager.h"
 
+namespace crepe {
 /**
  * \class IKeyListener
  * \brief Interface for keyboard event handling in the application.
@@ -76,3 +77,5 @@ private:
 	//!< Key release event handler.
 	EventHandler<KeyReleaseEvent> key_released_handler;
 };
+
+} // namespace crepe
diff --git a/src/crepe/api/IMouseListener.h b/src/crepe/api/IMouseListener.h
index 7e92956..1df55af 100644
--- a/src/crepe/api/IMouseListener.h
+++ b/src/crepe/api/IMouseListener.h
@@ -4,6 +4,7 @@
 #include "EventHandler.h"
 #include "EventManager.h"
 
+namespace crepe {
 /**
  * \class IMouseListener
  * \brief Interface for mouse event handling in the application.
@@ -115,3 +116,5 @@ private:
 	//! Mouse move event handler.
 	EventHandler<MouseMoveEvent> mouse_move_handler;
 };
+
+} //namespace crepe
-- 
cgit v1.2.3


From da379a58033c0ef3c9c854326a3fca25d6e54319 Mon Sep 17 00:00:00 2001
From: Loek Le Blansch <loek@pipeframe.xyz>
Date: Wed, 20 Nov 2024 22:18:54 +0100
Subject: add Script::subscribe

---
 src/crepe/api/BehaviorScript.hpp |  1 +
 src/crepe/api/CMakeLists.txt     |  1 +
 src/crepe/api/Script.cpp         | 11 +++++++++++
 src/crepe/api/Script.h           | 36 +++++++++++++++++++++++++++++++++---
 src/crepe/api/Script.hpp         |  9 ++++++++-
 5 files changed, 54 insertions(+), 4 deletions(-)
 create mode 100644 src/crepe/api/Script.cpp

(limited to 'src/crepe/api/CMakeLists.txt')

diff --git a/src/crepe/api/BehaviorScript.hpp b/src/crepe/api/BehaviorScript.hpp
index d80321d..dd1efd5 100644
--- a/src/crepe/api/BehaviorScript.hpp
+++ b/src/crepe/api/BehaviorScript.hpp
@@ -16,6 +16,7 @@ BehaviorScript & BehaviorScript::set_script() {
 	Script * s = new T();
 	s->game_object_id = this->game_object_id;
 	s->component_manager_ref = &this->component_manager;
+	s->event_manager_ref = &EventManager::get_instance();
 	this->script = std::unique_ptr<Script>(s);
 	return *this;
 }
diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt
index a185ca6..a63c5ff 100644
--- a/src/crepe/api/CMakeLists.txt
+++ b/src/crepe/api/CMakeLists.txt
@@ -23,6 +23,7 @@ target_sources(crepe PUBLIC
 	LoopManager.cpp
 	LoopTimer.cpp
 	EventHandler.cpp
+	Script.cpp
 )
 
 target_sources(crepe PUBLIC FILE_SET HEADERS FILES
diff --git a/src/crepe/api/Script.cpp b/src/crepe/api/Script.cpp
new file mode 100644
index 0000000..9ebb074
--- /dev/null
+++ b/src/crepe/api/Script.cpp
@@ -0,0 +1,11 @@
+#include "Script.h"
+
+using namespace crepe;
+
+Script::~Script() {
+	EventManager & evmgr = *this->event_manager_ref;
+	for (auto id : this->listeners) {
+		evmgr.unsubscribe(id);
+	}
+}
+
diff --git a/src/crepe/api/Script.h b/src/crepe/api/Script.h
index ddb499c..c9eb211 100644
--- a/src/crepe/api/Script.h
+++ b/src/crepe/api/Script.h
@@ -4,6 +4,8 @@
 
 #include "../types.h"
 
+#include "EventManager.h"
+
 namespace crepe {
 
 class ScriptSystem;
@@ -85,6 +87,14 @@ protected:
 	template <typename... Args>
 	void logf(Args &&... args);
 
+	/**
+	 * \brief Subscribe to an event
+	 *
+	 * \see EventManager::subscribe
+	 */
+	template <typename EventType>
+	void subscribe(const EventHandler<EventType> & callback, event_channel_t channel = EventManager::CHANNEL_ALL);
+
 	//! \}
 
 protected:
@@ -93,17 +103,37 @@ protected:
 	Script() = default;
 	//! Only \c BehaviorScript instantiates Script
 	friend class BehaviorScript;
+public:
+	// std::unique_ptr destroys script
+	virtual ~Script();
+
+	Script(const Script &) = delete;
+	Script(Script &&) = delete;
+	Script & operator=(const Script &) = delete;
+	Script & operator=(Script &&) = delete;
 
 private:
-	// These references are set by BehaviorScript immediately after calling the constructor of
-	// Script.
+	/**
+	 * \name Late references
+	 *
+	 * These references are set by BehaviorScript immediately after calling the constructor of
+	 * Script.
+	 *
+	 * \{
+	 */
+	//! Game object ID of game object parent BehaviorScript is attached to
 	game_object_id_t game_object_id = -1;
+	//! Reference to component manager instance
 	ComponentManager * component_manager_ref = nullptr;
-	// TODO: use OptionalRef instead of pointer
+	//! Reference to event manager instance
+	EventManager * event_manager_ref = nullptr;
+	//! \}
 
 private:
 	//! Flag to indicate if \c init() has been called already
 	bool initialized = false;
+	//! List of subscribed events
+	std::vector<subscription_t> listeners;
 };
 
 } // namespace crepe
diff --git a/src/crepe/api/Script.hpp b/src/crepe/api/Script.hpp
index 4593d69..42c8f0b 100644
--- a/src/crepe/api/Script.hpp
+++ b/src/crepe/api/Script.hpp
@@ -20,7 +20,7 @@ T & Script::get_component() const {
 
 template <typename T>
 std::vector<std::reference_wrapper<T>> Script::get_components() const {
-	auto & mgr = *this->component_manager_ref;
+	ComponentManager & mgr = *this->component_manager_ref;
 
 	return mgr.get_components_by_id<T>(this->game_object_id);
 }
@@ -30,4 +30,11 @@ void Script::logf(Args &&... args) {
 	Log::logf(std::forward<Args>(args)...);
 }
 
+template <typename EventType>
+void Script::subscribe(const EventHandler<EventType> & callback, event_channel_t channel) {
+	EventManager & mgr = *this->event_manager_ref;
+	subscription_t listener = mgr.subscribe<EventType>(callback, channel);
+	this->listeners.push_back(listener);
+}
+
 } // namespace crepe
-- 
cgit v1.2.3


From ea95685b4dd2adf09a9be4e2dd9233d0cf98b1ef Mon Sep 17 00:00:00 2001
From: max-001 <maxsmits21@kpnmail.nl>
Date: Thu, 21 Nov 2024 17:04:58 +0100
Subject: Minor changes due to templating of Vector2

---
 src/crepe/ComponentManager.cpp      |  2 +-
 src/crepe/ComponentManager.h        |  2 +-
 src/crepe/Particle.cpp              |  4 ++--
 src/crepe/Particle.h                | 10 +++++-----
 src/crepe/api/CMakeLists.txt        |  2 +-
 src/crepe/api/GameObject.cpp        |  2 +-
 src/crepe/api/GameObject.h          |  4 ++--
 src/crepe/api/ParticleEmitter.h     |  6 +++---
 src/crepe/api/Rigidbody.cpp         |  2 +-
 src/crepe/api/Rigidbody.h           |  8 ++++----
 src/crepe/api/Transform.cpp         |  3 ++-
 src/crepe/api/Transform.h           |  5 +++--
 src/crepe/facade/SDLContext.cpp     |  4 ++--
 src/crepe/facade/SDLContext.h       |  8 ++++----
 src/crepe/system/ParticleSystem.cpp |  9 +++++----
 src/crepe/system/PhysicsSystem.cpp  |  2 +-
 src/doc/feature/scene.dox           |  4 ++--
 src/example/rendering_particle.cpp  |  6 +++---
 src/test/ECSTest.cpp                | 39 ++++++++++++++++++++-----------------
 src/test/ParticleTest.cpp           | 10 +++++-----
 src/test/PhysicsTest.cpp            |  4 ++--
 src/test/SceneManagerTest.cpp       | 21 +++++++++++++-------
 22 files changed, 85 insertions(+), 72 deletions(-)

(limited to 'src/crepe/api/CMakeLists.txt')

diff --git a/src/crepe/ComponentManager.cpp b/src/crepe/ComponentManager.cpp
index e310577..20c6dd4 100644
--- a/src/crepe/ComponentManager.cpp
+++ b/src/crepe/ComponentManager.cpp
@@ -26,7 +26,7 @@ void ComponentManager::delete_all_components() {
 }
 
 GameObject ComponentManager::new_object(const string & name, const string & tag,
-										const Vector2 & position, double rotation,
+										const Vector2<double> & position, double rotation,
 										double scale) {
 	GameObject object{*this, this->next_id, name, tag, position, rotation, scale};
 	this->next_id++;
diff --git a/src/crepe/ComponentManager.h b/src/crepe/ComponentManager.h
index 0956d1e..906e3a7 100644
--- a/src/crepe/ComponentManager.h
+++ b/src/crepe/ComponentManager.h
@@ -45,7 +45,7 @@ public:
 	 * \note This method automatically assigns a new entity ID
 	 */
 	GameObject new_object(const std::string & name, const std::string & tag = "",
-						  const Vector2 & position = {0, 0}, double rotation = 0,
+						  const Vector2<double> & position = {0, 0}, double rotation = 0,
 						  double scale = 1);
 
 protected:
diff --git a/src/crepe/Particle.cpp b/src/crepe/Particle.cpp
index 1068cbf..4c994fa 100644
--- a/src/crepe/Particle.cpp
+++ b/src/crepe/Particle.cpp
@@ -2,8 +2,8 @@
 
 using namespace crepe;
 
-void Particle::reset(uint32_t lifespan, const Vector2 & position, const Vector2 & velocity,
-					 double angle) {
+void Particle::reset(uint32_t lifespan, const Vector2<double> & position,
+					 const Vector2<double> & velocity, double angle) {
 	// Initialize the particle state
 	this->time_in_life = 0;
 	this->lifespan = lifespan;
diff --git a/src/crepe/Particle.h b/src/crepe/Particle.h
index 19859fe..570c9be 100644
--- a/src/crepe/Particle.h
+++ b/src/crepe/Particle.h
@@ -18,11 +18,11 @@ class Particle {
 
 public:
 	//! Position of the particle in 2D space.
-	Vector2 position;
+	Vector2<double> position;
 	//! Velocity vector indicating the speed and direction of the particle.
-	Vector2 velocity;
+	Vector2<double> velocity;
 	//! Accumulated force affecting the particle over time.
-	Vector2 force_over_time;
+	Vector2<double> force_over_time;
 	//! Total lifespan of the particle in milliseconds.
 	uint32_t lifespan;
 	//! Active state of the particle; true if it is in use, false otherwise.
@@ -43,8 +43,8 @@ public:
 	 * \param velocity  The initial velocity of the particle.
 	 * \param angle     The angle of the particle's trajectory or orientation.
 	 */
-	void reset(uint32_t lifespan, const Vector2 & position, const Vector2 & velocity,
-			   double angle);
+	void reset(uint32_t lifespan, const Vector2<double> & position,
+			   const Vector2<double> & velocity, double angle);
 	/**
 	 * \brief Updates the particle's state.
 	 *
diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt
index d6b6801..92ff328 100644
--- a/src/crepe/api/CMakeLists.txt
+++ b/src/crepe/api/CMakeLists.txt
@@ -14,7 +14,6 @@ target_sources(crepe PUBLIC
 	Metadata.cpp
 	Scene.cpp
 	SceneManager.cpp
-	Vector2.cpp
 	Camera.cpp
 	Animator.cpp
 	EventManager.cpp
@@ -37,6 +36,7 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	Rigidbody.h
 	Sprite.h
 	Vector2.h
+	Vector2.hpp
 	Color.h
 	Texture.h 
 	AssetManager.h 
diff --git a/src/crepe/api/GameObject.cpp b/src/crepe/api/GameObject.cpp
index 4874426..49bb158 100644
--- a/src/crepe/api/GameObject.cpp
+++ b/src/crepe/api/GameObject.cpp
@@ -9,7 +9,7 @@ using namespace std;
 
 GameObject::GameObject(ComponentManager & component_manager, game_object_id_t id,
 					   const std::string & name, const std::string & tag,
-					   const Vector2 & position, double rotation, double scale)
+					   const Vector2<double> & position, double rotation, double scale)
 	: id(id),
 	  component_manager(component_manager) {
 
diff --git a/src/crepe/api/GameObject.h b/src/crepe/api/GameObject.h
index 34ef8bb..29c9fcd 100644
--- a/src/crepe/api/GameObject.h
+++ b/src/crepe/api/GameObject.h
@@ -30,8 +30,8 @@ private:
 	 * \param scale The scale of the GameObject
 	 */
 	GameObject(ComponentManager & component_manager, game_object_id_t id,
-			   const std::string & name, const std::string & tag, const Vector2 & position,
-			   double rotation, double scale);
+			   const std::string & name, const std::string & tag,
+			   const Vector2<double> & position, double rotation, double scale);
 	//! ComponentManager instances GameObject
 	friend class ComponentManager;
 
diff --git a/src/crepe/api/ParticleEmitter.h b/src/crepe/api/ParticleEmitter.h
index 33112e1..1960d0d 100644
--- a/src/crepe/api/ParticleEmitter.h
+++ b/src/crepe/api/ParticleEmitter.h
@@ -30,7 +30,7 @@ public:
 		//! boundary height (midpoint is emitter location)
 		double height = 0.0;
 		//! boundary offset from particle emitter location
-		Vector2 offset;
+		Vector2<double> offset;
 		//! reset on exit or stop velocity and set max postion
 		bool reset_on_exit = false;
 	};
@@ -43,7 +43,7 @@ public:
 	 */
 	struct Data {
 		//! position of the emitter
-		Vector2 position;
+		Vector2<double> position;
 		//! maximum number of particles
 		const unsigned int max_particles = 0;
 		//! rate of particle emission per update (Lowest value = 0.001 any lower is ignored)
@@ -61,7 +61,7 @@ public:
 		//! end Lifespan of particle
 		double end_lifespan = 0.0;
 		//! force over time (physics)
-		Vector2 force_over_time;
+		Vector2<double> force_over_time;
 		//! particle boundary
 		Boundary boundary;
 		//! collection of particles
diff --git a/src/crepe/api/Rigidbody.cpp b/src/crepe/api/Rigidbody.cpp
index 6b87695..384aabb 100644
--- a/src/crepe/api/Rigidbody.cpp
+++ b/src/crepe/api/Rigidbody.cpp
@@ -6,7 +6,7 @@ crepe::Rigidbody::Rigidbody(game_object_id_t id, const Data & data)
 	: Component(id),
 	  data(data) {}
 
-void crepe::Rigidbody::add_force_linear(const Vector2 & force) {
+void crepe::Rigidbody::add_force_linear(const Vector2<double> & force) {
 	this->data.linear_velocity += force;
 }
 
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index 3e5c7a3..4745d56 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -56,11 +56,11 @@ public:
 		//! Changes if physics apply
 		BodyType body_type = BodyType::DYNAMIC;
 		//! linear velocity of object
-		Vector2 linear_velocity;
+		Vector2<double> linear_velocity;
 		//! maximum linear velocity of object
-		Vector2 max_linear_velocity;
+		Vector2<double> max_linear_velocity;
 		//! linear damping of object
-		Vector2 linear_damping;
+		Vector2<double> linear_damping;
 		//! angular velocity of object
 		double angular_velocity = 0.0;
 		//! max angular velocity of object
@@ -90,7 +90,7 @@ public:
 	 * 
 	 * \param force Vector2 that is added to the linear force.
 	 */
-	void add_force_linear(const Vector2 & force);
+	void add_force_linear(const Vector2<double> & force);
 	/** 
 	 * \brief add a angular force to the Rigidbody.
 	 * 
diff --git a/src/crepe/api/Transform.cpp b/src/crepe/api/Transform.cpp
index cd944bd..1ca5b4d 100644
--- a/src/crepe/api/Transform.cpp
+++ b/src/crepe/api/Transform.cpp
@@ -4,7 +4,8 @@
 
 using namespace crepe;
 
-Transform::Transform(game_object_id_t id, const Vector2 & point, double rotation, double scale)
+Transform::Transform(game_object_id_t id, const Vector2<double> & point, double rotation,
+					 double scale)
 	: Component(id),
 	  position(point),
 	  rotation(rotation),
diff --git a/src/crepe/api/Transform.h b/src/crepe/api/Transform.h
index 18aa293..b0488f5 100644
--- a/src/crepe/api/Transform.h
+++ b/src/crepe/api/Transform.h
@@ -15,7 +15,7 @@ namespace crepe {
 class Transform : public Component {
 public:
 	//! Translation (shift)
-	Vector2 position = {0, 0};
+	Vector2<double> position = {0, 0};
 	//! Rotation, in degrees
 	double rotation = 0;
 	//! Multiplication factor
@@ -28,7 +28,8 @@ protected:
 	 * \param rotation The rotation of the GameObject
 	 * \param scale The scale of the GameObject
 	 */
-	Transform(game_object_id_t id, const Vector2 & point, double rotation, double scale);
+	Transform(game_object_id_t id, const Vector2<double> & point, double rotation,
+			  double scale);
 	/**
 	 * There is always exactly one transform component per entity
 	 * \return 1
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 00523a6..c808d41 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -104,7 +104,7 @@ SDL_Rect SDLContext::get_src_rect(const Sprite & sprite) const {
 		.h = sprite.sprite_rect.h,
 	};
 }
-SDL_Rect SDLContext::get_dst_rect(const Sprite & sprite, const Vector2 & pos,
+SDL_Rect SDLContext::get_dst_rect(const Sprite & sprite, const Vector2<double> & pos,
 								  const double & scale, const Camera & cam) const {
 
 	double adjusted_x = (pos.x - cam.x) * cam.zoom;
@@ -120,7 +120,7 @@ SDL_Rect SDLContext::get_dst_rect(const Sprite & sprite, const Vector2 & pos,
 	};
 }
 
-void SDLContext::draw_particle(const Sprite & sprite, const Vector2 & pos,
+void SDLContext::draw_particle(const Sprite & sprite, const Vector2<double> & pos,
 							   const double & angle, const double & scale,
 							   const Camera & camera) {
 
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index 841ffc9..e4a0da5 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -120,8 +120,8 @@ private:
 	 */
 	void draw(const Sprite & sprite, const Transform & transform, const Camera & camera);
 
-	void draw_particle(const Sprite & sprite, const Vector2 & pos, const double & angle,
-					   const double & scale, const Camera & camera);
+	void draw_particle(const Sprite & sprite, const Vector2<double> & pos,
+					   const double & angle, const double & scale, const Camera & camera);
 
 	//! Clears the screen, preparing for a new frame.
 	void clear_screen();
@@ -153,8 +153,8 @@ private:
 	 * on the camera 
 	 * \return sdl rectangle to draw a dst image to draw on the screen
 	 */
-	SDL_Rect get_dst_rect(const Sprite & sprite, const Vector2 & pos, const double & scale,
-						  const Camera & cam) const;
+	SDL_Rect get_dst_rect(const Sprite & sprite, const Vector2<double> & pos,
+						  const double & scale, const Camera & cam) const;
 
 private:
 	//! sdl Window
diff --git a/src/crepe/system/ParticleSystem.cpp b/src/crepe/system/ParticleSystem.cpp
index fcf7522..b839f35 100644
--- a/src/crepe/system/ParticleSystem.cpp
+++ b/src/crepe/system/ParticleSystem.cpp
@@ -44,7 +44,7 @@ void ParticleSystem::update() {
 void ParticleSystem::emit_particle(ParticleEmitter & emitter, const Transform & transform) {
 	constexpr double DEG_TO_RAD = M_PI / 180.0;
 
-	Vector2 initial_position = emitter.data.position + transform.position;
+	Vector2<double> initial_position = emitter.data.position + transform.position;
 	double random_angle
 		= generate_random_angle(emitter.data.min_angle, emitter.data.max_angle);
 
@@ -52,7 +52,7 @@ void ParticleSystem::emit_particle(ParticleEmitter & emitter, const Transform &
 		= generate_random_speed(emitter.data.min_speed, emitter.data.max_speed);
 	double angle_radians = random_angle * DEG_TO_RAD;
 
-	Vector2 velocity
+	Vector2<double> velocity
 		= {random_speed * std::cos(angle_radians), random_speed * std::sin(angle_radians)};
 
 	for (Particle & particle : emitter.data.particles) {
@@ -77,7 +77,8 @@ int ParticleSystem::calculate_update(int count, double emission) const {
 }
 
 void ParticleSystem::check_bounds(ParticleEmitter & emitter, const Transform & transform) {
-	Vector2 offset = emitter.data.boundary.offset + transform.position + emitter.data.position;
+	Vector2<double> offset
+		= emitter.data.boundary.offset + transform.position + emitter.data.position;
 	double half_width = emitter.data.boundary.width / 2.0;
 	double half_height = emitter.data.boundary.height / 2.0;
 
@@ -87,7 +88,7 @@ void ParticleSystem::check_bounds(ParticleEmitter & emitter, const Transform & t
 	const double BOTTOM = offset.y + half_height;
 
 	for (Particle & particle : emitter.data.particles) {
-		const Vector2 & position = particle.position;
+		const Vector2<double> & position = particle.position;
 		bool within_bounds = (position.x >= LEFT && position.x <= RIGHT && position.y >= TOP
 							  && position.y <= BOTTOM);
 
diff --git a/src/crepe/system/PhysicsSystem.cpp b/src/crepe/system/PhysicsSystem.cpp
index bcde431..e7ecd14 100644
--- a/src/crepe/system/PhysicsSystem.cpp
+++ b/src/crepe/system/PhysicsSystem.cpp
@@ -34,7 +34,7 @@ void PhysicsSystem::update() {
 						if (rigidbody.data.angular_damping != 0) {
 							rigidbody.data.angular_velocity *= rigidbody.data.angular_damping;
 						}
-						if (rigidbody.data.linear_damping != Vector2{0, 0}) {
+						if (rigidbody.data.linear_damping != Vector2<double>{0, 0}) {
 							rigidbody.data.linear_velocity *= rigidbody.data.linear_damping;
 						}
 
diff --git a/src/doc/feature/scene.dox b/src/doc/feature/scene.dox
index 5f34446..5f1214e 100644
--- a/src/doc/feature/scene.dox
+++ b/src/doc/feature/scene.dox
@@ -46,8 +46,8 @@ public:
 
 	void load_scene() {
 		auto & mgr = this->component_manager;
-		GameObject object1 = mgr.new_object("object1", "tag_my_scene", Vector2{0, 0}, 0, 1);
-		GameObject object2 = mgr.new_object("object2", "tag_my_scene", Vector2{1, 0}, 0, 1);
+		GameObject object1 = mgr.new_object("object1", "tag_my_scene", Vector2<double>{0, 0}, 0, 1);
+		GameObject object2 = mgr.new_object("object2", "tag_my_scene", Vector2<double>{1, 0}, 0, 1);
 	}
 
 	string get_name() const { return "my_scene"; }
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 4571afb..9b4ce83 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -23,7 +23,7 @@ using namespace std;
 
 int main(int argc, char * argv[]) {
 	ComponentManager mgr;
-	GameObject game_object = mgr.new_object("", "", Vector2{100, 100}, 0, 0.1);
+	GameObject game_object = mgr.new_object("", "", Vector2<double>{100, 100}, 0, 0.1);
 	RenderSystem sys{mgr};
 	ParticleSystem psys{mgr};
 
@@ -43,11 +43,11 @@ int main(int argc, char * argv[]) {
 		.max_angle = 20,
 		.begin_lifespan = 0,
 		.end_lifespan = 60,
-		.force_over_time = Vector2{0, 0},
+		.force_over_time = Vector2<double>{0, 0},
 		.boundary{
 			.width = 1000,
 			.height = 1000,
-			.offset = Vector2{0, 0},
+			.offset = Vector2<double>{0, 0},
 			.reset_on_exit = false,
 		},
 		.sprite = test_sprite,
diff --git a/src/test/ECSTest.cpp b/src/test/ECSTest.cpp
index d5a5826..98d3a27 100644
--- a/src/test/ECSTest.cpp
+++ b/src/test/ECSTest.cpp
@@ -17,7 +17,7 @@ public:
 };
 
 TEST_F(ECSTest, createGameObject) {
-	GameObject obj = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
+	GameObject obj = mgr.new_object("body", "person", Vector2<double>{0, 0}, 0, 1);
 
 	vector<reference_wrapper<Metadata>> metadata = mgr.get_components_by_type<Metadata>();
 	vector<reference_wrapper<Transform>> transform = mgr.get_components_by_type<Transform>();
@@ -37,8 +37,8 @@ TEST_F(ECSTest, createGameObject) {
 }
 
 TEST_F(ECSTest, deleteAllGameObjects) {
-	GameObject obj0 = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
-	GameObject obj1 = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
+	GameObject obj0 = mgr.new_object("body", "person", Vector2<double>{0, 0}, 0, 1);
+	GameObject obj1 = mgr.new_object("body", "person", Vector2<double>{0, 0}, 0, 1);
 
 	mgr.delete_all_components();
 
@@ -48,7 +48,7 @@ TEST_F(ECSTest, deleteAllGameObjects) {
 	EXPECT_EQ(metadata.size(), 0);
 	EXPECT_EQ(transform.size(), 0);
 
-	GameObject obj2 = mgr.new_object("body2", "person2", Vector2{1, 0}, 5, 1);
+	GameObject obj2 = mgr.new_object("body2", "person2", Vector2<double>{1, 0}, 5, 1);
 
 	metadata = mgr.get_components_by_type<Metadata>();
 	transform = mgr.get_components_by_type<Transform>();
@@ -70,8 +70,8 @@ TEST_F(ECSTest, deleteAllGameObjects) {
 }
 
 TEST_F(ECSTest, deleteGameObject) {
-	GameObject obj0 = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
-	GameObject obj1 = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
+	GameObject obj0 = mgr.new_object("body", "person", Vector2<double>{0, 0}, 0, 1);
+	GameObject obj1 = mgr.new_object("body", "person", Vector2<double>{0, 0}, 0, 1);
 
 	mgr.delete_all_components_of_id(0);
 
@@ -96,7 +96,7 @@ TEST_F(ECSTest, deleteGameObject) {
 
 TEST_F(ECSTest, manyGameObjects) {
 	for (int i = 0; i < 5000; i++) {
-		GameObject obj = mgr.new_object("body", "person", Vector2{0, 0}, 0, i);
+		GameObject obj = mgr.new_object("body", "person", Vector2<double>{0, 0}, 0, i);
 	}
 
 	vector<reference_wrapper<Metadata>> metadata = mgr.get_components_by_type<Metadata>();
@@ -128,7 +128,7 @@ TEST_F(ECSTest, manyGameObjects) {
 
 	for (int i = 0; i < 10000 - 5000; i++) {
 		string tag = "person" + to_string(i);
-		GameObject obj = mgr.new_object("body", tag, Vector2{0, 0}, i, 0);
+		GameObject obj = mgr.new_object("body", tag, Vector2<double>{0, 0}, i, 0);
 	}
 
 	metadata = mgr.get_components_by_type<Metadata>();
@@ -139,8 +139,8 @@ TEST_F(ECSTest, manyGameObjects) {
 }
 
 TEST_F(ECSTest, getComponentsByID) {
-	GameObject obj0 = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
-	GameObject obj1 = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
+	GameObject obj0 = mgr.new_object("body", "person", Vector2<double>{0, 0}, 0, 1);
+	GameObject obj1 = mgr.new_object("body", "person", Vector2<double>{0, 0}, 0, 1);
 
 	vector<reference_wrapper<Metadata>> metadata = mgr.get_components_by_id<Metadata>(0);
 	vector<reference_wrapper<Transform>> transform = mgr.get_components_by_id<Transform>(1);
@@ -163,15 +163,15 @@ TEST_F(ECSTest, getComponentsByID) {
 
 TEST_F(ECSTest, tooMuchComponents) {
 	try {
-		GameObject obj0 = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
-		obj0.add_component<Transform>(Vector2{10, 10}, 0, 1);
+		GameObject obj0 = mgr.new_object("body", "person", Vector2<double>{0, 0}, 0, 1);
+		obj0.add_component<Transform>(Vector2<double>{10, 10}, 0, 1);
 	} catch (const exception & e) {
 		EXPECT_EQ(e.what(),
 				  string("Exceeded maximum number of instances for this component type"));
 	}
 
 	try {
-		GameObject obj1 = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
+		GameObject obj1 = mgr.new_object("body", "person", Vector2<double>{0, 0}, 0, 1);
 		obj1.add_component<Metadata>("body", "person");
 	} catch (const exception & e) {
 		EXPECT_EQ(e.what(),
@@ -187,11 +187,14 @@ TEST_F(ECSTest, tooMuchComponents) {
 
 TEST_F(ECSTest, partentChild) {
 	{
-		GameObject body = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
-		GameObject right_leg = mgr.new_object("rightLeg", "person", Vector2{1, 1}, 0, 1);
-		GameObject left_leg = mgr.new_object("leftLeg", "person", Vector2{1, 1}, 0, 1);
-		GameObject right_foot = mgr.new_object("rightFoot", "person", Vector2{2, 2}, 0, 1);
-		GameObject left_foot = mgr.new_object("leftFoot", "person", Vector2{2, 2}, 0, 1);
+		GameObject body = mgr.new_object("body", "person", Vector2<double>{0, 0}, 0, 1);
+		GameObject right_leg
+			= mgr.new_object("rightLeg", "person", Vector2<double>{1, 1}, 0, 1);
+		GameObject left_leg = mgr.new_object("leftLeg", "person", Vector2<double>{1, 1}, 0, 1);
+		GameObject right_foot
+			= mgr.new_object("rightFoot", "person", Vector2<double>{2, 2}, 0, 1);
+		GameObject left_foot
+			= mgr.new_object("leftFoot", "person", Vector2<double>{2, 2}, 0, 1);
 
 		// Set the parent of each GameObject
 		right_foot.set_parent(right_leg);
diff --git a/src/test/ParticleTest.cpp b/src/test/ParticleTest.cpp
index eee022f..48e6630 100644
--- a/src/test/ParticleTest.cpp
+++ b/src/test/ParticleTest.cpp
@@ -25,7 +25,7 @@ public:
 		std::vector<std::reference_wrapper<Transform>> transforms
 			= mgr.get_components_by_id<Transform>(0);
 		if (transforms.empty()) {
-			GameObject game_object = mgr.new_object("", "", Vector2{0, 0}, 0, 0);
+			GameObject game_object = mgr.new_object("", "", Vector2<double>{0, 0}, 0, 0);
 
 			Color color(0, 0, 0, 0);
 			Sprite & test_sprite = game_object.add_component<Sprite>(
@@ -42,11 +42,11 @@ public:
 				.max_angle = 0,
 				.begin_lifespan = 0,
 				.end_lifespan = 0,
-				.force_over_time = Vector2{0, 0},
+				.force_over_time = Vector2<double>{0, 0},
 				.boundary{
 					.width = 0,
 					.height = 0,
-					.offset = Vector2{0, 0},
+					.offset = Vector2<double>{0, 0},
 					.reset_on_exit = false,
 				},
 				.sprite = test_sprite,
@@ -68,8 +68,8 @@ public:
 		emitter.data.max_angle = 0;
 		emitter.data.begin_lifespan = 0;
 		emitter.data.end_lifespan = 0;
-		emitter.data.force_over_time = Vector2{0, 0};
-		emitter.data.boundary = {0, 0, Vector2{0, 0}, false};
+		emitter.data.force_over_time = Vector2<double>{0, 0};
+		emitter.data.boundary = {0, 0, Vector2<double>{0, 0}, false};
 		for (auto & particle : emitter.data.particles) {
 			particle.active = false;
 		}
diff --git a/src/test/PhysicsTest.cpp b/src/test/PhysicsTest.cpp
index 1e37c26..4fd9b14 100644
--- a/src/test/PhysicsTest.cpp
+++ b/src/test/PhysicsTest.cpp
@@ -20,12 +20,12 @@ public:
 		vector<reference_wrapper<Transform>> transforms
 			= mgr.get_components_by_id<Transform>(0);
 		if (transforms.empty()) {
-			auto entity = mgr.new_object("", "", Vector2{0, 0}, 0, 0);
+			auto entity = mgr.new_object("", "", Vector2<double>{0, 0}, 0, 0);
 			entity.add_component<Rigidbody>(Rigidbody::Data{
 				.mass = 1,
 				.gravity_scale = 1,
 				.body_type = Rigidbody::BodyType::DYNAMIC,
-				.max_linear_velocity = Vector2{10, 10},
+				.max_linear_velocity = Vector2<double>{10, 10},
 				.max_angular_velocity = 10,
 				.constraints = {0, 0},
 				.use_gravity = true,
diff --git a/src/test/SceneManagerTest.cpp b/src/test/SceneManagerTest.cpp
index 1efcfb2..f4cf4fd 100644
--- a/src/test/SceneManagerTest.cpp
+++ b/src/test/SceneManagerTest.cpp
@@ -16,9 +16,12 @@ public:
 
 	void load_scene() {
 		auto & mgr = this->component_manager;
-		GameObject object1 = mgr.new_object("scene_1", "tag_scene_1", Vector2{0, 0}, 0, 1);
-		GameObject object2 = mgr.new_object("scene_1", "tag_scene_1", Vector2{1, 0}, 0, 1);
-		GameObject object3 = mgr.new_object("scene_1", "tag_scene_1", Vector2{2, 0}, 0, 1);
+		GameObject object1
+			= mgr.new_object("scene_1", "tag_scene_1", Vector2<double>{0, 0}, 0, 1);
+		GameObject object2
+			= mgr.new_object("scene_1", "tag_scene_1", Vector2<double>{1, 0}, 0, 1);
+		GameObject object3
+			= mgr.new_object("scene_1", "tag_scene_1", Vector2<double>{2, 0}, 0, 1);
 	}
 
 	string get_name() const { return "scene1"; }
@@ -30,10 +33,14 @@ public:
 
 	void load_scene() {
 		auto & mgr = this->component_manager;
-		GameObject object1 = mgr.new_object("scene_2", "tag_scene_2", Vector2{0, 0}, 0, 1);
-		GameObject object2 = mgr.new_object("scene_2", "tag_scene_2", Vector2{0, 1}, 0, 1);
-		GameObject object3 = mgr.new_object("scene_2", "tag_scene_2", Vector2{0, 2}, 0, 1);
-		GameObject object4 = mgr.new_object("scene_2", "tag_scene_2", Vector2{0, 3}, 0, 1);
+		GameObject object1
+			= mgr.new_object("scene_2", "tag_scene_2", Vector2<double>{0, 0}, 0, 1);
+		GameObject object2
+			= mgr.new_object("scene_2", "tag_scene_2", Vector2<double>{0, 1}, 0, 1);
+		GameObject object3
+			= mgr.new_object("scene_2", "tag_scene_2", Vector2<double>{0, 2}, 0, 1);
+		GameObject object4
+			= mgr.new_object("scene_2", "tag_scene_2", Vector2<double>{0, 3}, 0, 1);
 	}
 
 	string get_name() const { return "scene2"; }
-- 
cgit v1.2.3