From 428182f45797de73b0bc2335916d25762b0d719b Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Sun, 10 Nov 2024 19:49:10 +0100
Subject: created colliders

---
 src/crepe/api/BoxCollider.cpp    |  8 ++++++++
 src/crepe/api/BoxCollider.h      | 15 +++++++++++++++
 src/crepe/api/CircleCollider.cpp |  8 ++++++++
 src/crepe/api/CircleCollider.h   |  7 ++++---
 4 files changed, 35 insertions(+), 3 deletions(-)
 create mode 100644 src/crepe/api/BoxCollider.cpp
 create mode 100644 src/crepe/api/BoxCollider.h
 create mode 100644 src/crepe/api/CircleCollider.cpp

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/BoxCollider.cpp b/src/crepe/api/BoxCollider.cpp
new file mode 100644
index 0000000..c3cb60c
--- /dev/null
+++ b/src/crepe/api/BoxCollider.cpp
@@ -0,0 +1,8 @@
+#pragma once
+
+#include "BoxCollider.h"
+
+using namespace crepe;
+
+
+BoxCollider::BoxCollider(game_object_id_t game_object_id,Vector2 offset, int width, int height) : Collider(game_object_id,offset), width(width), height(height) {}
diff --git a/src/crepe/api/BoxCollider.h b/src/crepe/api/BoxCollider.h
new file mode 100644
index 0000000..2461636
--- /dev/null
+++ b/src/crepe/api/BoxCollider.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "Vector2.h"
+#include "../Collider.h"
+
+namespace crepe {
+
+class BoxCollider : public Collider {
+public:
+	BoxCollider(game_object_id_t game_object_id,Vector2 offset, int width, int height);
+	double width;
+	double height;
+};
+
+} // namespace crepe
diff --git a/src/crepe/api/CircleCollider.cpp b/src/crepe/api/CircleCollider.cpp
new file mode 100644
index 0000000..9365793
--- /dev/null
+++ b/src/crepe/api/CircleCollider.cpp
@@ -0,0 +1,8 @@
+#pragma once
+
+#include "CircleCollider.h"
+
+using namespace crepe;
+
+
+CircleCollider::CircleCollider(game_object_id_t game_object_id,Vector2 offset, int radius) : Collider(game_object_id,offset), radius(radius) {}
diff --git a/src/crepe/api/CircleCollider.h b/src/crepe/api/CircleCollider.h
index caa7e43..3a66355 100644
--- a/src/crepe/api/CircleCollider.h
+++ b/src/crepe/api/CircleCollider.h
@@ -1,13 +1,14 @@
 #pragma once
+
+#include "Vector2.h"
 #include "../Collider.h"
 
 namespace crepe {
 
 class CircleCollider : public Collider {
 public:
-	CircleCollider(game_object_id_t game_object_id, int radius)
-		: Collider(game_object_id), radius(radius) {}
-	int radius;
+	CircleCollider(game_object_id_t game_object_id,Vector2 offset, int radius);
+	double radius;
 };
 
 } // namespace crepe
-- 
cgit v1.2.3


From 47dd27c42f375b65ee53f8b1e8c1b25327315a92 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Sun, 10 Nov 2024 21:38:58 +0100
Subject: box-box collision

---
 src/crepe/api/BoxCollider.cpp        |  5 +--
 src/crepe/api/BoxCollider.h          |  2 +-
 src/crepe/api/CMakeLists.txt         |  4 ++
 src/crepe/api/CircleCollider.cpp     |  2 -
 src/crepe/api/CircleCollider.h       |  1 +
 src/crepe/api/Rigidbody.h            |  2 +
 src/crepe/system/CollisionSystem.cpp | 82 +++++++++++++++++++++++++++++++++++-
 src/crepe/system/CollisionSystem.h   | 14 ++++++
 src/example/CMakeLists.txt           |  1 +
 src/example/collision.cpp            | 42 ++++++++++++++++++
 10 files changed, 148 insertions(+), 7 deletions(-)
 create mode 100644 src/example/collision.cpp

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/BoxCollider.cpp b/src/crepe/api/BoxCollider.cpp
index c3cb60c..eafbdb2 100644
--- a/src/crepe/api/BoxCollider.cpp
+++ b/src/crepe/api/BoxCollider.cpp
@@ -1,8 +1,7 @@
-#pragma once
-
 #include "BoxCollider.h"
+#include "../Collider.h" 
 
 using namespace crepe;
 
 
-BoxCollider::BoxCollider(game_object_id_t game_object_id,Vector2 offset, int width, int height) : Collider(game_object_id,offset), width(width), height(height) {}
+BoxCollider::BoxCollider(game_object_id_t game_object_id,Vector2 offset, double width, double height) : Collider(game_object_id,offset), width(width), height(height) {}
diff --git a/src/crepe/api/BoxCollider.h b/src/crepe/api/BoxCollider.h
index 2461636..357c979 100644
--- a/src/crepe/api/BoxCollider.h
+++ b/src/crepe/api/BoxCollider.h
@@ -7,7 +7,7 @@ namespace crepe {
 
 class BoxCollider : public Collider {
 public:
-	BoxCollider(game_object_id_t game_object_id,Vector2 offset, int width, int height);
+	BoxCollider(game_object_id_t game_object_id,Vector2 offset, double width, double height);
 	double width;
 	double height;
 };
diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt
index 87cbb09..6915074 100644
--- a/src/crepe/api/CMakeLists.txt
+++ b/src/crepe/api/CMakeLists.txt
@@ -18,6 +18,8 @@ target_sources(crepe PUBLIC
 	Vector2.cpp
 	Camera.cpp
 	Animator.cpp
+	BoxCollider.cpp
+	CircleCollider.cpp
 )
 
 target_sources(crepe PUBLIC FILE_SET HEADERS FILES
@@ -42,4 +44,6 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	SceneManager.hpp
 	Camera.h
 	Animator.h
+	BoxCollider.h
+	CircleCollider.h
 )
diff --git a/src/crepe/api/CircleCollider.cpp b/src/crepe/api/CircleCollider.cpp
index 9365793..04a4995 100644
--- a/src/crepe/api/CircleCollider.cpp
+++ b/src/crepe/api/CircleCollider.cpp
@@ -1,5 +1,3 @@
-#pragma once
-
 #include "CircleCollider.h"
 
 using namespace crepe;
diff --git a/src/crepe/api/CircleCollider.h b/src/crepe/api/CircleCollider.h
index 3a66355..29a9c1e 100644
--- a/src/crepe/api/CircleCollider.h
+++ b/src/crepe/api/CircleCollider.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "Vector2.h"
+
 #include "../Collider.h"
 
 namespace crepe {
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index 68481f4..b9edec2 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -75,6 +75,8 @@ public:
 		bool use_gravity = true;
 		//! if object bounces
 		bool bounce = false;
+		//! offset of all colliders
+		Vector2 offset;
 	};
 
 public:
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 55e0fdc..75d5c58 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -1,7 +1,87 @@
+#include <cmath>
+
 #include "CollisionSystem.h"
 
+#include "../ComponentManager.h"
+#include "../api/BoxCollider.h"
+#include "../api/CircleCollider.h"
+#include "../api/Vector2.h"
+#include "../api/Rigidbody.h"
+#include "../api/Transform.h"
+
+#include "Collider.h"
+#include "iostream"
+
 using namespace crepe;
 
 CollisionSystem::CollisionSystem() {}
 
-void CollisionSystem::update() {}
+void CollisionSystem::update() {
+	ComponentManager & mgr = ComponentManager::get_instance();
+	std::vector<std::reference_wrapper<BoxCollider>> boxcolliders	= mgr.get_components_by_type<BoxCollider>();
+	
+	Transform & transform1 = mgr.get_components_by_id<Transform>(boxcolliders[0].get().game_object_id).front().get();
+	Rigidbody & rigidbody1 = mgr.get_components_by_id<Rigidbody>(boxcolliders[0].get().game_object_id).front().get();
+	Transform & transform2 = mgr.get_components_by_id<Transform>(boxcolliders[1].get().game_object_id).front().get();
+	Rigidbody & rigidbody2 = mgr.get_components_by_id<Rigidbody>(boxcolliders[1].get().game_object_id).front().get();
+	BoxCollider & collider1 = boxcolliders[0].get();
+	BoxCollider & collider2 = boxcolliders[1].get();
+	bool test = check_box_box_collision(collider1, collider2, transform1, transform2, rigidbody1, rigidbody2);
+	std::cout << "collided? " << test << std::endl;
+}
+
+
+
+bool CollisionSystem::check_collisions(const std::vector<Collider*>& colliders1, const std::vector<Collider*>& colliders2) {}
+bool CollisionSystem::check_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2)
+{
+	// Function to convert degrees to radians
+	auto degrees_to_radians = [](double degrees) {
+			return degrees * (M_PI / 180.0);
+	};
+
+	// Get the rotation in radians
+	double radians1 = degrees_to_radians(transform1.rotation);
+	double radians2 = degrees_to_radians(transform2.rotation);
+
+	// Calculate the scale factor (for both rigidbody and box offsets)
+	double scale1 = transform1.scale;
+	double scale2 = transform2.scale;
+
+	Vector2 total_offset1 = (rigidbody1.data.offset + box1.offset) * transform1.scale;
+	Vector2 total_offset2 = (rigidbody2.data.offset + box2.offset) * transform2.scale;
+
+	// Rotate
+	double rotated_total_offset_x1 = total_offset1.x * cos(radians1) - total_offset1.y * sin(radians1);
+	double rotated_total_offset_y1 = total_offset1.x * sin(radians1) + total_offset1.y * cos(radians1);
+
+	double rotated_total_offset_x2 = total_offset2.x * cos(radians2) - total_offset2.y * sin(radians2);
+	double rotated_total_offset_y2 = total_offset2.x * sin(radians2) + total_offset2.y * cos(radians2);
+
+	// Final positions considering scaling and rotation
+	Vector2 final_position1 = transform1.position + Vector2(rotated_total_offset_x1, rotated_total_offset_y1);
+	Vector2 final_position2 = transform2.position + Vector2(rotated_total_offset_x2, rotated_total_offset_y2);
+
+	 // Log final positions for debugging purposes
+	std::cout << "Final Position of Box 1: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
+	std::cout << "Final Position of Box 2: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
+
+	// Log rotation values for debugging
+	std::cout << "Rotation of Box 1: " << transform1.rotation << " degrees" << std::endl;
+	std::cout << "Rotation of Box 2: " << transform2.rotation << " degrees" << std::endl;
+
+
+	// Calculate half-extents (half width and half height)
+	double half_width1 = box1.width / 2.0;
+	double half_height1 = box1.height / 2.0;
+	double half_width2 = box2.width / 2.0;
+	double half_height2 = box2.height / 2.0;
+
+	// Check if the boxes overlap along the X and Y axes
+	return !(final_position1.x + half_width1 < final_position2.x - half_width2 ||  // box1 is left of box2
+						final_position1.x - half_width1 > final_position2.x + half_width2 ||  // box1 is right of box2
+						final_position1.y + half_height1 < final_position2.y - half_height2 || // box1 is above box2
+						final_position1.y - half_height1 > final_position2.y + half_height2);  // box1 is below box2
+}
+bool CollisionSystem::check_box_circle_collision(const BoxCollider& box, const CircleCollider& circle) {}
+bool CollisionSystem::check_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2) {}
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 1e9f1aa..402ba64 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -1,11 +1,25 @@
 #pragma once
 
+#include "Collider.h"
+#include <vector>
+
 namespace crepe {
 
+class Collider;
+class BoxCollider;
+class CircleCollider;
+class Transform;
+class Rigidbody;
+
 class CollisionSystem {
 public:
 	CollisionSystem();
 	void update();
+private:
+	bool check_collisions(const std::vector<Collider*>& colliders1, const std::vector<Collider*>& colliders2);
+	bool check_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
+	bool check_box_circle_collision(const BoxCollider& box, const CircleCollider& circle);
+	bool check_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2);
 };
 
 } // namespace crepe
diff --git a/src/example/CMakeLists.txt b/src/example/CMakeLists.txt
index 36f9d4d..d43d56c 100644
--- a/src/example/CMakeLists.txt
+++ b/src/example/CMakeLists.txt
@@ -28,4 +28,5 @@ add_example(proxy)
 add_example(db)
 add_example(ecs)
 add_example(scene_manager)
+add_example(collision)
 
diff --git a/src/example/collision.cpp b/src/example/collision.cpp
new file mode 100644
index 0000000..9faac69
--- /dev/null
+++ b/src/example/collision.cpp
@@ -0,0 +1,42 @@
+#include "api/BoxCollider.h"
+#include "system/CollisionSystem.h"
+#include <crepe/Component.h>
+#include <crepe/ComponentManager.h>
+#include <crepe/api/GameObject.h>
+#include <crepe/api/Rigidbody.h>
+#include <crepe/api/BoxCollider.h>
+#include <crepe/api/Transform.h>
+#include <crepe/system/PhysicsSystem.h>
+
+using namespace crepe;
+using namespace std;
+
+int main(int argc, char * argv[]) {
+
+	GameObject game_object1(0, "Name", "Tag", Vector2{1, 1}, 90, 1);
+	game_object1.add_component<Rigidbody>(Rigidbody::Data{
+		.mass = 1,
+		.gravity_scale = 1,
+		.body_type = Rigidbody::BodyType::DYNAMIC,
+		.constraints = {0, 0, 0},
+		.use_gravity = true,
+		.bounce = false,
+		.offset = {3,3}
+	});
+	game_object1.add_component<BoxCollider>(Vector2{5, 5}, 100, 50);
+
+	GameObject game_object2(1, "Name", "Tag", Vector2{20, 2}, 90, 1);
+	game_object2.add_component<Rigidbody>(Rigidbody::Data{
+		.mass = 1,
+		.gravity_scale = 1,
+		.body_type = Rigidbody::BodyType::DYNAMIC,
+		.constraints = {0, 0, 0},
+		.use_gravity = true,
+		.bounce = false,
+		.offset = {4,4}
+	});
+	game_object2.add_component<BoxCollider>(Vector2{6, 6}, 100, 50);
+	CollisionSystem coltest;
+	coltest.update();
+	return 0;
+}
-- 
cgit v1.2.3


From f2e5b685fd1357b55beeea967b12b353c5d65fb5 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Mon, 11 Nov 2024 20:49:55 +0100
Subject: fixed build issue

---
 src/crepe/api/Vector2.cpp | 10 +++++++---
 src/crepe/api/Vector2.h   | 13 ++++++++-----
 src/example/collision.cpp | 12 ++++++------
 3 files changed, 21 insertions(+), 14 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Vector2.cpp b/src/crepe/api/Vector2.cpp
index 09bb59b..947c49e 100644
--- a/src/crepe/api/Vector2.cpp
+++ b/src/crepe/api/Vector2.cpp
@@ -3,7 +3,7 @@
 namespace crepe {
 
 // Constructor with initial values
-Vector2::Vector2(float x, float y) : x(x), y(y) {}
+Vector2::Vector2(double x, double y) : x(x), y(y) {}
 
 // Subtracts another vector from this vector and returns the result.
 Vector2 Vector2::operator-(const Vector2 & other) const {
@@ -16,7 +16,7 @@ Vector2 Vector2::operator+(const Vector2 & other) const {
 }
 
 // Multiplies this vector by a scalar and returns the result.
-Vector2 Vector2::operator*(float scalar) const {
+Vector2 Vector2::operator*(double scalar) const {
 	return {x * scalar, y * scalar};
 }
 
@@ -35,7 +35,7 @@ Vector2 & Vector2::operator+=(const Vector2 & other) {
 }
 
 // Adds a scalar value to both components of this vector and updates this vector.
-Vector2 & Vector2::operator+=(float other) {
+Vector2 & Vector2::operator+=(double other) {
 	x += other;
 	y += other;
 	return *this;
@@ -54,4 +54,8 @@ bool Vector2::operator!=(const Vector2 & other) const {
 	return !(*this == other);
 }
 
+double Vector2::dot(const Vector2& other) const {
+	return this->x * other.x + this->y * other.y;
+}
+
 } // namespace crepe
diff --git a/src/crepe/api/Vector2.h b/src/crepe/api/Vector2.h
index 741951b..90d9d57 100644
--- a/src/crepe/api/Vector2.h
+++ b/src/crepe/api/Vector2.h
@@ -6,15 +6,15 @@ namespace crepe {
 class Vector2 {
 public:
 	//! X component of the vector
-	float x;
+	double x;
 	//! Y component of the vector
-	float y;
+	double y;
 
 	//! Default constructor
 	Vector2() = default;
 
 	//! Constructor with initial values
-	Vector2(float x, float y);
+	Vector2(double x, double y);
 
 	//! Subtracts another vector from this vector and returns the result.
 	Vector2 operator-(const Vector2 & other) const;
@@ -23,7 +23,7 @@ public:
 	Vector2 operator+(const Vector2 & other) const;
 
 	//! Multiplies this vector by a scalar and returns the result.
-	Vector2 operator*(float scalar) const;
+	Vector2 operator*(double scalar) const;
 
 	//! Multiplies this vector by another vector element-wise and updates this vector.
 	Vector2 & operator*=(const Vector2 & other);
@@ -32,7 +32,7 @@ public:
 	Vector2 & operator+=(const Vector2 & other);
 
 	//! Adds a scalar value to both components of this vector and updates this vector.
-	Vector2 & operator+=(float other);
+	Vector2 & operator+=(double other);
 
 	//! Returns the negation of this vector.
 	Vector2 operator-() const;
@@ -42,6 +42,9 @@ public:
 
 	//! Checks if this vector is not equal to another vector.
 	bool operator!=(const Vector2 & other) const;
+
+	//!
+	double dot(const Vector2& other) const;
 };
 
 } // namespace crepe
diff --git a/src/example/collision.cpp b/src/example/collision.cpp
index 9faac69..dc97c81 100644
--- a/src/example/collision.cpp
+++ b/src/example/collision.cpp
@@ -13,7 +13,7 @@ using namespace std;
 
 int main(int argc, char * argv[]) {
 
-	GameObject game_object1(0, "Name", "Tag", Vector2{1, 1}, 90, 1);
+	GameObject game_object1(0, "Name", "Tag", Vector2{10, 10}, 0, 1);
 	game_object1.add_component<Rigidbody>(Rigidbody::Data{
 		.mass = 1,
 		.gravity_scale = 1,
@@ -21,11 +21,11 @@ int main(int argc, char * argv[]) {
 		.constraints = {0, 0, 0},
 		.use_gravity = true,
 		.bounce = false,
-		.offset = {3,3}
+		.offset = {0,0}
 	});
-	game_object1.add_component<BoxCollider>(Vector2{5, 5}, 100, 50);
+	game_object1.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
 
-	GameObject game_object2(1, "Name", "Tag", Vector2{20, 2}, 90, 1);
+	GameObject game_object2(1, "Name", "Tag", Vector2{20, 0}, 90, 1);
 	game_object2.add_component<Rigidbody>(Rigidbody::Data{
 		.mass = 1,
 		.gravity_scale = 1,
@@ -33,9 +33,9 @@ int main(int argc, char * argv[]) {
 		.constraints = {0, 0, 0},
 		.use_gravity = true,
 		.bounce = false,
-		.offset = {4,4}
+		.offset = {0,0}
 	});
-	game_object2.add_component<BoxCollider>(Vector2{6, 6}, 100, 50);
+	game_object2.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
 	CollisionSystem coltest;
 	coltest.update();
 	return 0;
-- 
cgit v1.2.3


From e6bc46a30152a7585dda24fde66622575349d25e Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Fri, 15 Nov 2024 15:05:19 +0100
Subject: added data struct for event

---
 src/crepe/api/Event.h                |  6 +++++-
 src/crepe/system/CollisionSystem.cpp | 28 ++++++++++++++++++++++------
 src/crepe/system/CollisionSystem.h   | 15 +++++++++++++--
 3 files changed, 40 insertions(+), 9 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Event.h b/src/crepe/api/Event.h
index 701ecdf..3431f29 100644
--- a/src/crepe/api/Event.h
+++ b/src/crepe/api/Event.h
@@ -3,6 +3,7 @@
 #include <iostream>
 #include <string>
 #include <typeindex>
+#include "system/CollisionSystem.h"
 
 class Event {
 public:
@@ -45,7 +46,10 @@ public:
 };
 class CollisionEvent : public Event {
 public:
-	//Collision collisionData;
+	crepe::CollisionSystem::CollisionInfo info;
+	CollisionEvent(const crepe::CollisionSystem::CollisionInfo& collisionInfo)
+        : info(collisionInfo) {}
+
 };
 class TextSubmitEvent : public Event {
 public:
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index ac35026..56f07cc 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -1,11 +1,12 @@
 #include <cmath>
 #include <algorithm>
 #include <cstddef>
-#include <tuple>
 #include <utility>
 #include <variant>
 
 #include "CollisionSystem.h"
+#include "../api/Event.h"
+#include "../api/EventManager.h"
 
 #include "../ComponentManager.h"
 #include "../api/BoxCollider.h"
@@ -38,19 +39,24 @@ void CollisionSystem::update() {
 }
 
 void CollisionSystem::call_collision_handler(const CollidedInfoStor& data1,const CollidedInfoStor& data2){
-
+	const Collider* collider1 = nullptr;
+	const Collider* collider2 = nullptr;
 	// Check collision type and get values for handler
 	game_object_id_t first = 0,second = 0;
 	if (std::holds_alternative<BoxCollider>(data1.collider)) {
 		if (std::holds_alternative<BoxCollider>(data2.collider)) {
 			const BoxCollider& box_collider1 = std::get<BoxCollider>(data1.collider);
 			const BoxCollider& box_collider2 = std::get<BoxCollider>(data2.collider);
+			collider1 = &box_collider1;
+			collider2 = &box_collider2;
 			first = box_collider1.game_object_id;
 			second = box_collider2.game_object_id;
 		}
 		else {
 			const BoxCollider& box_collider = std::get<BoxCollider>(data1.collider);
 			const CircleCollider& circle_collider = std::get<CircleCollider>(data2.collider);
+			collider1 = &box_collider;
+			collider2 = &circle_collider;
 			first = box_collider.game_object_id;
 			second = circle_collider.game_object_id;
 		}
@@ -59,12 +65,16 @@ void CollisionSystem::call_collision_handler(const CollidedInfoStor& data1,const
 		if (std::holds_alternative<CircleCollider>(data2.collider)) {
 			const CircleCollider& circle_collider1 = std::get<CircleCollider>(data1.collider);
 			const CircleCollider& circle_collider2 = std::get<CircleCollider>(data2.collider);
+			collider1 = &circle_collider1;
+			collider2 = &circle_collider2;
 			first = circle_collider1.game_object_id;
 			second = circle_collider2.game_object_id;
 		}
 		else {
 			const CircleCollider& circle_collider = std::get<CircleCollider>(data1.collider);
 			const BoxCollider& box_collider = std::get<BoxCollider>(data2.collider);
+			collider1 = &circle_collider;
+			collider2 = &box_collider;
 			first = circle_collider.game_object_id;
 			second = box_collider.game_object_id;
 		}
@@ -74,10 +84,16 @@ void CollisionSystem::call_collision_handler(const CollidedInfoStor& data1,const
 	if(data1.rigidbody.data.body_type != Rigidbody::BodyType::STATIC)
 	{
 		// If second body is static move back
-		if(data2.rigidbody.data.body_type == Rigidbody::BodyType::STATIC) return; 
-		//call static handler (is bounce true?)
-
-		// call script handler
+		if(data2.rigidbody.data.body_type == Rigidbody::BodyType::STATIC){
+			//call static handler (is bounce true?)
+		}; 
+		
+		crepe::CollisionSystem::CollisionInfo collision_info{
+            { *collider1, data1.transform, data1.rigidbody },
+            { *collider2, data2.transform, data2.rigidbody }
+        };
+		CollisionEvent data(collision_info);
+		EventManager::get_instance().trigger_event<CollisionEvent>(data, 0);
 	}		
 }
 
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 9a72948..c7e8e0b 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -17,8 +17,9 @@ private:
 	using collider_stor = std::variant<BoxCollider, CircleCollider>;
 private:
 	struct CollidedInfoStor {
-		collider_stor collider;  // Store either BoxCollider or CircleCollider
-		Transform transform;      // Transform data
+		//! Store either BoxCollider or CircleCollider
+		collider_stor collider; 
+		Transform transform;
 		Rigidbody rigidbody;      // Rigidbody data
 	};
 public:
@@ -31,6 +32,16 @@ private:
 	bool check_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
 	bool check_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
 	Vector2 current_position(const Collider& collider, const Transform& transform, const Rigidbody& rigidbody);
+public:
+	struct ColliderInfo {
+		Collider collider;
+		Transform transform;
+		Rigidbody rigidbody;
+	};
+	struct CollisionInfo{
+    ColliderInfo first;
+    ColliderInfo second;
+	};
 };
 
 } // namespace crepe
-- 
cgit v1.2.3


From b019b401c3a1de0ffea7e6776242ae73599651ef Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Fri, 15 Nov 2024 16:10:45 +0100
Subject: collision handeling example

---
 src/crepe/api/Event.h                |  1 -
 src/crepe/api/Rigidbody.h            |  5 +++--
 src/crepe/api/Script.h               |  2 +-
 src/crepe/system/CollisionSystem.cpp |  2 +-
 src/crepe/system/CollisionSystem.h   |  2 +-
 src/crepe/system/ScriptSystem.cpp    |  6 +++++-
 src/example/collision.cpp            | 39 ++++++++++++++++++++++++++++++++----
 7 files changed, 46 insertions(+), 11 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Event.h b/src/crepe/api/Event.h
index 3431f29..bd6a541 100644
--- a/src/crepe/api/Event.h
+++ b/src/crepe/api/Event.h
@@ -49,7 +49,6 @@ public:
 	crepe::CollisionSystem::CollisionInfo info;
 	CollisionEvent(const crepe::CollisionSystem::CollisionInfo& collisionInfo)
         : info(collisionInfo) {}
-
 };
 class TextSubmitEvent : public Event {
 public:
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index b9edec2..a45623f 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cmath>
 #include <cstdint>
 
 #include "../Component.h"
@@ -60,13 +61,13 @@ public:
 		//! linear velocity of object
 		Vector2 linear_velocity;
 		//! maximum linear velocity of object
-		Vector2 max_linear_velocity;
+		Vector2 max_linear_velocity = {INFINITY ,INFINITY};
 		//! linear damping of object
 		Vector2 linear_damping;
 		//! angular velocity of object
 		double angular_velocity = 0.0;
 		//! max angular velocity of object
-		double max_angular_velocity = 0.0;
+		double max_angular_velocity = INFINITY;
 		//! angular damping of object
 		double angular_damping = 0.0;
 		//! movements constraints of object
diff --git a/src/crepe/api/Script.h b/src/crepe/api/Script.h
index 49e625f..0a10848 100644
--- a/src/crepe/api/Script.h
+++ b/src/crepe/api/Script.h
@@ -28,7 +28,7 @@ protected:
 	template <typename T>
 	std::vector<std::reference_wrapper<T>> get_components();
 
-private:
+public:
 	friend class crepe::BehaviorScript;
 	BehaviorScript * parent = nullptr;
 };
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 56f07cc..b9366df 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -93,7 +93,7 @@ void CollisionSystem::call_collision_handler(const CollidedInfoStor& data1,const
             { *collider2, data2.transform, data2.rigidbody }
         };
 		CollisionEvent data(collision_info);
-		EventManager::get_instance().trigger_event<CollisionEvent>(data, 0);
+		EventManager::get_instance().trigger_event<CollisionEvent>(data, first);
 	}		
 }
 
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index c7e8e0b..a31ac48 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -27,7 +27,7 @@ public:
 	void update();
 private:
 	void call_collision_handler(const CollidedInfoStor& data1,const CollidedInfoStor& data2);
-  std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders);
+  	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders);
 	bool check_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
 	bool check_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
 	bool check_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
diff --git a/src/crepe/system/ScriptSystem.cpp b/src/crepe/system/ScriptSystem.cpp
index f2673e7..e41961e 100644
--- a/src/crepe/system/ScriptSystem.cpp
+++ b/src/crepe/system/ScriptSystem.cpp
@@ -17,7 +17,11 @@ void ScriptSystem::update() {
 	dbg_trace();
 
 	forward_list<Script *> scripts = this->get_scripts();
-	for (Script * script : scripts) script->update();
+	for (Script * script : scripts) 
+	{
+		script->init();
+		script->update();
+	};
 }
 
 forward_list<Script *> ScriptSystem::get_scripts() {
diff --git a/src/example/collision.cpp b/src/example/collision.cpp
index e82b493..45ed0b0 100644
--- a/src/example/collision.cpp
+++ b/src/example/collision.cpp
@@ -1,5 +1,6 @@
 #include "api/BoxCollider.h"
 #include "system/CollisionSystem.h"
+#include <crepe/system/ScriptSystem.h>
 #include <crepe/Component.h>
 #include <crepe/ComponentManager.h>
 #include <crepe/api/GameObject.h>
@@ -10,12 +11,15 @@
 #include <crepe/system/RenderSystem.h>
 #include <crepe/util/log.h>
 
+#include <crepe/api/Script.h>
 #include <crepe/api/AssetManager.h>
 #include <crepe/api/Color.h>
 #include <crepe/api/Sprite.h>
 #include <crepe/api/Texture.h>
 #include <crepe/api/Transform.h>
 #include <crepe/api/Vector2.h>
+#include <crepe/api/Event.h>
+#include <crepe/api/EventManager.h>
 
 #include <chrono>
 #include <memory>
@@ -23,6 +27,22 @@
 using namespace crepe;
 using namespace std;
 
+class MyScript : public Script {
+	static bool oncollision(const CollisionEvent& test) {
+		std::cout << "test collision: " << test.info.first.collider.game_object_id << std::endl;
+		return true;
+	}
+	void init() {
+		EventManager::get_instance().subscribe<CollisionEvent>(oncollision, this->parent->game_object_id);
+	}
+	void update() {
+		// Retrieve component from the same GameObject this script is on
+		
+	}
+	
+	
+};
+
 int main(int argc, char * argv[]) {
 	Color color(0, 0, 0, 0);
 
@@ -33,16 +53,19 @@ int main(int argc, char * argv[]) {
 		.body_type = Rigidbody::BodyType::DYNAMIC,
 		.constraints = {0, 0, 0},
 		.use_gravity = true,
-		.bounce = false,
+		.bounce = true,
 		.offset = {0,0}
 	});
 	game_object1.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
+	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
+	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
+
 	// game_object1.add_component<Sprite>(
 	// make_shared<Texture>("/home/jaro/crepe/asset/texture/img.png"), color,
 	// FlipSettings{true, true});
 	
 
-	GameObject game_object2(1, "Name", "Tag", Vector2{20, 0}, 90, 1);
+	GameObject game_object2(1, "Name", "Tag", Vector2{10, 10}, 0, 1);
 	game_object2.add_component<Rigidbody>(Rigidbody::Data{
 		.mass = 1,
 		.gravity_scale = 1,
@@ -53,16 +76,24 @@ int main(int argc, char * argv[]) {
 		.offset = {0,0}
 	});
 	game_object2.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
+	game_object2.add_component<BehaviorScript>().set_script<MyScript>();
 	// game_object2.add_component<Sprite>(
 	// make_shared<Texture>("/home/jaro/crepe/asset/texture/img.png"), color,
 	// FlipSettings{true, true});
 
-	CollisionSystem coltest;
-	coltest.update();
+	
+	ScriptSystem sys;
+	// Update all scripts. This should result in MyScript::update being called
+	sys.update();
 	// auto & sys = crepe::RenderSystem::get_instance();
 	// auto start = std::chrono::steady_clock::now();
 	// while (std::chrono::steady_clock::now() - start < std::chrono::seconds(5)) {
 	// 	sys.update();
 	// }
+	CollisionSystem coltest;
+	coltest.update();
+
+
+
 	return 0;
 }
-- 
cgit v1.2.3


From 876a2e2ba115f6f8afa45155c8c6ed90d10576de Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Sun, 17 Nov 2024 15:34:32 +0100
Subject: added functionality to example and added pictures

---
 asset/texture/green_square.png       | Bin 0 -> 135 bytes
 asset/texture/red_square.png         | Bin 0 -> 135 bytes
 src/crepe/api/LoopManager.cpp        |  13 +++++--
 src/crepe/facade/SDLContext.cpp      |   4 +-
 src/crepe/system/CollisionSystem.cpp |  22 +++++------
 src/example/collision.cpp            |  72 ++++++++++++++++++++++-------------
 src/example/rendering.cpp            |   4 +-
 7 files changed, 70 insertions(+), 45 deletions(-)
 create mode 100755 asset/texture/green_square.png
 create mode 100755 asset/texture/red_square.png

(limited to 'src/crepe/api')

diff --git a/asset/texture/green_square.png b/asset/texture/green_square.png
new file mode 100755
index 0000000..7772c87
Binary files /dev/null and b/asset/texture/green_square.png differ
diff --git a/asset/texture/red_square.png b/asset/texture/red_square.png
new file mode 100755
index 0000000..6ffbbec
Binary files /dev/null and b/asset/texture/red_square.png differ
diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index 2e9823f..f9c5362 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -2,6 +2,8 @@
 #include "../facade/SDLContext.h"
 #include "../system/RenderSystem.h"
 #include "../system/ScriptSystem.h"
+#include "..//system/PhysicsSystem.h"
+#include "..//system/CollisionSystem.h"
 
 #include "LoopManager.h"
 #include "LoopTimer.h"
@@ -18,7 +20,12 @@ void LoopManager::start() {
 }
 void LoopManager::set_running(bool running) { this->game_running = running; }
 
-void LoopManager::fixed_update() {}
+void LoopManager::fixed_update() {
+	PhysicsSystem phys;
+	phys.update();
+	CollisionSystem col;
+	col.update();
+}
 
 void LoopManager::loop() {
 	LoopTimer & timer = LoopTimer::get_instance();
@@ -27,11 +34,11 @@ void LoopManager::loop() {
 	while (game_running) {
 		timer.update();
 
-		while (timer.get_lag() >= timer.get_fixed_delta_time()) {
+		//while (timer.get_lag() >= timer.get_fixed_delta_time()) {
 			this->process_input();
 			this->fixed_update();
 			timer.advance_fixed_update();
-		}
+		//}
 
 		this->update();
 		this->render();
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 236bf8c..274cd7a 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -130,8 +130,8 @@ void SDLContext::draw(const Sprite & sprite, const Transform & transform,
 	};
 
 	SDL_Rect dstrect = {
-		.x = static_cast<int>(adjusted_x),
-		.y = static_cast<int>(adjusted_y),
+		.x = static_cast<int>(adjusted_x/2),
+		.y = static_cast<int>(adjusted_y/2),
 		.w = static_cast<int>(adjusted_w),
 		.h = static_cast<int>(adjusted_h),
 	};
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index b9366df..d59539e 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -27,7 +27,7 @@ void CollisionSystem::update() {
 	std::vector<std::reference_wrapper<BoxCollider>> boxcolliders	= mgr.get_components_by_type<BoxCollider>();
 	std::vector<std::reference_wrapper<CircleCollider>> circlecolliders	= mgr.get_components_by_type<CircleCollider>();
 	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> collided = check_collisions(boxcolliders,circlecolliders);
-	std::cout << "DEBUG INFO" << std::endl;
+	// std::cout << "DEBUG INFO" << std::endl;
 	for (const auto& collision_pair : collided) {
 		call_collision_handler(collision_pair.first,collision_pair.second); // First collider
 		call_collision_handler(collision_pair.second,collision_pair.first); // First collider
@@ -202,12 +202,12 @@ bool CollisionSystem::check_box_box_collision(const BoxCollider& box1, const Box
 	Vector2 final_position2 = current_position(box2,transform2,rigidbody2);
 
 	 // Log final positions for debugging purposes
-	std::cout << "Final Position of Box 1: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
-	std::cout << "Final Position of Box 2: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
+	// std::cout << "Final Position of Box 1: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
+	// std::cout << "Final Position of Box 2: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
 
 	// Log rotation values for debugging
-	std::cout << "Rotation of Box 1: " << transform1.rotation << " degrees" << std::endl;
-	std::cout << "Rotation of Box 2: " << transform2.rotation << " degrees" << std::endl;
+	// std::cout << "Rotation of Box 1: " << transform1.rotation << " degrees" << std::endl;
+	// std::cout << "Rotation of Box 2: " << transform2.rotation << " degrees" << std::endl;
 
 
 	// Calculate half-extents (half width and half height)
@@ -229,8 +229,8 @@ bool CollisionSystem::check_box_circle_collision(const BoxCollider& box1, const
 	Vector2 final_position2 = current_position(circle2, transform2, rigidbody2);
 
 	// Log final positions for debugging purposes
-	std::cout << "Final Position of Box: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
-	std::cout << "Final Position of Circle: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
+	// std::cout << "Final Position of Box: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
+	// std::cout << "Final Position of Circle: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
 
 	// Calculate box half-extents
 	double half_width = box1.width / 2.0;
@@ -256,12 +256,12 @@ bool CollisionSystem::check_circle_circle_collision(const CircleCollider& circle
 	Vector2 final_position2 = current_position(circle2,transform2,rigidbody2);
 
 	// Log final positions for debugging purposes
-	std::cout << "Final Position of Circle 1: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
-	std::cout << "Final Position of Circle 2: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
+	// std::cout << "Final Position of Circle 1: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
+	// std::cout << "Final Position of Circle 2: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
 
 	// Log rotation values for debugging (circles do not rotate, so this might not be needed for circles)
-	std::cout << "Rotation of Circle 1: " << transform1.rotation << " degrees" << std::endl;
-	std::cout << "Rotation of Circle 2: " << transform2.rotation << " degrees" << std::endl;
+	// std::cout << "Rotation of Circle 1: " << transform1.rotation << " degrees" << std::endl;
+	// std::cout << "Rotation of Circle 2: " << transform2.rotation << " degrees" << std::endl;
 
 	double distance_x = final_position1.x - final_position2.x;
 	double distance_y = final_position1.y - final_position2.y;
diff --git a/src/example/collision.cpp b/src/example/collision.cpp
index 45ed0b0..a1b22f0 100644
--- a/src/example/collision.cpp
+++ b/src/example/collision.cpp
@@ -20,6 +20,7 @@
 #include <crepe/api/Vector2.h>
 #include <crepe/api/Event.h>
 #include <crepe/api/EventManager.h>
+#include <crepe/api/LoopManager.h>
 
 #include <chrono>
 #include <memory>
@@ -44,55 +45,72 @@ class MyScript : public Script {
 };
 
 int main(int argc, char * argv[]) {
+	//setup
+	LoopManager gameloop;
 	Color color(0, 0, 0, 0);
 
-	GameObject game_object1(0, "Name", "Tag", Vector2{10, 10}, 0, 1);
-	game_object1.add_component<Rigidbody>(Rigidbody::Data{
-		.mass = 1,
-		.gravity_scale = 1,
-		.body_type = Rigidbody::BodyType::DYNAMIC,
+	//define playable world 
+	GameObject World(0, "Name", "Tag", Vector2{0, 0}, 0, 1);
+	World.add_component<Rigidbody>(Rigidbody::Data{
+		.mass = 0,
+		.gravity_scale = 0,
+		.body_type = Rigidbody::BodyType::STATIC,
 		.constraints = {0, 0, 0},
-		.use_gravity = true,
-		.bounce = true,
-		.offset = {0,0}
+		.use_gravity = false,
+		.bounce = false,
+		.offset = {320,240}
 	});
-	game_object1.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
-	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
-	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
+	World.add_component<BoxCollider>(Vector2{0, -740}, 1000, 1000);	// Top
+	World.add_component<BoxCollider>(Vector2{0, 740}, 1000, 1000); // Bottom
+	World.add_component<BoxCollider>(Vector2{-820, 0}, 1000, 1000); // Left
+	World.add_component<BoxCollider>(Vector2{820, 0}, 1000, 1000); // right
 
-	// game_object1.add_component<Sprite>(
-	// make_shared<Texture>("/home/jaro/crepe/asset/texture/img.png"), color,
-	// FlipSettings{true, true});
-	
 
-	GameObject game_object2(1, "Name", "Tag", Vector2{10, 10}, 0, 1);
-	game_object2.add_component<Rigidbody>(Rigidbody::Data{
+	GameObject game_object1(1, "Name", "Tag", Vector2{320, 240}, 0, 1);
+	game_object1.add_component<Rigidbody>(Rigidbody::Data{
 		.mass = 1,
 		.gravity_scale = 1,
 		.body_type = Rigidbody::BodyType::DYNAMIC,
 		.constraints = {0, 0, 0},
-		.use_gravity = true,
+		.use_gravity = false,
 		.bounce = false,
 		.offset = {0,0}
 	});
-	game_object2.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
-	game_object2.add_component<BehaviorScript>().set_script<MyScript>();
+	game_object1.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
+	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
+	game_object1.add_component<Sprite>(
+	make_shared<Texture>("/home/jaro/crepe/asset/texture/img.png"), color,
+	FlipSettings{true, true});
+	game_object1.add_component<Camera>(Color::get_white());
+	
+
+	// GameObject game_object2(2, "Name", "Tag", Vector2{10, 10}, 0, 1);
+	// game_object2.add_component<Rigidbody>(Rigidbody::Data{
+	// 	.mass = 1,
+	// 	.gravity_scale = 1,
+	// 	.body_type = Rigidbody::BodyType::DYNAMIC,
+	// 	.constraints = {0, 0, 0},
+	// 	.use_gravity = false,
+	// 	.bounce = false,
+	// 	.offset = {0,0}
+	// });
+	// game_object2.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
+	// game_object2.add_component<BehaviorScript>().set_script<MyScript>();
 	// game_object2.add_component<Sprite>(
 	// make_shared<Texture>("/home/jaro/crepe/asset/texture/img.png"), color,
 	// FlipSettings{true, true});
-
 	
-	ScriptSystem sys;
+	
+	crepe::ScriptSystem sys;
 	// Update all scripts. This should result in MyScript::update being called
 	sys.update();
-	// auto & sys = crepe::RenderSystem::get_instance();
+	
+	gameloop.start();
+	// auto & render = crepe::RenderSystem::get_instance();
 	// auto start = std::chrono::steady_clock::now();
 	// while (std::chrono::steady_clock::now() - start < std::chrono::seconds(5)) {
-	// 	sys.update();
+	//	 render.update();
 	// }
-	CollisionSystem coltest;
-	coltest.update();
-
 
 
 	return 0;
diff --git a/src/example/rendering.cpp b/src/example/rendering.cpp
index 827ad07..813fd25 100644
--- a/src/example/rendering.cpp
+++ b/src/example/rendering.cpp
@@ -28,14 +28,14 @@ int main() {
 	{
 		Color color(0, 0, 0, 0);
 		obj.add_component<Sprite>(
-			make_shared<Texture>("../asset/texture/img.png"), color,
+			make_shared<Texture>("/home/jaro/crepe/asset/texture/img.png"), color,
 			FlipSettings{false, false});
 		obj.add_component<Camera>(Color::get_red());
 	}
 	{
 		Color color(0, 0, 0, 0);
 		obj1.add_component<Sprite>(
-			make_shared<Texture>("../asset/texture/second.png"), color,
+			make_shared<Texture>("/home/jaro/crepe/asset/texture/img.png"), color,
 			FlipSettings{true, true});
 	}
 
-- 
cgit v1.2.3


From b1c82f914f18457f9a30791b01896ea40832c2d3 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Sun, 17 Nov 2024 18:45:46 +0100
Subject: bounce

---
 src/crepe/api/Rigidbody.h            |  2 ++
 src/crepe/facade/SDLContext.cpp      |  8 ++++----
 src/crepe/system/CollisionSystem.cpp |  8 +++++++-
 src/example/collision.cpp            | 19 ++++++++++---------
 4 files changed, 23 insertions(+), 14 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index a45623f..b55297c 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -76,6 +76,8 @@ public:
 		bool use_gravity = true;
 		//! if object bounces
 		bool bounce = false;
+		//! bounce factor of material
+		double bouncie_factor = 0.0;
 		//! offset of all colliders
 		Vector2 offset;
 	};
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 274cd7a..5d22cdf 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -117,8 +117,8 @@ void SDLContext::draw(const Sprite & sprite, const Transform & transform,
 		= (SDL_RendererFlip) ((SDL_FLIP_HORIZONTAL * sprite.flip.flip_x)
 							  | (SDL_FLIP_VERTICAL * sprite.flip.flip_y));
 
-	double adjusted_x = (transform.position.x - cam.x) * cam.zoom;
-	double adjusted_y = (transform.position.y - cam.y) * cam.zoom;
+	double adjusted_x = (transform.position.x - cam.x -(sprite.sprite_rect.w/2)) * cam.zoom;
+	double adjusted_y = (transform.position.y - cam.y -(sprite.sprite_rect.h/2)) * cam.zoom;
 	double adjusted_w = sprite.sprite_rect.w * transform.scale * cam.zoom;
 	double adjusted_h = sprite.sprite_rect.h * transform.scale * cam.zoom;
 
@@ -130,8 +130,8 @@ void SDLContext::draw(const Sprite & sprite, const Transform & transform,
 	};
 
 	SDL_Rect dstrect = {
-		.x = static_cast<int>(adjusted_x/2),
-		.y = static_cast<int>(adjusted_y/2),
+		.x = static_cast<int>(adjusted_x),
+		.y = static_cast<int>(adjusted_y),
 		.w = static_cast<int>(adjusted_w),
 		.h = static_cast<int>(adjusted_h),
 	};
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 4b74e67..8377823 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -152,7 +152,13 @@ void CollisionSystem::call_collision_handler(CollidedInfoStor& data1,CollidedInf
 void CollisionSystem::static_collision_handler(CollisionInfo& info){
 	std::cout << "INFO: x:" << info.first.transform.position.x << "y:" << info.first.transform.position.y << std::endl;
 	info.first.transform.position += info.move_back_value;
-	info.first.rigidbody.data.linear_velocity = {0,0};
+	if(info.first.rigidbody.data.bounce) {
+		info.first.rigidbody.data.linear_velocity = -info.first.rigidbody.data.linear_velocity * info.first.rigidbody.data.bouncie_factor;
+	}
+	else {
+		info.first.rigidbody.data.linear_velocity = {0,0};
+	}
+	
 }
 
 std::vector<std::pair<CollisionSystem::CollidedInfoStor,CollisionSystem::CollidedInfoStor>> CollisionSystem::check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders) {
diff --git a/src/example/collision.cpp b/src/example/collision.cpp
index a5cec83..b141d3d 100644
--- a/src/example/collision.cpp
+++ b/src/example/collision.cpp
@@ -49,8 +49,8 @@ int main(int argc, char * argv[]) {
 	LoopManager gameloop;
 	Color color(0, 0, 0, 0);
 
-	double screen_size_width = 1280;
-	double screen_size_height = 960;
+	double screen_size_width = 640;
+	double screen_size_height = 480;
 	double world_collider = 1000;
 	//define playable world 
 	GameObject World(0, "Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
@@ -72,15 +72,16 @@ int main(int argc, char * argv[]) {
 	GameObject game_object1(1, "Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
 	game_object1.add_component<Rigidbody>(Rigidbody::Data{
 		.mass = 1,
-		.gravity_scale = 1,
+		.gravity_scale = 0.01,
 		.body_type = Rigidbody::BodyType::DYNAMIC,
-		.linear_velocity = {0,1},
+		.linear_velocity = {0,0},
 		.constraints = {0, 0, 0},
-		.use_gravity = false,
-		.bounce = false,
+		.use_gravity = true,
+		.bounce = true,
+		.bouncie_factor = 1,
 		.offset = {0,0},
 	});
-	game_object1.add_component<BoxCollider>(Vector2{0, 0}, 40, 40);
+	game_object1.add_component<BoxCollider>(Vector2{0, 0}, 20, 20);
 	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
 	game_object1.add_component<Sprite>(
 	make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
@@ -88,7 +89,7 @@ int main(int argc, char * argv[]) {
 	game_object1.add_component<Camera>(Color::get_white());
 	
 
-	// GameObject game_object2(2, "Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2+100}, 0, 1);
+	// GameObject game_object2(2, "Name", "Tag", Vector2{20, 470}, 0, 1);
 	// game_object2.add_component<Rigidbody>(Rigidbody::Data{
 	// 	.mass = 1,
 	// 	.gravity_scale = 1,
@@ -99,7 +100,7 @@ int main(int argc, char * argv[]) {
 	// 	.bounce = false,
 	// 	.offset = {0,0},
 	// });
-	// game_object2.add_component<BoxCollider>(Vector2{0, 0}, 40, 40);
+	// game_object2.add_component<BoxCollider>(Vector2{0, 0}, 0, 0);
 	// game_object2.add_component<BehaviorScript>().set_script<MyScript>();
 	// game_object2.add_component<Sprite>(
 	// make_shared<Texture>("/home/jaro/crepe/asset/texture/red_square.png"), color,
-- 
cgit v1.2.3


From 0a49b688a79c9cb59c1ed1bdbd1c15f9572deed9 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Tue, 19 Nov 2024 20:39:42 +0100
Subject: added doxygen

---
 src/crepe/api/Rigidbody.h            |   2 +-
 src/crepe/system/CollisionSystem.cpp | 250 +++++++++++++++++------------------
 src/crepe/system/CollisionSystem.h   | 157 ++++++++++++++++++++--
 src/example/collision.cpp            |   2 +-
 4 files changed, 268 insertions(+), 143 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index b55297c..782de22 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -77,7 +77,7 @@ public:
 		//! if object bounces
 		bool bounce = false;
 		//! bounce factor of material
-		double bouncie_factor = 0.0;
+		double elastisity = 0.0;
 		//! offset of all colliders
 		Vector2 offset;
 	};
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 3c6f22e..df0ee41 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -4,179 +4,200 @@
 #include <utility>
 #include <variant>
 
+#include "api/Event.h"
+#include "api/EventManager.h"
+#include "api/BoxCollider.h"
+#include "api/CircleCollider.h"
+#include "api/Vector2.h"
+#include "api/Rigidbody.h"
+#include "api/Transform.h"
+
+#include "ComponentManager.h"
 #include "CollisionSystem.h"
-#include "../api/Event.h"
-#include "../api/EventManager.h"
-
-#include "../ComponentManager.h"
-#include "../api/BoxCollider.h"
-#include "../api/CircleCollider.h"
-#include "../api/Vector2.h"
-#include "../api/Rigidbody.h"
-#include "../api/Transform.h"
-
 #include "Collider.h"
-#include "iostream"
 
 using namespace crepe;
 
 CollisionSystem::CollisionSystem() {}
 
 void CollisionSystem::update() {
+	// Get collider components and keep them seperate
 	ComponentManager & mgr = ComponentManager::get_instance();
 	std::vector<std::reference_wrapper<BoxCollider>> boxcolliders	= mgr.get_components_by_type<BoxCollider>();
 	std::vector<std::reference_wrapper<CircleCollider>> circlecolliders	= mgr.get_components_by_type<CircleCollider>();
+	
+	// Check between all colliders if there is a collision
 	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> collided = check_collisions(boxcolliders,circlecolliders);
-	// std::cout << "DEBUG INFO" << std::endl;
-	for (auto& collision_pair : collided) {
-		call_collision_handler(collision_pair.first,collision_pair.second); // First collider
-		call_collision_handler(collision_pair.second,collision_pair.first); // First collider
-	}
 
-	if(collided.empty()) {
-		std::cout << "No objects collided" << std::endl;
+	// For both objects call the collision handler 
+	for (auto& collision_pair : collided) {
+		collision_handler(collision_pair.first,collision_pair.second);
+		collision_handler(collision_pair.second,collision_pair.first);
 	}
 }
 
-void CollisionSystem::call_collision_handler(CollidedInfoStor& data1,CollidedInfoStor& data2){
+void CollisionSystem::collision_handler(CollidedInfoStor& data1,CollidedInfoStor& data2){
+
+	// Data needed for collision handler info
 	const Collider* collider1 = nullptr;
 	const Collider* collider2 = nullptr;
-	double height1 = 0,width1 = 0;
-	double height2 = 0,width2 = 0;
-	Vector2 final_position1;
-	Vector2 final_position2;
-	Vector2 temp;
+	Vector2 move_back;
+
 	// Check collision type and get values for handler
-	game_object_id_t first = 0,second = 0;
 	if (std::holds_alternative<BoxCollider>(data1.collider)) {
 		if (std::holds_alternative<BoxCollider>(data2.collider)) {
+			
+			// Get colliders from variant to be used to determine collision handler info
 			const BoxCollider& box_collider1 = std::get<BoxCollider>(data1.collider);
 			const BoxCollider& box_collider2 = std::get<BoxCollider>(data2.collider);
 			collider1 = &box_collider1;
 			collider2 = &box_collider2;
-			first = box_collider1.game_object_id;
-			second = box_collider2.game_object_id;
-			height1 = box_collider1.height;
-			height2 = box_collider2.height;
-			width1 = box_collider1.width;
-			width2 = box_collider2.width;
-			final_position1 = current_position(box_collider1,data1.transform,data1.rigidbody);
-			final_position2 = current_position(box_collider2,data2.transform,data2.rigidbody);
-
-			Vector2 delta = final_position2 - final_position1;
-
-			double half_width1 = width1 / 2.0;
-			double half_height1 = height1 / 2.0;
-			double half_width2 = width2 / 2.0;
-			double half_height2 = height2 / 2.0;
-
-			// Compute overlap in X and Y directions
-			double overlap_x = (half_width1 + half_width2) - std::abs(delta.x);
-			double overlap_y = (half_height1 + half_height2) - std::abs(delta.y);
-
-			// Check if there is actually a collision
-			if (overlap_x > 0 && overlap_y > 0) {
-					// Resolve in the smallest overlap direction
-					if (overlap_x < overlap_y) {
-							// Resolve along X-axis
-							temp = {delta.x > 0 ? -overlap_x : overlap_x, 0};
-					} else {
-							// Resolve along Y-axis
-							temp = {0, delta.y > 0 ? -overlap_y : overlap_y};
-					}
-			}
-
 
+			// TODO: send with the collider info to this function because this is calculated previously
+			// Get the current position of the collider
+			Vector2 final_position1 = current_position(box_collider1,data1.transform,data1.rigidbody);
+			Vector2 final_position2 = current_position(box_collider2,data2.transform,data2.rigidbody);
 
+			// Determine move_back value for smallest overlap (x or y)
+			move_back = box_box_collision_move_back(box_collider1,box_collider2,final_position1,final_position2);
+			
 		}
 		else {
+			// TODO: calcualte Box - Circle collision info
 			const BoxCollider& box_collider = std::get<BoxCollider>(data1.collider);
 			const CircleCollider& circle_collider = std::get<CircleCollider>(data2.collider);
 			collider1 = &box_collider;
 			collider2 = &circle_collider;
-			first = box_collider.game_object_id;
-			second = circle_collider.game_object_id;
-			height1 = box_collider.height;
-			height2 = circle_collider.radius + circle_collider.radius;
-			width1 = box_collider.width;
-			width2 = circle_collider.radius + circle_collider.radius;
 		}
 	}
 	else {
 		if (std::holds_alternative<CircleCollider>(data2.collider)) {
+			// TODO: calcualte Circle - Circle collision info
 			const CircleCollider& circle_collider1 = std::get<CircleCollider>(data1.collider);
 			const CircleCollider& circle_collider2 = std::get<CircleCollider>(data2.collider);
 			collider1 = &circle_collider1;
 			collider2 = &circle_collider2;
-			first = circle_collider1.game_object_id;
-			second = circle_collider2.game_object_id;
-			height1 = circle_collider1.radius + circle_collider1.radius;
-			height2 = circle_collider2.radius + circle_collider2.radius;
-			width1 = circle_collider1.radius + circle_collider1.radius;
-			width2 = circle_collider2.radius + circle_collider2.radius;
 		}
 		else {
+			// TODO: calcualte Circle - Box collision info
 			const CircleCollider& circle_collider = std::get<CircleCollider>(data1.collider);
 			const BoxCollider& box_collider = std::get<BoxCollider>(data2.collider);
 			collider1 = &circle_collider;
 			collider2 = &box_collider;
-			first = circle_collider.game_object_id;
-			second = box_collider.game_object_id;
-			height1 = circle_collider.radius + circle_collider.radius;
-			height2 = box_collider.height;
-			width1 = circle_collider.radius + circle_collider.radius;
-			width2 = box_collider.width;
 		}
 	}
+
+	// One vaue is calculated for moving back. Calculate the other value (x or y) relateive to the move_back value.
+	Direction move_back_direction = Direction::NONE;
+	if(move_back.x != 0 && move_back.y > 0) {
+		move_back_direction = Direction::BOTH;
+	} else if (move_back.x != 0) {
+		move_back_direction = Direction::X_DIRECTION;
+		move_back.y = data1.rigidbody.data.linear_velocity.y * (move_back.x/data1.rigidbody.data.linear_velocity.x);
+	} else if (move_back.y != 0) {
+		move_back_direction = Direction::Y_DIRECTION;
+		move_back.x = data1.rigidbody.data.linear_velocity.x * (move_back.y/data1.rigidbody.data.linear_velocity.y);
+	}
+
+	// collision info
 	crepe::CollisionSystem::CollisionInfo collision_info{
             .first={ *collider1, data1.transform, data1.rigidbody },
             .second={ *collider2, data2.transform, data2.rigidbody },
-						.move_back_value = temp,
+						.move_back_value = move_back,
+						.move_back_direction = move_back_direction,
         };
 
-	// check rigidbody type
-	if(data1.rigidbody.data.body_type != Rigidbody::BodyType::STATIC)
+	// Determine if static needs to be called
+	determine_collision_handler(collision_info);	
+}
+
+
+Vector2 CollisionSystem::box_box_collision_move_back(const BoxCollider& box_collider1,const BoxCollider& box_collider2,Vector2 final_position1,Vector2 final_position2)
+{
+	Vector2 resolution; // Default resolution vector
+	Vector2 delta = final_position2 - final_position1;
+
+	// Compute half-dimensions of the boxes
+	double half_width1 = box_collider1.width / 2.0;
+	double half_height1 = box_collider1.height / 2.0;
+	double half_width2 = box_collider2.width / 2.0;
+	double half_height2 = box_collider2.height / 2.0;
+
+	// Calculate overlaps along X and Y axes
+	double overlap_x = (half_width1 + half_width2) - std::abs(delta.x);
+	double overlap_y = (half_height1 + half_height2) - std::abs(delta.y);
+
+	// Check if there is a collision
+	if (overlap_x > 0 && overlap_y > 0) {//should always be true check if this can be removed
+		// Determine the direction of resolution
+		if (overlap_x < overlap_y) {
+			// Resolve along the X-axis (smallest overlap)
+			resolution.x = (delta.x > 0) ? -overlap_x : overlap_x;
+		} else if (overlap_y < overlap_x) {
+			// Resolve along the Y-axis (smallest overlap)
+			resolution.y = (delta.y > 0) ? -overlap_y : overlap_y;
+		} else {
+			// Equal overlap, resolve both directions with preference
+			resolution.x = (delta.x > 0) ? -overlap_x : overlap_x;
+			resolution.y = (delta.y > 0) ? -overlap_y : overlap_y;
+		}
+	}
+
+	return resolution;
+}
+
+void CollisionSystem::determine_collision_handler(CollisionInfo& info){
+	// Check rigidbody type for static
+	if(info.first.rigidbody.data.body_type != Rigidbody::BodyType::STATIC)
 	{
-		// If second body is static move back
-		if(data2.rigidbody.data.body_type == Rigidbody::BodyType::STATIC){
-			//call static handler (is bounce true?)
-			static_collision_handler(collision_info);
+		// If second body is static perform the static collision handler in this system
+		if(info.second.rigidbody.data.body_type == Rigidbody::BodyType::STATIC){
+			static_collision_handler(info);
 		}; 
-		
-		
-		CollisionEvent data(collision_info);
-		EventManager::get_instance().trigger_event<CollisionEvent>(data, first);
+		// Call collision event for user
+		CollisionEvent data(info);
+		EventManager::get_instance().trigger_event<CollisionEvent>(data, info.first.collider.game_object_id);
 	}		
 }
 
 void CollisionSystem::static_collision_handler(CollisionInfo& info){
-	std::cout << "INFO: x:" << info.first.transform.position.x << "y:" << info.first.transform.position.y << std::endl;
+	// Move object back using calculate move back value 
 	info.first.transform.position += info.move_back_value;
+
+	// If bounce is enabled mirror velocity
 	if(info.first.rigidbody.data.bounce) {
-		if(info.move_back_value.x != 0) {
-			info.first.rigidbody.data.linear_velocity.x = -info.first.rigidbody.data.linear_velocity.x * info.first.rigidbody.data.bouncie_factor;
+		if(info.move_back_direction == Direction::BOTH)
+		{
+			info.first.rigidbody.data.linear_velocity.y = -info.first.rigidbody.data.linear_velocity.y * info.first.rigidbody.data.elastisity;
+			info.first.rigidbody.data.linear_velocity.x = -info.first.rigidbody.data.linear_velocity.x * info.first.rigidbody.data.elastisity;
+		}
+		else if(info.move_back_direction == Direction::Y_DIRECTION) {
+			info.first.rigidbody.data.linear_velocity.y = -info.first.rigidbody.data.linear_velocity.y * info.first.rigidbody.data.elastisity;
 		}
-		if(info.move_back_value.y != 0) {
-			info.first.rigidbody.data.linear_velocity.y = -info.first.rigidbody.data.linear_velocity.y * info.first.rigidbody.data.bouncie_factor;
+		else if(info.move_back_direction == Direction::X_DIRECTION){
+			info.first.rigidbody.data.linear_velocity.x = -info.first.rigidbody.data.linear_velocity.x * info.first.rigidbody.data.elastisity;
 		}
 	}
+	// Stop movement if bounce is disabled
 	else {
 		info.first.rigidbody.data.linear_velocity = {0,0};
 	}
-	
 }
 
 std::vector<std::pair<CollisionSystem::CollidedInfoStor,CollisionSystem::CollidedInfoStor>> CollisionSystem::check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders) {
 	ComponentManager & mgr = ComponentManager::get_instance();
 	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> collisions_ret;
-	//if no colliders skip
-	//check if colliders has rigibocdy if not skip
 
-	//if amount is higer than lets say 16 for now use quadtree otwerwise skip
-	//quadtree code
-	//quadtree is placed over the input vector
+	// TODO:
+	// If no colliders skip
+	// Check if colliders has rigidbody if not skip
 
-	// Check collisions
+	// TODO:
+	// If amount is higer than lets say 16 for now use quadtree otwerwise skip
+	// Quadtree code
+	// Quadtree is placed over the input vector
+
+	// Check collisions for each collider
 	for (size_t i = 0; i < boxcolliders.size(); ++i) {
 		// Fetch components for the first box collider
 		if(!boxcolliders[i].get().active) continue;
@@ -270,32 +291,12 @@ bool CollisionSystem::check_box_box_collision(const BoxCollider& box1, const Box
 	Vector2 final_position1 = current_position(box1,transform1,rigidbody1);
 	Vector2 final_position2 = current_position(box2,transform2,rigidbody2);
 
-	 // Log final positions for debugging purposes
-	std::cout << "Final Position of Box 1: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
-	std::cout << "Final Position of Box 2: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
-
-	// Log rotation values for debugging
-	std::cout << "Rotation of Box 1: " << transform1.rotation << " degrees" << std::endl;
-	std::cout << "Rotation of Box 2: " << transform2.rotation << " degrees" << std::endl;
-
-
 	// Calculate half-extents (half width and half height)
 	double half_width1 = box1.width / 2.0;
 	double half_height1 = box1.height / 2.0;
 	double half_width2 = box2.width / 2.0;
 	double half_height2 = box2.height / 2.0;
 
-	std::cout << "half_width of Box 1: " << half_width1 << std::endl;
-	std::cout << "half_height of Box 2: " << half_height1 << std::endl;
-	std::cout << "half_width of Box 1: " << half_width2 << std::endl;
-	std::cout << "half_height of Box 2: " << half_height2 << std::endl;
-
-
-	std::cout << "final_position1.x + half_width1 < final_position2.x - half_width2 " << (final_position1.x + half_width1 < final_position2.x - half_width2) << std::endl;
-	std::cout << "final_position1.x - half_width1 > final_position2.x + half_width2 " << (final_position1.x - half_width1 > final_position2.x + half_width2) << std::endl;
-	std::cout << "final_position1.y + half_height1 < final_position2.y - half_height2 " << (final_position1.y + half_height1 < final_position2.y - half_height2) << std::endl;
-	std::cout << "final_position1.y - half_height1 > final_position2.y + half_height2 " << (final_position1.y - half_height1 > final_position2.y + half_height2) << std::endl;
-
 	// Check if the boxes overlap along the X and Y axes
 	return !(final_position1.x + half_width1 <= final_position2.x - half_width2 ||  // box1 is left of box2
 						final_position1.x - half_width1 >= final_position2.x + half_width2 ||  // box1 is right of box2
@@ -308,10 +309,6 @@ bool CollisionSystem::check_box_circle_collision(const BoxCollider& box1, const
 	Vector2 final_position1 = current_position(box1, transform1, rigidbody1);
 	Vector2 final_position2 = current_position(circle2, transform2, rigidbody2);
 
-	// Log final positions for debugging purposes
-	// std::cout << "Final Position of Box: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
-	// std::cout << "Final Position of Circle: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
-
 	// Calculate box half-extents
 	double half_width = box1.width / 2.0;
 	double half_height = box1.height / 2.0;
@@ -320,7 +317,6 @@ bool CollisionSystem::check_box_circle_collision(const BoxCollider& box1, const
 	double closest_x = std::max(final_position1.x - half_width, std::min(final_position2.x, final_position1.x + half_width));
 	double closest_y = std::max(final_position1.y - half_height, std::min(final_position2.y, final_position1.y + half_height));
 
-
 	// Calculate the distance squared between the circle's center and the closest point on the box
 	double distance_x = final_position2.x - closest_x;
 	double distance_y = final_position2.y - closest_y;
@@ -335,14 +331,6 @@ bool CollisionSystem::check_circle_circle_collision(const CircleCollider& circle
 	Vector2 final_position1 = current_position(circle1,transform1,rigidbody1);
 	Vector2 final_position2 = current_position(circle2,transform2,rigidbody2);
 
-	// Log final positions for debugging purposes
-	// std::cout << "Final Position of Circle 1: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
-	// std::cout << "Final Position of Circle 2: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
-
-	// Log rotation values for debugging (circles do not rotate, so this might not be needed for circles)
-	// std::cout << "Rotation of Circle 1: " << transform1.rotation << " degrees" << std::endl;
-	// std::cout << "Rotation of Circle 2: " << transform2.rotation << " degrees" << std::endl;
-
 	double distance_x = final_position1.x - final_position2.x;
 	double distance_y = final_position1.y - final_position2.y;
 	double distance_squared = distance_x * distance_x + distance_y * distance_y;
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index cfa599e..f3242b1 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -1,54 +1,191 @@
 #pragma once
 
-#include "Collider.h"
+#include <vector>
+#include <variant>
+
 #include "api/Rigidbody.h"
 #include "api/Transform.h"
 #include "api/BoxCollider.h"
 #include "api/CircleCollider.h"
 #include "api/Vector2.h"
-#include <tuple>
-#include <vector>
-#include <variant>
+
+#include "Collider.h"
 
 namespace crepe {
 
 
+//! A system responsible for detecting and handling collisions between colliders.
 class CollisionSystem {
 private:
+	
+	//! A variant type that can hold either a BoxCollider or a CircleCollider.
 	using collider_stor = std::variant<BoxCollider, CircleCollider>;
-private:
+
+	/**
+		* \brief A structure to store the collision data of a single collider.
+		* 
+		* This structure stores the collider type, its associated transform, and its rigidbody.
+		*/
 	struct CollidedInfoStor {
 		//! Store either BoxCollider or CircleCollider
 		collider_stor collider; 
 		Transform& transform;
-		Rigidbody& rigidbody;      // Rigidbody data
+		Rigidbody& rigidbody;
 	};
+	
+	//! Enum representing movement directions during collision resolution.
+	enum class Direction {
+    NONE,
+    X_DIRECTION,
+    Y_DIRECTION,
+    BOTH
+	};
+
 public:
+	/**
+		* \brief A structure representing the collision information between two colliders.
+		* 
+		* This structure contains both colliders, their associated transforms and rigidbodies,
+		* as well as the movement vector to resolve the collision.
+		*/
 	struct ColliderInfo {
 		const Collider& collider;
 		Transform& transform;
 		Rigidbody& rigidbody;
 	};
+	/**
+		* \brief A structure representing detailed collision information between two colliders.
+		* 
+		* This includes the movement data required to resolve the collision.
+		*/
 	struct CollisionInfo{
     ColliderInfo first;
     ColliderInfo second;
 		Vector2 move_back_value;
+		Direction move_back_direction = Direction::NONE;
 	};
+
 public:
+
 	CollisionSystem();
+
+	//! Updates the collision system by checking for collisions between colliders and handling them.
 	void update();
-private: //handling
-	void call_collision_handler(CollidedInfoStor& data1,CollidedInfoStor& data2);
+
+private:
+	/**
+		* \brief Handles a collision between two colliders.
+		* 
+		* This function calculates the necessary response to resolve the collision, including
+		* moving the objects back to prevent overlap and applying any velocity changes.
+		*
+		* \param data1 The collision data for the first collider.
+		* \param data2 The collision data for the second collider.
+		*/
+	void collision_handler(CollidedInfoStor& data1,CollidedInfoStor& data2);
+	
+	/**
+		* \brief Resolves the movement of two box colliders that are colliding.
+		* 
+		* This function calculates the smallest overlap (along the X or Y axis) and determines
+		* the move-back vector to prevent overlap.
+		*
+		* \param box_collider1 The first box collider.
+		* \param box_collider2 The second box collider.
+		* \param final_position1 The final position of the first box collider.
+		* \param final_position2 The final position of the second box collider.
+		* \return The move-back vector to resolve the collision.
+		*/
+	Vector2 box_box_collision_move_back(const BoxCollider& box_collider1,const BoxCollider& box_collider2,Vector2 position1,Vector2 position2);
+
+	/**
+		* \brief Determines the appropriate collision handler based on the rigidbody types of the colliding objects.
+		* 
+		* This function checks if the second object is static, and if so, it calls the static collision handler.
+		* Otherwise, it triggers a collision event.
+		*
+		* \param info The collision information containing the colliders, transforms, rigidbodies, and move-back data.
+		*/
+	void determine_collision_handler(CollisionInfo& info);
+
+	/**
+		* \brief Handles the collision with a static object.
+		* 
+		* This function resolves the collision by moving the object back and applying any bounce or stop behavior.
+		*
+		* \param info The collision information containing the colliders, transforms, rigidbodies, and move-back data.
+		*/
 	void static_collision_handler(CollisionInfo& info);
 private: //detection
 	
+	/**
+		* \brief Checks for collisions between box colliders and circle colliders
+		* and returns the collision pairs that need to be resolved.
+		* 
+		* \param boxcolliders A vector of references to all box colliders.
+		* \param circlecolliders A vector of references to all circle colliders.
+		* \return A vector of pairs containing collision information for the detected collisions.
+		*/
 	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders);
+	
+	/**
+		* \brief Checks for a collision between two box colliders.
+		* 
+		* This function checks if two box colliders overlap based on their positions and dimensions.
+		*
+		* \param box1 The first box collider.
+		* \param box2 The second box collider.
+		* \param transform1 The transform component of the first box collider.
+		* \param transform2 The transform component of the second box collider.
+		* \param rigidbody1 The rigidbody component of the first box collider.
+		* \param rigidbody2 The rigidbody component of the second box collider.
+		* \return True if the two box colliders overlap, otherwise false.
+		*/
 	bool check_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
+	
+	/**
+		* \brief Checks for a collision between a box collider and a circle collider.
+		* 
+		* This function checks if a box collider overlaps with a circle collider based on their positions
+		* and dimensions.
+		*
+		* \param box1 The box collider.
+		* \param circle2 The circle collider.
+		* \param transform1 The transform component of the box collider.
+		* \param transform2 The transform component of the circle collider.
+		* \param rigidbody1 The rigidbody component of the box collider.
+		* \param rigidbody2 The rigidbody component of the circle collider.
+		* \return True if the box collider and circle collider overlap, otherwise false.
+		*/
 	bool check_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
+	
+	/**
+		* \brief Checks for a collision between two circle colliders.
+		* 
+		* This function checks if two circle colliders overlap based on their positions and radii.
+		*
+		* \param circle1 The first circle collider.
+		* \param circle2 The second circle collider.
+		* \param transform1 The transform component of the first circle collider.
+		* \param transform2 The transform component of the second circle collider.
+		* \param rigidbody1 The rigidbody component of the first circle collider.
+		* \param rigidbody2 The rigidbody component of the second circle collider.
+		* \return True if the two circle colliders overlap, otherwise false.
+		*/
 	bool check_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
+	
+	/**
+		* \brief Gets the current position of a collider by combining its transform and rigidbody data.
+		* 
+		* This function calculates the current position of the collider by considering its transform and 
+		* rigidbody velocity.
+		*
+		* \param collider The collider whose position is being determined.
+		* \param transform The transform component associated with the collider.
+		* \param rigidbody The rigidbody component associated with the collider.
+		* \return The current position of the collider as a Vector2.
+		*/
 	Vector2 current_position(const Collider& collider, const Transform& transform, const Rigidbody& rigidbody);
-
-
 };
 
 } // namespace crepe
diff --git a/src/example/collision.cpp b/src/example/collision.cpp
index 2c476ca..f51380e 100644
--- a/src/example/collision.cpp
+++ b/src/example/collision.cpp
@@ -78,7 +78,7 @@ int main(int argc, char * argv[]) {
 		.constraints = {0, 0, 0},
 		.use_gravity = true,
 		.bounce = true,
-		.bouncie_factor = 1,
+		.elastisity = 1,
 		.offset = {0,0},
 	});
 	game_object1.add_component<BoxCollider>(Vector2{0, 0}, 20, 20);
-- 
cgit v1.2.3


From 3b615d87f421b576227ef6d0f7e3c5d66c545da2 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Tue, 19 Nov 2024 20:42:02 +0100
Subject: doxygen comment colliders

---
 src/crepe/api/BoxCollider.h    | 9 +++++++++
 src/crepe/api/CircleCollider.h | 8 ++++++++
 2 files changed, 17 insertions(+)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/BoxCollider.h b/src/crepe/api/BoxCollider.h
index 357c979..7f51cba 100644
--- a/src/crepe/api/BoxCollider.h
+++ b/src/crepe/api/BoxCollider.h
@@ -5,10 +5,19 @@
 
 namespace crepe {
 
+/**
+ * \brief A class representing a box-shaped collider.
+ * 
+ * This class is used for collision detection with other colliders (e.g., CircleCollider).
+ */
 class BoxCollider : public Collider {
 public:
 	BoxCollider(game_object_id_t game_object_id,Vector2 offset, double width, double height);
+
+	//! Width of box collider 
 	double width;
+
+	//! Height of box collider
 	double height;
 };
 
diff --git a/src/crepe/api/CircleCollider.h b/src/crepe/api/CircleCollider.h
index 29a9c1e..4e04fa4 100644
--- a/src/crepe/api/CircleCollider.h
+++ b/src/crepe/api/CircleCollider.h
@@ -6,9 +6,17 @@
 
 namespace crepe {
 
+/**
+ * \brief A class representing a circle-shaped collider.
+ * 
+ * This class is used for collision detection with other colliders (e.g., BoxCollider).
+ */
 class CircleCollider : public Collider {
 public:
+
 	CircleCollider(game_object_id_t game_object_id,Vector2 offset, int radius);
+
+	//! Radius of the circle collider.
 	double radius;
 };
 
-- 
cgit v1.2.3


From 38a2476bcfa41b6d83a9a72d35f5acb684dc87fd Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Tue, 19 Nov 2024 20:43:53 +0100
Subject: added doxygen comments

---
 src/crepe/Collider.h      | 5 ++++-
 src/crepe/api/Rigidbody.h | 2 +-
 2 files changed, 5 insertions(+), 2 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/Collider.h b/src/crepe/Collider.h
index 54695b1..e910ae4 100644
--- a/src/crepe/Collider.h
+++ b/src/crepe/Collider.h
@@ -1,13 +1,16 @@
 #pragma once
 
-#include "Component.h"
 #include "api/Vector2.h"
 
+#include "Component.h"
+
 namespace crepe {
 
 class Collider : public Component {
 public:
 	Collider(game_object_id_t id, Vector2 offset);
+
+	//! Offset of the collider relative to rigidbody position 
 	Vector2 offset;
 };
 
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index 782de22..a007107 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -78,7 +78,7 @@ public:
 		bool bounce = false;
 		//! bounce factor of material
 		double elastisity = 0.0;
-		//! offset of all colliders
+		//! offset of all colliders relative to transform position
 		Vector2 offset;
 	};
 
-- 
cgit v1.2.3


From 690471c7c4536c074a4dca5aab7cc618d47bfb5f Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Wed, 20 Nov 2024 10:43:32 +0100
Subject: merge with maser

---
 src/crepe/api/LoopManager.cpp        |   6 +-
 src/crepe/api/LoopManager.h          |   5 +-
 src/crepe/api/Script.h               |   9 ++-
 src/crepe/system/CollisionSystem.cpp |   6 +-
 src/crepe/system/CollisionSystem.h   |   2 -
 src/example/CMakeLists.txt           |   2 +-
 src/example/collision.cpp            | 123 -----------------------------------
 src/example/game.cpp                 |  89 +++++++++++++++++++++++++
 src/example/particles.cpp            |  43 ------------
 src/example/physics.cpp              |  24 -------
 src/example/rendering.cpp            |   4 +-
 src/test/CMakeLists.txt              |   2 -
 src/test/CollisionTest.cpp           | 121 ++++++++++++++++------------------
 13 files changed, 165 insertions(+), 271 deletions(-)
 delete mode 100644 src/example/collision.cpp
 create mode 100644 src/example/game.cpp
 delete mode 100644 src/example/particles.cpp
 delete mode 100644 src/example/physics.cpp

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index a4bc101..586919d 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -35,10 +35,8 @@ void LoopManager::start() {
 void LoopManager::set_running(bool running) { this->game_running = running; }
 
 void LoopManager::fixed_update() {
-	PhysicsSystem phys;
-	phys.update();
-	CollisionSystem col;
-	col.update();
+	this->get_system<PhysicsSystem>().update();
+	this->get_system<CollisionSystem>().update();
 }
 
 void LoopManager::loop() {
diff --git a/src/crepe/api/LoopManager.h b/src/crepe/api/LoopManager.h
index f6904be..37f13ac 100644
--- a/src/crepe/api/LoopManager.h
+++ b/src/crepe/api/LoopManager.h
@@ -4,6 +4,7 @@
 
 #include "../ComponentManager.h"
 #include "../system/System.h"
+#include "api/SceneManager.h"
 
 namespace crepe {
 
@@ -71,7 +72,9 @@ private:
 private:
 	//! Component manager instance
 	ComponentManager component_manager{};
-
+public:
+	//! Scene manager instance
+	SceneManager scene_manager{component_manager};
 private:
 	/**
 	 * \brief Collection of System instances
diff --git a/src/crepe/api/Script.h b/src/crepe/api/Script.h
index 2b70379..939d142 100644
--- a/src/crepe/api/Script.h
+++ b/src/crepe/api/Script.h
@@ -63,7 +63,14 @@ protected:
 	 */
 	template <typename T>
 	std::vector<std::reference_wrapper<T>> get_components() const;
-
+	
+	/**
+	 * \brief Gets game object id this script is attached to
+	 *
+	 * \returns game object id
+	 */
+	game_object_id_t get_game_object_id() const {return this->game_object_id;};
+	
 protected:
 	// NOTE: Script must have a constructor without arguments so the game programmer doesn't need
 	// to manually add `using Script::Script` to their concrete script class.
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index df0ee41..3e73b44 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -18,11 +18,9 @@
 
 using namespace crepe;
 
-CollisionSystem::CollisionSystem() {}
-
 void CollisionSystem::update() {
 	// Get collider components and keep them seperate
-	ComponentManager & mgr = ComponentManager::get_instance();
+	ComponentManager & mgr = this->component_manager;
 	std::vector<std::reference_wrapper<BoxCollider>> boxcolliders	= mgr.get_components_by_type<BoxCollider>();
 	std::vector<std::reference_wrapper<CircleCollider>> circlecolliders	= mgr.get_components_by_type<CircleCollider>();
 	
@@ -185,7 +183,7 @@ void CollisionSystem::static_collision_handler(CollisionInfo& info){
 }
 
 std::vector<std::pair<CollisionSystem::CollidedInfoStor,CollisionSystem::CollidedInfoStor>> CollisionSystem::check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders) {
-	ComponentManager & mgr = ComponentManager::get_instance();
+	ComponentManager & mgr = this->component_manager;
 	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> collisions_ret;
 
 	// TODO:
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 0518b34..d94f6bc 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -70,8 +70,6 @@ public:
 
 public:
 
-	CollisionSystem();
-
 	//! Updates the collision system by checking for collisions between colliders and handling them.
 	void update() override;
 
diff --git a/src/example/CMakeLists.txt b/src/example/CMakeLists.txt
index d2ea926..2facc4d 100644
--- a/src/example/CMakeLists.txt
+++ b/src/example/CMakeLists.txt
@@ -28,7 +28,7 @@ add_example(proxy)
 add_example(db)
 add_example(ecs)
 add_example(scene_manager)
-add_example(collision)
+add_example(game)
 add_example(events)
 add_example(particles)
 add_example(gameloop)
diff --git a/src/example/collision.cpp b/src/example/collision.cpp
deleted file mode 100644
index f51380e..0000000
--- a/src/example/collision.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-#include "api/BoxCollider.h"
-#include "system/CollisionSystem.h"
-#include <crepe/system/ScriptSystem.h>
-#include <crepe/Component.h>
-#include <crepe/ComponentManager.h>
-#include <crepe/api/GameObject.h>
-#include <crepe/api/Rigidbody.h>
-#include <crepe/api/BoxCollider.h>
-#include <crepe/api/Transform.h>
-#include <crepe/system/PhysicsSystem.h>
-#include <crepe/system/RenderSystem.h>
-#include <crepe/util/log.h>
-
-#include <crepe/api/Script.h>
-#include <crepe/api/AssetManager.h>
-#include <crepe/api/Color.h>
-#include <crepe/api/Sprite.h>
-#include <crepe/api/Texture.h>
-#include <crepe/api/Transform.h>
-#include <crepe/api/Vector2.h>
-#include <crepe/api/Event.h>
-#include <crepe/api/EventManager.h>
-#include <crepe/api/LoopManager.h>
-
-#include <chrono>
-#include <memory>
-
-using namespace crepe;
-using namespace std;
-
-class MyScript : public Script {
-	static bool oncollision(const CollisionEvent& test) {
-		std::cout << "test collision: " << test.info.first.collider.game_object_id << std::endl;
-		return true;
-	}
-	void init() {
-		EventManager::get_instance().subscribe<CollisionEvent>(oncollision, this->parent->game_object_id);
-	}
-	void update() {
-		// Retrieve component from the same GameObject this script is on
-		
-	}
-	
-	
-};
-
-int main(int argc, char * argv[]) {
-	//setup
-	LoopManager gameloop;
-	Color color(0, 0, 0, 0);
-
-	double screen_size_width = 640;
-	double screen_size_height = 480;
-	double world_collider = 1000;
-	//define playable world 
-	GameObject World(0, "Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
-	World.add_component<Rigidbody>(Rigidbody::Data{
-		.mass = 0,
-		.gravity_scale = 0,
-		.body_type = Rigidbody::BodyType::STATIC,
-		.constraints = {0, 0, 0},
-		.use_gravity = false,
-		.bounce = false,
-		.offset = {0,0}
-	});
-	World.add_component<BoxCollider>(Vector2{0, 0-(screen_size_height/2+world_collider/2)}, world_collider, world_collider);;	// Top
-	World.add_component<BoxCollider>(Vector2{0, screen_size_height/2+world_collider/2}, world_collider, world_collider); // Bottom
-	World.add_component<BoxCollider>(Vector2{0-(screen_size_width/2+world_collider/2), 0}, world_collider, world_collider); // Left
-	World.add_component<BoxCollider>(Vector2{screen_size_width/2+world_collider/2, 0}, world_collider, world_collider); // right
-
-
-	GameObject game_object1(1, "Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
-	game_object1.add_component<Rigidbody>(Rigidbody::Data{
-		.mass = 1,
-		.gravity_scale = 0.01,
-		.body_type = Rigidbody::BodyType::DYNAMIC,
-		.linear_velocity = {1,0},
-		.constraints = {0, 0, 0},
-		.use_gravity = true,
-		.bounce = true,
-		.elastisity = 1,
-		.offset = {0,0},
-	});
-	game_object1.add_component<BoxCollider>(Vector2{0, 0}, 20, 20);
-	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
-	game_object1.add_component<Sprite>(
-	make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
-	FlipSettings{true, true});
-	game_object1.add_component<Camera>(Color::get_white());
-	
-
-	// GameObject game_object2(2, "Name", "Tag", Vector2{20, 470}, 0, 1);
-	// game_object2.add_component<Rigidbody>(Rigidbody::Data{
-	// 	.mass = 1,
-	// 	.gravity_scale = 1,
-	// 	.body_type = Rigidbody::BodyType::DYNAMIC,
-	// 	.linear_velocity = {0,0},
-	// 	.constraints = {0, 0, 0},
-	// 	.use_gravity = false,
-	// 	.bounce = false,
-	// 	.offset = {0,0},
-	// });
-	// game_object2.add_component<BoxCollider>(Vector2{0, 0}, 0, 0);
-	// game_object2.add_component<BehaviorScript>().set_script<MyScript>();
-	// game_object2.add_component<Sprite>(
-	// make_shared<Texture>("/home/jaro/crepe/asset/texture/red_square.png"), color,
-	// FlipSettings{true, true});
-	
-	
-	crepe::ScriptSystem sys;
-	// Update all scripts. This should result in MyScript::update being called
-	sys.update();
-	
-	gameloop.start();
-	// auto & render = crepe::RenderSystem::get_instance();
-	// auto start = std::chrono::steady_clock::now();
-	// while (std::chrono::steady_clock::now() - start < std::chrono::seconds(5)) {
-	//	 render.update();
-	// }
-
-
-	return 0;
-}
diff --git a/src/example/game.cpp b/src/example/game.cpp
new file mode 100644
index 0000000..a9f6103
--- /dev/null
+++ b/src/example/game.cpp
@@ -0,0 +1,89 @@
+#include <crepe/api/GameObject.h>
+#include <crepe/api/Transform.h>
+#include <crepe/api/Rigidbody.h>
+#include <crepe/api/BoxCollider.h>
+#include <crepe/api/Camera.h>
+#include <crepe/api/Script.h>
+#include <crepe/api/Color.h>
+#include <crepe/api/Sprite.h>
+#include <crepe/api/Texture.h>
+#include <crepe/api/Vector2.h>
+#include <crepe/api/Event.h>
+#include <crepe/api/EventManager.h>
+#include <crepe/api/LoopManager.h>
+
+using namespace crepe;
+
+using namespace std;
+
+class MyScript : public Script {
+	static bool oncollision(const CollisionEvent& test) {
+		std::cout << "test collision: " << test.info.first.collider.game_object_id << std::endl;
+		return true;
+	}
+	void init() {
+		EventManager::get_instance().subscribe<CollisionEvent>(oncollision, this->get_game_object_id());
+	}
+	void update() {
+		// Retrieve component from the same GameObject this script is on
+		
+	}
+};
+
+class ConcreteScene1 : public Scene {
+public:
+	using Scene::Scene;
+
+	void load_scene() {
+		ComponentManager & mgr = this->component_manager;
+		Color color(0, 0, 0, 0);
+
+	double screen_size_width = 640;
+	double screen_size_height = 480;
+	double world_collider = 1000;
+	//define playable world 
+	GameObject world = mgr.new_object("Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
+	world.add_component<Rigidbody>(Rigidbody::Data{
+		.mass = 0,
+		.gravity_scale = 0,
+		.body_type = Rigidbody::BodyType::STATIC,
+		.constraints = {0, 0, 0},
+		.use_gravity = false,
+		.bounce = false,
+		.offset = {0,0}
+	});
+	world.add_component<BoxCollider>(Vector2{0, 0-(screen_size_height/2+world_collider/2)}, world_collider, world_collider);;	// Top
+	world.add_component<BoxCollider>(Vector2{0, screen_size_height/2+world_collider/2}, world_collider, world_collider); // Bottom
+	world.add_component<BoxCollider>(Vector2{0-(screen_size_width/2+world_collider/2), 0}, world_collider, world_collider); // Left
+	world.add_component<BoxCollider>(Vector2{screen_size_width/2+world_collider/2, 0}, world_collider, world_collider); // right
+
+
+	GameObject game_object1 = mgr.new_object("Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
+	game_object1.add_component<Rigidbody>(Rigidbody::Data{
+		.mass = 1,
+		.gravity_scale = 0.01,
+		.body_type = Rigidbody::BodyType::DYNAMIC,
+		.linear_velocity = {1,0},
+		.constraints = {0, 0, 0},
+		.use_gravity = true,
+		.bounce = true,
+		.elastisity = 1,
+		.offset = {0,0},
+	});
+	game_object1.add_component<BoxCollider>(Vector2{0, 0}, 20, 20);
+	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
+	game_object1.add_component<Sprite>(
+	make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
+	FlipSettings{true, true});
+	game_object1.add_component<Camera>(Color::get_white());
+	}
+};
+
+int main(int argc, char * argv[]) {
+
+	LoopManager gameloop;
+	gameloop.scene_manager.add_scene<ConcreteScene1>("scene1");
+	gameloop.scene_manager.load_next_scene();
+	gameloop.start();
+	return 0;
+}
diff --git a/src/example/particles.cpp b/src/example/particles.cpp
deleted file mode 100644
index 3d5f676..0000000
--- a/src/example/particles.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include <crepe/ComponentManager.h>
-#include <crepe/api/AssetManager.h>
-
-#include <crepe/Component.h>
-#include <crepe/api/Color.h>
-#include <crepe/api/GameObject.h>
-#include <crepe/api/ParticleEmitter.h>
-#include <crepe/api/Rigidbody.h>
-#include <crepe/api/Sprite.h>
-#include <crepe/api/Texture.h>
-#include <crepe/api/Transform.h>
-
-using namespace crepe;
-using namespace std;
-
-int main(int argc, char * argv[]) {
-	ComponentManager mgr{};
-	GameObject game_object = mgr.new_object("", "", Vector2{0, 0}, 0, 0);
-	Color color(0, 0, 0, 0);
-	Sprite test_sprite = game_object.add_component<Sprite>(
-		make_shared<Texture>("../asset/texture/img.png"), color, FlipSettings{true, true});
-	game_object.add_component<ParticleEmitter>(ParticleEmitter::Data{
-		.position = {0, 0},
-		.max_particles = 100,
-		.emission_rate = 0,
-		.min_speed = 0,
-		.max_speed = 0,
-		.min_angle = 0,
-		.max_angle = 0,
-		.begin_lifespan = 0,
-		.end_lifespan = 0,
-		.force_over_time = Vector2{0, 0},
-		.boundary{
-			.width = 0,
-			.height = 0,
-			.offset = Vector2{0, 0},
-			.reset_on_exit = false,
-		},
-		.sprite = test_sprite,
-	});
-
-	return 0;
-}
diff --git a/src/example/physics.cpp b/src/example/physics.cpp
deleted file mode 100644
index ad663a0..0000000
--- a/src/example/physics.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include <crepe/Component.h>
-#include <crepe/ComponentManager.h>
-#include <crepe/api/GameObject.h>
-#include <crepe/api/Rigidbody.h>
-#include <crepe/api/Transform.h>
-#include <crepe/system/PhysicsSystem.h>
-
-using namespace crepe;
-using namespace std;
-
-int main(int argc, char * argv[]) {
-	ComponentManager mgr{};
-
-	GameObject game_object = mgr.new_object("Name", "Tag", Vector2{0, 0}, 0, 0);
-	game_object.add_component<Rigidbody>(Rigidbody::Data{
-		.mass = 1,
-		.gravity_scale = 1,
-		.body_type = Rigidbody::BodyType::DYNAMIC,
-		.constraints = {0, 0, 0},
-		.use_gravity = true,
-		.bounce = false,
-	});
-	return 0;
-}
diff --git a/src/example/rendering.cpp b/src/example/rendering.cpp
index c9e62f1..14ecaa9 100644
--- a/src/example/rendering.cpp
+++ b/src/example/rendering.cpp
@@ -30,13 +30,13 @@ int main() {
 	// Normal adding components
 	{
 		Color color(0, 0, 0, 0);
-		obj.add_component<Sprite>(make_shared<Texture>("../asset/texture/img.png"), color,
+		obj.add_component<Sprite>(make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
 								  FlipSettings{false, false});
 		obj.add_component<Camera>(Color::get_red());
 	}
 	{
 		Color color(0, 0, 0, 0);
-		obj1.add_component<Sprite>(make_shared<Texture>("../asset/texture/second.png"), color,
+		obj1.add_component<Sprite>(make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
 								   FlipSettings{true, true});
 	}
 
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index a41d097..f830165 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -1,6 +1,4 @@
 target_sources(test_main PUBLIC
-	dummy.cpp
-	# audio.cpp
 	CollisionTest.cpp
 	main.cpp
 	PhysicsTest.cpp
diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp
index 3e43479..83564e1 100644
--- a/src/test/CollisionTest.cpp
+++ b/src/test/CollisionTest.cpp
@@ -1,83 +1,76 @@
-#include "api/BoxCollider.h"
-#include "api/CircleCollider.h"
-#include "api/Vector2.h"
 #include <crepe/ComponentManager.h>
 #include <crepe/api/Config.h>
 #include <crepe/api/GameObject.h>
 #include <crepe/api/Rigidbody.h>
 #include <crepe/api/Transform.h>
-#include <crepe/system/CollisionSystem.h>
+#include <crepe/system/PhysicsSystem.h>
 #include <gtest/gtest.h>
 
 using namespace std;
 using namespace std::chrono_literals;
 using namespace crepe;
 
-class CollisionTest : public ::testing::Test {
-protected:
-	GameObject * game_object1;
-	GameObject * game_object2;
-	CollisionSystem collision_system;
-	void SetUp() override {
-		ComponentManager & mgr = ComponentManager::get_instance();
-		mgr.delete_all_components();
-		std::vector<std::reference_wrapper<Transform>> transforms
-			= mgr.get_components_by_id<Transform>(0);
-
-		// ob 1
-		game_object1 = new GameObject(0, "", "", Vector2{0, 0}, 0, 0);
-		game_object1->add_component<Rigidbody>(Rigidbody::Data{
-			.mass = 1,
-			.gravity_scale = 1,
-			.body_type = Rigidbody::BodyType::DYNAMIC,
-			.max_linear_velocity = Vector2{10, 10},
-			.max_angular_velocity = 10,
-			.constraints = {0, 0, 0},
-			.use_gravity = false,
-			.bounce = false,
-		});
-		
-		game_object1->add_component<BoxCollider>(Vector2{0,0},10,10);
+class MyScript : public Script {
+	static bool oncollision(const CollisionEvent& test) {
+		std::cout << "test collision: " << test.info.first.collider.game_object_id << std::endl;
+		return true;
+	}
+	void init() {
+		EventManager::get_instance().subscribe<CollisionEvent>(oncollision, this->get_game_object_id());
+	}
+	void update() {
+		// Retrieve component from the same GameObject this script is on
 		
+	}
+};
+
+class PhysicsTest : public ::testing::Test {
+public:
+	ComponentManager component_manager;
+	PhysicsSystem system{component_manager};
 
-		//ob 2
-		game_object2 = new GameObject(1, "", "", Vector2{50, 50}, 0, 0);
-		game_object2->add_component<Rigidbody>(Rigidbody::Data{
-			.mass = 1,
-			.gravity_scale = 1,
-			.body_type = Rigidbody::BodyType::DYNAMIC,
-			.max_linear_velocity = Vector2{10, 10},
-			.max_angular_velocity = 10,
-			.constraints = {0, 0, 0},
-			.use_gravity = false,
-			.bounce = false,
-		});
-		game_object2->add_component<CircleCollider>(Vector2{0,0},5);
+	void SetUp() override {
+		ComponentManager & mgr = this->component_manager;
+		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);
+			entity.add_component<Rigidbody>(Rigidbody::Data{
+				.mass = 1,
+				.gravity_scale = 1,
+				.body_type = Rigidbody::BodyType::DYNAMIC,
+				.max_linear_velocity = Vector2{10, 10},
+				.max_angular_velocity = 10,
+				.constraints = {0, 0},
+				.use_gravity = true,
+				.bounce = false,
+			});
+		}
+		transforms = mgr.get_components_by_id<Transform>(0);
+		Transform & transform = transforms.front().get();
+		transform.position.x = 0.0;
+		transform.position.y = 0.0;
+		transform.rotation = 0.0;
+		vector<reference_wrapper<Rigidbody>> rigidbodies
+			= mgr.get_components_by_id<Rigidbody>(0);
+		Rigidbody & rigidbody = rigidbodies.front().get();
+		rigidbody.data.angular_velocity = 0;
+		rigidbody.data.linear_velocity.x = 0;
+		rigidbody.data.linear_velocity.y = 0;
 	}
 };
 
-TEST_F(CollisionTest, box_box_collision) {
+TEST_F(PhysicsTest, gravity) {
 	Config::get_instance().physics.gravity = 1;
-	ComponentManager & mgr = ComponentManager::get_instance();
-	std::vector<std::reference_wrapper<Transform>> transforms
-		= mgr.get_components_by_id<Transform>(0);
-	Transform & transform = transforms.front().get();
+	ComponentManager & mgr = this->component_manager;
+	vector<reference_wrapper<Transform>> transforms = mgr.get_components_by_id<Transform>(0);
+	const Transform & transform = transforms.front().get();
 	ASSERT_FALSE(transforms.empty());
-	transform.position = {39,50};
-	collision_system.update();
-	transform.position = {40,50};
-	collision_system.update();
-	transform.position = {50,39};
-	collision_system.update();
-	transform.position = {50,40};
-	collision_system.update();
-	transform.position = {50,60};
-	collision_system.update();
-	transform.position = {50,61};
-	collision_system.update();
-	transform.position = {60,50};
-	collision_system.update();
-	transform.position = {61,50};
-	collision_system.update();
-}
+	EXPECT_EQ(transform.position.y, 0);
+
+	system.update();
+	EXPECT_EQ(transform.position.y, 1);
 
+	system.update();
+	EXPECT_EQ(transform.position.y, 3);
+}
-- 
cgit v1.2.3


From a67c52325bc8cbd264293b9dcc217fc07bfbaf57 Mon Sep 17 00:00:00 2001
From: Loek Le Blansch <loek@pipeframe.xyz>
Date: Wed, 20 Nov 2024 18:07:48 +0100
Subject: merge `master` into `loek/collision-system`

---
 Doxyfile                            |   1 +
 contributing.md                     |  23 +++-
 makefile                            |   3 +-
 src/crepe/api/Color.cpp             |  37 ++----
 src/crepe/api/Color.h               |  49 +++-----
 src/crepe/api/Sprite.h              |   3 +-
 src/crepe/facade/SDLContext.h       |   6 -
 src/crepe/system/RenderSystem.cpp   |  43 +++++--
 src/crepe/system/RenderSystem.h     |  32 +++--
 src/example/CMakeLists.txt          |   3 -
 src/example/components_internal.cpp |  51 --------
 src/example/ecs.cpp                 |  53 --------
 src/example/events.cpp              |  30 ++---
 src/example/game.cpp                |   2 +-
 src/example/rendering.cpp           |  10 +-
 src/example/scene_manager.cpp       |  79 ------------
 src/makefile                        |   7 +-
 src/test/CMakeLists.txt             |   2 +
 src/test/ECSTest.cpp                | 236 ++++++++++++++++++++++++++++++++++++
 src/test/RenderSystemTest.cpp       | 174 ++++++++++++++++++++++++++
 src/test/SceneManagerTest.cpp       | 122 +++++++++++++++++++
 21 files changed, 667 insertions(+), 299 deletions(-)
 delete mode 100644 src/example/components_internal.cpp
 delete mode 100644 src/example/ecs.cpp
 delete mode 100644 src/example/scene_manager.cpp
 create mode 100644 src/test/ECSTest.cpp
 create mode 100644 src/test/RenderSystemTest.cpp
 create mode 100644 src/test/SceneManagerTest.cpp

(limited to 'src/crepe/api')

diff --git a/Doxyfile b/Doxyfile
index 9328b24..e0a31df 100644
--- a/Doxyfile
+++ b/Doxyfile
@@ -24,6 +24,7 @@ USE_MDFILE_AS_MAINPAGE = ./readme.md
 REPEAT_BRIEF = NO
 
 INTERNAL_DOCS = YES
+EXTRACT_PRIVATE = YES
 EXTRACT_STATIC = YES
 HIDE_UNDOC_NAMESPACES = YES
 HIDE_UNDOC_CLASSES = YES
diff --git a/contributing.md b/contributing.md
index 5b0c79d..9c95851 100644
--- a/contributing.md
+++ b/contributing.md
@@ -20,7 +20,7 @@ that you can click on to open them.
 # Code style
 
 - Formatting nitty-gritty is handled by clang-format/clang-tidy (run `make
-  format` in the root folder of this repository to format all sources files)
+  format` or `make lint`)
 - <details><summary>
   ASCII only
   </summary><table><tr><th>Good</th><th>Bad</th></tr><tr><td>
@@ -798,6 +798,27 @@ that you can click on to open them.
   resolving merge conflicts when multiple sources were added by different
   people to the same CMakeLists.txt easier.
 
+## GoogleTest-specific
+
+- Unit tests are not *required* to follow all code standards
+- <details><summary>
+  Private/protected members may be accessed using preprocessor tricks
+  </summary>
+
+  ```cpp
+  // include unrelated headers before
+
+  #define private public
+  #define protected public
+
+  // headers included after *will* be affected
+  ```
+  </details>
+- Each test source file defines tests within a single test suite (first
+  parameter of `TEST()` / `TEST_F()` macro)
+- Test source files match their suite name (or test fixture name in the case of
+  tests that use a fixture)
+
 # Structure
 
 - Files are placed in the appropriate directory:
diff --git a/makefile b/makefile
index dd7c587..c46e8a5 100644
--- a/makefile
+++ b/makefile
@@ -6,5 +6,6 @@ doxygen: Doxyfile FORCE
 FMT += $(shell git ls-files '*.c' '*.cpp' '*.h' '*.hpp')
 format: FORCE
 	clang-format -i $(FMT)
-	$(MAKE) -C src $@
 
+lint: FORCE
+	$(MAKE) -C src $@
diff --git a/src/crepe/api/Color.cpp b/src/crepe/api/Color.cpp
index 9e5f187..29bd77a 100644
--- a/src/crepe/api/Color.cpp
+++ b/src/crepe/api/Color.cpp
@@ -2,32 +2,11 @@
 
 using namespace crepe;
 
-Color Color::white = Color(255, 255, 255, 0);
-Color Color::red = Color(255, 0, 0, 0);
-Color Color::green = Color(0, 255, 0, 0);
-Color Color::blue = Color(0, 0, 255, 0);
-Color Color::black = Color(0, 0, 0, 0);
-Color Color::cyan = Color(0, 255, 255, 0);
-Color Color::yellow = Color(255, 255, 0, 0);
-Color Color::magenta = Color(255, 0, 255, 0);
-
-Color::Color(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) {
-	this->a = alpha;
-	this->r = red;
-	this->g = green;
-	this->b = blue;
-};
-
-const Color & Color::get_white() { return Color::white; };
-
-const Color & Color::get_red() { return Color::red; };
-const Color & Color::get_green() { return Color::green; };
-const Color & Color::get_blue() { return Color::blue; };
-
-const Color & Color::get_black() { return Color::black; };
-
-const Color & Color::get_cyan() { return Color::cyan; };
-
-const Color & Color::get_yellow() { return Color::yellow; };
-
-const Color & Color::get_magenta() { return Color::magenta; };
+const Color Color::WHITE{0xff, 0xff, 0xff};
+const Color Color::RED{0xff, 0x00, 0x00};
+const Color Color::GREEN{0x00, 0xff, 0x00};
+const Color Color::BLUE{0x00, 0x00, 0xff};
+const Color Color::BLACK{0x00, 0x00, 0x00};
+const Color Color::CYAN{0x00, 0xff, 0xff};
+const Color Color::YELLOW{0xff, 0xff, 0x00};
+const Color Color::MAGENTA{0xff, 0x00, 0xff};
diff --git a/src/crepe/api/Color.h b/src/crepe/api/Color.h
index aa47bf4..84edb5c 100644
--- a/src/crepe/api/Color.h
+++ b/src/crepe/api/Color.h
@@ -4,41 +4,20 @@
 
 namespace crepe {
 
-// TODO: make Color a struct w/o constructors/destructors
-class Color {
-
-	// FIXME: can't these colors be defined as a `static constexpr const Color`
-	// instead?
-
-public:
-	Color(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha);
-	static const Color & get_white();
-	static const Color & get_red();
-	static const Color & get_green();
-	static const Color & get_blue();
-	static const Color & get_cyan();
-	static const Color & get_magenta();
-	static const Color & get_yellow();
-	static const Color & get_black();
-
-private:
-	// TODO: why are these private!?
-	uint8_t r;
-	uint8_t g;
-	uint8_t b;
-	uint8_t a;
-
-	static Color white;
-	static Color red;
-	static Color green;
-	static Color blue;
-	static Color cyan;
-	static Color magenta;
-	static Color yellow;
-	static Color black;
-
-private:
-	friend class SDLContext;
+struct Color {
+	uint8_t r = 0x00;
+	uint8_t g = 0x00;
+	uint8_t b = 0x00;
+	uint8_t a = 0xff;
+
+	static const Color WHITE;
+	static const Color RED;
+	static const Color GREEN;
+	static const Color BLUE;
+	static const Color CYAN;
+	static const Color MAGENTA;
+	static const Color YELLOW;
+	static const Color BLACK;
 };
 
 } // namespace crepe
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index 0192793..74a55d4 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -2,8 +2,9 @@
 
 #include <memory>
 
+#include "../Component.h"
+
 #include "Color.h"
-#include "Component.h"
 #include "Texture.h"
 
 namespace crepe {
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index 007092b..652a83e 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -21,9 +21,6 @@ namespace crepe {
 // typedef is unusable when crepe is packaged. Wouter will fix this later.
 typedef SDL_Keycode CREPE_KEYCODES;
 
-class Texture;
-class LoopManager;
-
 /**
  * \class SDLContext
  * \brief Facade for the SDL library
@@ -91,9 +88,6 @@ private:
 	//! Will use the funtions: texture_from_path, get_width,get_height.
 	friend class Texture;
 
-	//! Will use the funtions: texture_from_path, get_width,get_height.
-	friend class Animator;
-
 	/**
 	 * \brief Loads a texture from a file path.
 	 * \param path Path to the image file.
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index fa3d0de..96c5f27 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -1,38 +1,59 @@
+#include <algorithm>
+#include <cassert>
 #include <functional>
+#include <stdexcept>
 #include <vector>
 
 #include "../ComponentManager.h"
 #include "../api/Sprite.h"
 #include "../api/Transform.h"
 #include "../facade/SDLContext.h"
-#include "../util/Log.h"
 
 #include "RenderSystem.h"
 
 using namespace crepe;
+using namespace std;
 
-void RenderSystem::clear_screen() const { SDLContext::get_instance().clear_screen(); }
+void RenderSystem::clear_screen() { this->context.clear_screen(); }
 
-void RenderSystem::present_screen() const { SDLContext::get_instance().present_screen(); }
+void RenderSystem::present_screen() { this->context.present_screen(); }
 void RenderSystem::update_camera() {
 	ComponentManager & mgr = this->component_manager;
 
 	std::vector<std::reference_wrapper<Camera>> cameras = mgr.get_components_by_type<Camera>();
 
+	if (cameras.size() == 0) throw std::runtime_error("No cameras in current scene");
+
 	for (Camera & cam : cameras) {
-		SDLContext::get_instance().camera(cam);
-		this->curr_cam = &cam;
+		this->context.camera(cam);
+		this->curr_cam_ref = &cam;
 	}
 }
-void RenderSystem::render_sprites() const {
-	ComponentManager & mgr = this->component_manager;
 
-	std::vector<std::reference_wrapper<Sprite>> sprites = mgr.get_components_by_type<Sprite>();
+bool sorting_comparison(const Sprite & a, const Sprite & b) {
+	if (a.sorting_in_layer < b.sorting_in_layer) return true;
+	if (a.sorting_in_layer == b.sorting_in_layer) return a.order_in_layer < b.order_in_layer;
+
+	return false;
+}
+
+std::vector<std::reference_wrapper<Sprite>>
+RenderSystem::sort(std::vector<std::reference_wrapper<Sprite>> & objs) {
+
+	std::vector<std::reference_wrapper<Sprite>> sorted_objs(objs);
+	std::sort(sorted_objs.begin(), sorted_objs.end(), sorting_comparison);
+
+	return sorted_objs;
+}
+
+void RenderSystem::render_sprites() {
+	ComponentManager & mgr = this->component_manager;
+	vector<reference_wrapper<Sprite>> sprites = mgr.get_components_by_type<Sprite>();
+	vector<reference_wrapper<Sprite>> sorted_sprites = this->sort(sprites);
 
-	SDLContext & render = SDLContext::get_instance();
-	for (const Sprite & sprite : sprites) {
+	for (const Sprite & sprite : sorted_sprites) {
 		auto transforms = mgr.get_components_by_id<Transform>(sprite.game_object_id);
-		render.draw(sprite, transforms[0], *curr_cam);
+		this->context.draw(sprite, transforms[0], *this->curr_cam_ref);
 	}
 }
 
diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h
index 87ec494..57b9c73 100644
--- a/src/crepe/system/RenderSystem.h
+++ b/src/crepe/system/RenderSystem.h
@@ -1,18 +1,23 @@
 #pragma once
 
-#include "api/Camera.h"
+#include <functional>
+#include <vector>
+
+#include "facade/SDLContext.h"
 
 #include "System.h"
 
 namespace crepe {
 
+class Camera;
+class Sprite;
+
 /**
  * \class RenderSystem
  * \brief Manages rendering operations for all game objects.
  *
- * RenderSystem is responsible for rendering sprites, clearing and presenting the screen, and
- * managing the active camera. It functions as a singleton, providing centralized rendering
- * services for the application.
+ * RenderSystem is responsible for rendering, clearing and presenting the screen, and
+ * managing the active camera. 
  */
 class RenderSystem : public System {
 public:
@@ -25,16 +30,25 @@ public:
 
 private:
 	//! Clears the screen in preparation for rendering.
-	void clear_screen() const;
+	void clear_screen();
 
 	//! Presents the rendered frame to the display.
-	void present_screen() const;
+	void present_screen();
 
 	//! Updates the active camera used for rendering.
 	void update_camera();
 
 	//! Renders all active sprites to the screen.
-	void render_sprites() const;
+	void render_sprites();
+
+	/**
+	 * \brief sort a vector sprite objects with
+	 *
+	 * \param objs the vector that will do a sorting algorithm on 
+	 * \return returns a sorted reference vector
+	 */
+	std::vector<std::reference_wrapper<Sprite>>
+	sort(std::vector<std::reference_wrapper<Sprite>> & objs);
 
 	/**
 	 * \todo Include color handling for sprites.
@@ -48,8 +62,10 @@ private:
 
 private:
 	//! Pointer to the current active camera for rendering
-	Camera * curr_cam = nullptr;
+	Camera * curr_cam_ref = nullptr;
 	// TODO: needs a better solution
+
+	SDLContext & context = SDLContext::get_instance();
 };
 
 } // namespace crepe
diff --git a/src/example/CMakeLists.txt b/src/example/CMakeLists.txt
index c5cb63f..045f4d4 100644
--- a/src/example/CMakeLists.txt
+++ b/src/example/CMakeLists.txt
@@ -17,7 +17,6 @@ function(add_example target_name)
 endfunction()
 
 add_example(audio_internal)
-# add_example(components_internal)
 add_example(script)
 add_example(log)
 add_example(rendering)
@@ -25,8 +24,6 @@ add_example(asset_manager)
 add_example(savemgr)
 add_example(proxy)
 add_example(db)
-add_example(ecs)
-add_example(scene_manager)
 add_example(game)
 add_example(events)
 add_example(gameloop)
diff --git a/src/example/components_internal.cpp b/src/example/components_internal.cpp
deleted file mode 100644
index 2a232a9..0000000
--- a/src/example/components_internal.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-/** \file
- * 
- * Standalone example for usage of the internal ECS
- */
-
-#include <cassert>
-#include <chrono>
-
-#include <crepe/Component.h>
-#include <crepe/ComponentManager.h>
-
-#include <crepe/api/GameObject.h>
-#include <crepe/api/Rigidbody.h>
-#include <crepe/api/Sprite.h>
-
-#include <crepe/util/Log.h>
-
-using namespace crepe;
-using namespace std;
-
-#define OBJ_COUNT 100000
-
-int main() {
-	dbg_trace();
-
-	ComponentManager mgr{};
-
-	auto start_adding = chrono::high_resolution_clock::now();
-
-	for (int i = 0; i < OBJ_COUNT; ++i) {
-		GameObject obj = mgr.new_object("Name", "Tag");
-		obj.add_component<Sprite>("test");
-		obj.add_component<Rigidbody>(0, 0, i);
-	}
-
-	auto stop_adding = chrono::high_resolution_clock::now();
-
-	auto sprites = mgr.get_components_by_type<Sprite>();
-	for (auto sprite : sprites) {
-		assert(true);
-	}
-
-	auto stop_looping = chrono::high_resolution_clock::now();
-
-	auto add_time = chrono::duration_cast<chrono::microseconds>(stop_adding - start_adding);
-	auto loop_time = chrono::duration_cast<chrono::microseconds>(stop_looping - stop_adding);
-	printf("add time:  %ldus\n", add_time.count());
-	printf("loop time: %ldus\n", loop_time.count());
-
-	return 0;
-}
diff --git a/src/example/ecs.cpp b/src/example/ecs.cpp
deleted file mode 100644
index d5ba51b..0000000
--- a/src/example/ecs.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include <iostream>
-
-#include <crepe/ComponentManager.h>
-#include <crepe/api/GameObject.h>
-#include <crepe/api/Metadata.h>
-#include <crepe/api/Transform.h>
-
-using namespace crepe;
-using namespace std;
-
-int main() {
-	ComponentManager mgr{};
-
-	// Create a few GameObjects
-	try {
-		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);
-
-		// Set the parent of each GameObject
-		right_foot.set_parent(right_leg);
-		left_foot.set_parent(left_leg);
-		right_leg.set_parent(body);
-		left_leg.set_parent(body);
-
-		// Adding a second Transform component is not allowed and will invoke an exception
-		body.add_component<Transform>(Vector2{10, 10}, 0, 1);
-	} catch (const exception & e) {
-		cerr << e.what() << endl;
-	}
-
-	// Get the Metadata and Transform components of each GameObject
-	vector<reference_wrapper<Metadata>> metadata = mgr.get_components_by_type<Metadata>();
-	vector<reference_wrapper<Transform>> transform = mgr.get_components_by_type<Transform>();
-
-	// Print the Metadata and Transform components
-	for (auto & m : metadata) {
-		cout << "Id: " << m.get().game_object_id << " Name: " << m.get().name
-			 << " Tag: " << m.get().tag << " Parent: " << m.get().parent << " Children: ";
-		for (auto & c : m.get().children) {
-			cout << c << " ";
-		}
-		cout << endl;
-	}
-	for (auto & t : transform) {
-		cout << "Id: " << t.get().game_object_id << " Position: [" << t.get().position.x
-			 << ", " << t.get().position.y << "]" << endl;
-	}
-
-	return 0;
-}
diff --git a/src/example/events.cpp b/src/example/events.cpp
index ed519ff..e6d91aa 100644
--- a/src/example/events.cpp
+++ b/src/example/events.cpp
@@ -2,7 +2,7 @@
 
 #include <crepe/ComponentManager.h>
 #include <crepe/system/ScriptSystem.h>
-#include <crepe/util/log.h>
+#include <crepe/util/Log.h>
 
 #include <crepe/api/BehaviorScript.h>
 #include <crepe/api/Config.h>
@@ -65,6 +65,10 @@ public:
 	}
 };
 int main() {
+	EventManager & evmgr = EventManager::get_instance();
+	ComponentManager mgr{};
+	ScriptSystem sys{mgr};
+
 	// two events to trigger
 	KeyPressEvent key_press;
 	key_press.key = Keycode::A;
@@ -74,22 +78,19 @@ int main() {
 	click_event.mouse_x = 100;
 	click_event.mouse_y = 200;
 	// queue events to test queue
-	EventManager::get_instance().queue_event<KeyPressEvent>(
-		std::move(key_press), 0);
-	EventManager::get_instance().queue_event<MouseClickEvent>(
-		std::move(click_event), 0);
+	evmgr.queue_event<KeyPressEvent>(std::move(key_press), 0);
+	evmgr.queue_event<MouseClickEvent>(std::move(click_event), 0);
 	{
 		TestKeyListener test_listener;
 		test_listener.set_channel(1);
-		auto obj = GameObject(0, "name", "tag", Vector2{1.2, 3.4}, 0, 1);
+		auto obj = mgr.new_object("name", "tag", Vector2{1.2, 3.4}, 0, 1);
 		obj.add_component<BehaviorScript>().set_script<MyScript>();
 
-		ScriptSystem sys;
 		sys.update();
 
 		// Trigger the events while `testListener` is in scope
-		EventManager::get_instance().trigger_event<KeyPressEvent>(key_press, 1);
-		EventManager::get_instance().trigger_event(MouseClickEvent{
+		evmgr.trigger_event<KeyPressEvent>(key_press, 1);
+		evmgr.trigger_event(MouseClickEvent{
     		.mouse_x = 100,
     		.mouse_y = 100,
     		.button = MouseButton::LEFT_MOUSE,
@@ -100,14 +101,13 @@ int main() {
 		std::cout << "lambda test" << std::endl;
 		return false;
 	};
-	EventManager::get_instance().subscribe<KeyPressEvent>(
-		std::move(event_handler), 0);
+	evmgr.subscribe<KeyPressEvent>(std::move(event_handler), 0);
 	// testing trigger with testListener not in scope (unsubscribed)
-	EventManager::get_instance().trigger_event<KeyPressEvent>(key_press, 0);
-	EventManager::get_instance().trigger_event<MouseClickEvent>(click_event, 0);
+	evmgr.trigger_event<KeyPressEvent>(key_press, 0);
+	evmgr.trigger_event<MouseClickEvent>(click_event, 0);
 	// dispatching queued events
-	EventManager::get_instance().dispatch_events();
+	evmgr.dispatch_events();
 
-	EventManager::get_instance().unsubscribe<KeyPressEvent>(event_handler, 0);
+	evmgr.unsubscribe<KeyPressEvent>(event_handler, 0);
 	return EXIT_SUCCESS;
 }
diff --git a/src/example/game.cpp b/src/example/game.cpp
index b6a0c31..a557be7 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -74,7 +74,7 @@ public:
 	game_object1.add_component<Sprite>(
 	make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
 	FlipSettings{true, true});
-	game_object1.add_component<Camera>(Color::get_white());
+	game_object1.add_component<Camera>(Color::WHITE);
 	}
 };
 
diff --git a/src/example/rendering.cpp b/src/example/rendering.cpp
index 14ecaa9..9e3c8cc 100644
--- a/src/example/rendering.cpp
+++ b/src/example/rendering.cpp
@@ -30,13 +30,13 @@ int main() {
 	// Normal adding components
 	{
 		Color color(0, 0, 0, 0);
-		obj.add_component<Sprite>(make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
+		obj.add_component<Sprite>(make_shared<Texture>("../asset/texture/green_square.png"), color,
 								  FlipSettings{false, false});
-		obj.add_component<Camera>(Color::get_red());
+		obj.add_component<Camera>(Color::RED);
 	}
 	{
 		Color color(0, 0, 0, 0);
-		obj1.add_component<Sprite>(make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
+		obj1.add_component<Sprite>(make_shared<Texture>("../asset/texture/green_square.png"), color,
 								   FlipSettings{true, true});
 	}
 
@@ -48,8 +48,12 @@ int main() {
 	}
 	*/
 
+	sys.update();
+	/*
+
 	auto start = std::chrono::steady_clock::now();
 	while (std::chrono::steady_clock::now() - start < std::chrono::seconds(5)) {
 		sys.update();
 	}
+	*/
 }
diff --git a/src/example/scene_manager.cpp b/src/example/scene_manager.cpp
deleted file mode 100644
index accec7d..0000000
--- a/src/example/scene_manager.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-#include <iostream>
-
-#include <crepe/ComponentManager.h>
-#include <crepe/api/GameObject.h>
-#include <crepe/api/Metadata.h>
-#include <crepe/api/Scene.h>
-#include <crepe/api/SceneManager.h>
-#include <crepe/api/Vector2.h>
-
-using namespace crepe;
-using namespace std;
-
-class ConcreteScene1 : public Scene {
-public:
-	using Scene::Scene;
-
-	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);
-	}
-};
-
-class ConcreteScene2 : public Scene {
-public:
-	using Scene::Scene;
-
-	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);
-	}
-};
-
-int main() {
-	ComponentManager component_mgr{};
-	SceneManager scene_mgr{component_mgr};
-
-	// Add the scenes to the scene manager
-	scene_mgr.add_scene<ConcreteScene1>("scene1");
-	scene_mgr.add_scene<ConcreteScene2>("scene2");
-
-	// There is no need to call set_next_scene() at the beginnen, because the first scene will be
-	// automatically set as the next scene
-
-	// Load scene1 (the first scene added)
-	scene_mgr.load_next_scene();
-
-	// Get the Metadata components of each GameObject of Scene1
-	vector<reference_wrapper<Metadata>> metadata
-		= component_mgr.get_components_by_type<Metadata>();
-
-	cout << "Metadata components of Scene1:" << endl;
-	// Print the Metadata
-	for (auto & m : metadata) {
-		cout << "Id: " << m.get().game_object_id << " Name: " << m.get().name
-			 << " Tag: " << m.get().tag << endl;
-	}
-
-	// Set scene2 as the next scene
-	scene_mgr.set_next_scene("scene2");
-	// Load scene2
-	scene_mgr.load_next_scene();
-
-	// Get the Metadata components of each GameObject of Scene2
-	metadata = component_mgr.get_components_by_type<Metadata>();
-
-	cout << "Metadata components of Scene2:" << endl;
-	// Print the Metadata
-	for (auto & m : metadata) {
-		cout << "Id: " << m.get().game_object_id << " Name: " << m.get().name
-			 << " Tag: " << m.get().tag << endl;
-	}
-
-	return 0;
-}
diff --git a/src/makefile b/src/makefile
index 5f80204..a0e8f02 100644
--- a/src/makefile
+++ b/src/makefile
@@ -1,6 +1,9 @@
 .PHONY: FORCE
 
-FMT := $(shell git ls-files '*.c' '*.cpp' '*.h' '*.hpp')
 format: FORCE
-	clang-tidy -p build/compile_commands.json --fix-errors $(FMT)
+	$(MAKE) -C .. $@
+
+LINT := $(shell git ls-files '*.c' '*.cpp' '*.h' '*.hpp')
+lint: FORCE
+	clang-tidy -p build/compile_commands.json --fix-errors $(LINT)
 
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index f830165..14c5123 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -4,5 +4,7 @@ target_sources(test_main PUBLIC
 	PhysicsTest.cpp
 	ScriptTest.cpp
 	ParticleTest.cpp
+	ECSTest.cpp
+	SceneManagerTest.cpp
 )
 
diff --git a/src/test/ECSTest.cpp b/src/test/ECSTest.cpp
new file mode 100644
index 0000000..d5a5826
--- /dev/null
+++ b/src/test/ECSTest.cpp
@@ -0,0 +1,236 @@
+#include <gtest/gtest.h>
+
+#define protected public
+
+#include <crepe/ComponentManager.h>
+#include <crepe/api/GameObject.h>
+#include <crepe/api/Metadata.h>
+#include <crepe/api/Transform.h>
+#include <crepe/api/Vector2.h>
+
+using namespace std;
+using namespace crepe;
+
+class ECSTest : public ::testing::Test {
+public:
+	ComponentManager mgr{};
+};
+
+TEST_F(ECSTest, createGameObject) {
+	GameObject obj = mgr.new_object("body", "person", Vector2{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>();
+
+	EXPECT_EQ(metadata.size(), 1);
+	EXPECT_EQ(transform.size(), 1);
+
+	EXPECT_EQ(metadata[0].get().name, "body");
+	EXPECT_EQ(metadata[0].get().tag, "person");
+	EXPECT_EQ(metadata[0].get().parent, -1);
+	EXPECT_EQ(metadata[0].get().children.size(), 0);
+
+	EXPECT_EQ(transform[0].get().position.x, 0);
+	EXPECT_EQ(transform[0].get().position.y, 0);
+	EXPECT_EQ(transform[0].get().rotation, 0);
+	EXPECT_EQ(transform[0].get().scale, 1);
+}
+
+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);
+
+	mgr.delete_all_components();
+
+	vector<reference_wrapper<Metadata>> metadata = mgr.get_components_by_type<Metadata>();
+	vector<reference_wrapper<Transform>> transform = mgr.get_components_by_type<Transform>();
+
+	EXPECT_EQ(metadata.size(), 0);
+	EXPECT_EQ(transform.size(), 0);
+
+	GameObject obj2 = mgr.new_object("body2", "person2", Vector2{1, 0}, 5, 1);
+
+	metadata = mgr.get_components_by_type<Metadata>();
+	transform = mgr.get_components_by_type<Transform>();
+
+	EXPECT_EQ(metadata.size(), 1);
+	EXPECT_EQ(transform.size(), 1);
+
+	EXPECT_EQ(metadata[0].get().game_object_id, 0);
+	EXPECT_EQ(metadata[0].get().name, "body2");
+	EXPECT_EQ(metadata[0].get().tag, "person2");
+	EXPECT_EQ(metadata[0].get().parent, -1);
+	EXPECT_EQ(metadata[0].get().children.size(), 0);
+
+	EXPECT_EQ(transform[0].get().game_object_id, 0);
+	EXPECT_EQ(transform[0].get().position.x, 1);
+	EXPECT_EQ(transform[0].get().position.y, 0);
+	EXPECT_EQ(transform[0].get().rotation, 5);
+	EXPECT_EQ(transform[0].get().scale, 1);
+}
+
+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);
+
+	mgr.delete_all_components_of_id(0);
+
+	vector<reference_wrapper<Metadata>> metadata = mgr.get_components_by_type<Metadata>();
+	vector<reference_wrapper<Transform>> transform = mgr.get_components_by_type<Transform>();
+
+	EXPECT_EQ(metadata.size(), 1);
+	EXPECT_EQ(transform.size(), 1);
+
+	EXPECT_EQ(metadata[0].get().game_object_id, 1);
+	EXPECT_EQ(metadata[0].get().name, "body");
+	EXPECT_EQ(metadata[0].get().tag, "person");
+	EXPECT_EQ(metadata[0].get().parent, -1);
+	EXPECT_EQ(metadata[0].get().children.size(), 0);
+
+	EXPECT_EQ(transform[0].get().game_object_id, 1);
+	EXPECT_EQ(transform[0].get().position.x, 0);
+	EXPECT_EQ(transform[0].get().position.y, 0);
+	EXPECT_EQ(transform[0].get().rotation, 0);
+	EXPECT_EQ(transform[0].get().scale, 1);
+}
+
+TEST_F(ECSTest, manyGameObjects) {
+	for (int i = 0; i < 5000; i++) {
+		GameObject obj = mgr.new_object("body", "person", Vector2{0, 0}, 0, i);
+	}
+
+	vector<reference_wrapper<Metadata>> metadata = mgr.get_components_by_type<Metadata>();
+	vector<reference_wrapper<Transform>> transform = mgr.get_components_by_type<Transform>();
+
+	EXPECT_EQ(metadata.size(), 5000);
+	EXPECT_EQ(transform.size(), 5000);
+	for (int i = 0; i < 5000; i++) {
+		EXPECT_EQ(metadata[i].get().game_object_id, i);
+		EXPECT_EQ(metadata[i].get().name, "body");
+		EXPECT_EQ(metadata[i].get().tag, "person");
+		EXPECT_EQ(metadata[i].get().parent, -1);
+		EXPECT_EQ(metadata[i].get().children.size(), 0);
+
+		EXPECT_EQ(transform[i].get().game_object_id, i);
+		EXPECT_EQ(transform[i].get().position.x, 0);
+		EXPECT_EQ(transform[i].get().position.y, 0);
+		EXPECT_EQ(transform[i].get().rotation, 0);
+		EXPECT_EQ(transform[i].get().scale, i);
+	}
+
+	mgr.delete_components<Metadata>();
+
+	metadata = mgr.get_components_by_type<Metadata>();
+	transform = mgr.get_components_by_type<Transform>();
+
+	EXPECT_EQ(metadata.size(), 0);
+	EXPECT_EQ(transform.size(), 5000);
+
+	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);
+	}
+
+	metadata = mgr.get_components_by_type<Metadata>();
+	transform = mgr.get_components_by_type<Transform>();
+
+	EXPECT_EQ(metadata.size(), 10000 - 5000);
+	EXPECT_EQ(transform.size(), 10000);
+}
+
+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);
+
+	vector<reference_wrapper<Metadata>> metadata = mgr.get_components_by_id<Metadata>(0);
+	vector<reference_wrapper<Transform>> transform = mgr.get_components_by_id<Transform>(1);
+
+	EXPECT_EQ(metadata.size(), 1);
+	EXPECT_EQ(transform.size(), 1);
+
+	EXPECT_EQ(metadata[0].get().game_object_id, 0);
+	EXPECT_EQ(metadata[0].get().name, "body");
+	EXPECT_EQ(metadata[0].get().tag, "person");
+	EXPECT_EQ(metadata[0].get().parent, -1);
+	EXPECT_EQ(metadata[0].get().children.size(), 0);
+
+	EXPECT_EQ(transform[0].get().game_object_id, 1);
+	EXPECT_EQ(transform[0].get().position.x, 0);
+	EXPECT_EQ(transform[0].get().position.y, 0);
+	EXPECT_EQ(transform[0].get().rotation, 0);
+	EXPECT_EQ(transform[0].get().scale, 1);
+}
+
+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);
+	} 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);
+		obj1.add_component<Metadata>("body", "person");
+	} catch (const exception & e) {
+		EXPECT_EQ(e.what(),
+				  string("Exceeded maximum number of instances for this component type"));
+	}
+
+	vector<reference_wrapper<Metadata>> metadata = mgr.get_components_by_type<Metadata>();
+
+	EXPECT_EQ(metadata.size(), 2);
+	EXPECT_EQ(metadata[0].get().name, "body");
+	EXPECT_EQ(metadata[1].get().name, "body");
+}
+
+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);
+
+		// Set the parent of each GameObject
+		right_foot.set_parent(right_leg);
+		left_foot.set_parent(left_leg);
+		right_leg.set_parent(body);
+		left_leg.set_parent(body);
+	}
+
+	// Get the Metadata and Transform components of each GameObject
+	vector<reference_wrapper<Metadata>> metadata = mgr.get_components_by_type<Metadata>();
+
+	// Check IDs
+	EXPECT_EQ(metadata[0].get().game_object_id, 0);
+	EXPECT_EQ(metadata[1].get().game_object_id, 1);
+	EXPECT_EQ(metadata[2].get().game_object_id, 2);
+	EXPECT_EQ(metadata[3].get().game_object_id, 3);
+	EXPECT_EQ(metadata[4].get().game_object_id, 4);
+
+	// Check the parent-child relationships
+	EXPECT_EQ(metadata[0].get().name, "body");
+	EXPECT_EQ(metadata[1].get().name, "rightLeg");
+	EXPECT_EQ(metadata[2].get().name, "leftLeg");
+	EXPECT_EQ(metadata[3].get().name, "rightFoot");
+	EXPECT_EQ(metadata[4].get().name, "leftFoot");
+
+	EXPECT_EQ(metadata[0].get().parent, -1);
+	EXPECT_EQ(metadata[1].get().parent, 0);
+	EXPECT_EQ(metadata[2].get().parent, 0);
+	EXPECT_EQ(metadata[3].get().parent, 1);
+	EXPECT_EQ(metadata[4].get().parent, 2);
+
+	EXPECT_EQ(metadata[0].get().children.size(), 2);
+	EXPECT_EQ(metadata[1].get().children.size(), 1);
+	EXPECT_EQ(metadata[2].get().children.size(), 1);
+	EXPECT_EQ(metadata[3].get().children.size(), 0);
+	EXPECT_EQ(metadata[4].get().children.size(), 0);
+
+	EXPECT_EQ(metadata[0].get().children[0], 1);
+	EXPECT_EQ(metadata[0].get().children[1], 2);
+	EXPECT_EQ(metadata[1].get().children[0], 3);
+	EXPECT_EQ(metadata[2].get().children[0], 4);
+}
diff --git a/src/test/RenderSystemTest.cpp b/src/test/RenderSystemTest.cpp
new file mode 100644
index 0000000..ac479d3
--- /dev/null
+++ b/src/test/RenderSystemTest.cpp
@@ -0,0 +1,174 @@
+#include "api/Camera.h"
+#include <functional>
+#include <gtest/gtest.h>
+#include <memory>
+#include <vector>
+
+#define private public
+#define protected public
+
+#include <crepe/ComponentManager.h>
+#include <crepe/api/Color.h>
+#include <crepe/api/GameObject.h>
+#include <crepe/api/Sprite.h>
+#include <crepe/api/Texture.h>
+
+#include <crepe/system/RenderSystem.h>
+
+using namespace std;
+using namespace crepe;
+using namespace testing;
+
+class RenderSystemTest : public Test {
+public:
+	ComponentManager mgr{};
+	RenderSystem sys{mgr};
+	GameObject entity1 = this->mgr.new_object("name");
+	GameObject entity2 = this->mgr.new_object("name");
+	GameObject entity3 = this->mgr.new_object("name");
+	GameObject entity4 = this->mgr.new_object("name");
+
+	void SetUp() override {
+		auto & sprite1
+			= entity1.add_component<Sprite>(make_shared<Texture>("../asset/texture/img.png"),
+											Color(0, 0, 0, 0), FlipSettings{false, false});
+		ASSERT_NE(sprite1.sprite_image.get(), nullptr);
+		sprite1.order_in_layer = 5;
+		sprite1.sorting_in_layer = 5;
+		EXPECT_EQ(sprite1.order_in_layer, 5);
+		EXPECT_EQ(sprite1.sorting_in_layer, 5);
+		auto & sprite2
+			= entity2.add_component<Sprite>(make_shared<Texture>("../asset/texture/img.png"),
+											Color(0, 0, 0, 0), FlipSettings{false, false});
+		ASSERT_NE(sprite2.sprite_image.get(), nullptr);
+		sprite2.sorting_in_layer = 2;
+		sprite2.order_in_layer = 1;
+
+		EXPECT_EQ(sprite2.sorting_in_layer, 2);
+		EXPECT_EQ(sprite2.order_in_layer, 1);
+
+		auto & sprite3
+			= entity3.add_component<Sprite>(make_shared<Texture>("../asset/texture/img.png"),
+											Color(0, 0, 0, 0), FlipSettings{false, false});
+		ASSERT_NE(sprite3.sprite_image.get(), nullptr);
+		sprite3.sorting_in_layer = 1;
+		sprite3.order_in_layer = 2;
+
+		EXPECT_EQ(sprite3.sorting_in_layer, 1);
+		EXPECT_EQ(sprite3.order_in_layer, 2);
+
+		auto & sprite4
+			= entity4.add_component<Sprite>(make_shared<Texture>("../asset/texture/img.png"),
+											Color(0, 0, 0, 0), FlipSettings{false, false});
+		ASSERT_NE(sprite4.sprite_image.get(), nullptr);
+		sprite4.sorting_in_layer = 1;
+		sprite4.order_in_layer = 1;
+		EXPECT_EQ(sprite4.sorting_in_layer, 1);
+		EXPECT_EQ(sprite4.order_in_layer, 1);
+	}
+};
+
+TEST_F(RenderSystemTest, expected_throws) {
+	GameObject entity1 = this->mgr.new_object("NAME");
+
+	// no texture img
+	EXPECT_ANY_THROW({
+		entity1.add_component<Sprite>(make_shared<Texture>("NO_IMAGE"), Color(0, 0, 0, 0),
+									  FlipSettings{false, false});
+	});
+
+	// No camera
+	EXPECT_ANY_THROW({ this->sys.update(); });
+}
+
+TEST_F(RenderSystemTest, make_sprites) {}
+
+TEST_F(RenderSystemTest, sorting_sprites) {
+	vector<reference_wrapper<Sprite>> sprites = this->mgr.get_components_by_type<Sprite>();
+	ASSERT_EQ(sprites.size(), 4);
+
+	vector<reference_wrapper<Sprite>> sorted_sprites = this->sys.sort(sprites);
+	ASSERT_EQ(sorted_sprites.size(), 4);
+
+	// Expected order after sorting:
+	// 1. sorting_in_layer: 1, order_in_layer: 1 (entity4)
+	// 2. sorting_in_layer: 1, order_in_layer: 2 (entity3)
+	// 3. sorting_in_layer: 2, order_in_layer: 1 (entity2)
+	// 4. sorting_in_layer: 5, order_in_layer: 5 (entity1)
+
+	EXPECT_EQ(sorted_sprites[0].get().sorting_in_layer, 1);
+	EXPECT_EQ(sorted_sprites[0].get().order_in_layer, 1);
+
+	EXPECT_EQ(sorted_sprites[1].get().sorting_in_layer, 1);
+	EXPECT_EQ(sorted_sprites[1].get().order_in_layer, 2);
+
+	EXPECT_EQ(sorted_sprites[2].get().sorting_in_layer, 2);
+	EXPECT_EQ(sorted_sprites[2].get().order_in_layer, 1);
+
+	EXPECT_EQ(sorted_sprites[3].get().sorting_in_layer, 5);
+	EXPECT_EQ(sorted_sprites[3].get().order_in_layer, 5);
+
+	for (size_t i = 1; i < sorted_sprites.size(); ++i) {
+		const Sprite & prev = sorted_sprites[i - 1].get();
+		const Sprite & curr = sorted_sprites[i].get();
+
+		if (prev.sorting_in_layer == curr.sorting_in_layer) {
+			EXPECT_LE(prev.order_in_layer, curr.order_in_layer);
+		} else {
+			EXPECT_LE(prev.sorting_in_layer, curr.sorting_in_layer);
+		}
+	}
+}
+
+TEST_F(RenderSystemTest, Update) {
+	entity1.add_component<Camera>(Color::WHITE);
+	{
+		vector<reference_wrapper<Sprite>> sprites = this->mgr.get_components_by_type<Sprite>();
+		ASSERT_EQ(sprites.size(), 4);
+
+		EXPECT_EQ(sprites[0].get().game_object_id, 0);
+		EXPECT_EQ(sprites[1].get().game_object_id, 1);
+		EXPECT_EQ(sprites[2].get().game_object_id, 2);
+		EXPECT_EQ(sprites[3].get().game_object_id, 3);
+	}
+	this->sys.update();
+	{
+		vector<reference_wrapper<Sprite>> sprites = this->mgr.get_components_by_type<Sprite>();
+		ASSERT_EQ(sprites.size(), 4);
+
+		EXPECT_EQ(sprites[0].get().game_object_id, 0);
+		EXPECT_EQ(sprites[1].get().game_object_id, 1);
+		EXPECT_EQ(sprites[2].get().game_object_id, 2);
+		EXPECT_EQ(sprites[3].get().game_object_id, 3);
+	}
+}
+
+TEST_F(RenderSystemTest, Camera) {
+	{
+		auto cameras = this->mgr.get_components_by_type<Camera>();
+		EXPECT_NE(cameras.size(), 1);
+	}
+	{
+		entity1.add_component<Camera>(Color::WHITE);
+		auto cameras = this->mgr.get_components_by_type<Camera>();
+		EXPECT_EQ(cameras.size(), 1);
+	}
+
+	//TODO improve with newer version
+}
+TEST_F(RenderSystemTest, Color) {
+	entity1.add_component<Camera>(Color::WHITE);
+	auto & sprite = this->mgr.get_components_by_id<Sprite>(entity1.id).front().get();
+	ASSERT_NE(sprite.sprite_image.get(), nullptr);
+
+	sprite.color = Color::GREEN;
+	EXPECT_EQ(sprite.color.r, Color::GREEN.r);
+	EXPECT_EQ(sprite.color.g, Color::GREEN.g);
+	EXPECT_EQ(sprite.color.b, Color::GREEN.b);
+	EXPECT_EQ(sprite.color.a, Color::GREEN.a);
+	this->sys.update();
+	EXPECT_EQ(sprite.color.r, Color::GREEN.r);
+	EXPECT_EQ(sprite.color.g, Color::GREEN.g);
+	EXPECT_EQ(sprite.color.b, Color::GREEN.b);
+	EXPECT_EQ(sprite.color.a, Color::GREEN.a);
+}
diff --git a/src/test/SceneManagerTest.cpp b/src/test/SceneManagerTest.cpp
new file mode 100644
index 0000000..69e1171
--- /dev/null
+++ b/src/test/SceneManagerTest.cpp
@@ -0,0 +1,122 @@
+#include <crepe/ComponentManager.h>
+#include <crepe/api/GameObject.h>
+#include <crepe/api/Metadata.h>
+#include <crepe/api/Scene.h>
+#include <crepe/api/SceneManager.h>
+#include <crepe/api/Transform.h>
+#include <crepe/api/Vector2.h>
+#include <gtest/gtest.h>
+
+using namespace std;
+using namespace crepe;
+
+class ConcreteScene1 : public Scene {
+public:
+	using Scene::Scene;
+
+	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);
+	}
+};
+
+class ConcreteScene2 : public Scene {
+public:
+	using Scene::Scene;
+
+	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);
+	}
+};
+
+class SceneManagerTest : public ::testing::Test {
+public:
+	ComponentManager component_mgr{};
+	SceneManager scene_mgr{component_mgr};
+};
+
+TEST_F(SceneManagerTest, loadScene) {
+	scene_mgr.add_scene<ConcreteScene1>("scene1");
+	scene_mgr.add_scene<ConcreteScene2>("scene2");
+
+	scene_mgr.load_next_scene();
+
+	vector<reference_wrapper<Metadata>> metadata
+		= component_mgr.get_components_by_type<Metadata>();
+	vector<reference_wrapper<Transform>> transform
+		= component_mgr.get_components_by_type<Transform>();
+
+	EXPECT_EQ(metadata.size(), 3);
+	EXPECT_EQ(transform.size(), 3);
+
+	EXPECT_EQ(metadata[0].get().game_object_id, 0);
+	EXPECT_EQ(metadata[0].get().name, "scene_1");
+	EXPECT_EQ(metadata[0].get().tag, "tag_scene_1");
+	EXPECT_EQ(metadata[0].get().parent, -1);
+	EXPECT_EQ(metadata[0].get().children.size(), 0);
+	EXPECT_EQ(transform[0].get().position.x, 0);
+	EXPECT_EQ(transform[0].get().position.y, 0);
+
+	EXPECT_EQ(metadata[1].get().game_object_id, 1);
+	EXPECT_EQ(metadata[1].get().name, "scene_1");
+	EXPECT_EQ(metadata[1].get().tag, "tag_scene_1");
+	EXPECT_EQ(metadata[1].get().parent, -1);
+	EXPECT_EQ(metadata[1].get().children.size(), 0);
+	EXPECT_EQ(transform[1].get().position.x, 1);
+	EXPECT_EQ(transform[1].get().position.y, 0);
+
+	EXPECT_EQ(metadata[2].get().game_object_id, 2);
+	EXPECT_EQ(metadata[2].get().name, "scene_1");
+	EXPECT_EQ(metadata[2].get().tag, "tag_scene_1");
+	EXPECT_EQ(metadata[2].get().parent, -1);
+	EXPECT_EQ(metadata[2].get().children.size(), 0);
+	EXPECT_EQ(transform[2].get().position.x, 2);
+	EXPECT_EQ(transform[2].get().position.y, 0);
+
+	scene_mgr.set_next_scene("scene2");
+	scene_mgr.load_next_scene();
+
+	metadata = component_mgr.get_components_by_type<Metadata>();
+	transform = component_mgr.get_components_by_type<Transform>();
+
+	EXPECT_EQ(metadata.size(), 4);
+	EXPECT_EQ(transform.size(), 4);
+
+	EXPECT_EQ(metadata[0].get().game_object_id, 0);
+	EXPECT_EQ(metadata[0].get().name, "scene_2");
+	EXPECT_EQ(metadata[0].get().tag, "tag_scene_2");
+	EXPECT_EQ(metadata[0].get().parent, -1);
+	EXPECT_EQ(metadata[0].get().children.size(), 0);
+	EXPECT_EQ(transform[0].get().position.x, 0);
+	EXPECT_EQ(transform[0].get().position.y, 0);
+
+	EXPECT_EQ(metadata[1].get().game_object_id, 1);
+	EXPECT_EQ(metadata[1].get().name, "scene_2");
+	EXPECT_EQ(metadata[1].get().tag, "tag_scene_2");
+	EXPECT_EQ(metadata[1].get().parent, -1);
+	EXPECT_EQ(metadata[1].get().children.size(), 0);
+	EXPECT_EQ(transform[1].get().position.x, 0);
+	EXPECT_EQ(transform[1].get().position.y, 1);
+
+	EXPECT_EQ(metadata[2].get().game_object_id, 2);
+	EXPECT_EQ(metadata[2].get().name, "scene_2");
+	EXPECT_EQ(metadata[2].get().tag, "tag_scene_2");
+	EXPECT_EQ(metadata[2].get().parent, -1);
+	EXPECT_EQ(metadata[2].get().children.size(), 0);
+	EXPECT_EQ(transform[2].get().position.x, 0);
+	EXPECT_EQ(transform[2].get().position.y, 2);
+
+	EXPECT_EQ(metadata[3].get().game_object_id, 3);
+	EXPECT_EQ(metadata[3].get().name, "scene_2");
+	EXPECT_EQ(metadata[3].get().tag, "tag_scene_2");
+	EXPECT_EQ(metadata[3].get().parent, -1);
+	EXPECT_EQ(metadata[3].get().children.size(), 0);
+	EXPECT_EQ(transform[3].get().position.x, 0);
+	EXPECT_EQ(transform[3].get().position.y, 3);
+}
-- 
cgit v1.2.3


From f0effabc7555c08bec9a4284baad8c4e1c61c110 Mon Sep 17 00:00:00 2001
From: Loek Le Blansch <loek@pipeframe.xyz>
Date: Wed, 20 Nov 2024 18:09:06 +0100
Subject: clean up CollisionTest

---
 src/crepe/api/BehaviorScript.h   |   7 +-
 src/crepe/api/BehaviorScript.hpp |   6 +-
 src/test/CollisionTest.cpp       | 212 ++++++++++++++-------------------------
 src/test/main.cpp                |   2 +-
 4 files changed, 83 insertions(+), 144 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/BehaviorScript.h b/src/crepe/api/BehaviorScript.h
index 9d85d4c..d556fe5 100644
--- a/src/crepe/api/BehaviorScript.h
+++ b/src/crepe/api/BehaviorScript.h
@@ -39,11 +39,14 @@ public:
 	 * \brief Set the concrete script of this component
 	 *
 	 * \tparam T Concrete script type (derived from \c crepe::Script)
+	 * \tparam Args Arguments for concrete script constructor
+	 *
+	 * \param args Arguments for concrete script constructor (forwarded using perfect forwarding)
 	 *
 	 * \returns Reference to BehaviorScript component (`*this`)
 	 */
-	template <class T>
-	BehaviorScript & set_script();
+	template <class T, typename... Args>
+	BehaviorScript & set_script(Args &&... args);
 
 protected:
 	//! Script instance
diff --git a/src/crepe/api/BehaviorScript.hpp b/src/crepe/api/BehaviorScript.hpp
index d80321d..6bd123d 100644
--- a/src/crepe/api/BehaviorScript.hpp
+++ b/src/crepe/api/BehaviorScript.hpp
@@ -9,11 +9,11 @@
 
 namespace crepe {
 
-template <class T>
-BehaviorScript & BehaviorScript::set_script() {
+template <class T, typename... Args>
+BehaviorScript & BehaviorScript::set_script(Args &&... args) {
 	dbg_trace();
 	static_assert(std::is_base_of<Script, T>::value);
-	Script * s = new T();
+	Script * s = new T(std::forward<Args>(args)...);
 	s->game_object_id = this->game_object_id;
 	s->component_manager_ref = &this->component_manager;
 	this->script = std::unique_ptr<Script>(s);
diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp
index 78765b4..b15db71 100644
--- a/src/test/CollisionTest.cpp
+++ b/src/test/CollisionTest.cpp
@@ -1,80 +1,65 @@
-#include "system/ScriptSystem.h"
-#include "types.h"
 #include <gtest/gtest.h>
 
-#include <crepe/api/Config.h>
-#include <crepe/api/GameObject.h>
-#include <crepe/api/Rigidbody.h>
-#include <crepe/api/Transform.h>
+#define private public
+#define protected public
+
+#include <crepe/ComponentManager.h>
 #include <crepe/api/Event.h>
 #include <crepe/api/EventManager.h>
+#include <crepe/api/GameObject.h>
+#include <crepe/api/Rigidbody.h>
 #include <crepe/api/Script.h>
-
-#include <crepe/ComponentManager.h>
+#include <crepe/api/Transform.h>
 #include <crepe/system/CollisionSystem.h>
-#include "iostream"
+#include <crepe/system/ScriptSystem.h>
+#include <crepe/types.h>
+#include <crepe/util/Log.h>
 
 using namespace std;
 using namespace std::chrono_literals;
 using namespace crepe;
+using namespace testing;
 
-//scripts for object 1 collision test
-class UnitTestBoxBoxCollision1 : public Script {
-	static bool oncollision(const CollisionEvent& test) {
-		std::cout << "collision event 1" << std::endl;
-		std::cout << "collision event 1 x" << test.info.move_back_value.x << std::endl;
-		std::cout << "collision event 1 y" << test.info.move_back_value.y << std::endl;
-		return true;
-	}
-	void init() {
-		EventManager::get_instance().subscribe<CollisionEvent>(oncollision, this->get_game_object_id());
-	}
-	void update() {
-		// Retrieve component from the same GameObject this script is on
-		
+class CollisionHandler : public Script {
+public:
+	int box_id;
+	EventManager & evmgr = EventManager::get_instance();
+
+	CollisionHandler(int box_id) {
+		this->box_id = box_id;
 	}
-};
 
-//scripts for object 1 collision test
-class UnitTestBoxBoxCollision2 : public Script {
-	static bool oncollision(const CollisionEvent& test) {
-		std::cout << "collision event 1" << std::endl;
+	bool on_collision(const CollisionEvent& ev) {
+		Log::logf("Box {} event x={} y={}", box_id, ev.info.move_back_value.x, ev.info.move_back_value.y);
 		return true;
 	}
+
 	void init() {
-		EventManager::get_instance().subscribe<CollisionEvent>(oncollision, this->get_game_object_id());
-	}
-	void update() {
-		// Retrieve component from the same GameObject this script is on
-		
+		Log::logf("Box {} script init()", box_id);
+
+		// TODO: this should be built into script
+		evmgr.subscribe<CollisionEvent>([this](const CollisionEvent & ev) {
+			return this->on_collision(ev);
+		}, this->get_game_object_id());
 	}
 };
 
-class CollisionTest : public ::testing::Test {
+class CollisionTest : public Test {
 public:
-	ComponentManager component_manager;
-	CollisionSystem system{component_manager};
-	ScriptSystem sr{component_manager};
-	const double screen_size_width = 640;
-	const double screen_size_height = 480;
-	const double world_collider = 1000;
+	ComponentManager mgr;
+	CollisionSystem collision_sys{mgr};
+	ScriptSystem script_sys{mgr};
+
+	GameObject world = mgr.new_object("world");
+	GameObject game_object1 = mgr.new_object("object1", "", { 0, 0 });
+	GameObject game_object2 = mgr.new_object("object2", "", { 0, 0 });
+
+	Script * script_object1_ref = nullptr;
+	Script * script_object2_ref = nullptr;
 	
 	void SetUp() override {
-		ComponentManager & mgr = this->component_manager;
-		if(mgr.get_components_by_id<Transform>(0).empty())
-		{
-			create_test_world();
-			create_test_components();
-		}
-		reset_test_components();
-		sr.update();
-	}
-
-	void create_test_world() {
-		
-		ComponentManager & mgr = this->component_manager;
-		GameObject world = mgr.new_object("Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
 		world.add_component<Rigidbody>(Rigidbody::Data{
+			// TODO: remove unrelated properties:
 			.mass = 0,
 			.gravity_scale = 0,
 			.body_type = Rigidbody::BodyType::STATIC,
@@ -83,98 +68,51 @@ public:
 			.bounce = false,
 			.offset = {0,0}
 		});
-		world.add_component<BoxCollider>(Vector2{0, 0-(screen_size_height/2+world_collider/2)}, world_collider, world_collider);;	// Top
-		world.add_component<BoxCollider>(Vector2{0, screen_size_height/2+world_collider/2}, world_collider, world_collider); // Bottom
-		world.add_component<BoxCollider>(Vector2{0-(screen_size_width/2+world_collider/2), 0}, world_collider, world_collider); // Left
-		world.add_component<BoxCollider>(Vector2{screen_size_width/2+world_collider/2, 0}, world_collider, world_collider); // right
-	}
+		// Create a box with an inner size of 10x10 units
+		world.add_component<BoxCollider>(Vector2{5, 11}, 10, 2); // Top
+		world.add_component<BoxCollider>(Vector2{5, -1}, 10, 2); // Bottom
+		world.add_component<BoxCollider>(Vector2{-1, 5}, 2, 10); // Left
+		world.add_component<BoxCollider>(Vector2{11, 5}, 2, 10); // right
 
-	void create_test_components()
-	{
-		ComponentManager & mgr = this->component_manager;
-		GameObject game_object1 = mgr.new_object("Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
 		game_object1.add_component<Rigidbody>(Rigidbody::Data{
-		.mass = 1,
-		.gravity_scale = 0.01,
-		.body_type = Rigidbody::BodyType::DYNAMIC,
-		.linear_velocity = {1,0},
-		.constraints = {0, 0, 0},
-		.use_gravity = true,
-		.bounce = true,
-		.elastisity = 1,
-		.offset = {0,0},
+			.mass = 1,
+			.gravity_scale = 0.01,
+			.body_type = Rigidbody::BodyType::DYNAMIC,
+			.linear_velocity = {1,0},
+			.constraints = {0, 0, 0},
+			.use_gravity = true,
+			.bounce = true,
+			.elastisity = 1,
+			.offset = {0,0},
 		});
 		game_object1.add_component<BoxCollider>(Vector2{0, 0}, 20, 20);
-		game_object1.add_component<BehaviorScript>().set_script<UnitTestBoxBoxCollision1>();
-
+		BehaviorScript & script_object1 = game_object1.add_component<BehaviorScript>().set_script<CollisionHandler>(1);
+		script_object1_ref = script_object1.script.get();
+		ASSERT_NE(script_object1_ref, nullptr);
 		
-		GameObject game_object2 = mgr.new_object("Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2-100}, 0, 1);
 		game_object2.add_component<Rigidbody>(Rigidbody::Data{
-		.mass = 1,
-		.gravity_scale = 0.01,
-		.body_type = Rigidbody::BodyType::DYNAMIC,
-		.linear_velocity = {1,0},
-		.constraints = {0, 0, 0},
-		.use_gravity = true,
-		.bounce = true,
-		.elastisity = 1,
-		.offset = {0,0},
+			.mass = 1,
+			.gravity_scale = 0.01,
+			.body_type = Rigidbody::BodyType::DYNAMIC,
+			.linear_velocity = {1,0},
+			.constraints = {0, 0, 0},
+			.use_gravity = true,
+			.bounce = true,
+			.elastisity = 1,
+			.offset = {0,0},
 		});
 		game_object2.add_component<BoxCollider>(Vector2{0, 0}, 20, 20);
-		game_object2.add_component<BehaviorScript>().set_script<UnitTestBoxBoxCollision2>();
-	}
-
-	void reset_test_components()
-	{
-		ComponentManager & mgr = this->component_manager;
-		//game object 1
-		{
-			game_object_id_t id = 1;
-			Transform & tf = mgr.get_components_by_id<Transform>(id).front().get();
-			tf.position = Vector2{screen_size_width/2, screen_size_height/2};
-			tf.rotation = 0;
-			tf.scale = 1;
-			tf.active = 1;
-			Rigidbody & rg = mgr.get_components_by_id<Rigidbody>(id).front().get();
-			rg.data.angular_damping = 0;
-			rg.data.angular_velocity = 0;
-			rg.data.max_angular_velocity = 100;
-			rg.data.linear_velocity = {0,0};
-			rg.data.linear_damping = {0,0};
-			rg.data.max_linear_velocity = {100,100};
-			rg.data.bounce = false;
-			rg.data.elastisity = 0;
-			rg.data.offset = {0,0};
-			rg.data.constraints = {0,0,0};
-		}
+		BehaviorScript & script_object2 = game_object2.add_component<BehaviorScript>().set_script<CollisionHandler>(2);
+		script_object2_ref = script_object2.script.get();
+		ASSERT_NE(script_object2_ref, nullptr);
 
-		{
-			game_object_id_t id = 2;
-			Transform & tf = mgr.get_components_by_id<Transform>(id).front().get();
-			tf.position = Vector2{screen_size_width/2, screen_size_height/2-100};
-			tf.rotation = 0;
-			tf.scale = 1;
-			tf.active = 1;
-			Rigidbody & rg = mgr.get_components_by_id<Rigidbody>(id).front().get();
-			rg.data.angular_damping = 0;
-			rg.data.angular_velocity = 0;
-			rg.data.max_angular_velocity = 100;
-			rg.data.linear_velocity = {0,0};
-			rg.data.linear_damping = {0,0};
-			rg.data.max_linear_velocity = {100,100};
-			rg.data.bounce = false;
-			rg.data.elastisity = 0;
-			rg.data.offset = {0,0};
-			rg.data.constraints = {0,0,0};
-		}
+		// Ensure Script::init() is called on all BehaviorScript instances
+		script_sys.update();
 	}
 };
 
 TEST_F(CollisionTest, collision_example) {
-	// change object data before calling update
-
-	// call collision system update
-	system.update();
+	collision_sys.update();
 	// should be nullptr after update with no collision
 	//ASSERT_EQ(MyScriptCollider1::last_collision_info_1, nullptr);
 	//ASSERT_EQ(MyScriptCollider2::last_collision_info_2, nullptr);
@@ -186,11 +124,9 @@ TEST_F(CollisionTest, collision_example) {
 
 TEST_F(CollisionTest, collision_box_box_dynamic) {
 	// change object data before calling update
-	ComponentManager & mgr = this->component_manager;
-	Transform & test = mgr.get_components_by_id<Transform>(2).front().get();
-	test.position = {screen_size_width/2,screen_size_height/2};
-	// call collision system update
-	system.update();
+	Transform & test = mgr.get_components_by_id<Transform>(game_object1.id).front().get();
+	// call collision collision_sys update
+	collision_sys.update();
 	// should be nullptr after update with no collision
 	// ASSERT_NE(MyScriptCollider1::last_collision_info_1, nullptr);
 	// ASSERT_NE(MyScriptCollider2::last_collision_info_2, nullptr);
diff --git a/src/test/main.cpp b/src/test/main.cpp
index 241015d..f792239 100644
--- a/src/test/main.cpp
+++ b/src/test/main.cpp
@@ -9,7 +9,7 @@ int main(int argc, char ** argv) {
 	InitGoogleTest(&argc, argv);
 
 	auto & cfg = Config::get_instance();
-	cfg.log.level = Log::Level::ERROR;
+	cfg.log.level = Log::Level::INFO;
 
 	return RUN_ALL_TESTS();
 }
-- 
cgit v1.2.3


From 3f63143b4005936da446fb2cdbbd1072b47fc8c1 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Fri, 22 Nov 2024 15:36:14 +0100
Subject: merge with master

---
 src/crepe/Collider.cpp               |  2 +-
 src/crepe/Collider.h                 |  5 ++-
 src/crepe/api/BoxCollider.cpp        |  2 +-
 src/crepe/api/BoxCollider.h          |  2 +-
 src/crepe/api/CircleCollider.cpp     |  2 +-
 src/crepe/api/CircleCollider.h       |  2 +-
 src/crepe/api/LoopManager.cpp        |  1 +
 src/crepe/api/Rigidbody.h            |  2 +-
 src/crepe/system/CollisionSystem.cpp | 79 ++++++++++++++++++------------------
 src/crepe/system/CollisionSystem.h   |  8 ++--
 src/example/CMakeLists.txt           |  1 +
 src/example/game.cpp                 | 30 +++++++-------
 12 files changed, 71 insertions(+), 65 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/Collider.cpp b/src/crepe/Collider.cpp
index 0706371..80a944d 100644
--- a/src/crepe/Collider.cpp
+++ b/src/crepe/Collider.cpp
@@ -2,4 +2,4 @@
 
 using namespace crepe;
 
-Collider::Collider(game_object_id_t id, Vector2 offset) : Component(id), offset(offset) {}
+Collider::Collider(game_object_id_t id, vec2 offset) : Component(id), offset(offset) {}
diff --git a/src/crepe/Collider.h b/src/crepe/Collider.h
index 0157324..5b26af5 100644
--- a/src/crepe/Collider.h
+++ b/src/crepe/Collider.h
@@ -3,16 +3,17 @@
 #include "api/Vector2.h"
 
 #include "Component.h"
+#include "types.h"
 
 namespace crepe {
 
 class Collider : public Component {
 public:
-	Collider(game_object_id_t id, Vector2 offset);
+	Collider(game_object_id_t id, vec2 offset);
 
 public:
 	//! Offset of the collider relative to rigidbody position 
-	Vector2 offset;
+	vec2 offset;
 };
 
 } // namespace crepe
diff --git a/src/crepe/api/BoxCollider.cpp b/src/crepe/api/BoxCollider.cpp
index eafbdb2..83fb632 100644
--- a/src/crepe/api/BoxCollider.cpp
+++ b/src/crepe/api/BoxCollider.cpp
@@ -4,4 +4,4 @@
 using namespace crepe;
 
 
-BoxCollider::BoxCollider(game_object_id_t game_object_id,Vector2 offset, double width, double height) : Collider(game_object_id,offset), width(width), height(height) {}
+BoxCollider::BoxCollider(game_object_id_t game_object_id,vec2 offset, double width, double height) : Collider(game_object_id,offset), width(width), height(height) {}
diff --git a/src/crepe/api/BoxCollider.h b/src/crepe/api/BoxCollider.h
index 7f51cba..6135954 100644
--- a/src/crepe/api/BoxCollider.h
+++ b/src/crepe/api/BoxCollider.h
@@ -12,7 +12,7 @@ namespace crepe {
  */
 class BoxCollider : public Collider {
 public:
-	BoxCollider(game_object_id_t game_object_id,Vector2 offset, double width, double height);
+	BoxCollider(game_object_id_t game_object_id,vec2 offset, double width, double height);
 
 	//! Width of box collider 
 	double width;
diff --git a/src/crepe/api/CircleCollider.cpp b/src/crepe/api/CircleCollider.cpp
index 04a4995..43de991 100644
--- a/src/crepe/api/CircleCollider.cpp
+++ b/src/crepe/api/CircleCollider.cpp
@@ -3,4 +3,4 @@
 using namespace crepe;
 
 
-CircleCollider::CircleCollider(game_object_id_t game_object_id,Vector2 offset, int radius) : Collider(game_object_id,offset), radius(radius) {}
+CircleCollider::CircleCollider(game_object_id_t game_object_id,vec2 offset, int radius) : Collider(game_object_id,offset), radius(radius) {}
diff --git a/src/crepe/api/CircleCollider.h b/src/crepe/api/CircleCollider.h
index 4e04fa4..843547f 100644
--- a/src/crepe/api/CircleCollider.h
+++ b/src/crepe/api/CircleCollider.h
@@ -14,7 +14,7 @@ namespace crepe {
 class CircleCollider : public Collider {
 public:
 
-	CircleCollider(game_object_id_t game_object_id,Vector2 offset, int radius);
+	CircleCollider(game_object_id_t game_object_id,vec2 offset, int radius);
 
 	//! Radius of the circle collider.
 	double radius;
diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index 586919d..10b59c8 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -63,6 +63,7 @@ void LoopManager::setup() {
 	this->game_running = true;
 	LoopTimer::get_instance().start();
 	LoopTimer::get_instance().set_fps(60);
+	this->scene_manager.load_next_scene();
 }
 
 void LoopManager::render() {
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index b96b463..7939563 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -78,7 +78,7 @@ public:
 		//! bounce factor of material
 		double elastisity = 0.0;
 		//! offset of all colliders relative to transform position
-		Vector2 offset;
+		vec2 offset;
 	};
 
 public:
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 9ca8b3a..8d9b356 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -15,6 +15,7 @@
 #include "ComponentManager.h"
 #include "CollisionSystem.h"
 #include "Collider.h"
+#include "types.h"
 
 using namespace crepe;
 
@@ -39,7 +40,7 @@ void CollisionSystem::collision_handler(CollidedInfoStor& data1,CollidedInfoStor
 	// Data needed for collision handler info
 	const Collider* collider1 = nullptr;
 	const Collider* collider2 = nullptr;
-	Vector2 move_back;
+	vec2 move_back;
 
 	// Check collision type and get values for handler
 	if (std::holds_alternative<std::reference_wrapper<BoxCollider>>(data1.collider)) {
@@ -53,8 +54,8 @@ void CollisionSystem::collision_handler(CollidedInfoStor& data1,CollidedInfoStor
 
 			// TODO: send with the collider info to this function because this is calculated previously
 			// Get the current position of the collider
-			Vector2 final_position1 = current_position(box_collider1,data1.transform,data1.rigidbody);
-			Vector2 final_position2 = current_position(box_collider2,data2.transform,data2.rigidbody);
+			vec2 final_position1 = current_position(box_collider1,data1.transform,data1.rigidbody);
+			vec2 final_position2 = current_position(box_collider2,data2.transform,data2.rigidbody);
 
 			// Determine move_back value for smallest overlap (x or y)
 			move_back = box_box_collision_move_back(box_collider1,box_collider2,final_position1,final_position2);
@@ -112,20 +113,20 @@ void CollisionSystem::collision_handler(CollidedInfoStor& data1,CollidedInfoStor
 }
 
 
-Vector2 CollisionSystem::box_box_collision_move_back(const BoxCollider& box_collider1,const BoxCollider& box_collider2,Vector2 final_position1,Vector2 final_position2)
+vec2 CollisionSystem::box_box_collision_move_back(const BoxCollider& box_collider1,const BoxCollider& box_collider2,vec2 final_position1,vec2 final_position2)
 {
-	Vector2 resolution; // Default resolution vector
-	Vector2 delta = final_position2 - final_position1;
+	vec2 resolution; // Default resolution vector
+	vec2 delta = final_position2 - final_position1;
 
 	// Compute half-dimensions of the boxes
-	double half_width1 = box_collider1.width / 2.0;
-	double half_height1 = box_collider1.height / 2.0;
-	double half_width2 = box_collider2.width / 2.0;
-	double half_height2 = box_collider2.height / 2.0;
+	float half_width1 = box_collider1.width / 2.0;
+	float half_height1 = box_collider1.height / 2.0;
+	float half_width2 = box_collider2.width / 2.0;
+	float half_height2 = box_collider2.height / 2.0;
 
 	// Calculate overlaps along X and Y axes
-	double overlap_x = (half_width1 + half_width2) - std::abs(delta.x);
-	double overlap_y = (half_height1 + half_height2) - std::abs(delta.y);
+	float overlap_x = (half_width1 + half_width2) - std::abs(delta.x);
+	float overlap_y = (half_height1 + half_height2) - std::abs(delta.y);
 
 	// Check if there is a collision
 	if (overlap_x > 0 && overlap_y > 0) {//should always be true check if this can be removed
@@ -288,14 +289,14 @@ std::vector<std::pair<CollisionSystem::CollidedInfoStor,CollisionSystem::Collide
 bool CollisionSystem::check_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2)
 {
 	// Get current positions of colliders
-	Vector2 final_position1 = current_position(box1,transform1,rigidbody1);
-	Vector2 final_position2 = current_position(box2,transform2,rigidbody2);
+	vec2 final_position1 = current_position(box1,transform1,rigidbody1);
+	vec2 final_position2 = current_position(box2,transform2,rigidbody2);
 
 	// Calculate half-extents (half width and half height)
-	double half_width1 = box1.width / 2.0;
-	double half_height1 = box1.height / 2.0;
-	double half_width2 = box2.width / 2.0;
-	double half_height2 = box2.height / 2.0;
+	float half_width1 = box1.width / 2.0;
+	float half_height1 = box1.height / 2.0;
+	float half_width2 = box2.width / 2.0;
+	float half_height2 = box2.height / 2.0;
 
 	// Check if the boxes overlap along the X and Y axes
 	return !(final_position1.x + half_width1 <= final_position2.x - half_width2 ||  // box1 is left of box2
@@ -306,21 +307,21 @@ bool CollisionSystem::check_box_box_collision(const BoxCollider& box1, const Box
 
 bool CollisionSystem::check_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) {
 	// Get current positions of colliders
-	Vector2 final_position1 = current_position(box1, transform1, rigidbody1);
-	Vector2 final_position2 = current_position(circle2, transform2, rigidbody2);
+	vec2 final_position1 = current_position(box1, transform1, rigidbody1);
+	vec2 final_position2 = current_position(circle2, transform2, rigidbody2);
 
 	// Calculate box half-extents
-	double half_width = box1.width / 2.0;
-	double half_height = box1.height / 2.0;
+	float half_width = box1.width / 2.0;
+	float half_height = box1.height / 2.0;
 
 	// Find the closest point on the box to the circle's center
-	double closest_x = std::max(final_position1.x - half_width, std::min(final_position2.x, final_position1.x + half_width));
-	double closest_y = std::max(final_position1.y - half_height, std::min(final_position2.y, final_position1.y + half_height));
+	float closest_x = std::max(final_position1.x - half_width, std::min(final_position2.x, final_position1.x + half_width));
+	float closest_y = std::max(final_position1.y - half_height, std::min(final_position2.y, final_position1.y + half_height));
 
 	// Calculate the distance squared between the circle's center and the closest point on the box
-	double distance_x = final_position2.x - closest_x;
-	double distance_y = final_position2.y - closest_y;
-	double distance_squared = distance_x * distance_x + distance_y * distance_y;
+	float distance_x = final_position2.x - closest_x;
+	float distance_y = final_position2.y - closest_y;
+	float distance_squared = distance_x * distance_x + distance_y * distance_y;
 
 	// Compare distance squared with the square of the circle's radius
 	return distance_squared <= circle2.radius * circle2.radius;
@@ -328,32 +329,32 @@ bool CollisionSystem::check_box_circle_collision(const BoxCollider& box1, const
 
 bool CollisionSystem::check_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) {
 	// Get current positions of colliders
-	Vector2 final_position1 = current_position(circle1,transform1,rigidbody1);
-	Vector2 final_position2 = current_position(circle2,transform2,rigidbody2);
+	vec2 final_position1 = current_position(circle1,transform1,rigidbody1);
+	vec2 final_position2 = current_position(circle2,transform2,rigidbody2);
 
-	double distance_x = final_position1.x - final_position2.x;
-	double distance_y = final_position1.y - final_position2.y;
-	double distance_squared = distance_x * distance_x + distance_y * distance_y;
+	float distance_x = final_position1.x - final_position2.x;
+	float distance_y = final_position1.y - final_position2.y;
+	float distance_squared = distance_x * distance_x + distance_y * distance_y;
 
 	// Calculate the sum of the radii
-	double radius_sum = circle1.radius + circle2.radius;
+	float radius_sum = circle1.radius + circle2.radius;
 
 	// Check if the distance between the centers is less than or equal to the sum of the radii
 	return distance_squared <= radius_sum * radius_sum;
 }
 
-Vector2 CollisionSystem::current_position(const Collider& collider, const Transform& transform, const Rigidbody& rigidbody) {
+vec2 CollisionSystem::current_position(const Collider& collider, const Transform& transform, const Rigidbody& rigidbody) {
 	// Get the rotation in radians
-	double radians1 = transform.rotation * (M_PI / 180.0);
+	float radians1 = transform.rotation * (M_PI / 180.0);
 
 	// Calculate total offset with scale
-	Vector2 total_offset = (rigidbody.data.offset + collider.offset) * transform.scale;
+	vec2 total_offset = (rigidbody.data.offset + collider.offset) * transform.scale;
 
 	// Rotate
-	double rotated_total_offset_x1 = total_offset.x * cos(radians1) - total_offset.y * sin(radians1);
-	double rotated_total_offset_y1 = total_offset.x * sin(radians1) + total_offset.y * cos(radians1);
+	float rotated_total_offset_x1 = total_offset.x * cos(radians1) - total_offset.y * sin(radians1);
+	float rotated_total_offset_y1 = total_offset.x * sin(radians1) + total_offset.y * cos(radians1);
 
 	// Final positions considering scaling and rotation
-	return(transform.position + Vector2(rotated_total_offset_x1, rotated_total_offset_y1));
+	return(transform.position + vec2(rotated_total_offset_x1, rotated_total_offset_y1));
 
 }
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 69d1d23..44fff4e 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -65,7 +65,7 @@ public:
 	struct CollisionInfo{
     ColliderInfo first;
     ColliderInfo second;
-		Vector2 move_back_value;
+		vec2 move_back_value;
 		Direction move_back_direction = Direction::NONE;
 	};
 
@@ -98,7 +98,7 @@ private:
 		* \param final_position2 The final position of the second box collider.
 		* \return The move-back vector to resolve the collision.
 		*/
-	Vector2 box_box_collision_move_back(const BoxCollider& box_collider1,const BoxCollider& box_collider2,Vector2 position1,Vector2 position2);
+	vec2 box_box_collision_move_back(const BoxCollider& box_collider1,const BoxCollider& box_collider2,vec2 position1,vec2 position2);
 
 	/**
 		* \brief Determines the appropriate collision handler based on the rigidbody types of the colliding objects.
@@ -185,9 +185,9 @@ private: //detection
 		* \param collider The collider whose position is being determined.
 		* \param transform The transform component associated with the collider.
 		* \param rigidbody The rigidbody component associated with the collider.
-		* \return The current position of the collider as a Vector2.
+		* \return The current position of the collider as a vec2.
 		*/
-	Vector2 current_position(const Collider& collider, const Transform& transform, const Rigidbody& rigidbody);
+	vec2 current_position(const Collider& collider, const Transform& transform, const Rigidbody& rigidbody);
 };
 
 } // namespace crepe
diff --git a/src/example/CMakeLists.txt b/src/example/CMakeLists.txt
index 560e2bc..3ec5e43 100644
--- a/src/example/CMakeLists.txt
+++ b/src/example/CMakeLists.txt
@@ -20,4 +20,5 @@ add_example(asset_manager)
 add_example(savemgr)
 add_example(rendering_particle)
 add_example(gameloop)
+add_example(game)
 
diff --git a/src/example/game.cpp b/src/example/game.cpp
index a557be7..f6b580a 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -18,17 +18,18 @@ using namespace std;
 
 class MyScript : public Script {
 	static bool oncollision(const CollisionEvent& test) {
-		std::cout << "test collision: " << test.info.first.collider.game_object_id << std::endl;
+		Log::logf("Box {} script on_collision()", test.info.first.collider.game_object_id);
 		return true;
 	}
 	void init() {
-		EventManager::get_instance().subscribe<CollisionEvent>(oncollision, this->get_game_object_id());
+		EventManager::get_instance().subscribe<CollisionEvent>(oncollision, 0);
 	}
 	void update() {
 		// Retrieve component from the same GameObject this script is on
 	}
 };
 
+
 class ConcreteScene1 : public Scene {
 public:
 	using Scene::Scene;
@@ -37,11 +38,11 @@ public:
 	ComponentManager & mgr = this->component_manager;
 	Color color(0, 0, 0, 0);
 
-	double screen_size_width = 640;
-	double screen_size_height = 480;
-	double world_collider = 1000;
+	float screen_size_width = 640;
+	float screen_size_height = 480;
+	float world_collider = 1000;
 	//define playable world 
-	GameObject world = mgr.new_object("Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
+	GameObject world = mgr.new_object("Name", "Tag", vec2{screen_size_width/2, screen_size_height/2}, 0, 1);
 	world.add_component<Rigidbody>(Rigidbody::Data{
 		.mass = 0,
 		.gravity_scale = 0,
@@ -51,13 +52,13 @@ public:
 		.bounce = false,
 		.offset = {0,0}
 	});
-	world.add_component<BoxCollider>(Vector2{0, 0-(screen_size_height/2+world_collider/2)}, world_collider, world_collider);;	// Top
-	world.add_component<BoxCollider>(Vector2{0, screen_size_height/2+world_collider/2}, world_collider, world_collider); // Bottom
-	world.add_component<BoxCollider>(Vector2{0-(screen_size_width/2+world_collider/2), 0}, world_collider, world_collider); // Left
-	world.add_component<BoxCollider>(Vector2{screen_size_width/2+world_collider/2, 0}, world_collider, world_collider); // right
+	world.add_component<BoxCollider>(vec2{0, 0-(screen_size_height/2+world_collider/2)}, world_collider, world_collider);;	// Top
+	world.add_component<BoxCollider>(vec2{0, screen_size_height/2+world_collider/2}, world_collider, world_collider); // Bottom
+	world.add_component<BoxCollider>(vec2{0-(screen_size_width/2+world_collider/2), 0}, world_collider, world_collider); // Left
+	world.add_component<BoxCollider>(vec2{screen_size_width/2+world_collider/2, 0}, world_collider, world_collider); // right
 
 
-	GameObject game_object1 = mgr.new_object("Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
+	GameObject game_object1 = mgr.new_object("Name", "Tag", vec2{screen_size_width/2, screen_size_height/2}, 0, 1);
 	game_object1.add_component<Rigidbody>(Rigidbody::Data{
 		.mass = 1,
 		.gravity_scale = 0.01,
@@ -69,20 +70,21 @@ public:
 		.elastisity = 1,
 		.offset = {0,0},
 	});
-	game_object1.add_component<BoxCollider>(Vector2{0, 0}, 20, 20);
+	game_object1.add_component<BoxCollider>(vec2{0, 0}, 20, 20);
 	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
 	game_object1.add_component<Sprite>(
 	make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
 	FlipSettings{true, true});
 	game_object1.add_component<Camera>(Color::WHITE);
 	}
+
+	string get_name() const { return "scene1"; }
 };
 
 int main(int argc, char * argv[]) {
 
 	LoopManager gameloop;
-	gameloop.scene_manager.add_scene<ConcreteScene1>("scene1");
-	gameloop.scene_manager.load_next_scene();
+	gameloop.add_scene<ConcreteScene1>();
 	gameloop.start();
 	return 0;
 }
-- 
cgit v1.2.3


From bcf57e81f68913049f84cabb66871931c8f47b2b Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Fri, 22 Nov 2024 16:11:39 +0100
Subject: script fix

---
 src/crepe/api/Config.h        | 2 +-
 src/crepe/api/LoopManager.cpp | 1 +
 src/example/game.cpp          | 6 ++++--
 src/test/CollisionTest.cpp    | 7 +++----
 4 files changed, 9 insertions(+), 7 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Config.h b/src/crepe/api/Config.h
index 13eabd1..b6c2ccf 100644
--- a/src/crepe/api/Config.h
+++ b/src/crepe/api/Config.h
@@ -33,7 +33,7 @@ public:
 		 *
 		 * Only messages with equal or higher priority than this value will be logged.
 		 */
-		Log::Level level = Log::Level::INFO;
+		Log::Level level = Log::Level::DEBUG;
 		/**
 		 * \brief Colored log output
 		 *
diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index 10b59c8..ff8b90e 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -35,6 +35,7 @@ void LoopManager::start() {
 void LoopManager::set_running(bool running) { this->game_running = running; }
 
 void LoopManager::fixed_update() {
+	this->get_system<ScriptSystem>().update();
 	this->get_system<PhysicsSystem>().update();
 	this->get_system<CollisionSystem>().update();
 }
diff --git a/src/example/game.cpp b/src/example/game.cpp
index f6b580a..991d2ec 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -17,12 +17,14 @@ using namespace crepe;
 using namespace std;
 
 class MyScript : public Script {
-	static bool oncollision(const CollisionEvent& test) {
+	bool oncollision(const CollisionEvent& test) {
 		Log::logf("Box {} script on_collision()", test.info.first.collider.game_object_id);
 		return true;
 	}
 	void init() {
-		EventManager::get_instance().subscribe<CollisionEvent>(oncollision, 0);
+		subscribe<CollisionEvent>([this](const CollisionEvent& ev) -> bool {
+			return this->oncollision(ev);
+		});
 	}
 	void update() {
 		// Retrieve component from the same GameObject this script is on
diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp
index c175eb4..bbf6348 100644
--- a/src/test/CollisionTest.cpp
+++ b/src/test/CollisionTest.cpp
@@ -25,7 +25,6 @@ using namespace testing;
 class CollisionHandler : public Script {
 public:
 	int box_id;
-	EventManager & evmgr = EventManager::get_instance();
 	function<void(const CollisionEvent& ev)> test_fn = [](const CollisionEvent & ev) { };
 
 	CollisionHandler(int box_id) {
@@ -42,9 +41,9 @@ public:
 		//Log::logf("Box {} script init()", box_id);
 
 		// TODO: this should be built into script
-		evmgr.subscribe<CollisionEvent>([this](const CollisionEvent & ev) {
-			return this->on_collision(ev);
-		}, this->get_game_object_id());
+		subscribe<CollisionEvent>([](const CollisionEvent&) -> bool {
+			return true;
+		});	
 	}
 };
 
-- 
cgit v1.2.3


From cec167477de8afcb53c2f0b18c3453e1599eb980 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Sat, 23 Nov 2024 19:52:15 +0100
Subject: Fixing PR

---
 src/crepe/api/BehaviorScript.hpp  | 1 +
 src/crepe/api/Config.h            | 2 +-
 src/crepe/system/RenderSystem.cpp | 2 --
 src/test/main.cpp                 | 2 +-
 4 files changed, 3 insertions(+), 4 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/BehaviorScript.hpp b/src/crepe/api/BehaviorScript.hpp
index 484c318..2e2def3 100644
--- a/src/crepe/api/BehaviorScript.hpp
+++ b/src/crepe/api/BehaviorScript.hpp
@@ -14,6 +14,7 @@ BehaviorScript & BehaviorScript::set_script(Args &&... args) {
 	dbg_trace();
 	static_assert(std::is_base_of<Script, T>::value);
 	Script * s = new T(std::forward<Args>(args)...);
+	
 	s->game_object_id = this->game_object_id;
 	s->active = this->active;
 	s->component_manager = this->component_manager;
diff --git a/src/crepe/api/Config.h b/src/crepe/api/Config.h
index b6c2ccf..13eabd1 100644
--- a/src/crepe/api/Config.h
+++ b/src/crepe/api/Config.h
@@ -33,7 +33,7 @@ public:
 		 *
 		 * Only messages with equal or higher priority than this value will be logged.
 		 */
-		Log::Level level = Log::Level::DEBUG;
+		Log::Level level = Log::Level::INFO;
 		/**
 		 * \brief Colored log output
 		 *
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index 8f9467e..ad510f5 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -28,8 +28,6 @@ void RenderSystem::update_camera() {
 
 	if (cameras.size() == 0) throw std::runtime_error("No cameras in current scene");
 
-	if (cameras.size() == 0) throw std::runtime_error("No cameras in current scene");
-
 	for (Camera & cam : cameras) {
 		if (!cam.active) continue;
 		this->context.set_camera(cam);
diff --git a/src/test/main.cpp b/src/test/main.cpp
index f792239..241015d 100644
--- a/src/test/main.cpp
+++ b/src/test/main.cpp
@@ -9,7 +9,7 @@ int main(int argc, char ** argv) {
 	InitGoogleTest(&argc, argv);
 
 	auto & cfg = Config::get_instance();
-	cfg.log.level = Log::Level::INFO;
+	cfg.log.level = Log::Level::ERROR;
 
 	return RUN_ALL_TESTS();
 }
-- 
cgit v1.2.3


From da3b2b032b50c6b1e1cb00aba96c0d46da5be6d4 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Sat, 23 Nov 2024 20:55:46 +0100
Subject: added doxygen comments

---
 src/crepe/api/BehaviorScript.hpp   |   2 +-
 src/crepe/system/CollisionSystem.h | 138 +++++++++++++++++++++++++++++++++++--
 2 files changed, 134 insertions(+), 6 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/BehaviorScript.hpp b/src/crepe/api/BehaviorScript.hpp
index 2e2def3..bd59337 100644
--- a/src/crepe/api/BehaviorScript.hpp
+++ b/src/crepe/api/BehaviorScript.hpp
@@ -14,7 +14,7 @@ BehaviorScript & BehaviorScript::set_script(Args &&... args) {
 	dbg_trace();
 	static_assert(std::is_base_of<Script, T>::value);
 	Script * s = new T(std::forward<Args>(args)...);
-	
+
 	s->game_object_id = this->game_object_id;
 	s->active = this->active;
 	s->component_manager = this->component_manager;
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 80f8818..6334ba1 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -33,7 +33,6 @@ private:
     CIRCLE_BOX,
 	};
 
-
 	/**
 		* \brief A structure to store the collision data of a single collider.
 		* 
@@ -54,8 +53,6 @@ private:
     BOTH
 	};
 
-
-
 public:
 	/**
 		* \brief A structure representing the collision information between two colliders.
@@ -85,33 +82,164 @@ public:
 	//! Updates the collision system by checking for collisions between colliders and handling them.
 	void update() override;
 private: //generic
+
+	/**
+	 * \brief Returns a type of the colliders combined into a pair.
+	 * 
+	 * This function uses the holds_alternative to determine what both colliders are.
+	 * This caluclated value is returned so get can be savely used.
+	 *
+	 * \param collider1 Variant of collider. Can be a box or circle collider
+	 * \param collider2 Variant of collider. Can be a box or circle collider
+	 *
+	 * \return collider pair type.
+	 */
 	ColliderStorType check_collider_type(const collider_stor& collider1,const collider_stor& collider2);
 
+	/**
+	 * \brief Calculates the position of the Collider
+	 * 
+	 * Using the \c Collider offset, \c Transform position and \c Rigidbody offset the place of the collider is calculated.
+	 *
+	 * \param collider_offset Collider offset value.
+	 * \param transform Transform of same gameobject as collider.
+	 * \param rigidbody Rigidbody of same gameobject as collider. 
+	 *
+	 * \return Postion of collider.
+	 */
 	vec2 current_position(vec2 collider_offset, const Transform& transform, const Rigidbody& rigidbody);
 
 private:// handeling
 
+	/**
+	 * \brief Calculates the position of the Collider
+	 * 
+	 * Using the \c Collider offset, \c Transform position and \c Rigidbody offset the place of the collider is calculated.
+	 *
+	 * \param collider_offset Collider offset value.
+	 * \param transform Transform of same gameobject as collider.
+	 * \param rigidbody Rigidbody of same gameobject as collider. 
+	 *
+	 * \return Postion of collider.
+	 */
 	void collision_handler_request(CollidedInfoStor& data1,CollidedInfoStor& data2);
 
+	/**
+	 * \brief Calculates the move back value and direction of the Collision
+	 * 
+	 * Uses data from both gameobjects to calculate the value of the gameobject to move out of other collider. 
+	 *
+	 * \param data1 Has data about the first gameobject of the collision
+	 * \param data2 Has data about the second gameobject of the collision
+	 * \param type Type of collider pair used for variant
+	 *
+	 * \return Move back value and direction for first gameobject
+	 */
 	std::pair<vec2,Direction> collision_handler(CollidedInfoStor& data1,CollidedInfoStor& data2 ,ColliderStorType type);
 
-
-	
+	/**
+	 * \brief Calculates the move back value for box box collision
+	 * 
+	 * Uses both collider and positions to calculate move back value 
+	 *
+	 * \param box_collider1 First boxcollider of collision
+	 * \param box_collider2 Second boxcollider of collision
+	 * \param position1 Position of first boxcollider
+	 * \param position2 Position of second boxcollider
+	 *
+	 * \return Move back value and direction for first gameobject
+	 */
 	vec2 box_box_move_back(const BoxCollider& box_collider1,const BoxCollider& box_collider2,vec2 position1,vec2 position2);
 
+	/**
+	 * \brief Determines what collision handler is called
+	 * 
+	 * If the object is static is does nothing.
+	 * If the object is dynamic and collides with not static object it calls the script collision handeler.
+	 * If the object is dynamic and collides with static it handles it and calls the script collision handeler.
+	 *
+	 * \param info Collision info of both gameobjects
+	 */
 	void determine_collision_handler(CollisionInfo& info);
 
+	/**
+	 * \brief handles static collision
+	 * 
+	 * Moves the object back out of static gameobject.
+	 * If bounce is active change velocity.
+	 *
+	 * \param info Collision info of both gameobjects
+	 */
 	void static_collision_handler(CollisionInfo& info);
 private: // detection
 	
+	/**
+	 * \brief Checks if there is an collision between two colliders
+	 * 
+	 * Does not use the type of a collider to determine if there is collision.
+	 * uses variant with comment data to determine if even collision needs to be checked.
+	 *
+	 * \param colliders Holds all colliders
+	 *
+	 * \return Move back value and direction for first gameobject
+	 */
 	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> check_collisions(std::vector<collider_stor> & colliders);
 
+	/**
+	 * \brief Calls the correct check collision function.
+	 * 
+	 * Uses the type to check what colliders are used, converts the colliders and calls the check function.
+	 *
+	 * \param collider1 First collider
+	 * \param components1 Transform and rigidbody from first object
+	 * \param collider2 Second collider
+	 * \param components2 Transform and rigidbody from second object
+	 * \param type Type of collider pair
+	 *
+	 * \return status of collision
+	 */
 	bool check_collision(const collider_stor& collider1,std::pair<std::reference_wrapper<Transform>, std::reference_wrapper<Rigidbody>> components1,const collider_stor& collider2,std::pair<std::reference_wrapper<Transform>, std::reference_wrapper<Rigidbody>> components2,CollisionSystem::ColliderStorType type);
 	
+	/**
+	 * \brief Check collision for box on box collider
+	 *
+	 * \param box1 First collider
+	 * \param box2 Second collider
+	 * \param transform1 Transform of first object
+	 * \param transform2 Transform of second object
+	 * \param rigidbody1 Rigidbody of first object
+	 * \param rigidbody2 Rigidbody of second object
+	 *
+	 * \return status of collision
+	 */
 	bool check_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
 	
+	/**
+	 * \brief Check collision for box on circle collider
+	 *
+	 * \param box1 First collider
+	 * \param circle2 Second collider
+	 * \param transform1 Transform of first object
+	 * \param transform2 Transform of second object
+	 * \param rigidbody1 Rigidbody of first object
+	 * \param rigidbody2 Rigidbody of second object
+	 *
+	 * \return status of collision
+	 */
 	bool check_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
 
+	/**
+	 * \brief Check collision for circle on circle collider
+	 *
+	 * \param circle1 First collider
+	 * \param circle2 Second collider
+	 * \param transform1 Transform of first object
+	 * \param transform2 Transform of second object
+	 * \param rigidbody1 Rigidbody of first object
+	 * \param rigidbody2 Rigidbody of second object
+	 *
+	 * \return status of collision
+	 */
 	bool check_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
 };
 
-- 
cgit v1.2.3


From 7ae597ac9268e031927f94dd89c20ab6c034f5de Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Fri, 29 Nov 2024 21:20:48 +0100
Subject: working floating point black bars

---
 src/crepe/api/Config.h             |  2 +-
 src/crepe/api/Sprite.cpp           |  2 +-
 src/crepe/api/Sprite.h             |  4 +--
 src/crepe/facade/SDLContext.cpp    | 71 ++++++++++++++++++++++++--------------
 src/example/rendering_particle.cpp |  7 ++--
 5 files changed, 55 insertions(+), 31 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Config.h b/src/crepe/api/Config.h
index 225e9b9..200a3b0 100644
--- a/src/crepe/api/Config.h
+++ b/src/crepe/api/Config.h
@@ -67,7 +67,7 @@ public:
 	//! default window settings
 	struct {
 		//TODO make this constexpr because this will never change
-		ivec2 default_size = {1080, 720};
+		ivec2 default_size = {1280, 720};
 		std::string window_title = "Jetpack joyride clone";
 
 	} window_settings;
diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp
index 8647794..1d57b53 100644
--- a/src/crepe/api/Sprite.cpp
+++ b/src/crepe/api/Sprite.cpp
@@ -11,7 +11,7 @@ using namespace std;
 using namespace crepe;
 
 Sprite::Sprite(game_object_id_t id, Texture & image, const Color & color,
-			   const FlipSettings & flip, int sort_layer, int order_layer, int height)
+			   const FlipSettings & flip, int sort_layer, int order_layer, float height)
 	: Component(id),
 	  color(color),
 	  flip(flip),
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index a0e90a0..5a7a1d9 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -41,7 +41,7 @@ public:
 	 * \param height the height of the image in game units
 	 */
 	Sprite(game_object_id_t id, Texture & image, const Color & color,
-		   const FlipSettings & flip, int sort_layer, int order_layer, int height);
+		   const FlipSettings & flip, int sort_layer, int order_layer, float height);
 
 	/**
 	 * \brief Destroys the Sprite instance.
@@ -63,7 +63,7 @@ public:
 	const int order_in_layer;
 
 	//! height in world units
-	const int height;
+	const float height;
 
 	/**
 	 * \aspect_ratio ratio of the img so that scaling will not become weird
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 9f60285..56ba61a 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -8,6 +8,7 @@
 #include <cmath>
 #include <cstddef>
 #include <functional>
+#include <iostream>
 #include <memory>
 #include <stdexcept>
 
@@ -94,7 +95,7 @@ void SDLContext::handle_events(bool & running) {
 }
 
 void SDLContext::clear_screen() {
-	SDL_SetRenderDrawColor(this->game_renderer.get(), 0, 0, 0, 255);
+	SDL_SetRenderDrawColor(this->game_renderer.get(), 255, 255, 255, 255);
 	SDL_RenderClear(this->game_renderer.get());
 }
 void SDLContext::present_screen() { SDL_RenderPresent(this->game_renderer.get()); }
@@ -110,17 +111,19 @@ SDL_Rect SDLContext::get_src_rect(const Sprite & sprite) const {
 SDL_Rect SDLContext::get_dst_rect(const Sprite & sprite, const vec2 & pos, const Camera & cam,
 								  const vec2 & cam_pos, const double & img_scale) const {
 
-	int width = sprite.height * sprite.aspect_ratio;
-	int height = sprite.height;
+	double width = sprite.height * sprite.aspect_ratio;
+	double height = sprite.height;
 
 	width *= img_scale * cam.zoom;
 	height *= img_scale * cam.zoom;
 
 	return SDL_Rect{
-		.x = static_cast<int>((pos.x - cam_pos.x + (cam.viewport_size.x / 2) - width / 2)),
-		.y = static_cast<int>((pos.y - cam_pos.y + (cam.viewport_size.y / 2) - height / 2)),
-		.w = width,
-		.h = height,
+		.x
+		= static_cast<int>(round(pos.x - cam_pos.x + (cam.viewport_size.x / 2) - width / 2)),
+		.y
+		= static_cast<int>(round(pos.y - cam_pos.y + (cam.viewport_size.y / 2) - height / 2)),
+		.w = static_cast<int>(width),
+		.h = static_cast<int>(height),
 	};
 }
 
@@ -134,6 +137,8 @@ void SDLContext::draw(const RenderContext & ctx) {
 	SDL_Rect dstrect
 		= this->get_dst_rect(ctx.sprite, ctx.pos, ctx.cam, ctx.cam_pos, ctx.scale);
 
+	cout << dstrect.x << " " << dstrect.y << " " << dstrect.w << " " << dstrect.h << endl;
+
 	SDL_RenderCopyEx(this->game_renderer.get(), ctx.sprite.sprite_image.texture.get(),
 					 &srcrect, &dstrect, ctx.angle, NULL, render_flip);
 }
@@ -147,30 +152,44 @@ void SDLContext::set_camera(const Camera & cam) {
 		SDL_SetWindowSize(this->game_window.get(), cam.screen.x, cam.screen.y);
 	}
 
-	double screen_aspect = cam.screen.x / cam.screen.y;
+	double screen_aspect = static_cast<double>(cam.screen.x) / cam.screen.y;
 	double viewport_aspect = cam.viewport_size.x / cam.viewport_size.y;
 
-	SDL_Rect view;
+	cout << screen_aspect << " " << viewport_aspect << endl;
+	SDL_FRect black_bars[2];
 	// calculate black bars
 	if (screen_aspect > viewport_aspect) {
-		// letterboxing
-		view.h = cam.screen.y / cam.zoom;
-		view.w = cam.screen.y * viewport_aspect;
-		view.x = (cam.screen.x - view.w) / 2;
-		view.y = 0;
-	} else {
 		// pillarboxing
-		view.h = cam.screen.x / viewport_aspect;
-		view.w = cam.screen.x / cam.zoom;
-		view.x = 0;
-		view.y = (cam.screen.y - view.h) / 2;
+		cout << "pillarboxing" << endl;
+		float render_scale = cam.screen.y / cam.viewport_size.y;
+		float adj_width = cam.viewport_size.x * render_scale;
+		float bar_width = (cam.screen.x - adj_width) / 2;
+		black_bars[0] = {0, 0, bar_width, (float)cam.screen.y};
+		black_bars[1] = {(cam.screen.x - bar_width), 0, bar_width, (float)cam.screen.y};
+		cout << render_scale << " " << adj_width << " " << bar_width << " " << cam.screen.y
+			 << " " << cam.viewport_size.y << endl;
+	} else {
+		// letterboxing
+		cout << "letterboxing" << endl;
+		float render_scale = cam.screen.y / cam.viewport_size.y;
+		float adj_width = cam.viewport_size.x * render_scale;
+		float bar_height = (cam.screen.x - adj_width) / 2;
+		black_bars[0] = {0, 0, (float) cam.screen.x, bar_height};
+		black_bars[1] = {0, (cam.screen.y - bar_height), (float) cam.screen.x, bar_height};
+		cout << render_scale << " " << adj_width << " " << bar_height << " " << cam.screen.y
+			 << " " << cam.viewport_size.y << endl;
 	}
-	// set drawing area
-	SDL_RenderSetViewport(this->game_renderer.get(), &view);
 
-	SDL_RenderSetLogicalSize(this->game_renderer.get(), static_cast<int>(cam.viewport_size.x),
-							 static_cast<int>(cam.viewport_size.y));
+	for (int i = 0; i < 2; ++i) {
+		cout << black_bars[i].x << " " << black_bars[i].y << " " << black_bars[i].w << " "
+			 << black_bars[i].h << endl;
+	}
+
+	SDL_SetRenderDrawColor(this->game_renderer.get(), 0, 0, 0, 255);
+	SDL_RenderFillRectF(this->game_renderer.get(), &black_bars[0]);
+	SDL_RenderFillRectF(this->game_renderer.get(), &black_bars[1]);
 
+	/*
 	// set bg color
 	SDL_SetRenderDrawColor(this->game_renderer.get(), cam.bg_color.r, cam.bg_color.g,
 						   cam.bg_color.b, cam.bg_color.a);
@@ -178,11 +197,13 @@ void SDLContext::set_camera(const Camera & cam) {
 	SDL_Rect bg = {
 		.x = 0,
 		.y = 0,
-		.w = static_cast<int>(cam.viewport_size.x),
-		.h = static_cast<int>(cam.viewport_size.y),
+		.w = (int)cam.viewport_size.x,
+		.h = (int)cam.viewport_size.y,
 	};
 	// fill bg color
 	SDL_RenderFillRect(this->game_renderer.get(), &bg);
+
+	*/
 }
 
 uint64_t SDLContext::get_ticks() const { return SDL_GetTicks64(); }
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 3a12144..5896c81 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -31,12 +31,15 @@ int main(int argc, char * argv[]) {
 	Color color(255, 255, 255, 255);
 
 	auto img = Texture("asset/texture/test_ap43.png");
+
+	/*
 	Sprite & test_sprite = game_object.add_component<Sprite>(
 		img, color, Sprite::FlipSettings{true, true}, 1, 1, 500);
 
 	//game_object.add_component<Animator>(test_sprite, 4, 1, 0).active = true;
 	game_object.add_component<Animator>(test_sprite, 1, 1, 0).active = true;
 
+	*/
 	/*
 	auto & test = game_object.add_component<ParticleEmitter>(ParticleEmitter::Data{
 		.position = {0, 0},
@@ -59,8 +62,8 @@ int main(int argc, char * argv[]) {
 	});
 	*/
 
-	auto & cam = game_object.add_component<Camera>(Color::WHITE, ivec2{1080, 720},
-												   vec2{2000, 2000}, 1.0f);
+	auto & cam = game_object.add_component<Camera>(Color::WHITE, ivec2{1600, 900},
+												   vec2{800,800}, 1.0f);
 
 	/*
 	game_object
-- 
cgit v1.2.3


From 4159c7187e17d6318e33d8a0c014ba042ae8261b Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Sat, 30 Nov 2024 15:22:17 +0100
Subject: first version of new viewport floats without the use of sdl functions

---
 src/crepe/api/Sprite.h             |  2 +-
 src/crepe/facade/SDLContext.cpp    | 60 +++++++++++++++++++++++---------------
 src/crepe/facade/SDLContext.h      |  2 +-
 src/example/rendering_particle.cpp |  9 +++---
 4 files changed, 42 insertions(+), 31 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index 5a7a1d9..7d9c14b 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -71,7 +71,7 @@ public:
 	 * cannot be const because if Animator component is addded then ratio becomes scuffed and
 	 * does it need to be calculated again in the Animator
 	 */
-	double aspect_ratio;
+	float aspect_ratio;
 
 private:
 	//! Reads the mask of sprite
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 56ba61a..0ba1db4 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -108,22 +108,30 @@ SDL_Rect SDLContext::get_src_rect(const Sprite & sprite) const {
 		.h = sprite.mask.h,
 	};
 }
-SDL_Rect SDLContext::get_dst_rect(const Sprite & sprite, const vec2 & pos, const Camera & cam,
+
+vec2 bar_size;
+vec2 scale;
+
+SDL_FRect SDLContext::get_dst_rect(const Sprite & sprite, const vec2 & pos, const Camera & cam,
 								  const vec2 & cam_pos, const double & img_scale) const {
 
-	double width = sprite.height * sprite.aspect_ratio;
-	double height = sprite.height;
 
-	width *= img_scale * cam.zoom;
-	height *= img_scale * cam.zoom;
+	vec2 size = { (sprite.height * sprite.aspect_ratio), sprite.height};
+	
+	size *=  scale * img_scale * cam.zoom ;
 
-	return SDL_Rect{
-		.x
-		= static_cast<int>(round(pos.x - cam_pos.x + (cam.viewport_size.x / 2) - width / 2)),
-		.y
-		= static_cast<int>(round(pos.y - cam_pos.y + (cam.viewport_size.y / 2) - height / 2)),
-		.w = static_cast<int>(width),
-		.h = static_cast<int>(height),
+	vec2 screen_pos = (pos - cam_pos + cam.viewport_size / 2) * scale - size / 2 + bar_size;
+
+	cout << size.x << " " << size.y << endl;
+	cout << pos.x << " " << pos.y << endl;
+	cout << scale.x << " " << scale.y << endl;
+	cout << screen_pos.x << " " << screen_pos.y << endl;
+
+	return SDL_FRect{
+		.x = screen_pos.x,
+		.y = screen_pos.y,
+		.w = size.x,
+		.h = size.y,
 	};
 }
 
@@ -134,12 +142,12 @@ void SDLContext::draw(const RenderContext & ctx) {
 							  | (SDL_FLIP_VERTICAL * ctx.sprite.flip.flip_y));
 
 	SDL_Rect srcrect = this->get_src_rect(ctx.sprite);
-	SDL_Rect dstrect
+	SDL_FRect dstrect
 		= this->get_dst_rect(ctx.sprite, ctx.pos, ctx.cam, ctx.cam_pos, ctx.scale);
 
 	cout << dstrect.x << " " << dstrect.y << " " << dstrect.w << " " << dstrect.h << endl;
 
-	SDL_RenderCopyEx(this->game_renderer.get(), ctx.sprite.sprite_image.texture.get(),
+	SDL_RenderCopyExF(this->game_renderer.get(), ctx.sprite.sprite_image.texture.get(),
 					 &srcrect, &dstrect, ctx.angle, NULL, render_flip);
 }
 
@@ -155,7 +163,7 @@ void SDLContext::set_camera(const Camera & cam) {
 	double screen_aspect = static_cast<double>(cam.screen.x) / cam.screen.y;
 	double viewport_aspect = cam.viewport_size.x / cam.viewport_size.y;
 
-	cout << screen_aspect << " " << viewport_aspect << endl;
+
 	SDL_FRect black_bars[2];
 	// calculate black bars
 	if (screen_aspect > viewport_aspect) {
@@ -164,22 +172,26 @@ void SDLContext::set_camera(const Camera & cam) {
 		float render_scale = cam.screen.y / cam.viewport_size.y;
 		float adj_width = cam.viewport_size.x * render_scale;
 		float bar_width = (cam.screen.x - adj_width) / 2;
-		black_bars[0] = {0, 0, bar_width, (float)cam.screen.y};
-		black_bars[1] = {(cam.screen.x - bar_width), 0, bar_width, (float)cam.screen.y};
-		cout << render_scale << " " << adj_width << " " << bar_width << " " << cam.screen.y
-			 << " " << cam.viewport_size.y << endl;
+		black_bars[0] = {0, 0, bar_width, (float) cam.screen.y};
+		black_bars[1] = {(cam.screen.x - bar_width), 0, bar_width, (float) cam.screen.y};
+
+		bar_size = {bar_width,0};
+		scale.x = scale.y = cam.screen.y / cam.viewport_size.y;
 	} else {
 		// letterboxing
 		cout << "letterboxing" << endl;
-		float render_scale = cam.screen.y / cam.viewport_size.y;
-		float adj_width = cam.viewport_size.x * render_scale;
-		float bar_height = (cam.screen.x - adj_width) / 2;
+		float render_scale = cam.screen.x / cam.viewport_size.x;
+		float adj_height = cam.viewport_size.y * render_scale;
+		float bar_height = (cam.screen.y - adj_height) / 2;
 		black_bars[0] = {0, 0, (float) cam.screen.x, bar_height};
 		black_bars[1] = {0, (cam.screen.y - bar_height), (float) cam.screen.x, bar_height};
-		cout << render_scale << " " << adj_width << " " << bar_height << " " << cam.screen.y
-			 << " " << cam.viewport_size.y << endl;
+
+		bar_size = {0,bar_height};
+		scale.x = scale.y = render_scale;
 	}
 
+	cout << "BARS" << endl;
+
 	for (int i = 0; i < 2; ++i) {
 		cout << black_bars[i].x << " " << black_bars[i].y << " " << black_bars[i].w << " "
 			 << black_bars[i].h << endl;
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index 6030a6e..ead0c72 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -158,7 +158,7 @@ private:
 	 * \param img_scale the image multiplier for increasing img size 
 	 * \return sdl rectangle to draw a dst image to draw on the screen
 	 */
-	SDL_Rect get_dst_rect(const Sprite & sprite, const vec2 & pos, const Camera & cam,
+	SDL_FRect get_dst_rect(const Sprite & sprite, const vec2 & pos, const Camera & cam,
 						  const vec2 & cam_pos, const double & img_scale) const;
 
 private:
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 5896c81..f5b9ab3 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -32,14 +32,12 @@ int main(int argc, char * argv[]) {
 
 	auto img = Texture("asset/texture/test_ap43.png");
 
-	/*
 	Sprite & test_sprite = game_object.add_component<Sprite>(
-		img, color, Sprite::FlipSettings{true, true}, 1, 1, 500);
+		img, color, Sprite::FlipSettings{true, true}, 1, 1, 3000);
 
 	//game_object.add_component<Animator>(test_sprite, 4, 1, 0).active = true;
 	game_object.add_component<Animator>(test_sprite, 1, 1, 0).active = true;
 
-	*/
 	/*
 	auto & test = game_object.add_component<ParticleEmitter>(ParticleEmitter::Data{
 		.position = {0, 0},
@@ -62,8 +60,9 @@ int main(int argc, char * argv[]) {
 	});
 	*/
 
-	auto & cam = game_object.add_component<Camera>(Color::WHITE, ivec2{1600, 900},
-												   vec2{800,800}, 1.0f);
+	auto & cam = game_object.add_component<Camera>(Color::WHITE, ivec2{1280, 720},
+												   vec2{8000,6000}, 1.0f);
+	cam.offset.x = 4000;
 
 	/*
 	game_object
-- 
cgit v1.2.3


From 6ae0b9038e432869b506cbdfe2779e97d3732d87 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Sat, 30 Nov 2024 21:02:27 +0100
Subject: improved animator

---
 src/crepe/api/Animator.cpp          |  1 -
 src/crepe/api/Animator.h            | 32 +++++++++++++------
 src/crepe/api/LoopManager.cpp       |  6 +++-
 src/crepe/api/Sprite.cpp            |  5 +--
 src/crepe/api/Sprite.h              |  8 ++---
 src/crepe/facade/SDLContext.cpp     |  6 +++-
 src/crepe/system/AnimatorSystem.cpp | 26 ++++++++++-----
 src/crepe/system/AnimatorSystem.h   |  7 +++--
 src/example/rendering_particle.cpp  | 63 +++++++++++++++++++------------------
 9 files changed, 93 insertions(+), 61 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp
index 45f67f6..7fe49ee 100644
--- a/src/crepe/api/Animator.cpp
+++ b/src/crepe/api/Animator.cpp
@@ -18,7 +18,6 @@ Animator::Animator(game_object_id_t id, Sprite & ss, int row, int col, int col_a
 	this->spritesheet.mask.w /= row;
 	this->spritesheet.mask.x = 0;
 	this->spritesheet.mask.y = col_animator * this->spritesheet.mask.h;
-	this->active = false;
 
 	// need to do this for to get the aspect ratio for a single clipping in the spritesheet
 	this->spritesheet.aspect_ratio
diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index 6c506aa..ede450a 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -17,11 +17,6 @@ class SDLContext;
  */
 class Animator : public Component {
 
-public:
-	//TODO: need to implement this
-	void loop();
-	void stop();
-
 public:
 	/**
 	 * \brief Constructs an Animator object that will control animations for a sprite sheet.
@@ -57,15 +52,32 @@ private:
 	//! The current row being animated.
 	int curr_row = 0;
 
-	//TODO: Is this necessary?
-	//int fps;
+	//! should the animation loop
+	bool looping = false;
+
+	//! starting frame for cycling
+	int cycle_start = 0;
+
+	//! end frame for cycling (-1 --> use last frame)
+	int cycle_end = -1;
+
+	//! frames per second for animation
+	int fps = 1;
+
+	int offset_x = 0;
+
+public:
+	void loop() { this->looping = true; }
+	void play() {this->active = true;}
+	void pause() {this->active = false;}
+	void stop() {this->active = false; this->curr_col = 0; this->curr_row = 0;}
+	void set_fps(int fps) {this->fps = fps;}
+	void set_cycle_range(int start, int end) {this->cycle_start = start, this->cycle_end = end;}
+	void set_anim(int col) {this->curr_row = 0; this->curr_col = col; }
 
 private:
 	//! AnimatorSystem adjust the private member parameters of Animator;
 	friend class AnimatorSystem;
-
-	//! SDLContext reads the Animator member var's
-	friend class SDLContext;
 };
 } // namespace crepe
 //
diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index 7edf4d1..88ca704 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -58,6 +58,7 @@ void LoopManager::setup() {
 	this->game_running = true;
 	LoopTimer::get_instance().start();
 	LoopTimer::get_instance().set_fps(200);
+	this->scene_manager.load_next_scene();
 }
 
 void LoopManager::render() {
@@ -66,4 +67,7 @@ void LoopManager::render() {
 	}
 }
 
-void LoopManager::update() { LoopTimer & timer = LoopTimer::get_instance(); }
+void LoopManager::update() { 
+	LoopTimer & timer = LoopTimer::get_instance(); 
+	this->get_system<AnimatorSystem>().update();
+}
diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp
index 1d57b53..29e415f 100644
--- a/src/crepe/api/Sprite.cpp
+++ b/src/crepe/api/Sprite.cpp
@@ -6,19 +6,20 @@
 #include "Component.h"
 #include "Sprite.h"
 #include "Texture.h"
+#include "types.h"
 
 using namespace std;
 using namespace crepe;
 
 Sprite::Sprite(game_object_id_t id, Texture & image, const Color & color,
-			   const FlipSettings & flip, int sort_layer, int order_layer, float height)
+			   const FlipSettings & flip, int sort_layer, int order_layer, const vec2 & size)
 	: Component(id),
 	  color(color),
 	  flip(flip),
 	  sprite_image(std::move(image)),
 	  sorting_in_layer(sort_layer),
 	  order_in_layer(order_layer),
-	  height(height) {
+	  size(size) {
 
 	dbg_trace();
 
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index 7d9c14b..f04f70c 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -1,11 +1,10 @@
 #pragma once
 
-#include <cstdint>
-
 #include "../Component.h"
 
 #include "Color.h"
 #include "Texture.h"
+#include "types.h"
 
 namespace crepe {
 
@@ -41,7 +40,7 @@ public:
 	 * \param height the height of the image in game units
 	 */
 	Sprite(game_object_id_t id, Texture & image, const Color & color,
-		   const FlipSettings & flip, int sort_layer, int order_layer, float height);
+		   const FlipSettings & flip, int sort_layer, int order_layer, const vec2 & size);
 
 	/**
 	 * \brief Destroys the Sprite instance.
@@ -62,8 +61,7 @@ public:
 	//! Order within the sorting layer
 	const int order_in_layer;
 
-	//! height in world units
-	const float height;
+	vec2 size;
 
 	/**
 	 * \aspect_ratio ratio of the img so that scaling will not become weird
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 1f729b2..f0a21d5 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -113,7 +113,11 @@ SDL_Rect SDLContext::get_src_rect(const Sprite & sprite) const {
 
 SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
 
-	vec2 size = {(ctx.sprite.height * ctx.sprite.aspect_ratio), ctx.sprite.height};
+
+	vec2 size = {
+		ctx.sprite.size.x == 0 && ctx.sprite.size.y != 0 ? ctx.sprite.size.y * ctx.sprite.aspect_ratio : ctx.sprite.size.x,
+		ctx.sprite.size.y == 0 && ctx.sprite.size.x != 0 ? ctx.sprite.size.x / ctx.sprite.aspect_ratio : ctx.sprite.size.y
+	};
 
 	const CameraValues & cam = ctx.cam;
 
diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp
index 4c40940..6a84150 100644
--- a/src/crepe/system/AnimatorSystem.cpp
+++ b/src/crepe/system/AnimatorSystem.cpp
@@ -1,7 +1,6 @@
-#include <cstdint>
+
 
 #include "api/Animator.h"
-#include "facade/SDLContext.h"
 
 #include "AnimatorSystem.h"
 #include "ComponentManager.h"
@@ -13,12 +12,25 @@ void AnimatorSystem::update() {
 
 	RefVector<Animator> animations = mgr.get_components_by_type<Animator>();
 
-	uint64_t tick = SDLContext::get_instance().get_ticks();
+	double elapsed_time = this->timer.get_current_time();
+
 	for (Animator & a : animations) {
 		if (!a.active) continue;
-		// (10 frames per second)
-		a.curr_row = (tick / 100) % a.row;
-		a.spritesheet.mask.x = (a.curr_row * a.spritesheet.mask.w) + a.curr_col;
-		a.spritesheet.mask = a.spritesheet.mask;
+
+		double frame_duration = 1.0f / a.fps;
+
+		int cycle_end = (a.cycle_end == -1) ? a.row : cycle_end;
+		int total_frames = cycle_end - a.cycle_start;
+
+
+		int curr_frame = static_cast<int>(elapsed_time / frame_duration) % total_frames;
+
+		a.curr_row = a.cycle_start + curr_frame;
+		a.spritesheet.mask.x = std::clamp((a.curr_row * a.spritesheet.mask.w - a.offset_x), 0, a.spritesheet.mask.w);
+		a.spritesheet.mask.y = (a.curr_col * a.spritesheet.mask.h);
+
+		if (!a.looping && curr_frame == total_frames) {
+			a.active = false;
+		}
 	}
 }
diff --git a/src/crepe/system/AnimatorSystem.h b/src/crepe/system/AnimatorSystem.h
index f8179a9..e8a5158 100644
--- a/src/crepe/system/AnimatorSystem.h
+++ b/src/crepe/system/AnimatorSystem.h
@@ -1,9 +1,7 @@
 #pragma once
 
 #include "System.h"
-
-//TODO:
-// control if flip works with animation system
+#include "api/LoopTimer.h"
 
 namespace crepe {
 
@@ -26,6 +24,9 @@ public:
 	 * looping).
 	 */
 	void update() override;
+
+private:
+	LoopTimer & timer = LoopTimer::get_instance();
 };
 
 } // namespace crepe
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 9dcaa49..026c9ce 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -1,5 +1,7 @@
 #include "api/Animator.h"
 #include "api/Camera.h"
+#include "api/LoopManager.h"
+#include "api/LoopTimer.h"
 #include "system/AnimatorSystem.h"
 #include "system/ParticleSystem.h"
 #include <SDL2/SDL_timer.h>
@@ -16,29 +18,10 @@
 #include <crepe/system/RenderSystem.h>
 #include <crepe/types.h>
 
-#include <chrono>
-
 using namespace crepe;
 using namespace std;
 
-int main(int argc, char * argv[]) {
-	ComponentManager mgr;
-	GameObject game_object = mgr.new_object("", "", vec2{0, 0}, 0, 1);
-	RenderSystem sys{mgr};
-	ParticleSystem psys{mgr};
-	AnimatorSystem asys{mgr};
-
-	Color color(255, 255, 255, 255);
-
-	auto img = Texture("asset/texture/test_ap43.png");
-
-	Sprite & test_sprite = game_object.add_component<Sprite>(
-		img, color, Sprite::FlipSettings{true, true}, 1, 1, 1.95);
-
-	//game_object.add_component<Animator>(test_sprite, 4, 1, 0).active = true;
-	game_object.add_component<Animator>(test_sprite, 1, 1, 0).active = true;
-
-	/*
+/*
 	auto & test = game_object.add_component<ParticleEmitter>(ParticleEmitter::Data{
 		.position = {0, 0},
 		.max_particles = 10,
@@ -60,9 +43,35 @@ int main(int argc, char * argv[]) {
 	});
 	*/
 
-	auto & cam = game_object.add_component<Camera>(Color::RED, ivec2{1280, 720},
-												   vec2{2.59,1.95}, 2.0);
-	cam.offset.x = 1;
+class TestScene : public Scene {
+public:
+	using Scene::Scene;
+
+	void load_scene() {
+		ComponentManager & mgr = this->component_manager;
+		GameObject game_object = mgr.new_object("", "", vec2{0, 0}, 0, 1);
+
+		Color color(255, 255, 255, 255);
+
+		auto img = Texture("asset/spritesheet/spritesheet_test.png");
+
+		Sprite & test_sprite = game_object.add_component<Sprite>(
+			img, color, Sprite::FlipSettings{true, true}, 1, 1, vec2{1, 1});
+
+		//game_object.add_component<Animator>(test_sprite, 4, 1, 0).active = true;
+		game_object.add_component<Animator>(test_sprite, 4, 1, 0).active = true;
+
+		auto & cam = game_object.add_component<Camera>(Color::RED, ivec2{1280, 720},
+													   vec2{2.59, 1.95}, 2.0);
+	}
+
+	string get_name() const { return "TestScene"; };
+};
+
+int main(int argc, char * argv[]) {
+	LoopManager engine;
+	engine.add_scene<TestScene>();
+	engine.start();
 
 	/*
 	game_object
@@ -73,13 +82,5 @@ int main(int argc, char * argv[]) {
 		= 6;
 	*/
 
-	auto start = std::chrono::steady_clock::now();
-	while (std::chrono::steady_clock::now() - start < std::chrono::seconds(5)) {
-		psys.update();
-		asys.update();
-		sys.update();
-		SDL_Delay(10);
-	}
-
 	return 0;
 }
-- 
cgit v1.2.3


From 3afcae9dd472ead2d5f2b667fc6479f8ee6db10c Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Sat, 30 Nov 2024 21:03:11 +0100
Subject: make format

---
 src/crepe/api/Animator.h            | 21 +++++++++++++++------
 src/crepe/api/LoopManager.cpp       |  4 ++--
 src/crepe/facade/SDLContext.cpp     | 13 +++++++------
 src/crepe/facade/SDLContext.h       |  1 -
 src/crepe/system/AnimatorSystem.cpp |  4 ++--
 src/crepe/system/RenderSystem.h     |  2 +-
 6 files changed, 27 insertions(+), 18 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index ede450a..0da0469 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -68,12 +68,21 @@ private:
 
 public:
 	void loop() { this->looping = true; }
-	void play() {this->active = true;}
-	void pause() {this->active = false;}
-	void stop() {this->active = false; this->curr_col = 0; this->curr_row = 0;}
-	void set_fps(int fps) {this->fps = fps;}
-	void set_cycle_range(int start, int end) {this->cycle_start = start, this->cycle_end = end;}
-	void set_anim(int col) {this->curr_row = 0; this->curr_col = col; }
+	void play() { this->active = true; }
+	void pause() { this->active = false; }
+	void stop() {
+		this->active = false;
+		this->curr_col = 0;
+		this->curr_row = 0;
+	}
+	void set_fps(int fps) { this->fps = fps; }
+	void set_cycle_range(int start, int end) {
+		this->cycle_start = start, this->cycle_end = end;
+	}
+	void set_anim(int col) {
+		this->curr_row = 0;
+		this->curr_col = col;
+	}
 
 private:
 	//! AnimatorSystem adjust the private member parameters of Animator;
diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index 88ca704..51d9122 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -67,7 +67,7 @@ void LoopManager::render() {
 	}
 }
 
-void LoopManager::update() { 
-	LoopTimer & timer = LoopTimer::get_instance(); 
+void LoopManager::update() {
+	LoopTimer & timer = LoopTimer::get_instance();
 	this->get_system<AnimatorSystem>().update();
 }
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index f0a21d5..9c2ead4 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -113,11 +113,12 @@ SDL_Rect SDLContext::get_src_rect(const Sprite & sprite) const {
 
 SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
 
-
-	vec2 size = {
-		ctx.sprite.size.x == 0 && ctx.sprite.size.y != 0 ? ctx.sprite.size.y * ctx.sprite.aspect_ratio : ctx.sprite.size.x,
-		ctx.sprite.size.y == 0 && ctx.sprite.size.x != 0 ? ctx.sprite.size.x / ctx.sprite.aspect_ratio : ctx.sprite.size.y
-	};
+	vec2 size = {ctx.sprite.size.x == 0 && ctx.sprite.size.y != 0
+					 ? ctx.sprite.size.y * ctx.sprite.aspect_ratio
+					 : ctx.sprite.size.x,
+				 ctx.sprite.size.y == 0 && ctx.sprite.size.x != 0
+					 ? ctx.sprite.size.x / ctx.sprite.aspect_ratio
+					 : ctx.sprite.size.y};
 
 	const CameraValues & cam = ctx.cam;
 
@@ -169,7 +170,7 @@ void SDLContext::set_camera(const Camera & cam, CameraValues & ctx) {
 	double screen_aspect = static_cast<double>(cam.screen.x) / cam.screen.y;
 	double viewport_aspect = zoomed_viewport.x / zoomed_viewport.y;
 
-	// calculate black bars 
+	// calculate black bars
 	if (screen_aspect > viewport_aspect) {
 		// pillarboxing
 		float scale = cam.screen.y / zoomed_viewport.y;
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index 285eee2..cd52be6 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -45,7 +45,6 @@ public:
 		const double & scale;
 	};
 
-
 public:
 	/**
 	 * \brief Gets the singleton instance of SDLContext.
diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp
index 6a84150..ee00728 100644
--- a/src/crepe/system/AnimatorSystem.cpp
+++ b/src/crepe/system/AnimatorSystem.cpp
@@ -22,11 +22,11 @@ void AnimatorSystem::update() {
 		int cycle_end = (a.cycle_end == -1) ? a.row : cycle_end;
 		int total_frames = cycle_end - a.cycle_start;
 
-
 		int curr_frame = static_cast<int>(elapsed_time / frame_duration) % total_frames;
 
 		a.curr_row = a.cycle_start + curr_frame;
-		a.spritesheet.mask.x = std::clamp((a.curr_row * a.spritesheet.mask.w - a.offset_x), 0, a.spritesheet.mask.w);
+		a.spritesheet.mask.x = std::clamp((a.curr_row * a.spritesheet.mask.w - a.offset_x), 0,
+										  a.spritesheet.mask.w);
 		a.spritesheet.mask.y = (a.curr_col * a.spritesheet.mask.h);
 
 		if (!a.looping && curr_frame == total_frames) {
diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h
index 9ff015e..249f3b8 100644
--- a/src/crepe/system/RenderSystem.h
+++ b/src/crepe/system/RenderSystem.h
@@ -76,7 +76,7 @@ private:
 
 private:
 	SDLContext & context = SDLContext::get_instance();
-	
+
 	SDLContext::CameraValues cam_ctx;
 };
 
-- 
cgit v1.2.3


From e8c83a6a4421ae81215cf8bd6393b0ff014f147e Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Sun, 1 Dec 2024 20:00:24 +0100
Subject: feedback changes

---
 src/crepe/api/BoxCollider.cpp | 2 +-
 src/crepe/api/LoopManager.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/BoxCollider.cpp b/src/crepe/api/BoxCollider.cpp
index 83fb632..4c767c8 100644
--- a/src/crepe/api/BoxCollider.cpp
+++ b/src/crepe/api/BoxCollider.cpp
@@ -1,7 +1,7 @@
 #include "BoxCollider.h"
+
 #include "../Collider.h" 
 
 using namespace crepe;
 
-
 BoxCollider::BoxCollider(game_object_id_t game_object_id,vec2 offset, double width, double height) : Collider(game_object_id,offset), width(width), height(height) {}
diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index ff8b90e..d3a7f44 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -7,7 +7,7 @@
 #include "../system/RenderSystem.h"
 #include "../system/ScriptSystem.h"
 #include "..//system/PhysicsSystem.h"
-#include "..//system/CollisionSystem.h"
+#include "../system/CollisionSystem.h"
 
 #include "LoopManager.h"
 #include "LoopTimer.h"
-- 
cgit v1.2.3


From cbd4b97d348c46f4f43fe59683a5e3d1bdbc500f Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Sun, 1 Dec 2024 23:03:07 +0100
Subject: improved readablity of check_collision function and reset LoopManager

---
 src/crepe/api/LoopManager.cpp        |  4 ++--
 src/crepe/system/CollisionSystem.cpp | 38 +++++++++++++++++++++++-------------
 src/crepe/system/CollisionSystem.h   |  8 +++-----
 3 files changed, 29 insertions(+), 21 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index d3a7f44..35919cc 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -47,11 +47,11 @@ void LoopManager::loop() {
 	while (game_running) {
 		timer.update();
 
-		//while (timer.get_lag() >= timer.get_fixed_delta_time()) {
+		while (timer.get_lag() >= timer.get_fixed_delta_time()) {
 			this->process_input();
 			this->fixed_update();
 			timer.advance_fixed_update();
-		//}
+		}
 
 		this->update();
 		this->render();
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index c7fbff9..e0c6d03 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -230,7 +230,17 @@ std::vector<std::pair<CollisionSystem::CollisionInternal,CollisionSystem::Collis
 					auto outer_components = get_active_transform_and_rigidbody(outer_collider_ref.get().game_object_id);
 					if (!outer_components) return;
 					CollisionInternalType type = check_collider_type(colliders[i],colliders[j]);
-					if(!check_collision(colliders[i],*inner_components,colliders[j],*outer_components,type)) return;
+					if(!check_collision({
+															.collider = colliders[i],
+															.transform = inner_components->first,
+															.rigidbody = inner_components->second,
+															},
+															{
+															.collider = colliders[j],
+															.transform = outer_components->first,
+															.rigidbody = outer_components->second,
+															},
+															type)) return;
 					collisions_ret.emplace_back(
                         CollisionInternal{colliders[i], inner_components->first.get(), inner_components->second.get()},
                         CollisionInternal{colliders[j], outer_components->first.get(), outer_components->second.get()}
@@ -282,27 +292,27 @@ CollisionSystem::CollisionInternalType CollisionSystem::check_collider_type(cons
 	}
 }
 
-bool CollisionSystem::check_collision(const collider_variant& collider1,std::pair<std::reference_wrapper<Transform>, std::reference_wrapper<Rigidbody>> components1,const collider_variant& collider2,std::pair<std::reference_wrapper<Transform>, std::reference_wrapper<Rigidbody>> components2, CollisionInternalType type){
+bool CollisionSystem::check_collision(const CollisionInternal& first_info,const CollisionInternal& second_info, CollisionInternalType type){
 	switch (type) {
 		case CollisionInternalType::BOX_BOX:	{
-			const BoxCollider & box_collider1 = std::get<std::reference_wrapper<BoxCollider>>(collider1);
-			const BoxCollider & box_collider2 = std::get<std::reference_wrapper<BoxCollider>>(collider2);
-			return check_box_box_collision(box_collider1,box_collider2,components1.first.get(),components2.first.get(),components1.second.get(),components2.second.get());
+			const BoxCollider & box_collider1 = std::get<std::reference_wrapper<BoxCollider>>(first_info.collider);
+			const BoxCollider & box_collider2 = std::get<std::reference_wrapper<BoxCollider>>(second_info.collider);
+			return check_box_box_collision(box_collider1,box_collider2,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
 		}
 		case CollisionInternalType::BOX_CIRCLE: {
-			const BoxCollider & box_collider = std::get<std::reference_wrapper<BoxCollider>>(collider1);
-			const CircleCollider & circle_collider = std::get<std::reference_wrapper<CircleCollider>>(collider2);
-			return check_box_circle_collision(box_collider,circle_collider,components1.first.get(),components2.first.get(),components1.second.get(),components2.second.get());
+			const BoxCollider & box_collider = std::get<std::reference_wrapper<BoxCollider>>(first_info.collider);
+			const CircleCollider & circle_collider = std::get<std::reference_wrapper<CircleCollider>>(second_info.collider);
+			return check_box_circle_collision(box_collider,circle_collider,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
 		}
 		case CollisionInternalType::CIRCLE_CIRCLE:	{
-			const CircleCollider & circle_collider1 = std::get<std::reference_wrapper<CircleCollider>>(collider1);
-			const CircleCollider & circle_collider2 = std::get<std::reference_wrapper<CircleCollider>>(collider2);
-			return check_circle_circle_collision(circle_collider1,circle_collider2,components1.first.get(),components2.first.get(),components1.second.get(),components2.second.get());
+			const CircleCollider & circle_collider1 = std::get<std::reference_wrapper<CircleCollider>>(first_info.collider);
+			const CircleCollider & circle_collider2 = std::get<std::reference_wrapper<CircleCollider>>(second_info.collider);
+			return check_circle_circle_collision(circle_collider1,circle_collider2,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
 		}
 		case CollisionInternalType::CIRCLE_BOX:	{
-			const CircleCollider & circle_collider = std::get<std::reference_wrapper<CircleCollider>>(collider1);
-			const BoxCollider & box_collider = std::get<std::reference_wrapper<BoxCollider>>(collider2);
-			return check_box_circle_collision(box_collider,circle_collider,components1.first.get(),components2.first.get(),components1.second.get(),components2.second.get());
+			const CircleCollider & circle_collider = std::get<std::reference_wrapper<CircleCollider>>(first_info.collider);
+			const BoxCollider & box_collider = std::get<std::reference_wrapper<BoxCollider>>(second_info.collider);
+			return check_box_circle_collision(box_collider,circle_collider,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
 		}
 	}
 	return false;
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 39ee83d..ea8c1e1 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -177,14 +177,12 @@ private:
 		* 
 		* Calls the appropriate collision detection function based on the collider types.
 		* 
-		* \param collider1 The first collider.
-		* \param components1 Transform and Rigidbody of the first object.
-		* \param collider2 The second collider.
-		* \param components2 Transform and Rigidbody of the second object.
+		* \param first_info Collision data for the first collider.
+		* \param second_info Collision data for the second collider.
 		* \param type The type of collider pair.
 		* \return True if a collision is detected, otherwise false.
 		*/
-	bool check_collision(const collider_variant& collider1,std::pair<std::reference_wrapper<Transform>, std::reference_wrapper<Rigidbody>> components1,const collider_variant& collider2,std::pair<std::reference_wrapper<Transform>, std::reference_wrapper<Rigidbody>> components2,CollisionSystem::CollisionInternalType type);
+	bool check_collision(const CollisionInternal& first_info,const CollisionInternal& second_info, CollisionInternalType type);
 	
 	/**
 		* \brief Retrieves the active Transform and Rigidbody components for a given game object.
-- 
cgit v1.2.3


From 54ab44e3508d526be6275378e5979290ec188d6f Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Mon, 2 Dec 2024 10:18:08 +0100
Subject: comments i animator and sprite. added sprite indepentdent scale and
 angle

---
 src/crepe/api/Animator.cpp      | 17 ++++++++++
 src/crepe/api/Animator.h        | 74 ++++++++++++++++++++++++++++++-----------
 src/crepe/api/Sprite.h          | 16 +++++++++
 src/crepe/api/Transform.h       |  2 +-
 src/crepe/facade/SDLContext.cpp |  8 +++--
 src/crepe/facade/SDLContext.h   |  2 --
 6 files changed, 94 insertions(+), 25 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp
index 7fe49ee..0b7e86d 100644
--- a/src/crepe/api/Animator.cpp
+++ b/src/crepe/api/Animator.cpp
@@ -24,3 +24,20 @@ Animator::Animator(game_object_id_t id, Sprite & ss, int row, int col, int col_a
 		= static_cast<double>(this->spritesheet.mask.w) / this->spritesheet.mask.h;
 }
 Animator::~Animator() { dbg_trace(); }
+
+void Animator::loop() { this->looping = true; }
+void Animator::play() { this->active = true; }
+void Animator::pause() { this->active = false; }
+void Animator::stop() {
+	this->active = false;
+	this->curr_col = 0;
+	this->curr_row = 0;
+}
+void Animator::set_fps(int fps) { this->fps = fps; }
+void Animator::set_cycle_range(int start, int end) {
+	this->cycle_start = start, this->cycle_end = end;
+}
+void Animator::set_anim(int col) {
+	this->curr_row = 0;
+	this->curr_col = col;
+}
diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index 0da0469..188f193 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -17,6 +17,59 @@ class SDLContext;
  */
 class Animator : public Component {
 
+public:
+	/**
+	 * \brief Animator will repeat the animation 
+	 *
+	 */
+	void loop();
+
+	/**
+	 * \brief starts the animation
+	 *
+	 */
+	void play();
+	/**
+	 * \brief pauses the animation
+	 *
+	 * sets the active false
+	 *
+	 */
+	void pause();
+
+	/**
+	 * \brief stops the animation
+	 *
+	 * sets the active on false and resets all the current rows and columns
+	 *
+	 */
+	void stop();
+	/**
+	 * \brief set frames per second
+	 *
+	 * \param fps frames per second
+	 */
+	void set_fps(int fps);
+	/**
+	 * \brief set the range in the row
+	 *
+	 * \param  start of row animation
+	 * \param  end of row animation	
+	 */
+	void set_cycle_range(int start, int end);
+	/**
+	 * \brief select which column to animate from
+	 *
+	 * \param col animation column
+	 */
+	void set_anim(int col);
+
+	/**
+	 * \brief will go to the next animaiton of current row 
+	 *
+	 */
+	void next_anim();
+
 public:
 	/**
 	 * \brief Constructs an Animator object that will control animations for a sprite sheet.
@@ -37,7 +90,7 @@ public:
 	~Animator(); // dbg_trace
 
 private:
-	//! A reference to the Sprite sheet containing the animation frames.
+	//! A reference to the Sprite sheet containing.
 	Sprite & spritesheet;
 
 	//! The maximum number of columns in the sprite sheet.
@@ -64,26 +117,9 @@ private:
 	//! frames per second for animation
 	int fps = 1;
 
+	//! offset in pixels.
 	int offset_x = 0;
 
-public:
-	void loop() { this->looping = true; }
-	void play() { this->active = true; }
-	void pause() { this->active = false; }
-	void stop() {
-		this->active = false;
-		this->curr_col = 0;
-		this->curr_row = 0;
-	}
-	void set_fps(int fps) { this->fps = fps; }
-	void set_cycle_range(int start, int end) {
-		this->cycle_start = start, this->cycle_end = end;
-	}
-	void set_anim(int col) {
-		this->curr_row = 0;
-		this->curr_col = col;
-	}
-
 private:
 	//! AnimatorSystem adjust the private member parameters of Animator;
 	friend class AnimatorSystem;
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index f04f70c..96b57e1 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -58,11 +58,27 @@ public:
 
 	//! Layer sorting level of the sprite
 	const int sorting_in_layer;
+
 	//! Order within the sorting layer
 	const int order_in_layer;
 
+	/**
+	 * \size width and height of the sprite in game units
+	 *
+	 * if height is filled in and not width it will multiply width by aspect_ratio.
+	 * if width is filled in and not height it will multiply height by aspect_ratio.
+	 * if neither is filled it will not show sprite because size will be zero
+	 * if both are filled will it use the width and height without making sure the aspect_ratio
+	 * is correct
+	 */
 	vec2 size;
 
+	//! independent sprite angle. rotating clockwise direction in degrees
+	double angle_offset;
+
+	//! independent sprite scale multiplier
+	double scale;
+
 	/**
 	 * \aspect_ratio ratio of the img so that scaling will not become weird
 	 *
diff --git a/src/crepe/api/Transform.h b/src/crepe/api/Transform.h
index 6243a93..34ac70a 100644
--- a/src/crepe/api/Transform.h
+++ b/src/crepe/api/Transform.h
@@ -15,7 +15,7 @@ class Transform : public Component {
 public:
 	//! Translation (shift)
 	vec2 position = {0, 0};
-	//! Rotation, in degrees
+	//! Rotation, in degrees clockwise
 	double rotation = 0;
 	//! Multiplication factor
 	double scale = 0;
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 9c2ead4..bba26a3 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -8,7 +8,6 @@
 #include <cmath>
 #include <cstddef>
 #include <functional>
-#include <iostream>
 #include <memory>
 #include <stdexcept>
 
@@ -113,6 +112,7 @@ SDL_Rect SDLContext::get_src_rect(const Sprite & sprite) const {
 
 SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
 
+	// this might not work all the time because of float checking zero -_-
 	vec2 size = {ctx.sprite.size.x == 0 && ctx.sprite.size.y != 0
 					 ? ctx.sprite.size.y * ctx.sprite.aspect_ratio
 					 : ctx.sprite.size.x,
@@ -122,7 +122,7 @@ SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
 
 	const CameraValues & cam = ctx.cam;
 
-	size *= cam.render_scale * ctx.img_scale;
+	size *= cam.render_scale * ctx.img_scale * ctx.sprite.scale;
 
 	vec2 screen_pos = (ctx.pos - cam.cam_pos + (cam.zoomed_viewport) / 2) * cam.render_scale
 					  - size / 2 + cam.bar_size;
@@ -149,8 +149,10 @@ void SDLContext::draw(const RenderContext & ctx) {
 		.img_scale = ctx.scale,
 	});
 
+	double angle = ctx.angle + ctx.sprite.angle_offset;
+
 	SDL_RenderCopyExF(this->game_renderer.get(), ctx.sprite.sprite_image.texture.get(),
-					  &srcrect, &dstrect, ctx.angle, NULL, render_flip);
+					  &srcrect, &dstrect, angle, NULL, render_flip);
 }
 
 void SDLContext::set_camera(const Camera & cam, CameraValues & ctx) {
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index cd52be6..0a6fce6 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -67,8 +67,6 @@ private:
 	void handle_events(bool & running);
 
 private:
-	//! Will only use get_ticks
-	friend class AnimatorSystem;
 	//! Will only use delay
 	friend class LoopTimer;
 	/**
-- 
cgit v1.2.3


From ad504dbf5152b663c3b503b04012efe092120b6d Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Mon, 2 Dec 2024 13:18:36 +0100
Subject: added some comments and const

---
 src/crepe/api/BoxCollider.cpp        |  2 +-
 src/crepe/api/BoxCollider.h          |  6 +++---
 src/crepe/api/CircleCollider.cpp     |  2 +-
 src/crepe/api/CircleCollider.h       |  4 ++--
 src/crepe/system/CollisionSystem.cpp | 12 ++++++++++--
 src/crepe/system/CollisionSystem.h   |  2 +-
 6 files changed, 18 insertions(+), 10 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/BoxCollider.cpp b/src/crepe/api/BoxCollider.cpp
index 4c767c8..6034837 100644
--- a/src/crepe/api/BoxCollider.cpp
+++ b/src/crepe/api/BoxCollider.cpp
@@ -4,4 +4,4 @@
 
 using namespace crepe;
 
-BoxCollider::BoxCollider(game_object_id_t game_object_id,vec2 offset, double width, double height) : Collider(game_object_id,offset), width(width), height(height) {}
+BoxCollider::BoxCollider(game_object_id_t game_object_id,vec2 offset, float width, float height) : Collider(game_object_id,offset), width(width), height(height) {}
diff --git a/src/crepe/api/BoxCollider.h b/src/crepe/api/BoxCollider.h
index 6135954..2ce1ee8 100644
--- a/src/crepe/api/BoxCollider.h
+++ b/src/crepe/api/BoxCollider.h
@@ -12,13 +12,13 @@ namespace crepe {
  */
 class BoxCollider : public Collider {
 public:
-	BoxCollider(game_object_id_t game_object_id,vec2 offset, double width, double height);
+	BoxCollider(game_object_id_t game_object_id,vec2 offset, float width, float height);
 
 	//! Width of box collider 
-	double width;
+	float width;
 
 	//! Height of box collider
-	double height;
+	float height;
 };
 
 } // namespace crepe
diff --git a/src/crepe/api/CircleCollider.cpp b/src/crepe/api/CircleCollider.cpp
index 43de991..497ebba 100644
--- a/src/crepe/api/CircleCollider.cpp
+++ b/src/crepe/api/CircleCollider.cpp
@@ -3,4 +3,4 @@
 using namespace crepe;
 
 
-CircleCollider::CircleCollider(game_object_id_t game_object_id,vec2 offset, int radius) : Collider(game_object_id,offset), radius(radius) {}
+CircleCollider::CircleCollider(game_object_id_t game_object_id,vec2 offset, float radius) : Collider(game_object_id,offset), radius(radius) {}
diff --git a/src/crepe/api/CircleCollider.h b/src/crepe/api/CircleCollider.h
index 843547f..c61f027 100644
--- a/src/crepe/api/CircleCollider.h
+++ b/src/crepe/api/CircleCollider.h
@@ -14,10 +14,10 @@ namespace crepe {
 class CircleCollider : public Collider {
 public:
 
-	CircleCollider(game_object_id_t game_object_id,vec2 offset, int radius);
+	CircleCollider(game_object_id_t game_object_id,vec2 offset, float radius);
 
 	//! Radius of the circle collider.
-	double radius;
+	float radius;
 };
 
 } // namespace crepe
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 0b83bce..70fe855 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -105,6 +105,7 @@ std::pair<vec2,CollisionSystem::Direction> CollisionSystem::collision_handler(Co
 			vec2 collider_pos1 = current_position(collider1.offset, data1.transform, data1.rigidbody);
 			vec2 collider_pos2 = current_position(collider2.offset, data2.transform, data2.rigidbody);
 			resolution = box_box_resolution(collider1,collider2,collider_pos1,collider_pos2);
+			break;
 		}
 		case CollisionInternalType::BOX_CIRCLE: {
 			const BoxCollider & collider1 = std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
@@ -112,7 +113,7 @@ std::pair<vec2,CollisionSystem::Direction> CollisionSystem::collision_handler(Co
 			vec2 collider_pos1 = current_position(collider1.offset, data1.transform, data1.rigidbody);
 			vec2 collider_pos2 = current_position(collider2.offset, data2.transform, data2.rigidbody);
 			resolution = circle_box_resolution(collider2,collider1,collider_pos2,collider_pos1);
-
+			break;
 		}
 		case CollisionInternalType::CIRCLE_CIRCLE:	{
 			const CircleCollider & collider1 = std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
@@ -120,6 +121,7 @@ std::pair<vec2,CollisionSystem::Direction> CollisionSystem::collision_handler(Co
 			vec2 collider_pos1 = current_position(collider1.offset, data1.transform, data1.rigidbody);
 			vec2 collider_pos2 = current_position(collider2.offset, data2.transform, data2.rigidbody);
 			resolution = circle_circle_resolution(collider1,collider2,collider_pos1,collider_pos2);
+			break;
 		}
 		case CollisionInternalType::CIRCLE_BOX:	{
 			const CircleCollider & collider1 = std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
@@ -127,6 +129,7 @@ std::pair<vec2,CollisionSystem::Direction> CollisionSystem::collision_handler(Co
 			vec2 collider_pos1 = current_position(collider1.offset, data1.transform, data1.rigidbody);
 			vec2 collider_pos2 = current_position(collider2.offset, data2.transform, data2.rigidbody);
 			resolution = circle_box_resolution(collider1,collider2,collider_pos1,collider_pos2);
+			break;
 		}
 	}
 
@@ -282,18 +285,23 @@ std::vector<std::pair<CollisionSystem::CollisionInternal,CollisionSystem::Collis
 	// Quadtree code
 	// Quadtree is placed over the input vector
 
+	// Return data of collided colliders which are variants
 	std::vector<std::pair<CollisionInternal,CollisionInternal>> collisions_ret;
+	//using visit to visit the variant to access the active and id.  
 	for (size_t i = 0; i < colliders.size(); ++i) {
     std::visit([&](auto& inner_collider_ref) {
+			// Return from visit if collider or components are not active 
 			if (!inner_collider_ref.get().active) return;
 			auto inner_components = get_active_transform_and_rigidbody(inner_collider_ref.get().game_object_id);
 			if (!inner_components) return;
 			for (size_t j = i + 1; j < colliders.size(); ++j) {
 				std::visit([&](auto& outer_collider_ref) { 
+					// Return from visit if collider or components are not active and if they have the same id.
 					if (!outer_collider_ref.get().active) return;
 					if (inner_collider_ref.get().game_object_id == outer_collider_ref.get().game_object_id) return;
 					auto outer_components = get_active_transform_and_rigidbody(outer_collider_ref.get().game_object_id);
 					if (!outer_components) return;
+					// Get collision type form variant colliders
 					CollisionInternalType type = check_collider_type(colliders[i],colliders[j]);
 					if(!check_collision({
 															.collider = colliders[i],
@@ -336,7 +344,7 @@ CollisionSystem::get_active_transform_and_rigidbody(game_object_id_t game_object
     return std::make_pair(std::ref(transform), std::ref(rigidbody));
 }
 
-CollisionSystem::CollisionInternalType CollisionSystem::check_collider_type(const collider_variant& collider1,const collider_variant& collider2){
+CollisionSystem::CollisionInternalType CollisionSystem::check_collider_type(const collider_variant& collider1,const collider_variant& collider2) const{
 	if(std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider1)){
 		if(std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider2))
 		{
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 86b8b7a..fc91603 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -92,7 +92,7 @@ private:
 		* \param collider2 Second collider variant (BoxCollider or CircleCollider).
 		* \return The combined type of the two colliders.
 		*/
-	CollisionInternalType check_collider_type(const collider_variant& collider1,const collider_variant& collider2);
+	CollisionInternalType check_collider_type(const collider_variant& collider1,const collider_variant& collider2) const;
 
 	/**
 		* \brief Calculates the current position of a collider.
-- 
cgit v1.2.3


From 0a867effdb02e35181ee31c36960aed05e19ac64 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Mon, 2 Dec 2024 13:33:19 +0100
Subject: feedback fix

---
 src/crepe/Collider.h        |  2 --
 src/crepe/api/Rigidbody.cpp |  2 +-
 src/crepe/api/Rigidbody.h   | 14 +++++++-------
 3 files changed, 8 insertions(+), 10 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/Collider.h b/src/crepe/Collider.h
index 5b26af5..e1624b4 100644
--- a/src/crepe/Collider.h
+++ b/src/crepe/Collider.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "api/Vector2.h"
-
 #include "Component.h"
 #include "types.h"
 
diff --git a/src/crepe/api/Rigidbody.cpp b/src/crepe/api/Rigidbody.cpp
index 576ca45..c4b1d6f 100644
--- a/src/crepe/api/Rigidbody.cpp
+++ b/src/crepe/api/Rigidbody.cpp
@@ -10,6 +10,6 @@ void crepe::Rigidbody::add_force_linear(const vec2 & force) {
 	this->data.linear_velocity += force;
 }
 
-void crepe::Rigidbody::add_force_angular(double force) {
+void crepe::Rigidbody::add_force_angular(float force) {
 	this->data.angular_velocity += force;
 }
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index 7939563..446c5dd 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -52,9 +52,9 @@ public:
 	 */
 	struct Data {
 		//! objects mass
-		double mass = 0.0;
+		float mass = 0.0;
 		//! gravtiy scale
-		double gravity_scale = 0.0;
+		float gravity_scale = 0.0;
 		//! Changes if physics apply
 		BodyType body_type = BodyType::DYNAMIC;
 		//! linear velocity of object
@@ -64,11 +64,11 @@ public:
 		//! linear damping of object
 		vec2 linear_damping;
 		//! angular velocity of object
-		double angular_velocity = 0.0;
+		float angular_velocity = 0.0;
 		//! max angular velocity of object
-		double max_angular_velocity = INFINITY;
+		float max_angular_velocity = INFINITY;
 		//! angular damping of object
-		double angular_damping = 0.0;
+		float angular_damping = 0.0;
 		//! movements constraints of object
 		PhysicsConstraints constraints;
 		//! if gravity applies
@@ -76,7 +76,7 @@ public:
 		//! if object bounces
 		bool bounce = false;
 		//! bounce factor of material
-		double elastisity = 0.0;
+		float elastisity = 0.0;
 		//! offset of all colliders relative to transform position
 		vec2 offset;
 	};
@@ -102,7 +102,7 @@ public:
 	 * 
 	 * \param force Vector2 that is added to the angular force.
 	 */
-	void add_force_angular(double force);
+	void add_force_angular(float force);
 };
 
 } // namespace crepe
-- 
cgit v1.2.3


From eeb66130e2cb94c94e1748576f98f78ce0f1ee86 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Mon, 2 Dec 2024 17:17:21 +0100
Subject: changed some values because of feedback and merged from master

---
 src/crepe/Collider.cpp               |  2 +-
 src/crepe/Collider.h                 |  2 +-
 src/crepe/api/BoxCollider.cpp        |  2 +-
 src/crepe/api/BoxCollider.h          |  2 +-
 src/crepe/api/CircleCollider.cpp     |  2 +-
 src/crepe/api/CircleCollider.h       |  2 +-
 src/crepe/api/Rigidbody.h            | 14 +++++-------
 src/crepe/system/CollisionSystem.cpp | 18 ++++++++--------
 src/crepe/system/CollisionSystem.h   |  8 +++----
 src/crepe/system/PhysicsSystem.cpp   | 10 ++++-----
 src/test/CMakeLists.txt              |  2 +-
 src/test/CollisionTest.cpp           |  5 -----
 src/test/Profiling.cpp               | 42 +++++++++++++++++++-----------------
 13 files changed, 52 insertions(+), 59 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/Collider.cpp b/src/crepe/Collider.cpp
index 80a944d..9d94152 100644
--- a/src/crepe/Collider.cpp
+++ b/src/crepe/Collider.cpp
@@ -2,4 +2,4 @@
 
 using namespace crepe;
 
-Collider::Collider(game_object_id_t id, vec2 offset) : Component(id), offset(offset) {}
+Collider::Collider(game_object_id_t id, const vec2& offset) : Component(id), offset(offset) {}
diff --git a/src/crepe/Collider.h b/src/crepe/Collider.h
index e1624b4..15d3a24 100644
--- a/src/crepe/Collider.h
+++ b/src/crepe/Collider.h
@@ -7,7 +7,7 @@ namespace crepe {
 
 class Collider : public Component {
 public:
-	Collider(game_object_id_t id, vec2 offset);
+	Collider(game_object_id_t id, const vec2& offset);
 
 public:
 	//! Offset of the collider relative to rigidbody position 
diff --git a/src/crepe/api/BoxCollider.cpp b/src/crepe/api/BoxCollider.cpp
index 6034837..1069e90 100644
--- a/src/crepe/api/BoxCollider.cpp
+++ b/src/crepe/api/BoxCollider.cpp
@@ -4,4 +4,4 @@
 
 using namespace crepe;
 
-BoxCollider::BoxCollider(game_object_id_t game_object_id,vec2 offset, float width, float height) : Collider(game_object_id,offset), width(width), height(height) {}
+BoxCollider::BoxCollider(game_object_id_t game_object_id,const vec2& offset, float width, float height) : Collider(game_object_id,offset), width(width), height(height) {}
diff --git a/src/crepe/api/BoxCollider.h b/src/crepe/api/BoxCollider.h
index 2ce1ee8..c83d54a 100644
--- a/src/crepe/api/BoxCollider.h
+++ b/src/crepe/api/BoxCollider.h
@@ -12,7 +12,7 @@ namespace crepe {
  */
 class BoxCollider : public Collider {
 public:
-	BoxCollider(game_object_id_t game_object_id,vec2 offset, float width, float height);
+	BoxCollider(game_object_id_t game_object_id,const vec2& offset, float width, float height);
 
 	//! Width of box collider 
 	float width;
diff --git a/src/crepe/api/CircleCollider.cpp b/src/crepe/api/CircleCollider.cpp
index 497ebba..473734e 100644
--- a/src/crepe/api/CircleCollider.cpp
+++ b/src/crepe/api/CircleCollider.cpp
@@ -3,4 +3,4 @@
 using namespace crepe;
 
 
-CircleCollider::CircleCollider(game_object_id_t game_object_id,vec2 offset, float radius) : Collider(game_object_id,offset), radius(radius) {}
+CircleCollider::CircleCollider(game_object_id_t game_object_id,const vec2& offset, float radius) : Collider(game_object_id,offset), radius(radius) {}
diff --git a/src/crepe/api/CircleCollider.h b/src/crepe/api/CircleCollider.h
index c61f027..bbcc330 100644
--- a/src/crepe/api/CircleCollider.h
+++ b/src/crepe/api/CircleCollider.h
@@ -14,7 +14,7 @@ namespace crepe {
 class CircleCollider : public Collider {
 public:
 
-	CircleCollider(game_object_id_t game_object_id,vec2 offset, float radius);
+	CircleCollider(game_object_id_t game_object_id,const vec2& offset, float radius);
 
 	//! Radius of the circle collider.
 	float radius;
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index 446c5dd..63b1b51 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -54,7 +54,7 @@ public:
 		//! objects mass
 		float mass = 0.0;
 		//! gravtiy scale
-		float gravity_scale = 0.0;
+		float gravity_scale = 0;
 		//! Changes if physics apply
 		BodyType body_type = BodyType::DYNAMIC;
 		//! linear velocity of object
@@ -62,20 +62,16 @@ public:
 		//! maximum linear velocity of object
 		vec2 max_linear_velocity = {INFINITY ,INFINITY};
 		//! linear damping of object
-		vec2 linear_damping;
+		vec2 linear_velocity_factor;
 		//! angular velocity of object
-		float angular_velocity = 0.0;
+		float angular_velocity = 1;
 		//! max angular velocity of object
 		float max_angular_velocity = INFINITY;
 		//! angular damping of object
-		float angular_damping = 0.0;
+		float angular_velocity_factor = 1;
 		//! movements constraints of object
 		PhysicsConstraints constraints;
-		//! if gravity applies
-		bool use_gravity = true;
-		//! if object bounces
-		bool bounce = false;
-		//! bounce factor of material
+		//! bounce factor of material. 0.0 <= means all velocity is lost, 1.0 means it gets the same momentum but the mirrored direction. 0.5 is half of the velocity is saved.
 		float elastisity = 0.0;
 		//! offset of all colliders relative to transform position
 		vec2 offset;
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 2fe3621..fbb16e8 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -146,10 +146,10 @@ std::pair<vec2,CollisionSystem::Direction> CollisionSystem::collision_handler(Co
 		resolution.x = data1.rigidbody.data.linear_velocity.x * (resolution.y/data1.rigidbody.data.linear_velocity.y);
 	}
 
-	return {resolution,resolution_direction};
+	return std::make_pair(resolution,resolution_direction);
 }
 
-vec2 CollisionSystem::get_box_box_resolution(const BoxCollider& box_collider1,const BoxCollider& box_collider2,vec2 final_position1,vec2 final_position2) const
+vec2 CollisionSystem::get_box_box_resolution(const BoxCollider& box_collider1,const BoxCollider& box_collider2,const vec2& final_position1,const vec2& final_position2) const
 {
 	vec2 resolution; // Default resolution vector
 	vec2 delta = final_position2 - final_position1;
@@ -183,7 +183,7 @@ vec2 CollisionSystem::get_box_box_resolution(const BoxCollider& box_collider1,co
 	return resolution;
 }
 
-vec2 CollisionSystem::get_circle_circle_resolution(const CircleCollider& circle_collider1, const CircleCollider& circle_collider2, vec2 final_position1, vec2 final_position2) const 
+vec2 CollisionSystem::get_circle_circle_resolution(const CircleCollider& circle_collider1, const CircleCollider& circle_collider2, const vec2& final_position1, const vec2& final_position2) const 
 {
     vec2 delta = final_position2 - final_position1;
 
@@ -205,7 +205,7 @@ vec2 CollisionSystem::get_circle_circle_resolution(const CircleCollider& circle_
     return resolution;
 }
 
-vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider& circle_collider, const BoxCollider& box_collider, vec2 circle_position, vec2 box_position) const 
+vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider& circle_collider, const BoxCollider& box_collider, const vec2& circle_position, const vec2& box_position) const 
 {
     vec2 delta = circle_position - box_position;
 
@@ -252,7 +252,7 @@ void CollisionSystem::static_collision_handler(CollisionInfo& info){
 	info.first_transform.position += info.resolution;
 
 	// If bounce is enabled mirror velocity
-	if(info.first_rigidbody.data.bounce) {
+	if(info.first_rigidbody.data.elastisity > 0) {
 		if(info.resolution_direction == Direction::BOTH)
 		{
 			info.first_rigidbody.data.linear_velocity.y = -info.first_rigidbody.data.linear_velocity.y * info.first_rigidbody.data.elastisity;
@@ -335,12 +335,12 @@ CollisionSystem::get_active_transform_and_rigidbody(game_object_id_t game_object
     RefVector<Transform> transforms = this->component_manager.get_components_by_id<Transform>(game_object_id);
     if (transforms.empty()) return std::nullopt;
 
+		Transform& transform = transforms.front().get();
+    if (!transform.active) return std::nullopt;
+
     RefVector<Rigidbody> rigidbodies = this->component_manager.get_components_by_id<Rigidbody>(game_object_id);
     if (rigidbodies.empty()) return std::nullopt;
 
-    Transform& transform = transforms.front().get();
-    if (!transform.active) return std::nullopt;
-
     Rigidbody& rigidbody = rigidbodies.front().get();
     if (!rigidbody.active) return std::nullopt;
 
@@ -453,7 +453,7 @@ bool CollisionSystem::get_circle_circle_collision(const CircleCollider& circle1,
 	return distance_squared <= radius_sum * radius_sum;
 }
 
-vec2 CollisionSystem::get_current_position(vec2 collider_offset, const Transform& transform, const Rigidbody& rigidbody) const {
+vec2 CollisionSystem::get_current_position(const vec2& collider_offset, const Transform& transform, const Rigidbody& rigidbody) const {
 	// Get the rotation in radians
 	float radians1 = transform.rotation * (M_PI / 180.0);
 
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 3f24db1..34c03ae 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -104,7 +104,7 @@ private:
 		* \param rigidbody The Rigidbody of the associated game object.
 		* \return The calculated position of the collider.
 		*/
-	vec2 get_current_position(vec2 collider_offset, const Transform& transform, const Rigidbody& rigidbody) const;
+	vec2 get_current_position(const vec2& collider_offset, const Transform& transform, const Rigidbody& rigidbody) const;
 
 private:
 
@@ -141,7 +141,7 @@ private:
 		* \param position2 The position of the second BoxCollider.
 		* \return The resolution vector for the collision.
 		*/
-	vec2 get_box_box_resolution(const BoxCollider& box_collider1,const BoxCollider& box_collider2,vec2 position1,vec2 position2) const;
+	vec2 get_box_box_resolution(const BoxCollider& box_collider1,const BoxCollider& box_collider2,const vec2& position1,const vec2& position2) const;
 
 	/**
 		* \brief Calculates the resolution vector for two CircleCollider.
@@ -154,7 +154,7 @@ private:
 		* \param position2 The position of the second CircleCollider.
 		* \return The resolution vector for the collision.
 		*/
-	vec2 get_circle_circle_resolution(const CircleCollider& circle_collider1, const CircleCollider& circle_collider2, vec2 final_position1, vec2 final_position2) const;
+	vec2 get_circle_circle_resolution(const CircleCollider& circle_collider1, const CircleCollider& circle_collider2, const vec2& final_position1, const vec2& final_position2) const;
 
 	/**
 		* \brief Calculates the resolution vector for two CircleCollider.
@@ -167,7 +167,7 @@ private:
 		* \param box_position The position of the BocCollider.
 		* \return The resolution vector for the collision.
 		*/
-	vec2 get_circle_box_resolution(const CircleCollider& circle_collider, const BoxCollider& box_collider, vec2 circle_position, vec2 box_position) const;
+	vec2 get_circle_box_resolution(const CircleCollider& circle_collider, const BoxCollider& box_collider, const vec2& circle_position, const vec2& box_position) const;
 
 	/**
 		* \brief Determines the appropriate collision handler for a collision.
diff --git a/src/crepe/system/PhysicsSystem.cpp b/src/crepe/system/PhysicsSystem.cpp
index 514a4b3..8f21727 100644
--- a/src/crepe/system/PhysicsSystem.cpp
+++ b/src/crepe/system/PhysicsSystem.cpp
@@ -25,17 +25,17 @@ void PhysicsSystem::update() {
 					if (transform.game_object_id == rigidbody.game_object_id) {
 
 						// Add gravity
-						if (rigidbody.data.use_gravity) {
+						if (rigidbody.data.gravity_scale > 0) {
 							rigidbody.data.linear_velocity.y
 								+= (rigidbody.data.mass * rigidbody.data.gravity_scale
 									* gravity);
 						}
 						// Add damping
-						if (rigidbody.data.angular_damping != 0) {
-							rigidbody.data.angular_velocity *= rigidbody.data.angular_damping;
+						if (rigidbody.data.angular_velocity_factor != 1 && rigidbody.data.angular_velocity_factor > 0) {
+							rigidbody.data.angular_velocity *= rigidbody.data.angular_velocity_factor;
 						}
-						if (rigidbody.data.linear_damping != vec2{0, 0}) {
-							rigidbody.data.linear_velocity *= rigidbody.data.linear_damping;
+						if (rigidbody.data.linear_velocity_factor != vec2{1, 1} && rigidbody.data.linear_velocity_factor.x > 0 && rigidbody.data.linear_velocity_factor.y > 0) {
+							rigidbody.data.linear_velocity *= rigidbody.data.linear_velocity_factor;
 						}
 
 						// Max velocity check
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index 616e238..4555c0b 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -13,5 +13,5 @@ target_sources(test_main PUBLIC
 	# ValueBrokerTest.cpp
 	# DBTest.cpp
 	# Vector2Test.cpp
-	# Profiling.cpp
+	Profiling.cpp
 )
diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp
index ed40b1b..92ff7ba 100644
--- a/src/test/CollisionTest.cpp
+++ b/src/test/CollisionTest.cpp
@@ -65,7 +65,6 @@ public:
 		world.add_component<Rigidbody>(Rigidbody::Data{
 			// TODO: remove unrelated properties:
 			.body_type = Rigidbody::BodyType::STATIC,
-			.bounce = false,
 			.offset = {0,0},
 		});
 		// Create a box with an inner size of 10x10 units
@@ -80,8 +79,6 @@ public:
 			.body_type = Rigidbody::BodyType::DYNAMIC,
 			.linear_velocity = {0,0},
 			.constraints = {0, 0, 0},
-			.use_gravity = true,
-			.bounce = true,
 			.elastisity = 1,
 			.offset = {0,0},
 		});
@@ -96,8 +93,6 @@ public:
 			.body_type = Rigidbody::BodyType::DYNAMIC,
 			.linear_velocity = {0,0},
 			.constraints = {0, 0, 0},
-			.use_gravity = true,
-			.bounce = true,
 			.elastisity = 1,
 			.offset = {0,0},
 		});
diff --git a/src/test/Profiling.cpp b/src/test/Profiling.cpp
index 2549c57..a88bf85 100644
--- a/src/test/Profiling.cpp
+++ b/src/test/Profiling.cpp
@@ -79,7 +79,8 @@ public:
 	void SetUp() override {
 		
 		GameObject do_not_use = mgr.new_object("DO_NOT_USE","",{0,0});
-		do_not_use.add_component<Camera>(Color::WHITE);
+		do_not_use.add_component<Camera>(Color::WHITE, ivec2{1080, 720},
+												   vec2{2000, 2000}, 1.0f);
 		// initialize systems here:
 		//calls init
 		script_sys.update();
@@ -110,14 +111,19 @@ public:
 
 	// Print timings of all functions
 	void log_timings() const {
-		std::stringstream ss;
-        ss << "\nFunction timings:\n";
-        for (const auto& [name, duration] : timings) {
-            ss << name << " took " << duration.count() / 1000.0 / average << " ms (" << duration.count() / average << " µs).\n";
-        }
-        ss << "Total time: " << this->total_time.count() / 1000.0 / average << " ms (" << this->total_time.count() / average << " µs)\n";
-        ss << "Amount of gameobjects: " << game_object_count << "\n";
-        GTEST_LOG_(INFO) << ss.str();
+		std::string result = "\nFunction timings:\n";
+    
+    for (const auto& [name, duration] : timings) {
+        result += name + " took " + std::to_string(duration.count() / 1000.0 / average) + " ms (" +
+                  std::to_string(duration.count() / average) + " µs).\n";
+    }
+
+    result += "Total time: " + std::to_string(this->total_time.count() / 1000.0 / average) + " ms (" +
+              std::to_string(this->total_time.count() / average) + " µs)\n";
+    
+    result += "Amount of gameobjects: " + std::to_string(game_object_count) + "\n";
+
+    GTEST_LOG_(INFO) << result;
 	}
 
 	void clear_timings() {
@@ -158,15 +164,14 @@ TEST_F(Profiling, Profiling_2) {
 			//define gameobject used for testing
 			GameObject gameobject = mgr.new_object("gameobject","",{static_cast<float>(game_object_count*2),0});
 			gameobject.add_component<Rigidbody>(Rigidbody::Data{
-			.body_type = Rigidbody::BodyType::STATIC,
-			.use_gravity = false,
+				.gravity_scale = 0.0,
+				.body_type = Rigidbody::BodyType::STATIC,
 			});
 			gameobject.add_component<BoxCollider>(vec2{0, 0}, 1, 1);
 			gameobject.add_component<BehaviorScript>().set_script<TestScript>();
 			Color color(0, 0, 0, 0);
-			gameobject.add_component<Sprite>(
-			make_shared<Texture>("asset/texture/green_square.png"), color,
-			FlipSettings{true, true});
+			auto img = Texture("asset/texture/green_square.png");
+			Sprite & test_sprite = gameobject.add_component<Sprite>(img, color, Sprite::FlipSettings{false, false}, 1, 1, 500);
 		}
 
 		this->game_object_count++;
@@ -190,17 +195,14 @@ TEST_F(Profiling, Profiling_3) {
 			//define gameobject used for testing
 			GameObject gameobject = mgr.new_object("gameobject","",{static_cast<float>(game_object_count*2),0});
 			gameobject.add_component<Rigidbody>(Rigidbody::Data{
+			.gravity_scale = 0,
 			.body_type = Rigidbody::BodyType::STATIC,
-			.use_gravity = false,
 			});
 			gameobject.add_component<BoxCollider>(vec2{0, 0}, 1, 1);
 			gameobject.add_component<BehaviorScript>().set_script<TestScript>();
 			Color color(0, 0, 0, 0);
-			gameobject.add_component<Sprite>(
-			make_shared<Texture>("asset/texture/green_square.png"), color,
-			FlipSettings{true, true});
-			Sprite & test_sprite = gameobject.add_component<Sprite>(
-			make_shared<Texture>("asset/texture/img.png"), color, FlipSettings{false, false});
+			auto img = Texture("asset/texture/green_square.png");
+			Sprite & test_sprite = gameobject.add_component<Sprite>(img, color, Sprite::FlipSettings{false, false}, 1, 1, 500);
 			auto & test = gameobject.add_component<ParticleEmitter>(ParticleEmitter::Data{
 			.max_particles = 10,
 			.emission_rate = 100,
-- 
cgit v1.2.3


From 135af8b0e0eaf8a5a5b7e1a42bfb20bb14ec97e5 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Mon, 2 Dec 2024 18:51:47 +0100
Subject: tmp commit

---
 src/crepe/api/Animator.h            |  2 +-
 src/crepe/api/Sprite.h              |  4 ++--
 src/crepe/system/AnimatorSystem.cpp |  9 +++++----
 src/example/rendering_particle.cpp  | 11 +++++------
 4 files changed, 13 insertions(+), 13 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index 188f193..511d6ef 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -89,7 +89,7 @@ public:
 
 	~Animator(); // dbg_trace
 
-private:
+public:
 	//! A reference to the Sprite sheet containing.
 	Sprite & spritesheet;
 
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index 96b57e1..354f663 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -74,10 +74,10 @@ public:
 	vec2 size;
 
 	//! independent sprite angle. rotating clockwise direction in degrees
-	double angle_offset;
+	double angle_offset = 0;
 
 	//! independent sprite scale multiplier
-	double scale;
+	double scale = 1;
 
 	/**
 	 * \aspect_ratio ratio of the img so that scaling will not become weird
diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp
index ee00728..1650b3d 100644
--- a/src/crepe/system/AnimatorSystem.cpp
+++ b/src/crepe/system/AnimatorSystem.cpp
@@ -4,6 +4,7 @@
 
 #include "AnimatorSystem.h"
 #include "ComponentManager.h"
+#include <iostream>
 
 using namespace crepe;
 
@@ -25,11 +26,11 @@ void AnimatorSystem::update() {
 		int curr_frame = static_cast<int>(elapsed_time / frame_duration) % total_frames;
 
 		a.curr_row = a.cycle_start + curr_frame;
-		a.spritesheet.mask.x = std::clamp((a.curr_row * a.spritesheet.mask.w - a.offset_x), 0,
-										  a.spritesheet.mask.w);
+		a.spritesheet.mask.x = a.curr_row * a.spritesheet.mask.w;
 		a.spritesheet.mask.y = (a.curr_col * a.spritesheet.mask.h);
-
-		if (!a.looping && curr_frame == total_frames) {
+	
+		std::cout << curr_frame << " " << total_frames << std::endl;
+		if (!a.looping && curr_frame == 0) {
 			a.active = false;
 		}
 	}
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 026c9ce..5a50d27 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -53,16 +53,15 @@ public:
 
 		Color color(255, 255, 255, 255);
 
-		auto img = Texture("asset/spritesheet/spritesheet_test.png");
+		auto img = Texture("asset/spritesheet/pokemon_spritesheet.png");
 
 		Sprite & test_sprite = game_object.add_component<Sprite>(
-			img, color, Sprite::FlipSettings{true, true}, 1, 1, vec2{1, 1});
+			img, color, Sprite::FlipSettings{false, false}, 1, 1, vec2{100, 100});
 
-		//game_object.add_component<Animator>(test_sprite, 4, 1, 0).active = true;
-		game_object.add_component<Animator>(test_sprite, 4, 1, 0).active = true;
+		auto & anim = game_object.add_component<Animator>(test_sprite, 4, 4, 0);
 
-		auto & cam = game_object.add_component<Camera>(Color::RED, ivec2{1280, 720},
-													   vec2{2.59, 1.95}, 2.0);
+		auto & cam = game_object.add_component<Camera>(Color::, ivec2{720, 1280},
+													   vec2{400, 400}, 1.0);
 	}
 
 	string get_name() const { return "TestScene"; };
-- 
cgit v1.2.3


From a84ca09e97d466643f022acfffcf4c6a77f42052 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Mon, 2 Dec 2024 20:02:14 +0100
Subject: making struct constructors

---
 src/crepe/api/Animator.cpp          | 34 ++++++-------
 src/crepe/api/Animator.h            | 66 +++++++++++++------------
 src/crepe/api/Camera.cpp            | 11 +----
 src/crepe/api/Camera.h              | 37 +++++++-------
 src/crepe/api/Sprite.cpp            | 17 +++----
 src/crepe/api/Sprite.h              | 98 +++++++++++++++++--------------------
 src/crepe/facade/SDLContext.cpp     | 25 +++++-----
 src/crepe/system/AnimatorSystem.cpp | 17 ++++---
 src/crepe/system/RenderSystem.cpp   |  5 +-
 src/example/rendering_particle.cpp  | 19 +++++--
 10 files changed, 166 insertions(+), 163 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp
index 0b7e86d..ce824e6 100644
--- a/src/crepe/api/Animator.cpp
+++ b/src/crepe/api/Animator.cpp
@@ -7,37 +7,37 @@
 
 using namespace crepe;
 
-Animator::Animator(game_object_id_t id, Sprite & ss, int row, int col, int col_animator)
+Animator::Animator(game_object_id_t id, const Animator::Data & ctx)
 	: Component(id),
-	  spritesheet(ss),
-	  row(row),
-	  col(col) {
+	data(ctx)
+{
 	dbg_trace();
 
-	this->spritesheet.mask.h /= col;
-	this->spritesheet.mask.w /= row;
-	this->spritesheet.mask.x = 0;
-	this->spritesheet.mask.y = col_animator * this->spritesheet.mask.h;
+	this->data.spritesheet.mask.h /= this->data.col;
+	this->data.spritesheet.mask.w /= this->data.row;
+	this->data.spritesheet.mask.x = 0;
+	this->data.spritesheet.mask.y = this->data.col * this->data.spritesheet.mask.h;
 
 	// need to do this for to get the aspect ratio for a single clipping in the spritesheet
-	this->spritesheet.aspect_ratio
-		= static_cast<double>(this->spritesheet.mask.w) / this->spritesheet.mask.h;
+	Sprite & ss = this->data.spritesheet;
+	ss.data.aspect_ratio
+		= static_cast<double>(this->data.spritesheet.mask.w) / this->data.spritesheet.mask.h;
 }
 Animator::~Animator() { dbg_trace(); }
 
-void Animator::loop() { this->looping = true; }
+void Animator::loop() { this->data.looping = true; }
 void Animator::play() { this->active = true; }
 void Animator::pause() { this->active = false; }
 void Animator::stop() {
 	this->active = false;
-	this->curr_col = 0;
-	this->curr_row = 0;
+	this->data.curr_col = 0;
+	this->data.curr_row = 0;
 }
-void Animator::set_fps(int fps) { this->fps = fps; }
+void Animator::set_fps(int fps) { this->data.fps = fps; }
 void Animator::set_cycle_range(int start, int end) {
-	this->cycle_start = start, this->cycle_end = end;
+	this->data.cycle_start = start, this->data.cycle_end = end;
 }
 void Animator::set_anim(int col) {
-	this->curr_row = 0;
-	this->curr_col = col;
+	this->data.curr_row = 0;
+	this->data.curr_col = col;
 }
diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index 511d6ef..194a9cf 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -16,6 +16,39 @@ class SDLContext;
  * sheet. It can be used to play animations, loop them, or stop them.
  */
 class Animator : public Component {
+public:
+	struct Data {
+		//! A reference to the Sprite sheet containing.
+		Sprite & spritesheet;
+
+		//! The maximum number of columns in the sprite sheet.
+		const int col;
+
+		//! The maximum number of rows in the sprite sheet.
+		const int row;
+
+		//! frames per second for animation
+		int fps;
+
+		//! The current col being animated.
+		int curr_col;
+
+		//! The current row being animated.
+		int curr_row = 0;
+
+		//! should the animation loop
+		bool looping = false;
+
+		//! starting frame for cycling
+		int cycle_start = 0;
+
+		//! end frame for cycling (-1 --> use last frame)
+		int cycle_end = -1;
+
+
+		//! offset in pixels.
+		int offset_x = 0;
+	};
 
 public:
 	/**
@@ -85,40 +118,11 @@ public:
 	 * This constructor sets up the Animator with the given parameters, and initializes the
 	 * animation system.
 	 */
-	Animator(uint32_t id, Sprite & spritesheet, int row, int col, int col_animate);
-
+	Animator(uint32_t id, const Animator::Data & ctx);
 	~Animator(); // dbg_trace
 
 public:
-	//! A reference to the Sprite sheet containing.
-	Sprite & spritesheet;
-
-	//! The maximum number of columns in the sprite sheet.
-	const int col;
-
-	//! The maximum number of rows in the sprite sheet.
-	const int row;
-
-	//! The current col being animated.
-	int curr_col = 0;
-
-	//! The current row being animated.
-	int curr_row = 0;
-
-	//! should the animation loop
-	bool looping = false;
-
-	//! starting frame for cycling
-	int cycle_start = 0;
-
-	//! end frame for cycling (-1 --> use last frame)
-	int cycle_end = -1;
-
-	//! frames per second for animation
-	int fps = 1;
-
-	//! offset in pixels.
-	int offset_x = 0;
+	Animator::Data data;
 
 private:
 	//! AnimatorSystem adjust the private member parameters of Animator;
diff --git a/src/crepe/api/Camera.cpp b/src/crepe/api/Camera.cpp
index 39d8ab0..27bcb35 100644
--- a/src/crepe/api/Camera.cpp
+++ b/src/crepe/api/Camera.cpp
@@ -2,19 +2,12 @@
 #include "util/Log.h"
 
 #include "Camera.h"
-#include "Color.h"
 #include "Component.h"
 
 using namespace crepe;
 
-Camera::Camera(game_object_id_t id, const Color & bg_color, const ivec2 & screen,
-			   const vec2 & viewport_size, const double & zoom, const vec2 & offset)
-	: Component(id),
-	  bg_color(bg_color),
-	  offset(offset),
-	  screen(screen),
-	  viewport_size(viewport_size),
-	  zoom(zoom) {
+Camera::Camera(game_object_id_t id, const Data & ctx) : Component(id), data(ctx) {
+
 	dbg_trace();
 }
 
diff --git a/src/crepe/api/Camera.h b/src/crepe/api/Camera.h
index 2d8fa48..e466d36 100644
--- a/src/crepe/api/Camera.h
+++ b/src/crepe/api/Camera.h
@@ -14,32 +14,35 @@ namespace crepe {
  * position, and zoom level. It controls what part of the game world is visible on the screen.
  */
 class Camera : public Component {
+public:
+	struct Data {
+		//! Background color of the camera view.
+		const Color bg_color;
+
+		//! screen the display size in pixels ( output resolution )
+		const ivec2 screen;
+
+		//! viewport is the area of the world visible through the camera (in world units)
+		const vec2 viewport_size;
+
+		//! Zoom level of the camera view.
+		double zoom;
+
+		//! offset postion from the game object transform component
+		vec2 offset;
+	};
 
 public:
 	/**
 	 * \brief Constructs a Camera with the specified ID and background color.
 	 * \param id Unique identifier for the camera component.
-	 * \param bg_color Background color for the camera view.
+	 * \param ctx the camera component data
 	 */
-	Camera(game_object_id_t id, const Color & bg_color, const ivec2 & screen,
-		   const vec2 & viewport_size, const double & zoom, const vec2 & offset = {0, 0});
+	Camera(game_object_id_t id, const Data & ctx);
 	~Camera(); // dbg_trace only
 
 public:
-	//! Background color of the camera view.
-	const Color bg_color;
-
-	//! offset postion from the game object transform component
-	vec2 offset;
-
-	//! screen the display size in pixels ( output resolution )
-	const ivec2 screen;
-
-	//! viewport is the area of the world visible through the camera (in world units)
-	const vec2 viewport_size;
-
-	//! Zoom level of the camera view.
-	const double zoom;
+	Camera::Data data;
 
 public:
 	/**
diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp
index 29e415f..fe495a1 100644
--- a/src/crepe/api/Sprite.cpp
+++ b/src/crepe/api/Sprite.cpp
@@ -11,21 +11,16 @@
 using namespace std;
 using namespace crepe;
 
-Sprite::Sprite(game_object_id_t id, Texture & image, const Color & color,
-			   const FlipSettings & flip, int sort_layer, int order_layer, const vec2 & size)
+Sprite::Sprite(game_object_id_t id, Texture & texture, const Sprite::Data & ctx)
 	: Component(id),
-	  color(color),
-	  flip(flip),
-	  sprite_image(std::move(image)),
-	  sorting_in_layer(sort_layer),
-	  order_in_layer(order_layer),
-	  size(size) {
+	  texture(std::move(texture)),
+	  data(ctx) {
 
 	dbg_trace();
 
-	this->mask.w = sprite_image.get_width();
-	this->mask.h = sprite_image.get_height();
-	this->aspect_ratio = static_cast<double>(this->mask.w) / this->mask.h;
+	this->mask.w = this->texture.get_width();
+	this->mask.h = this->texture.get_height();
+	this->data.aspect_ratio = static_cast<double>(this->mask.w) / this->mask.h;
 }
 
 Sprite::~Sprite() { dbg_trace(); }
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index 354f663..aef6a8d 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -19,73 +19,67 @@ class AnimatorSystem;
  * flip settings, and is managed in layers with defined sorting orders.
  */
 class Sprite : public Component {
-
 public:
 	struct FlipSettings {
 		bool flip_x = false;
 		bool flip_y = false;
 	};
 
+	struct Data {
+		//! Color tint of the sprite
+		Color color;
+
+		//! Flip settings for the sprite
+		FlipSettings flip;
+
+		//! Layer sorting level of the sprite
+		const int sorting_in_layer;
+
+		//! Order within the sorting layer
+		const int order_in_layer;
+
+		/**
+	 	* \size width and height of the sprite in game units
+	 	*
+	 	* if height is filled in and not width it will multiply width by aspect_ratio.
+	 	* if width is filled in and not height it will multiply height by aspect_ratio.
+	 	* if neither is filled it will not show sprite because size will be zero
+	 	* if both are filled will it use the width and height without making sure the aspect_ratio
+	 	* is correct
+	 	*/
+		vec2 size;
+
+		//! independent sprite angle. rotating clockwise direction in degrees
+		double angle_offset = 0;
+
+		//! independent sprite scale multiplier
+		double scale = 1;
+
+		/**
+	 	* \aspect_ratio ratio of the img so that scaling will not become weird
+	 	*
+	 	* cannot be const because if Animator component is addded then ratio becomes scuffed and
+	 	* does it need to be calculated again in the Animator
+	 	*/
+		float aspect_ratio;
+	};
+
 public:
-	// TODO: Loek comment in github #27 will be looked another time
-	// about shared_ptr Texture
 	/**
 	 * \brief Constructs a Sprite with specified parameters.
 	 * \param game_id Unique identifier for the game object this sprite belongs to.
-	 * \param image Shared pointer to the texture for this sprite.
-	 * \param color Color tint applied to the sprite.
-	 * \param flip Flip settings for horizontal and vertical orientation.
-	 * \param order_layer decides the sorting in layer of the sprite.
-	 * \param sort_layer decides the order in layer of the sprite.
-	 * \param height the height of the image in game units
-	 */
-	Sprite(game_object_id_t id, Texture & image, const Color & color,
-		   const FlipSettings & flip, int sort_layer, int order_layer, const vec2 & size);
-
-	/**
-	 * \brief Destroys the Sprite instance.
+	 * \param texture asset of the image
+	 * \param ctx all the sprite data
 	 */
+	//TODO: texture is outside the Sprite::Data because of the deleted copy constructer. eventually
+	//  texture will go into data when it becomes asset
+	Sprite(game_object_id_t id, Texture & texture, const Data & ctx);
 	~Sprite();
 
 	//! Texture used for the sprite
-	const Texture sprite_image;
-
-	//! Color tint of the sprite
-	Color color;
-
-	//! Flip settings for the sprite
-	FlipSettings flip;
-
-	//! Layer sorting level of the sprite
-	const int sorting_in_layer;
+	const Texture texture;
 
-	//! Order within the sorting layer
-	const int order_in_layer;
-
-	/**
-	 * \size width and height of the sprite in game units
-	 *
-	 * if height is filled in and not width it will multiply width by aspect_ratio.
-	 * if width is filled in and not height it will multiply height by aspect_ratio.
-	 * if neither is filled it will not show sprite because size will be zero
-	 * if both are filled will it use the width and height without making sure the aspect_ratio
-	 * is correct
-	 */
-	vec2 size;
-
-	//! independent sprite angle. rotating clockwise direction in degrees
-	double angle_offset = 0;
-
-	//! independent sprite scale multiplier
-	double scale = 1;
-
-	/**
-	 * \aspect_ratio ratio of the img so that scaling will not become weird
-	 *
-	 * cannot be const because if Animator component is addded then ratio becomes scuffed and
-	 * does it need to be calculated again in the Animator
-	 */
-	float aspect_ratio;
+	Data data;
 
 private:
 	//! Reads the mask of sprite
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index bba26a3..ab3fa45 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -112,17 +112,15 @@ SDL_Rect SDLContext::get_src_rect(const Sprite & sprite) const {
 
 SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
 
-	// this might not work all the time because of float checking zero -_-
-	vec2 size = {ctx.sprite.size.x == 0 && ctx.sprite.size.y != 0
-					 ? ctx.sprite.size.y * ctx.sprite.aspect_ratio
-					 : ctx.sprite.size.x,
-				 ctx.sprite.size.y == 0 && ctx.sprite.size.x != 0
-					 ? ctx.sprite.size.x / ctx.sprite.aspect_ratio
-					 : ctx.sprite.size.y};
+	const Sprite::Data & data = ctx.sprite.data;
+
+	vec2 size = {
+		data.size.x == 0 && data.size.y != 0 ? data.size.y * data.aspect_ratio : data.size.x,
+		data.size.y == 0 && data.size.x != 0 ? data.size.x / data.aspect_ratio : data.size.y};
 
 	const CameraValues & cam = ctx.cam;
 
-	size *= cam.render_scale * ctx.img_scale * ctx.sprite.scale;
+	size *= cam.render_scale * ctx.img_scale * data.scale;
 
 	vec2 screen_pos = (ctx.pos - cam.cam_pos + (cam.zoomed_viewport) / 2) * cam.render_scale
 					  - size / 2 + cam.bar_size;
@@ -137,9 +135,10 @@ SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
 
 void SDLContext::draw(const RenderContext & ctx) {
 
+	const Sprite::Data & data = ctx.sprite.data;
 	SDL_RendererFlip render_flip
-		= (SDL_RendererFlip) ((SDL_FLIP_HORIZONTAL * ctx.sprite.flip.flip_x)
-							  | (SDL_FLIP_VERTICAL * ctx.sprite.flip.flip_y));
+		= (SDL_RendererFlip) ((SDL_FLIP_HORIZONTAL * data.flip.flip_x)
+							  | (SDL_FLIP_VERTICAL * data.flip.flip_y));
 
 	SDL_Rect srcrect = this->get_src_rect(ctx.sprite);
 	SDL_FRect dstrect = this->get_dst_rect(SDLContext::DstRect{
@@ -149,10 +148,10 @@ void SDLContext::draw(const RenderContext & ctx) {
 		.img_scale = ctx.scale,
 	});
 
-	double angle = ctx.angle + ctx.sprite.angle_offset;
+	double angle = ctx.angle + data.angle_offset;
 
-	SDL_RenderCopyExF(this->game_renderer.get(), ctx.sprite.sprite_image.texture.get(),
-					  &srcrect, &dstrect, angle, NULL, render_flip);
+	SDL_RenderCopyExF(this->game_renderer.get(), ctx.sprite.texture.texture.get(), &srcrect,
+					  &dstrect, angle, NULL, render_flip);
 }
 
 void SDLContext::set_camera(const Camera & cam, CameraValues & ctx) {
diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp
index 1650b3d..b1f23d1 100644
--- a/src/crepe/system/AnimatorSystem.cpp
+++ b/src/crepe/system/AnimatorSystem.cpp
@@ -17,20 +17,21 @@ void AnimatorSystem::update() {
 
 	for (Animator & a : animations) {
 		if (!a.active) continue;
+		
+		Animator::Data & ctx = a.data;
+		double frame_duration = 1.0f / ctx.fps;
 
-		double frame_duration = 1.0f / a.fps;
-
-		int cycle_end = (a.cycle_end == -1) ? a.row : cycle_end;
-		int total_frames = cycle_end - a.cycle_start;
+		int cycle_end = (ctx.cycle_end == -1) ? ctx.row : cycle_end;
+		int total_frames = cycle_end - ctx.cycle_start;
 
 		int curr_frame = static_cast<int>(elapsed_time / frame_duration) % total_frames;
 
-		a.curr_row = a.cycle_start + curr_frame;
-		a.spritesheet.mask.x = a.curr_row * a.spritesheet.mask.w;
-		a.spritesheet.mask.y = (a.curr_col * a.spritesheet.mask.h);
+		ctx.curr_row = ctx.cycle_start + curr_frame;
+		ctx.spritesheet.mask.x = ctx.curr_row * ctx.spritesheet.mask.w;
+		ctx.spritesheet.mask.y = (ctx.curr_col * ctx.spritesheet.mask.h);
 	
 		std::cout << curr_frame << " " << total_frames << std::endl;
-		if (!a.looping && curr_frame == 0) {
+		if (!ctx.looping && curr_frame == 0) {
 			a.active = false;
 		}
 	}
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index 944ac86..08f254f 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -40,8 +40,9 @@ const Camera & RenderSystem::update_camera() {
 }
 
 bool sorting_comparison(const Sprite & a, const Sprite & b) {
-	if (a.sorting_in_layer < b.sorting_in_layer) return true;
-	if (a.sorting_in_layer == b.sorting_in_layer) return a.order_in_layer < b.order_in_layer;
+	if (a.data.sorting_in_layer < b.data.sorting_in_layer) return true;
+	if (a.data.sorting_in_layer == b.data.sorting_in_layer)
+		return a.data.order_in_layer < b.data.order_in_layer;
 
 	return false;
 }
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 5a50d27..4fd4071 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -56,11 +56,24 @@ public:
 		auto img = Texture("asset/spritesheet/pokemon_spritesheet.png");
 
 		Sprite & test_sprite = game_object.add_component<Sprite>(
-			img, color, Sprite::FlipSettings{false, false}, 1, 1, vec2{100, 100});
+			img, Sprite::Data{
+					 .color = color,
+					 .flip = Sprite::FlipSettings{false, false},
+					 .sorting_in_layer = 2,
+					 .order_in_layer = 2,
+					 .size = {0, 100},
+					 .angle_offset = 0,
+					 .scale = 1,
+				 });
 
-		auto & anim = game_object.add_component<Animator>(test_sprite, 4, 4, 0);
+		auto & anim = game_object.add_component<Animator>(Animator::Data{
+			.spritesheet = test_sprite,
+			.col = 4,
+			.row = 4,
+			.fps = 10,
+		});
 
-		auto & cam = game_object.add_component<Camera>(Color::, ivec2{720, 1280},
+		auto & cam = game_object.add_component<Camera>(Color::WHITE, ivec2{720, 1280},
 													   vec2{400, 400}, 1.0);
 	}
 
-- 
cgit v1.2.3


From 0a1739de21e5ab270cb45efb6fc0aed092d81227 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Mon, 2 Dec 2024 21:00:54 +0100
Subject: added all the contructor strutcts for animator,sprite and camera

---
 src/crepe/api/Animator.cpp          | 15 +++++++++++++--
 src/crepe/api/Animator.h            |  8 ++------
 src/crepe/api/Camera.cpp            |  1 -
 src/crepe/facade/SDLContext.cpp     | 35 ++++++++++++++++++-----------------
 src/crepe/facade/SDLContext.h       |  2 +-
 src/crepe/system/AnimatorSystem.cpp |  6 ++----
 src/crepe/system/RenderSystem.cpp   |  2 +-
 src/example/rendering_particle.cpp  | 14 +++++++++++---
 8 files changed, 48 insertions(+), 35 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp
index ce824e6..1234967 100644
--- a/src/crepe/api/Animator.cpp
+++ b/src/crepe/api/Animator.cpp
@@ -9,8 +9,7 @@ using namespace crepe;
 
 Animator::Animator(game_object_id_t id, const Animator::Data & ctx)
 	: Component(id),
-	data(ctx)
-{
+	  data(ctx) {
 	dbg_trace();
 
 	this->data.spritesheet.mask.h /= this->data.col;
@@ -23,21 +22,33 @@ Animator::Animator(game_object_id_t id, const Animator::Data & ctx)
 	ss.data.aspect_ratio
 		= static_cast<double>(this->data.spritesheet.mask.w) / this->data.spritesheet.mask.h;
 }
+
 Animator::~Animator() { dbg_trace(); }
 
 void Animator::loop() { this->data.looping = true; }
+
 void Animator::play() { this->active = true; }
+
 void Animator::pause() { this->active = false; }
+
 void Animator::stop() {
 	this->active = false;
 	this->data.curr_col = 0;
 	this->data.curr_row = 0;
 }
 void Animator::set_fps(int fps) { this->data.fps = fps; }
+
 void Animator::set_cycle_range(int start, int end) {
 	this->data.cycle_start = start, this->data.cycle_end = end;
 }
+
 void Animator::set_anim(int col) {
 	this->data.curr_row = 0;
 	this->data.curr_col = col;
 }
+
+void Animator::next_anim() {
+	Animator::Data & ctx = this->data;
+	ctx.curr_row = ctx.curr_row++ % ctx.row;
+	ctx.spritesheet.mask.x = ctx.curr_row * ctx.spritesheet.mask.w;
+}
diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index 194a9cf..36bc9f4 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -47,6 +47,7 @@ public:
 
 
 		//! offset in pixels.
+		// TODO implement
 		int offset_x = 0;
 	};
 
@@ -108,12 +109,7 @@ public:
 	 * \brief Constructs an Animator object that will control animations for a sprite sheet.
 	 *
 	 * \param id The unique identifier for the component, typically assigned automatically.
-	 * \param spritesheet A reference to the Sprite object which holds the sprite sheet for
-	 * animation.
-	 * \param row The maximum number of rows in the sprite sheet.
-	 * \param col The maximum number of columns in the sprite sheet.
-	 * \param col_animate The specific col index of the sprite sheet to animate. This allows
-	 * selecting which col to animate from multiple col in the sheet.
+	 * \param ctx animator data
 	 *
 	 * This constructor sets up the Animator with the given parameters, and initializes the
 	 * animation system.
diff --git a/src/crepe/api/Camera.cpp b/src/crepe/api/Camera.cpp
index 27bcb35..ff41710 100644
--- a/src/crepe/api/Camera.cpp
+++ b/src/crepe/api/Camera.cpp
@@ -7,7 +7,6 @@
 using namespace crepe;
 
 Camera::Camera(game_object_id_t id, const Data & ctx) : Component(id), data(ctx) {
-
 	dbg_trace();
 }
 
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index ab3fa45..32461f2 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -156,53 +156,54 @@ void SDLContext::draw(const RenderContext & ctx) {
 
 void SDLContext::set_camera(const Camera & cam, CameraValues & ctx) {
 
+	const Camera::Data & cam_data = cam.data;
 	// resize window
 	int w, h;
 	SDL_GetWindowSize(this->game_window.get(), &w, &h);
-	if (w != cam.screen.x || h != cam.screen.y) {
-		SDL_SetWindowSize(this->game_window.get(), cam.screen.x, cam.screen.y);
+	if (w != cam_data.screen.x || h != cam_data.screen.y) {
+		SDL_SetWindowSize(this->game_window.get(), cam_data.screen.x, cam_data.screen.y);
 	}
 
 	vec2 & zoomed_viewport = ctx.zoomed_viewport;
 	vec2 & bar_size = ctx.bar_size;
 	vec2 & render_scale = ctx.render_scale;
 
-	zoomed_viewport = cam.viewport_size * cam.zoom;
-	double screen_aspect = static_cast<double>(cam.screen.x) / cam.screen.y;
+	zoomed_viewport = cam_data.viewport_size * cam_data.zoom;
+	double screen_aspect = static_cast<double>(cam_data.screen.x) / cam_data.screen.y;
 	double viewport_aspect = zoomed_viewport.x / zoomed_viewport.y;
 
 	// calculate black bars
 	if (screen_aspect > viewport_aspect) {
 		// pillarboxing
-		float scale = cam.screen.y / zoomed_viewport.y;
+		float scale = cam_data.screen.y / zoomed_viewport.y;
 		float adj_width = zoomed_viewport.x * scale;
-		float bar_width = (cam.screen.x - adj_width) / 2;
-		this->black_bars[0] = {0, 0, bar_width, (float) cam.screen.y};
-		this->black_bars[1] = {(cam.screen.x - bar_width), 0, bar_width, (float) cam.screen.y};
+		float bar_width = (cam_data.screen.x - adj_width) / 2;
+		this->black_bars[0] = {0, 0, bar_width, (float) cam_data.screen.y};
+		this->black_bars[1] = {(cam_data.screen.x - bar_width), 0, bar_width, (float) cam_data.screen.y};
 
 		bar_size = {bar_width, 0};
 		render_scale.x = render_scale.y = scale;
 	} else {
 		// letterboxing
-		float scale = cam.screen.x / (cam.viewport_size.x * cam.zoom);
-		float adj_height = cam.viewport_size.y * scale;
-		float bar_height = (cam.screen.y - adj_height) / 2;
-		this->black_bars[0] = {0, 0, (float) cam.screen.x, bar_height};
+		float scale = cam_data.screen.x / (cam_data.viewport_size.x * cam_data.zoom);
+		float adj_height = cam_data.viewport_size.y * scale;
+		float bar_height = (cam_data.screen.y - adj_height) / 2;
+		this->black_bars[0] = {0, 0, (float) cam_data.screen.x, bar_height};
 		this->black_bars[1]
-			= {0, (cam.screen.y - bar_height), (float) cam.screen.x, bar_height};
+			= {0, (cam_data.screen.y - bar_height), (float) cam_data.screen.x, bar_height};
 
 		bar_size = {0, bar_height};
 		render_scale.x = render_scale.y = scale;
 	}
 
-	SDL_SetRenderDrawColor(this->game_renderer.get(), cam.bg_color.r, cam.bg_color.g,
-						   cam.bg_color.b, cam.bg_color.a);
+	SDL_SetRenderDrawColor(this->game_renderer.get(), cam_data.bg_color.r, cam_data.bg_color.g,
+						   cam_data.bg_color.b, cam_data.bg_color.a);
 
 	SDL_Rect bg = {
 		.x = 0,
 		.y = 0,
-		.w = cam.screen.x,
-		.h = cam.screen.y,
+		.w = cam_data.screen.x,
+		.h = cam_data.screen.y,
 	};
 
 	// fill bg color
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index 0a6fce6..a0d1da8 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -128,7 +128,7 @@ private:
 
 	/**
 	 * \brief Draws a sprite to the screen using the specified transform and camera.
-	 * \param RenderCtx Reference to rendering data to draw
+	 * \param RenderContext Reference to rendering data to draw
 	 */
 	void draw(const RenderContext & ctx);
 
diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp
index b1f23d1..ff8d2ce 100644
--- a/src/crepe/system/AnimatorSystem.cpp
+++ b/src/crepe/system/AnimatorSystem.cpp
@@ -4,7 +4,6 @@
 
 #include "AnimatorSystem.h"
 #include "ComponentManager.h"
-#include <iostream>
 
 using namespace crepe;
 
@@ -21,7 +20,7 @@ void AnimatorSystem::update() {
 		Animator::Data & ctx = a.data;
 		double frame_duration = 1.0f / ctx.fps;
 
-		int cycle_end = (ctx.cycle_end == -1) ? ctx.row : cycle_end;
+		int cycle_end = (ctx.cycle_end == -1) ? ctx.row : ctx.cycle_end;
 		int total_frames = cycle_end - ctx.cycle_start;
 
 		int curr_frame = static_cast<int>(elapsed_time / frame_duration) % total_frames;
@@ -30,8 +29,7 @@ void AnimatorSystem::update() {
 		ctx.spritesheet.mask.x = ctx.curr_row * ctx.spritesheet.mask.w;
 		ctx.spritesheet.mask.y = (ctx.curr_col * ctx.spritesheet.mask.h);
 	
-		std::cout << curr_frame << " " << total_frames << std::endl;
-		if (!ctx.looping && curr_frame == 0) {
+		if (!ctx.looping && curr_frame == total_frames - 1) {
 			a.active = false;
 		}
 	}
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index 08f254f..1bf5f65 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -33,7 +33,7 @@ const Camera & RenderSystem::update_camera() {
 		const Transform & transform
 			= mgr.get_components_by_id<Transform>(cam.game_object_id).front().get();
 		this->context.set_camera(cam, this->cam_ctx);
-		this->cam_ctx.cam_pos = transform.position + cam.offset;
+		this->cam_ctx.cam_pos = transform.position + cam.data.offset;
 		return cam;
 	}
 	throw std::runtime_error("No active cameras in current scene");
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 4fd4071..f84eb94 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -70,11 +70,19 @@ public:
 			.spritesheet = test_sprite,
 			.col = 4,
 			.row = 4,
-			.fps = 10,
+			.fps = 1,
+			.looping = true,
+			.cycle_start = 1,
+			.cycle_end = 3,
 		});
+		anim.set_anim(2);
 
-		auto & cam = game_object.add_component<Camera>(Color::WHITE, ivec2{720, 1280},
-													   vec2{400, 400}, 1.0);
+		auto & cam = game_object.add_component<Camera>(Camera::Data{
+			.bg_color = Color::WHITE,
+			.screen = ivec2{720, 1280},
+			.viewport_size = vec2{400, 400},
+			.zoom = 1.0,
+		});
 	}
 
 	string get_name() const { return "TestScene"; };
-- 
cgit v1.2.3


From 900cfa9f31de40308b9ea3d0c73372d44f11094c Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Mon, 2 Dec 2024 21:01:40 +0100
Subject: make format

---
 src/crepe/api/Animator.h            | 1 -
 src/crepe/facade/SDLContext.cpp     | 3 ++-
 src/crepe/system/AnimatorSystem.cpp | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index 36bc9f4..74abd5e 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -45,7 +45,6 @@ public:
 		//! end frame for cycling (-1 --> use last frame)
 		int cycle_end = -1;
 
-
 		//! offset in pixels.
 		// TODO implement
 		int offset_x = 0;
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 32461f2..391aa78 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -179,7 +179,8 @@ void SDLContext::set_camera(const Camera & cam, CameraValues & ctx) {
 		float adj_width = zoomed_viewport.x * scale;
 		float bar_width = (cam_data.screen.x - adj_width) / 2;
 		this->black_bars[0] = {0, 0, bar_width, (float) cam_data.screen.y};
-		this->black_bars[1] = {(cam_data.screen.x - bar_width), 0, bar_width, (float) cam_data.screen.y};
+		this->black_bars[1]
+			= {(cam_data.screen.x - bar_width), 0, bar_width, (float) cam_data.screen.y};
 
 		bar_size = {bar_width, 0};
 		render_scale.x = render_scale.y = scale;
diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp
index ff8d2ce..9cf8ba5 100644
--- a/src/crepe/system/AnimatorSystem.cpp
+++ b/src/crepe/system/AnimatorSystem.cpp
@@ -16,7 +16,7 @@ void AnimatorSystem::update() {
 
 	for (Animator & a : animations) {
 		if (!a.active) continue;
-		
+
 		Animator::Data & ctx = a.data;
 		double frame_duration = 1.0f / ctx.fps;
 
@@ -28,7 +28,7 @@ void AnimatorSystem::update() {
 		ctx.curr_row = ctx.cycle_start + curr_frame;
 		ctx.spritesheet.mask.x = ctx.curr_row * ctx.spritesheet.mask.w;
 		ctx.spritesheet.mask.y = (ctx.curr_col * ctx.spritesheet.mask.h);
-	
+
 		if (!ctx.looping && curr_frame == total_frames - 1) {
 			a.active = false;
 		}
-- 
cgit v1.2.3


From ff618da3f97237796042fa3664da59ed147bc1da Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Tue, 3 Dec 2024 19:32:15 +0100
Subject: improved comments

---
 src/crepe/Collider.h                 |  18 +++-
 src/crepe/api/BoxCollider.cpp        |   2 +-
 src/crepe/api/BoxCollider.h          |  10 +--
 src/crepe/api/Rigidbody.h            | 128 +++++++++++++++++++++++----
 src/crepe/system/CollisionSystem.cpp | 167 ++++++++++++++++-------------------
 src/crepe/system/CollisionSystem.h   |  32 ++-----
 src/crepe/system/PhysicsSystem.cpp   |   8 +-
 src/example/game.cpp                 |   4 +-
 src/test/CollisionTest.cpp           |  56 ++++++------
 src/test/PhysicsTest.cpp             |   8 +-
 src/test/Profiling.cpp               |   2 +-
 11 files changed, 257 insertions(+), 178 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/Collider.h b/src/crepe/Collider.h
index 15d3a24..f5f53d2 100644
--- a/src/crepe/Collider.h
+++ b/src/crepe/Collider.h
@@ -10,7 +10,23 @@ public:
 	Collider(game_object_id_t id, const vec2& offset);
 
 public:
-	//! Offset of the collider relative to rigidbody position 
+	/**
+	* \brief Offset of the collider relative to the rigidbody position.
+	*
+	* The `offset` defines the positional shift applied to the collider relative to the position of the rigidbody it is attached to.
+	* This allows the collider to be placed at a different position than the rigidbody, which can be useful for scenarios
+	* where the collider's position needs to differ from the rigidbody's center, such as in non-centered colliders.
+	* 
+	* - The `offset` is typically used when the collider is not meant to be centered exactly on the rigidbody's position.
+	* - For example, the collider might need to be shifted to account for an object with an asymmetrical shape or for objects
+	*   where the pivot point of the rigidbody is different from the collider's center.
+	* 
+	* When multiple colliders are added to the same object (e.g., a character with separate body parts or a vehicle with multiple zones),
+	* the offset is important for properly positioning each collider relative to the rigidbody, allowing accurate collision detection.
+	* 
+	* - Multiple colliders can be used on the same object, and each can have its own unique offset.
+	* - Overlap between colliders is allowed and does not impact performance.
+	*/
 	vec2 offset;
 };
 
diff --git a/src/crepe/api/BoxCollider.cpp b/src/crepe/api/BoxCollider.cpp
index 1069e90..f94ced7 100644
--- a/src/crepe/api/BoxCollider.cpp
+++ b/src/crepe/api/BoxCollider.cpp
@@ -4,4 +4,4 @@
 
 using namespace crepe;
 
-BoxCollider::BoxCollider(game_object_id_t game_object_id,const vec2& offset, float width, float height) : Collider(game_object_id,offset), width(width), height(height) {}
+BoxCollider::BoxCollider(game_object_id_t game_object_id,const vec2& offset, const vec2& dimensions) : Collider(game_object_id,offset), dimensions(dimensions) {}
diff --git a/src/crepe/api/BoxCollider.h b/src/crepe/api/BoxCollider.h
index c83d54a..1f5f1c1 100644
--- a/src/crepe/api/BoxCollider.h
+++ b/src/crepe/api/BoxCollider.h
@@ -2,6 +2,7 @@
 
 #include "Vector2.h"
 #include "../Collider.h"
+#include "types.h"
 
 namespace crepe {
 
@@ -12,13 +13,10 @@ namespace crepe {
  */
 class BoxCollider : public Collider {
 public:
-	BoxCollider(game_object_id_t game_object_id,const vec2& offset, float width, float height);
+	BoxCollider(game_object_id_t game_object_id,const vec2& offset, const vec2& dimensions);
 
-	//! Width of box collider 
-	float width;
-
-	//! Height of box collider
-	float height;
+	//! Width and height of the box collider 
+	vec2 dimensions;
 };
 
 } // namespace crepe
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index 63b1b51..9cdf3f5 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -36,11 +36,11 @@ public:
 	 * the systems will not move the object.
 	 */
 	struct PhysicsConstraints {
-		//! X constraint
+		//! Prevent movement along X axis
 		bool x = false;
-		//! Y constraint
+		//! Prevent movement along Y axis
 		bool y = false;
-		//! rotation constraint
+		//! Prevent rotation
 		bool rotation = false;
 	};
 
@@ -53,27 +53,112 @@ public:
 	struct Data {
 		//! objects mass
 		float mass = 0.0;
-		//! gravtiy scale
+		/**
+		* \brief Gravity scale factor.
+		*
+		* The `gravity_scale` controls how much gravity affects the object. It is a multiplier applied to the default
+		* gravity force, allowing for fine-grained control over how the object responds to gravity.
+		* 
+		* - A value of `0.0` means that gravity has **no effect** on the object (i.e., the object is completely immune to gravity).
+		* - A value of `1.0` means that gravity is applied at its **normal intensity** (the default behavior).
+		* - A value greater than `1.0` means the object is affected by gravity more strongly than normal.
+		* - A value less than `1.0` (but greater than `0.0`) reduces the effect of gravity on the object.
+		* 
+		* This is useful in cases where you need objects to behave differently under gravity, such as lighter objects (like feathers),
+		* objects that float in water, or heavier objects that fall faster.
+		*/
 		float gravity_scale = 0;
-		//! Changes if physics apply
+		/**
+		* \brief Defines the type of the physics body, which determines how the physics system interacts with the object.
+		*
+		* - **Static**: The object does not move and is not affected by forces. It is used for immovable objects like walls or terrain. Does not have collision detection.
+		* - **Dynamic**: The object is fully affected by physics forces, including gravity, collisions, and other physical interactions. It can move and be moved by forces.
+		* - **Kinematic**: The object does not move and is not affected by forces. It is typically controlled by external factors (e.g., animations or user input), and collision detection is handled without affecting its velocity.
+		*
+		* The `body_type` defines the behavior of the object in the physics system.
+		*
+		* \default BodyType::DYNAMIC
+		*/
 		BodyType body_type = BodyType::DYNAMIC;
-		//! linear velocity of object
+
+		/**
+		* \name Linear (positional) motion
+		*
+		* These variables define the linear motion (movement along the position) of an object.
+		* The linear velocity is applied to the object's position in each update of the PhysicsSystem.
+		* The motion is affected by the object's linear velocity, its maximum velocity, and a coefficient
+		* that can scale the velocity over time.
+		*
+		* \{
+		*/
+		//! Linear velocity of the object (speed and direction).
 		vec2 linear_velocity;
-		//! maximum linear velocity of object
+		//! Maximum linear velocity of the object. This limits the object's speed.
 		vec2 max_linear_velocity = {INFINITY ,INFINITY};
-		//! linear damping of object
-		vec2 linear_velocity_factor;
-		//! angular velocity of object
+		//! Linear velocity coefficient. This scales the object's velocity for adjustment or damping.
+		vec2 linear_velocity_coefficient = {1,1};
+		//! \}
+
+		/**
+		* \name Angular (rotational) motion
+		*
+		* These variables define the angular motion (rotation) of an object.
+		* The angular velocity determines how quickly the object rotates, while the maximum angular velocity
+		* sets a limit on the rotation speed. The angular velocity coefficient applies damping or scaling
+		* to the angular velocity, which can be used to simulate friction or other effects that slow down rotation.
+		*
+		* \{
+		*/
+		//! Angular velocity of the object, representing the rate of rotation (in radians per second).
 		float angular_velocity = 1;
-		//! max angular velocity of object
+		//! Maximum angular velocity of the object. This limits the maximum rate of rotation.
 		float max_angular_velocity = INFINITY;
-		//! angular damping of object
-		float angular_velocity_factor = 1;
-		//! movements constraints of object
+		//! Angular velocity coefficient. This scales the object's angular velocity, typically used for damping.
+		float angular_velocity_coefficient = 1;
+		//! \}
+
+		/**
+		* \brief Movement constraints for an object.
+		*
+		* The `PhysicsConstraints` struct defines the constraints that restrict an object's movement
+		* in certain directions or prevent rotation. These constraints effect only the physics system
+		* to prevent the object from moving or rotating in specified ways.
+		* 
+		* - **X Constraint**: If enabled, the object cannot move along the X-axis.
+		* - **Y Constraint**: If enabled, the object cannot move along the Y-axis.
+		* - **Rotation Constraint**: If enabled, the object cannot rotate.
+		* 
+		* These constraints allow you to restrict movement for specific scenarios (e.g., a platform that shouldn't move
+		* or a character that should only move horizontally).
+		*/
 		PhysicsConstraints constraints;
-		//! bounce factor of material. 0.0 <= means all velocity is lost, 1.0 means it gets the same momentum but the mirrored direction. 0.5 is half of the velocity is saved.
-		float elastisity = 0.0;
-		//! offset of all colliders relative to transform position
+
+		/**
+		* \brief Elasticity factor of the material (bounce factor).
+		*
+		* The `elasticity_coefficient` controls how much of the object's velocity is retained after a collision.
+		* It represents the material's ability to bounce or recover velocity upon impact. The coefficient is a value
+		* between 0.0 and 1.0, where:
+		*
+		* - **0.0** means no velocity is retained after the collision (all velocity is lost, and the object does not bounce).
+		* - **1.0** means the object retains its full velocity but in the opposite direction (perfect elastic bounce).
+		* - **0.5** means the object retains half of its velocity, resulting in a bounce with reduced speed.
+		*
+		* This factor can be used to simulate different materials, such as rubber (high elasticity) or concrete (low elasticity).
+		*/
+		float elastisity_coefficient = 0.0;
+
+		/**
+		* \brief Offset of all colliders relative to the object's transform position.
+		*
+		* The `offset` defines a positional shift applied to all colliders associated with the object, relative to the object's
+		* transform position. This allows for the colliders to be placed at a different position than the object's actual
+		* position, without modifying the object's transform itself.
+		* 
+		* - The `offset` is typically used to adjust the collider's position in cases where all colluders should be moved.
+		* - For example, if a character has a animation where all colliders should be moved this offset can be used to 
+		*		achieve this.
+		*/
 		vec2 offset;
 	};
 
@@ -99,6 +184,15 @@ public:
 	 * \param force Vector2 that is added to the angular force.
 	 */
 	void add_force_angular(float force);
+
+protected:
+	/**
+	* Ensures there is at most one Rigidbody component per entity.
+	* \return Always returns 1, indicating this constraint.
+	*/
+	virtual int get_instances_max() const { return 1; }
+	//! ComponentManager instantiates all components
+	friend class ComponentManager;
 };
 
 } // namespace crepe
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 380cc3d..2d5ce9d 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -10,6 +10,7 @@
 #include "api/EventManager.h"
 #include "api/BoxCollider.h"
 #include "api/CircleCollider.h"
+#include "api/Metadata.h"
 #include "api/Vector2.h"
 #include "api/Rigidbody.h"
 #include "api/Transform.h"
@@ -23,18 +24,16 @@
 using namespace crepe;
 
 void CollisionSystem::update() {
-	
 	std::vector<CollisionInternal> all_colliders;
-	ComponentManager & mgr = this->component_manager;
 	game_object_id_t id = 0;
-	RefVector<Rigidbody> rigidbodies = mgr.get_components_by_type<Rigidbody>();
+	RefVector<Rigidbody> rigidbodies = this->component_manager.get_components_by_type<Rigidbody>();
 	// Collisions can only happen on object with a rigidbody
 	for(Rigidbody& rigidbody : rigidbodies) {
 		if (!rigidbody.active) continue;
 		id = rigidbody.game_object_id;
 		Transform& transform = this->component_manager.get_components_by_id<Transform>(id).front().get();
 		// Check if the boxcollider is active and has the same id as the rigidbody.
-		RefVector<BoxCollider> boxcolliders	= mgr.get_components_by_type<BoxCollider>();
+		RefVector<BoxCollider> boxcolliders	= this->component_manager.get_components_by_type<BoxCollider>();
 		for (BoxCollider& boxcollider : boxcolliders) {
 			if(boxcollider.game_object_id != id) continue;
 			if(!boxcollider.active) continue;
@@ -48,7 +47,7 @@ void CollisionSystem::update() {
 				);
 		}
 		// Check if the circlecollider is active and has the same id as the rigidbody.
-		RefVector<CircleCollider> circlecolliders	= mgr.get_components_by_type<CircleCollider>();
+		RefVector<CircleCollider> circlecolliders	= this->component_manager.get_components_by_type<CircleCollider>();
 		for (CircleCollider& circlecollider : circlecolliders) {
 			if(circlecollider.game_object_id != id) continue;
 			if(!circlecollider.active) continue;
@@ -64,59 +63,63 @@ void CollisionSystem::update() {
 	}
 
 	// Check between all colliders if there is a collision
-	std::vector<std::pair<CollisionInternal,CollisionInternal>> collided = gather_collisions(all_colliders);
+	std::vector<std::pair<CollisionInternal,CollisionInternal>> collided = this->gather_collisions(all_colliders);
 
 	// For both objects call the collision handler 
 	for (auto& collision_pair : collided) {
-		collision_handler_request(collision_pair.first,collision_pair.second);
-		collision_handler_request(collision_pair.second,collision_pair.first);
+		this->collision_handler_request(collision_pair.first,collision_pair.second);
+		this->collision_handler_request(collision_pair.second,collision_pair.first);
 	}
 }
 
-void CollisionSystem::collision_handler_request(CollisionInternal& data1,CollisionInternal& data2){
+void CollisionSystem::collision_handler_request(CollisionInternal& this_data,CollisionInternal& other_data){
 
-	CollisionInternalType type = get_collider_type(data1.collider,data2.collider);
-	std::pair<vec2,CollisionSystem::Direction> resolution_data = collision_handler(data1,data2,type);
+	CollisionInternalType type = this->get_collider_type(this_data.collider,other_data.collider);
+	std::pair<vec2,CollisionSystem::Direction> resolution_data = this->collision_handler(this_data,other_data,type);
 
-	OptionalRef<Collider> collider1;
-	OptionalRef<Collider> collider2;
+	OptionalRef<Metadata> this_metadata = this->component_manager.get_components_by_id<Metadata>(this_data.id).front().get();
+	OptionalRef<Metadata> other_metadata = this->component_manager.get_components_by_id<Metadata>(other_data.id).front().get();
+	OptionalRef<Collider> this_collider;
+	OptionalRef<Collider> other_collider;
 	switch (type) {
 		case CollisionInternalType::BOX_BOX:{
-			collider1 = std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
-			collider2 = std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
+			this_collider = std::get<std::reference_wrapper<BoxCollider>>(this_data.collider);
+			other_collider = std::get<std::reference_wrapper<BoxCollider>>(other_data.collider);
 			break;
 		}
 		case CollisionInternalType::BOX_CIRCLE:{
-			collider1 = std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
-			collider2 = std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
+			this_collider = std::get<std::reference_wrapper<BoxCollider>>(this_data.collider);
+			other_collider = std::get<std::reference_wrapper<CircleCollider>>(other_data.collider);
 			break;
 		}
 		case CollisionInternalType::CIRCLE_BOX:{
-			collider1 = std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
-			collider2 = std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
+			this_collider = std::get<std::reference_wrapper<CircleCollider>>(this_data.collider);
+			other_collider = std::get<std::reference_wrapper<BoxCollider>>(other_data.collider);
 			break;
 		}
 		case CollisionInternalType::CIRCLE_CIRCLE:{
-			collider1 = std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
-			collider2 = std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
+			this_collider = std::get<std::reference_wrapper<CircleCollider>>(this_data.collider);
+			other_collider = std::get<std::reference_wrapper<CircleCollider>>(other_data.collider);
 			break;
 		}
 	}
-	
+
 	// collision info
 	crepe::CollisionSystem::CollisionInfo collision_info{
-						.first_collider = collider1,
-						.first_transform = data1.transform,
-						.first_rigidbody = data1.rigidbody,
-						.second_collider = collider2,
-						.second_transform = data2.transform,
-						.second_rigidbody = data2.rigidbody,
+						.this_collider = this_collider,
+						.this_transform = this_data.transform,
+						.this_rigidbody = this_data.rigidbody,
+						.this_metadata = this_metadata,
+						.other_collider = other_collider,
+						.other_transform = other_data.transform,
+						.other_rigidbody = other_data.rigidbody,
+						.other_metadata = other_metadata,
 						.resolution = resolution_data.first,
 						.resolution_direction = resolution_data.second,
         };
 
 	// Determine if static needs to be called
-	determine_collision_handler(collision_info);	
+	this->determine_collision_handler(collision_info);	
 }
 
 
@@ -126,33 +129,33 @@ std::pair<vec2,CollisionSystem::Direction> CollisionSystem::collision_handler(Co
 		case CollisionInternalType::BOX_BOX:	{
 			const BoxCollider & collider1 = std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
 			const BoxCollider & collider2 = std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
-			vec2 collider_pos1 = get_current_position(collider1.offset, data1.transform, data1.rigidbody);
-			vec2 collider_pos2 = get_current_position(collider2.offset, data2.transform, data2.rigidbody);
-			resolution = get_box_box_resolution(collider1,collider2,collider_pos1,collider_pos2);
+			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, data1.rigidbody);
+			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, data2.rigidbody);
+			resolution = this->get_box_box_resolution(collider1,collider2,collider_pos1,collider_pos2);
 			break;
 		}
 		case CollisionInternalType::BOX_CIRCLE: {
 			const BoxCollider & collider1 = std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
 			const CircleCollider & collider2 = std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
-			vec2 collider_pos1 = get_current_position(collider1.offset, data1.transform, data1.rigidbody);
-			vec2 collider_pos2 = get_current_position(collider2.offset, data2.transform, data2.rigidbody);
-			resolution = get_circle_box_resolution(collider2,collider1,collider_pos2,collider_pos1);
+			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, data1.rigidbody);
+			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, data2.rigidbody);
+			resolution = this->get_circle_box_resolution(collider2,collider1,collider_pos2,collider_pos1);
 			break;
 		}
 		case CollisionInternalType::CIRCLE_CIRCLE:	{
 			const CircleCollider & collider1 = std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
 			const CircleCollider & collider2 = std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
-			vec2 collider_pos1 = get_current_position(collider1.offset, data1.transform, data1.rigidbody);
-			vec2 collider_pos2 = get_current_position(collider2.offset, data2.transform, data2.rigidbody);
-			resolution = get_circle_circle_resolution(collider1,collider2,collider_pos1,collider_pos2);
+			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, data1.rigidbody);
+			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, data2.rigidbody);
+			resolution = this->get_circle_circle_resolution(collider1,collider2,collider_pos1,collider_pos2);
 			break;
 		}
 		case CollisionInternalType::CIRCLE_BOX:	{
 			const CircleCollider & collider1 = std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
 			const BoxCollider & collider2 = std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
-			vec2 collider_pos1 = get_current_position(collider1.offset, data1.transform, data1.rigidbody);
-			vec2 collider_pos2 = get_current_position(collider2.offset, data2.transform, data2.rigidbody);
-			resolution = get_circle_box_resolution(collider1,collider2,collider_pos1,collider_pos2);
+			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, data1.rigidbody);
+			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, data2.rigidbody);
+			resolution = this->get_circle_box_resolution(collider1,collider2,collider_pos1,collider_pos2);
 			break;
 		}
 	}
@@ -179,10 +182,10 @@ vec2 CollisionSystem::get_box_box_resolution(const BoxCollider& box_collider1,co
 	vec2 delta = final_position2 - final_position1;
 
 	// Compute half-dimensions of the boxes
-	float half_width1 = box_collider1.width / 2.0;
-	float half_height1 = box_collider1.height / 2.0;
-	float half_width2 = box_collider2.width / 2.0;
-	float half_height2 = box_collider2.height / 2.0;
+	float half_width1 = box_collider1.dimensions.x / 2.0;
+	float half_height1 = box_collider1.dimensions.y / 2.0;
+	float half_width2 = box_collider2.dimensions.x / 2.0;
+	float half_height2 = box_collider2.dimensions.y / 2.0;
 
 	// Calculate overlaps along X and Y axes
 	float overlap_x = (half_width1 + half_width2) - std::abs(delta.x);
@@ -234,8 +237,8 @@ vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider& circle_col
     vec2 delta = circle_position - box_position;
 
     // Compute half-dimensions of the box
-    float half_width = box_collider.width / 2.0f;
-    float half_height = box_collider.height / 2.0f;
+    float half_width = box_collider.dimensions.x / 2.0f;
+    float half_height = box_collider.dimensions.y / 2.0f;
 
     // Clamp circle center to the nearest point on the box
     vec2 closest_point;
@@ -261,37 +264,37 @@ vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider& circle_col
 
 void CollisionSystem::determine_collision_handler(CollisionInfo& info){
 	// Check rigidbody type for static
-	if(info.first_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) return;
+	if(info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) return;
 	// If second body is static perform the static collision handler in this system
-	if(info.second_rigidbody.data.body_type == Rigidbody::BodyType::STATIC){
+	if(info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC){
 		static_collision_handler(info);
 	}; 
 	// Call collision event for user
 	CollisionEvent data(info);
-	EventManager::get_instance().trigger_event<CollisionEvent>(data, info.first_collider.game_object_id);
+	EventManager::get_instance().trigger_event<CollisionEvent>(data, info.this_collider.game_object_id);
 }
 
 void CollisionSystem::static_collision_handler(CollisionInfo& info){
 	// Move object back using calculate move back value 
-	info.first_transform.position += info.resolution;
+	info.this_transform.position += info.resolution;
 
 	// If bounce is enabled mirror velocity
-	if(info.first_rigidbody.data.elastisity > 0) {
+	if(info.this_rigidbody.data.elastisity_coefficient > 0) {
 		if(info.resolution_direction == Direction::BOTH)
 		{
-			info.first_rigidbody.data.linear_velocity.y = -info.first_rigidbody.data.linear_velocity.y * info.first_rigidbody.data.elastisity;
-			info.first_rigidbody.data.linear_velocity.x = -info.first_rigidbody.data.linear_velocity.x * info.first_rigidbody.data.elastisity;
+			info.this_rigidbody.data.linear_velocity.y = -info.this_rigidbody.data.linear_velocity.y * info.this_rigidbody.data.elastisity_coefficient;
+			info.this_rigidbody.data.linear_velocity.x = -info.this_rigidbody.data.linear_velocity.x * info.this_rigidbody.data.elastisity_coefficient;
 		}
 		else if(info.resolution_direction == Direction::Y_DIRECTION) {
-			info.first_rigidbody.data.linear_velocity.y = -info.first_rigidbody.data.linear_velocity.y * info.first_rigidbody.data.elastisity;
+			info.this_rigidbody.data.linear_velocity.y = -info.this_rigidbody.data.linear_velocity.y * info.this_rigidbody.data.elastisity_coefficient;
 		}
 		else if(info.resolution_direction == Direction::X_DIRECTION){
-			info.first_rigidbody.data.linear_velocity.x = -info.first_rigidbody.data.linear_velocity.x * info.first_rigidbody.data.elastisity;
+			info.this_rigidbody.data.linear_velocity.x = -info.this_rigidbody.data.linear_velocity.x * info.this_rigidbody.data.elastisity_coefficient;
 		}
 	}
 	// Stop movement if bounce is disabled
 	else {
-		info.first_rigidbody.data.linear_velocity = {0,0};
+		info.this_rigidbody.data.linear_velocity = {0,0};
 	}
 }
 
@@ -332,24 +335,6 @@ std::vector<std::pair<CollisionSystem::CollisionInternal,CollisionSystem::Collis
 	return collisions_ret;
 }
 
-std::optional<std::pair<std::reference_wrapper<Transform>, std::reference_wrapper<Rigidbody>>>
-CollisionSystem::get_active_transform_and_rigidbody(game_object_id_t game_object_id) const{
-    RefVector<Transform> transforms = this->component_manager.get_components_by_id<Transform>(game_object_id);
-    if (transforms.empty()) return std::nullopt;
-
-		Transform& transform = transforms.front().get();
-    if (!transform.active) return std::nullopt;
-
-    RefVector<Rigidbody> rigidbodies = this->component_manager.get_components_by_id<Rigidbody>(game_object_id);
-    if (rigidbodies.empty()) return std::nullopt;
-
-    Rigidbody& rigidbody = rigidbodies.front().get();
-    if (!rigidbody.active) return std::nullopt;
-
-    // Return the active components
-    return std::make_pair(std::ref(transform), std::ref(rigidbody));
-}
-
 CollisionSystem::CollisionInternalType CollisionSystem::get_collider_type(const collider_variant& collider1,const collider_variant& collider2) const{
 	if(std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider1)){
 		if(std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider2))
@@ -376,22 +361,22 @@ bool CollisionSystem::get_collision(const CollisionInternal& first_info,const Co
 		case CollisionInternalType::BOX_BOX:	{
 			const BoxCollider & box_collider1 = std::get<std::reference_wrapper<BoxCollider>>(first_info.collider);
 			const BoxCollider & box_collider2 = std::get<std::reference_wrapper<BoxCollider>>(second_info.collider);
-			return get_box_box_collision(box_collider1,box_collider2,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
+			return this->get_box_box_collision(box_collider1,box_collider2,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
 		}
 		case CollisionInternalType::BOX_CIRCLE: {
 			const BoxCollider & box_collider = std::get<std::reference_wrapper<BoxCollider>>(first_info.collider);
 			const CircleCollider & circle_collider = std::get<std::reference_wrapper<CircleCollider>>(second_info.collider);
-			return get_box_circle_collision(box_collider,circle_collider,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
+			return this->get_box_circle_collision(box_collider,circle_collider,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
 		}
 		case CollisionInternalType::CIRCLE_CIRCLE:	{
 			const CircleCollider & circle_collider1 = std::get<std::reference_wrapper<CircleCollider>>(first_info.collider);
 			const CircleCollider & circle_collider2 = std::get<std::reference_wrapper<CircleCollider>>(second_info.collider);
-			return get_circle_circle_collision(circle_collider1,circle_collider2,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
+			return this->get_circle_circle_collision(circle_collider1,circle_collider2,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
 		}
 		case CollisionInternalType::CIRCLE_BOX:	{
 			const CircleCollider & circle_collider = std::get<std::reference_wrapper<CircleCollider>>(first_info.collider);
 			const BoxCollider & box_collider = std::get<std::reference_wrapper<BoxCollider>>(second_info.collider);
-			return get_box_circle_collision(box_collider,circle_collider,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
+			return this->get_box_circle_collision(box_collider,circle_collider,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
 		}
 	}
 	return false;
@@ -401,14 +386,14 @@ bool CollisionSystem::get_collision(const CollisionInternal& first_info,const Co
 bool CollisionSystem::get_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) const
 {
 	// Get current positions of colliders
-	vec2 final_position1 = get_current_position(box1.offset,transform1,rigidbody1);
-	vec2 final_position2 = get_current_position(box2.offset,transform2,rigidbody2);
+	vec2 final_position1 = this->get_current_position(box1.offset,transform1,rigidbody1);
+	vec2 final_position2 = this->get_current_position(box2.offset,transform2,rigidbody2);
 
 	// Calculate half-extents (half width and half height)
-	float half_width1 = box1.width / 2.0;
-	float half_height1 = box1.height / 2.0;
-	float half_width2 = box2.width / 2.0;
-	float half_height2 = box2.height / 2.0;
+	float half_width1 = box1.dimensions.x / 2.0;
+	float half_height1 = box1.dimensions.y / 2.0;
+	float half_width2 = box2.dimensions.x / 2.0;
+	float half_height2 = box2.dimensions.y / 2.0;
 
 	// Check if the boxes overlap along the X and Y axes
 	return (final_position1.x + half_width1 > final_position2.x - half_width2 &&
@@ -419,12 +404,12 @@ bool CollisionSystem::get_box_box_collision(const BoxCollider& box1, const BoxCo
 
 bool CollisionSystem::get_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) const {
 	// Get current positions of colliders
-	vec2 final_position1 = get_current_position(box1.offset, transform1, rigidbody1);
-	vec2 final_position2 = get_current_position(circle2.offset, transform2, rigidbody2);
+	vec2 final_position1 = this->get_current_position(box1.offset, transform1, rigidbody1);
+	vec2 final_position2 = this->get_current_position(circle2.offset, transform2, rigidbody2);
 
 	// Calculate box half-extents
-	float half_width = box1.width / 2.0;
-	float half_height = box1.height / 2.0;
+	float half_width = box1.dimensions.x / 2.0;
+	float half_height = box1.dimensions.y / 2.0;
 
 	// Find the closest point on the box to the circle's center
 	float closest_x = std::max(final_position1.x - half_width, std::min(final_position2.x, final_position1.x + half_width));
@@ -441,8 +426,8 @@ bool CollisionSystem::get_box_circle_collision(const BoxCollider& box1, const Ci
 
 bool CollisionSystem::get_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) const {
 	// Get current positions of colliders
-	vec2 final_position1 = get_current_position(circle1.offset,transform1,rigidbody1);
-	vec2 final_position2 = get_current_position(circle2.offset,transform2,rigidbody2);
+	vec2 final_position1 = this->get_current_position(circle1.offset,transform1,rigidbody1);
+	vec2 final_position2 = this->get_current_position(circle2.offset,transform2,rigidbody2);
 
 	float distance_x = final_position1.x - final_position2.x;
 	float distance_y = final_position1.y - final_position2.y;
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 7fb8b45..85ae5ad 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -8,6 +8,7 @@
 #include "api/Transform.h"
 #include "api/BoxCollider.h"
 #include "api/CircleCollider.h"
+#include "api/Metadata.h"
 #include "api/Vector2.h"
 
 #include "Collider.h"
@@ -68,12 +69,14 @@ public:
 		* Includes information about the colliding objects and the resolution data for handling the collision.
 		*/
 	struct CollisionInfo{
-    Collider& first_collider;
-		Transform& first_transform;
-		Rigidbody& first_rigidbody;
-    Collider& second_collider;
-		Transform& second_transform;
-		Rigidbody& second_rigidbody;
+    Collider& this_collider;
+		Transform& this_transform;
+		Rigidbody& this_rigidbody;
+		Metadata& this_metadata;
+    Collider& other_collider;
+		Transform& other_transform;
+		Rigidbody& other_rigidbody;
+		Metadata& other_metadata;
 		//! The resolution vector for the collision.
 		vec2 resolution;
 		//! The direction of movement for resolving the collision.
@@ -213,23 +216,6 @@ private:
 		*/
 	bool get_collision(const CollisionInternal& first_info,const CollisionInternal& second_info, CollisionInternalType type) const;
 	
-	/**
-		* \brief Retrieves the active Transform and Rigidbody components for a given game object.
-		* 
-		* This function looks up the Transform and Rigidbody components associated with the specified 
-		* game object ID. It checks if both components are present and active. If both are found 
-		* to be active, they are returned wrapped in reference wrappers; otherwise, an empty 
-		* optional is returned.
-		*
-		* \param game_object_id The ID of the game object for which to retrieve the components.
-		* 
-		* \return A std::optional containing a pair of reference wrappers to the active Transform 
-		*         and Rigidbody components, or std::nullopt if either component is not found 
-		*         or not active.
-		*/
-	std::optional<std::pair<std::reference_wrapper<Transform>, std::reference_wrapper<Rigidbody>>> get_active_transform_and_rigidbody(game_object_id_t game_object_id) const;
-
-
 	/**
 		* \brief Detects collisions between two BoxColliders.
 		* 
diff --git a/src/crepe/system/PhysicsSystem.cpp b/src/crepe/system/PhysicsSystem.cpp
index 8f21727..f3833cb 100644
--- a/src/crepe/system/PhysicsSystem.cpp
+++ b/src/crepe/system/PhysicsSystem.cpp
@@ -31,11 +31,11 @@ void PhysicsSystem::update() {
 									* gravity);
 						}
 						// Add damping
-						if (rigidbody.data.angular_velocity_factor != 1 && rigidbody.data.angular_velocity_factor > 0) {
-							rigidbody.data.angular_velocity *= rigidbody.data.angular_velocity_factor;
+						if (rigidbody.data.angular_velocity_coefficient != 1 && rigidbody.data.angular_velocity_coefficient > 0) {
+							rigidbody.data.angular_velocity *= rigidbody.data.angular_velocity_coefficient;
 						}
-						if (rigidbody.data.linear_velocity_factor != vec2{1, 1} && rigidbody.data.linear_velocity_factor.x > 0 && rigidbody.data.linear_velocity_factor.y > 0) {
-							rigidbody.data.linear_velocity *= rigidbody.data.linear_velocity_factor;
+						if (rigidbody.data.linear_velocity_coefficient != vec2{1, 1} && rigidbody.data.linear_velocity_coefficient.x > 0 && rigidbody.data.linear_velocity_coefficient.y > 0) {
+							rigidbody.data.linear_velocity *= rigidbody.data.linear_velocity_coefficient;
 						}
 
 						// Max velocity check
diff --git a/src/example/game.cpp b/src/example/game.cpp
index c439f5d..4e16d4a 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -18,7 +18,7 @@ using namespace std;
 
 class MyScript : public Script {
 	bool oncollision(const CollisionEvent& test) {
-		Log::logf("Box {} script on_collision()", test.info.first_collider.game_object_id);
+		Log::logf("Box {} script on_collision()", test.info.this_collider.game_object_id);
 		return true;
 	}
 	void init() {
@@ -65,7 +65,7 @@ public:
 		.body_type = Rigidbody::BodyType::DYNAMIC,
 		.linear_velocity = {1,1},
 		.constraints = {0, 0, 0},
-		.elastisity = 1,
+		.elastisity_coefficient = 1,
 		.offset = {0,0},
 	});
 	game_object1.add_component<BoxCollider>(vec2{0, 0}, 20, 20);
diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp
index 92ff7ba..fec42f3 100644
--- a/src/test/CollisionTest.cpp
+++ b/src/test/CollisionTest.cpp
@@ -68,10 +68,10 @@ public:
 			.offset = {0,0},
 		});
 		// Create a box with an inner size of 10x10 units
-		world.add_component<BoxCollider>(vec2{0, -100}, 100, 100); // Top
-		world.add_component<BoxCollider>(vec2{0, 100}, 100, 100); // Bottom
-		world.add_component<BoxCollider>(vec2{-100, 0}, 100, 100); // Left
-		world.add_component<BoxCollider>(vec2{100, 0}, 100, 100); // right
+		world.add_component<BoxCollider>(vec2{0, -100}, vec2{100, 100}); // Top
+		world.add_component<BoxCollider>(vec2{0, 100}, vec2{100, 100}); // Bottom
+		world.add_component<BoxCollider>(vec2{-100, 0}, vec2{100, 100}); // Left
+		world.add_component<BoxCollider>(vec2{100, 0}, vec2{100, 100}); // right
 
 		game_object1.add_component<Rigidbody>(Rigidbody::Data{
 			.mass = 1,
@@ -79,10 +79,10 @@ public:
 			.body_type = Rigidbody::BodyType::DYNAMIC,
 			.linear_velocity = {0,0},
 			.constraints = {0, 0, 0},
-			.elastisity = 1,
+			.elastisity_coefficient = 1,
 			.offset = {0,0},
 		});
-		game_object1.add_component<BoxCollider>(vec2{0, 0}, 10, 10);
+		game_object1.add_component<BoxCollider>(vec2{0, 0}, vec2{10, 10});
 		BehaviorScript & script_object1 = game_object1.add_component<BehaviorScript>().set_script<CollisionHandler>(1);
 		script_object1_ref = static_cast<CollisionHandler*>(script_object1.script.get());
 		ASSERT_NE(script_object1_ref, nullptr);
@@ -93,10 +93,10 @@ public:
 			.body_type = Rigidbody::BodyType::DYNAMIC,
 			.linear_velocity = {0,0},
 			.constraints = {0, 0, 0},
-			.elastisity = 1,
+			.elastisity_coefficient = 1,
 			.offset = {0,0},
 		});
-		game_object2.add_component<BoxCollider>(vec2{0, 0}, 10, 10);
+		game_object2.add_component<BoxCollider>(vec2{0, 0}, vec2{10, 10});
 		BehaviorScript & script_object2 = game_object2.add_component<BehaviorScript>().set_script<CollisionHandler>(2);
 		script_object2_ref = static_cast<CollisionHandler*>(script_object2.script.get());
 		ASSERT_NE(script_object2_ref, nullptr);
@@ -110,11 +110,11 @@ TEST_F(CollisionTest, collision_example) {
 	bool collision_happend = false;
 	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
 	};
 	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 2);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
 	};
 	EXPECT_FALSE(collision_happend);
 	collision_sys.update();
@@ -125,14 +125,14 @@ TEST_F(CollisionTest, collision_box_box_dynamic_both_no_velocity) {
 	bool collision_happend = false;
 	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
 		EXPECT_EQ(ev.info.resolution.x, 10);
 		EXPECT_EQ(ev.info.resolution.y, 10);
 		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH);
 	};
 	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 2);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
 		EXPECT_EQ(ev.info.resolution.x, 10);
 		EXPECT_EQ(ev.info.resolution.y, 10);
 		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH);
@@ -148,14 +148,14 @@ TEST_F(CollisionTest, collision_box_box_dynamic_x_direction_no_velocity) {
 	bool collision_happend = false;
 	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
 		EXPECT_EQ(ev.info.resolution.x, -5);
 		EXPECT_EQ(ev.info.resolution.y, 0);
 		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::X_DIRECTION);
 	};
 	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 2);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
 		EXPECT_EQ(ev.info.resolution.x, 5);
 		EXPECT_EQ(ev.info.resolution.y, 0);
 		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::X_DIRECTION);
@@ -171,14 +171,14 @@ TEST_F(CollisionTest, collision_box_box_dynamic_y_direction_no_velocity) {
 	bool collision_happend = false;
 	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
 		EXPECT_EQ(ev.info.resolution.x, 0);
 		EXPECT_EQ(ev.info.resolution.y, -5);
 		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::Y_DIRECTION);
 	};
 	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 2);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
 		EXPECT_EQ(ev.info.resolution.x, 0);
 		EXPECT_EQ(ev.info.resolution.y, 5);
 		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::Y_DIRECTION);
@@ -194,14 +194,14 @@ TEST_F(CollisionTest, collision_box_box_dynamic_both) {
 	bool collision_happend = false;
 	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
 		EXPECT_EQ(ev.info.resolution.x, 10);
 		EXPECT_EQ(ev.info.resolution.y, 10);
 		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH);
 	};
 	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 2);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
 		EXPECT_EQ(ev.info.resolution.x, 10);
 		EXPECT_EQ(ev.info.resolution.y, 10);
 		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH);
@@ -221,14 +221,14 @@ TEST_F(CollisionTest, collision_box_box_dynamic_x_direction) {
 	bool collision_happend = false;
 	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
 		EXPECT_EQ(ev.info.resolution.x, -5);
 		EXPECT_EQ(ev.info.resolution.y, -5);
 		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::X_DIRECTION);
 	};
 	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 2);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
 		EXPECT_EQ(ev.info.resolution.x, 5);
 		EXPECT_EQ(ev.info.resolution.y, 5);
 		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::X_DIRECTION);
@@ -248,14 +248,14 @@ TEST_F(CollisionTest, collision_box_box_dynamic_y_direction) {
 	bool collision_happend = false;
 	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
 		EXPECT_EQ(ev.info.resolution.x, -5);
 		EXPECT_EQ(ev.info.resolution.y, -5);
 		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::Y_DIRECTION);
 	};
 	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 2);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
 		EXPECT_EQ(ev.info.resolution.x, 5);
 		EXPECT_EQ(ev.info.resolution.y, 5);
 		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::Y_DIRECTION);
@@ -276,7 +276,7 @@ TEST_F(CollisionTest, collision_box_box_static_both) {
 	bool collision_happend = false;
 	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
 		EXPECT_EQ(ev.info.resolution.x, 10);
 		EXPECT_EQ(ev.info.resolution.y, 10);
 		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH);
@@ -298,7 +298,7 @@ TEST_F(CollisionTest, collision_box_box_static_x_direction) {
 	bool collision_happend = false;
 	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
 		EXPECT_EQ(ev.info.resolution.x, -5);
 		EXPECT_EQ(ev.info.resolution.y, -5);
 		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::X_DIRECTION);
@@ -322,7 +322,7 @@ TEST_F(CollisionTest, collision_box_box_static_y_direction) {
 	bool collision_happend = false;
 	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
 		EXPECT_EQ(ev.info.resolution.x, -5);
 		EXPECT_EQ(ev.info.resolution.y, -5);
 		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::Y_DIRECTION);
@@ -348,8 +348,8 @@ TEST_F(CollisionTest, collision_box_box_static_multiple) {//todo check visually
 	float resolution = 0;
 	script_object1_ref->test_fn = [&](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 1);
-		EXPECT_EQ(ev.info.first_collider.offset.x , offset_value);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.this_collider.offset.x , offset_value);
 		EXPECT_EQ(ev.info.resolution.x , resolution);
 	};
 	script_object2_ref->test_fn = [&](const CollisionEvent & ev) {
@@ -365,7 +365,7 @@ TEST_F(CollisionTest, collision_box_box_static_multiple) {//todo check visually
 	rg2.data.body_type = crepe::Rigidbody::BodyType::STATIC;
 	BoxCollider & bxc = this->mgr.get_components_by_id<BoxCollider>(1).front().get();
 	bxc.offset = {5,0};
-	this->game_object1.add_component<BoxCollider>(vec2{-5, 0}, 10, 10);
+	this->game_object1.add_component<BoxCollider>(vec2{-5, 0}, vec2{10, 10});
 	offset_value = 5;
 	resolution = 10;
 	collision_sys.update();
diff --git a/src/test/PhysicsTest.cpp b/src/test/PhysicsTest.cpp
index 5dd448f..ad7cb03 100644
--- a/src/test/PhysicsTest.cpp
+++ b/src/test/PhysicsTest.cpp
@@ -103,16 +103,16 @@ TEST_F(PhysicsTest, movement) {
 	EXPECT_EQ(transform.position.y, 1);
 	EXPECT_EQ(transform.rotation, 1);
 
-	rigidbody.data.linear_velocity_factor.x = 0.5;
-	rigidbody.data.linear_velocity_factor.y = 0.5;
-	rigidbody.data.angular_velocity_factor = 0.5;
+	rigidbody.data.linear_velocity_coefficient.x = 0.5;
+	rigidbody.data.linear_velocity_coefficient.y = 0.5;
+	rigidbody.data.angular_velocity_coefficient = 0.5;
 	system.update();
 	EXPECT_EQ(rigidbody.data.linear_velocity.x, 0.5);
 	EXPECT_EQ(rigidbody.data.linear_velocity.y, 0.5);
 	EXPECT_EQ(rigidbody.data.angular_velocity, 0.5);
 
 	rigidbody.data.constraints = {1, 1, 0};
-	rigidbody.data.angular_velocity_factor = 0;
+	rigidbody.data.angular_velocity_coefficient = 0;
 	rigidbody.data.max_angular_velocity = 1000;
 	rigidbody.data.angular_velocity = 360;
 	system.update();
diff --git a/src/test/Profiling.cpp b/src/test/Profiling.cpp
index e46d5ff..fa0f5f3 100644
--- a/src/test/Profiling.cpp
+++ b/src/test/Profiling.cpp
@@ -28,7 +28,7 @@ using namespace testing;
 
 class TestScript : public Script {
 	bool oncollision(const CollisionEvent& test) {
-		Log::logf("Box {} script on_collision()", test.info.first_collider.game_object_id);
+		Log::logf("Box {} script on_collision()", test.info.this_collider.game_object_id);
 		return true;
 	}
 	void init() {
-- 
cgit v1.2.3


From 9416841ad776d9117bc3b12ee3ceb9a8c7af4c73 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Tue, 3 Dec 2024 19:44:01 +0100
Subject: removed part of if

---
 src/crepe/api/Rigidbody.h          |  4 ++--
 src/crepe/system/PhysicsSystem.cpp |  4 ++--
 src/example/game.cpp               | 13 ++++++-------
 3 files changed, 10 insertions(+), 11 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index 9cdf3f5..14b183b 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -109,8 +109,8 @@ public:
 		*
 		* \{
 		*/
-		//! Angular velocity of the object, representing the rate of rotation (in radians per second).
-		float angular_velocity = 1;
+		//! Angular velocity of the object, representing the rate of rotation (in degrees).
+		float angular_velocity = 0;
 		//! Maximum angular velocity of the object. This limits the maximum rate of rotation.
 		float max_angular_velocity = INFINITY;
 		//! Angular velocity coefficient. This scales the object's angular velocity, typically used for damping.
diff --git a/src/crepe/system/PhysicsSystem.cpp b/src/crepe/system/PhysicsSystem.cpp
index f3833cb..b5da042 100644
--- a/src/crepe/system/PhysicsSystem.cpp
+++ b/src/crepe/system/PhysicsSystem.cpp
@@ -31,10 +31,10 @@ void PhysicsSystem::update() {
 									* gravity);
 						}
 						// Add damping
-						if (rigidbody.data.angular_velocity_coefficient != 1 && rigidbody.data.angular_velocity_coefficient > 0) {
+						if (rigidbody.data.angular_velocity_coefficient > 0) {
 							rigidbody.data.angular_velocity *= rigidbody.data.angular_velocity_coefficient;
 						}
-						if (rigidbody.data.linear_velocity_coefficient != vec2{1, 1} && rigidbody.data.linear_velocity_coefficient.x > 0 && rigidbody.data.linear_velocity_coefficient.y > 0) {
+						if (rigidbody.data.linear_velocity_coefficient.x > 0 && rigidbody.data.linear_velocity_coefficient.y > 0) {
 							rigidbody.data.linear_velocity *= rigidbody.data.linear_velocity_coefficient;
 						}
 
diff --git a/src/example/game.cpp b/src/example/game.cpp
index 4e16d4a..5e3fab7 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -52,11 +52,11 @@ public:
 		.constraints = {0, 0, 0},
 		.offset = {0,0}
 	});
-	world.add_component<BoxCollider>(vec2{0, 0-(screen_size_height/2+world_collider/2)}, world_collider, world_collider);;	// Top
-	world.add_component<BoxCollider>(vec2{0, screen_size_height/2+world_collider/2}, world_collider, world_collider); // Bottom
-	world.add_component<BoxCollider>(vec2{0-(screen_size_width/2+world_collider/2), 0}, world_collider, world_collider); // Left
-	world.add_component<BoxCollider>(vec2{screen_size_width/2+world_collider/2, 0}, world_collider, world_collider); // right
-
+	world.add_component<BoxCollider>(vec2{0, 0-(screen_size_height/2+world_collider/2)}, vec2{world_collider, world_collider});;	// Top
+	world.add_component<BoxCollider>(vec2{0, screen_size_height/2+world_collider/2}, vec2{world_collider, world_collider}); // Bottom
+	world.add_component<BoxCollider>(vec2{0-(screen_size_width/2+world_collider/2), 0}, vec2{world_collider, world_collider}); // Left
+	world.add_component<BoxCollider>(vec2{screen_size_width/2+world_collider/2, 0}, vec2{world_collider, world_collider}); // right
+	world.add_component<Camera>(Color::WHITE, ivec2{640, 480},vec2{640, 480}, 1.0f);
 
 	GameObject game_object1 = mgr.new_object("Name", "Tag", vec2{screen_size_width/2, screen_size_height/2}, 0, 1);
 	game_object1.add_component<Rigidbody>(Rigidbody::Data{
@@ -68,11 +68,10 @@ public:
 		.elastisity_coefficient = 1,
 		.offset = {0,0},
 	});
-	game_object1.add_component<BoxCollider>(vec2{0, 0}, 20, 20);
+	game_object1.add_component<BoxCollider>(vec2{0, 0}, vec2{20, 20});
 	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
 	auto img = Texture("asset/texture/green_square.png");
 	game_object1.add_component<Sprite>(img, color, Sprite::FlipSettings{false, false}, 1, 1, 500);
-	game_object1.add_component<Camera>(Color::WHITE, ivec2{1080, 720},vec2{2000, 2000}, 1.0f);
 	}
 
 	string get_name() const { return "scene1"; }
-- 
cgit v1.2.3


From 322e9a8ceaa8b2ce5d3e6056be4a9739817d47cf Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Tue, 3 Dec 2024 20:43:57 +0100
Subject: improved comments

---
 src/crepe/Collider.h      | 12 +-----------
 src/crepe/api/Rigidbody.h | 36 +++---------------------------------
 src/example/game.cpp      |  4 ++--
 3 files changed, 6 insertions(+), 46 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/Collider.h b/src/crepe/Collider.h
index f5f53d2..b3a09fb 100644
--- a/src/crepe/Collider.h
+++ b/src/crepe/Collider.h
@@ -14,18 +14,8 @@ public:
 	* \brief Offset of the collider relative to the rigidbody position.
 	*
 	* The `offset` defines the positional shift applied to the collider relative to the position of the rigidbody it is attached to.
-	* This allows the collider to be placed at a different position than the rigidbody, which can be useful for scenarios
-	* where the collider's position needs to differ from the rigidbody's center, such as in non-centered colliders.
+	* This allows the collider to be placed at a different position than the rigidbody.
 	* 
-	* - The `offset` is typically used when the collider is not meant to be centered exactly on the rigidbody's position.
-	* - For example, the collider might need to be shifted to account for an object with an asymmetrical shape or for objects
-	*   where the pivot point of the rigidbody is different from the collider's center.
-	* 
-	* When multiple colliders are added to the same object (e.g., a character with separate body parts or a vehicle with multiple zones),
-	* the offset is important for properly positioning each collider relative to the rigidbody, allowing accurate collision detection.
-	* 
-	* - Multiple colliders can be used on the same object, and each can have its own unique offset.
-	* - Overlap between colliders is allowed and does not impact performance.
 	*/
 	vec2 offset;
 };
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index 14b183b..431e000 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -59,26 +59,10 @@ public:
 		* The `gravity_scale` controls how much gravity affects the object. It is a multiplier applied to the default
 		* gravity force, allowing for fine-grained control over how the object responds to gravity.
 		* 
-		* - A value of `0.0` means that gravity has **no effect** on the object (i.e., the object is completely immune to gravity).
-		* - A value of `1.0` means that gravity is applied at its **normal intensity** (the default behavior).
-		* - A value greater than `1.0` means the object is affected by gravity more strongly than normal.
-		* - A value less than `1.0` (but greater than `0.0`) reduces the effect of gravity on the object.
-		* 
-		* This is useful in cases where you need objects to behave differently under gravity, such as lighter objects (like feathers),
-		* objects that float in water, or heavier objects that fall faster.
 		*/
 		float gravity_scale = 0;
-		/**
-		* \brief Defines the type of the physics body, which determines how the physics system interacts with the object.
-		*
-		* - **Static**: The object does not move and is not affected by forces. It is used for immovable objects like walls or terrain. Does not have collision detection.
-		* - **Dynamic**: The object is fully affected by physics forces, including gravity, collisions, and other physical interactions. It can move and be moved by forces.
-		* - **Kinematic**: The object does not move and is not affected by forces. It is typically controlled by external factors (e.g., animations or user input), and collision detection is handled without affecting its velocity.
-		*
-		* The `body_type` defines the behavior of the object in the physics system.
-		*
-		* \default BodyType::DYNAMIC
-		*/
+
+		//! Defines the type of the physics body, which determines how the physics system interacts with the object.
 		BodyType body_type = BodyType::DYNAMIC;
 
 		/**
@@ -124,12 +108,6 @@ public:
 		* in certain directions or prevent rotation. These constraints effect only the physics system
 		* to prevent the object from moving or rotating in specified ways.
 		* 
-		* - **X Constraint**: If enabled, the object cannot move along the X-axis.
-		* - **Y Constraint**: If enabled, the object cannot move along the Y-axis.
-		* - **Rotation Constraint**: If enabled, the object cannot rotate.
-		* 
-		* These constraints allow you to restrict movement for specific scenarios (e.g., a platform that shouldn't move
-		* or a character that should only move horizontally).
 		*/
 		PhysicsConstraints constraints;
 
@@ -138,13 +116,8 @@ public:
 		*
 		* The `elasticity_coefficient` controls how much of the object's velocity is retained after a collision.
 		* It represents the material's ability to bounce or recover velocity upon impact. The coefficient is a value
-		* between 0.0 and 1.0, where:
-		*
-		* - **0.0** means no velocity is retained after the collision (all velocity is lost, and the object does not bounce).
-		* - **1.0** means the object retains its full velocity but in the opposite direction (perfect elastic bounce).
-		* - **0.5** means the object retains half of its velocity, resulting in a bounce with reduced speed.
+		* above 0.0.
 		*
-		* This factor can be used to simulate different materials, such as rubber (high elasticity) or concrete (low elasticity).
 		*/
 		float elastisity_coefficient = 0.0;
 
@@ -155,9 +128,6 @@ public:
 		* transform position. This allows for the colliders to be placed at a different position than the object's actual
 		* position, without modifying the object's transform itself.
 		* 
-		* - The `offset` is typically used to adjust the collider's position in cases where all colluders should be moved.
-		* - For example, if a character has a animation where all colliders should be moved this offset can be used to 
-		*		achieve this.
 		*/
 		vec2 offset;
 	};
diff --git a/src/example/game.cpp b/src/example/game.cpp
index 5e3fab7..de08a22 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -38,7 +38,7 @@ public:
 
 	void load_scene() {
 	ComponentManager & mgr = this->component_manager;
-	Color color(0, 0, 0, 0);
+	Color color(0, 0, 0, 255);
 
 	float screen_size_width = 640;
 	float screen_size_height = 480;
@@ -71,7 +71,7 @@ public:
 	game_object1.add_component<BoxCollider>(vec2{0, 0}, vec2{20, 20});
 	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
 	auto img = Texture("asset/texture/green_square.png");
-	game_object1.add_component<Sprite>(img, color, Sprite::FlipSettings{false, false}, 1, 1, 500);
+	game_object1.add_component<Sprite>(img, color, Sprite::FlipSettings{false, false}, 1, 1, 20);
 	}
 
 	string get_name() const { return "scene1"; }
-- 
cgit v1.2.3


From a11824956b478e356fa684c9d88b980aa22cb19a Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Wed, 4 Dec 2024 10:56:53 +0100
Subject: implemented feedback, cameraValues need better name?

---
 src/crepe/api/Animator.cpp          | 29 ++++++++++++----------
 src/crepe/api/Animator.h            | 22 +++++++++--------
 src/crepe/api/Camera.cpp            |  7 +++++-
 src/crepe/api/Camera.h              | 19 ++++++++-------
 src/crepe/api/Sprite.cpp            |  2 +-
 src/crepe/api/Sprite.h              | 25 ++++++++++---------
 src/crepe/facade/SDLContext.cpp     | 48 ++++++++++++++++++++-----------------
 src/crepe/facade/SDLContext.h       |  2 +-
 src/crepe/system/AnimatorSystem.cpp |  6 ++---
 src/crepe/system/RenderSystem.cpp   | 19 +++++++--------
 src/crepe/system/RenderSystem.h     |  8 +++----
 src/example/rendering_particle.cpp  | 14 +++--------
 12 files changed, 103 insertions(+), 98 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp
index 1234967..dc99fd4 100644
--- a/src/crepe/api/Animator.cpp
+++ b/src/crepe/api/Animator.cpp
@@ -7,20 +7,23 @@
 
 using namespace crepe;
 
-Animator::Animator(game_object_id_t id, const Animator::Data & ctx)
+Animator::Animator(uint32_t id, Sprite & ss, int max_row, int max_col,
+				   const Animator::Data & ctx)
 	: Component(id),
+	  spritesheet(ss),
+	  row(max_row),
+	  col(max_col),
 	  data(ctx) {
 	dbg_trace();
 
-	this->data.spritesheet.mask.h /= this->data.col;
-	this->data.spritesheet.mask.w /= this->data.row;
-	this->data.spritesheet.mask.x = 0;
-	this->data.spritesheet.mask.y = this->data.col * this->data.spritesheet.mask.h;
+	this->spritesheet.mask.h /= this->col;
+	this->spritesheet.mask.w /= this->row;
+	this->spritesheet.mask.x = this->data.curr_row * this->spritesheet.mask.w;
+	this->spritesheet.mask.y = this->data.curr_col * this->spritesheet.mask.h;
 
 	// need to do this for to get the aspect ratio for a single clipping in the spritesheet
-	Sprite & ss = this->data.spritesheet;
-	ss.data.aspect_ratio
-		= static_cast<double>(this->data.spritesheet.mask.w) / this->data.spritesheet.mask.h;
+	this->spritesheet.aspect_ratio
+		= static_cast<double>(this->spritesheet.mask.w) / this->spritesheet.mask.h;
 }
 
 Animator::~Animator() { dbg_trace(); }
@@ -43,12 +46,14 @@ void Animator::set_cycle_range(int start, int end) {
 }
 
 void Animator::set_anim(int col) {
-	this->data.curr_row = 0;
-	this->data.curr_col = col;
+	Animator::Data & ctx = this->data;
+	this->spritesheet.mask.x = ctx.curr_row = 0;
+	ctx.curr_col = col;
+	this->spritesheet.mask.y = ctx.curr_col * this->spritesheet.mask.h;
 }
 
 void Animator::next_anim() {
 	Animator::Data & ctx = this->data;
-	ctx.curr_row = ctx.curr_row++ % ctx.row;
-	ctx.spritesheet.mask.x = ctx.curr_row * ctx.spritesheet.mask.w;
+	ctx.curr_row = ctx.curr_row++ % this->row;
+	this->spritesheet.mask.x = ctx.curr_row * this->spritesheet.mask.w;
 }
diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index 74abd5e..1fe2b6f 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -18,20 +18,13 @@ class SDLContext;
 class Animator : public Component {
 public:
 	struct Data {
-		//! A reference to the Sprite sheet containing.
-		Sprite & spritesheet;
 
-		//! The maximum number of columns in the sprite sheet.
-		const int col;
-
-		//! The maximum number of rows in the sprite sheet.
-		const int row;
 
 		//! frames per second for animation
-		int fps;
+		int fps = 1;
 
 		//! The current col being animated.
-		int curr_col;
+		int curr_col = 0;
 
 		//! The current row being animated.
 		int curr_row = 0;
@@ -113,10 +106,19 @@ public:
 	 * This constructor sets up the Animator with the given parameters, and initializes the
 	 * animation system.
 	 */
-	Animator(uint32_t id, const Animator::Data & ctx);
+	Animator(uint32_t id, Sprite & ss, int max_row, int max_col, const Animator::Data & ctx);
 	~Animator(); // dbg_trace
 
 public:
+	//! A reference to the Sprite sheet containing.
+	Sprite & spritesheet;
+
+	//! The maximum number of columns in the sprite sheet.
+	const int col;
+
+	//! The maximum number of rows in the sprite sheet.
+	const int row;
+
 	Animator::Data data;
 
 private:
diff --git a/src/crepe/api/Camera.cpp b/src/crepe/api/Camera.cpp
index ff41710..b042c35 100644
--- a/src/crepe/api/Camera.cpp
+++ b/src/crepe/api/Camera.cpp
@@ -6,7 +6,12 @@
 
 using namespace crepe;
 
-Camera::Camera(game_object_id_t id, const Data & ctx) : Component(id), data(ctx) {
+Camera::Camera(game_object_id_t id, const ivec2 & screen, const vec2 & viewport_size,
+			   const Data & ctx)
+	: Component(id),
+	  screen(screen),
+	  viewport_size(viewport_size),
+	  data(ctx) {
 	dbg_trace();
 }
 
diff --git a/src/crepe/api/Camera.h b/src/crepe/api/Camera.h
index e466d36..f626379 100644
--- a/src/crepe/api/Camera.h
+++ b/src/crepe/api/Camera.h
@@ -17,16 +17,10 @@ class Camera : public Component {
 public:
 	struct Data {
 		//! Background color of the camera view.
-		const Color bg_color;
-
-		//! screen the display size in pixels ( output resolution )
-		const ivec2 screen;
-
-		//! viewport is the area of the world visible through the camera (in world units)
-		const vec2 viewport_size;
+		const Color bg_color = Color::WHITE;
 
 		//! Zoom level of the camera view.
-		double zoom;
+		double zoom = 1;
 
 		//! offset postion from the game object transform component
 		vec2 offset;
@@ -38,12 +32,19 @@ public:
 	 * \param id Unique identifier for the camera component.
 	 * \param ctx the camera component data
 	 */
-	Camera(game_object_id_t id, const Data & ctx);
+	Camera(game_object_id_t id, const ivec2 & screen, const vec2 & viewport_size,
+		   const Data & ctx);
 	~Camera(); // dbg_trace only
 
 public:
 	Camera::Data data;
 
+	//! screen the display size in pixels ( output resolution )
+	const ivec2 screen;
+
+	//! viewport is the area of the world visible through the camera (in world units)
+	const vec2 viewport_size;
+
 public:
 	/**
 	 * \brief Gets the maximum number of camera instances allowed.
diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp
index fe495a1..3a1acac 100644
--- a/src/crepe/api/Sprite.cpp
+++ b/src/crepe/api/Sprite.cpp
@@ -20,7 +20,7 @@ Sprite::Sprite(game_object_id_t id, Texture & texture, const Sprite::Data & ctx)
 
 	this->mask.w = this->texture.get_width();
 	this->mask.h = this->texture.get_height();
-	this->data.aspect_ratio = static_cast<double>(this->mask.w) / this->mask.h;
+	this->aspect_ratio = static_cast<double>(this->mask.w) / this->mask.h;
 }
 
 Sprite::~Sprite() { dbg_trace(); }
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index aef6a8d..d82ae8d 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -27,16 +27,16 @@ public:
 
 	struct Data {
 		//! Color tint of the sprite
-		Color color;
+		Color color = Color::WHITE;
 
 		//! Flip settings for the sprite
 		FlipSettings flip;
 
 		//! Layer sorting level of the sprite
-		const int sorting_in_layer;
+		const int sorting_in_layer = 0;
 
 		//! Order within the sorting layer
-		const int order_in_layer;
+		const int order_in_layer = 0;
 
 		/**
 	 	* \size width and height of the sprite in game units
@@ -53,15 +53,8 @@ public:
 		double angle_offset = 0;
 
 		//! independent sprite scale multiplier
-		double scale = 1;
+		double scale_offset = 1;
 
-		/**
-	 	* \aspect_ratio ratio of the img so that scaling will not become weird
-	 	*
-	 	* cannot be const because if Animator component is addded then ratio becomes scuffed and
-	 	* does it need to be calculated again in the Animator
-	 	*/
-		float aspect_ratio;
 	};
 
 public:
@@ -71,8 +64,6 @@ public:
 	 * \param texture asset of the image
 	 * \param ctx all the sprite data
 	 */
-	//TODO: texture is outside the Sprite::Data because of the deleted copy constructer. eventually
-	//  texture will go into data when it becomes asset
 	Sprite(game_object_id_t id, Texture & texture, const Data & ctx);
 	~Sprite();
 
@@ -82,6 +73,14 @@ public:
 	Data data;
 
 private:
+	/**
+		* \aspect_ratio ratio of the img so that scaling will not become weird
+		*
+		* cannot be const because if Animator component is addded then ratio becomes scuffed and
+		* does it need to be calculated again in the Animator
+		*/
+	float aspect_ratio;
+
 	//! Reads the mask of sprite
 	friend class SDLContext;
 
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 391aa78..d3a15d9 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -115,12 +115,12 @@ SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
 	const Sprite::Data & data = ctx.sprite.data;
 
 	vec2 size = {
-		data.size.x == 0 && data.size.y != 0 ? data.size.y * data.aspect_ratio : data.size.x,
-		data.size.y == 0 && data.size.x != 0 ? data.size.x / data.aspect_ratio : data.size.y};
+		data.size.x == 0 && data.size.y != 0 ? data.size.y * ctx.sprite.aspect_ratio : data.size.x,
+		data.size.y == 0 && data.size.x != 0 ? data.size.x / ctx.sprite.aspect_ratio : data.size.y};
 
 	const CameraValues & cam = ctx.cam;
 
-	size *= cam.render_scale * ctx.img_scale * data.scale;
+	size *= cam.render_scale * ctx.img_scale * data.scale_offset;
 
 	vec2 screen_pos = (ctx.pos - cam.cam_pos + (cam.zoomed_viewport) / 2) * cam.render_scale
 					  - size / 2 + cam.bar_size;
@@ -154,44 +154,45 @@ void SDLContext::draw(const RenderContext & ctx) {
 					  &dstrect, angle, NULL, render_flip);
 }
 
-void SDLContext::set_camera(const Camera & cam, CameraValues & ctx) {
+SDLContext::CameraValues SDLContext::set_camera(const Camera & cam) {
 
 	const Camera::Data & cam_data = cam.data;
+	CameraValues ret_cam;
 	// resize window
 	int w, h;
 	SDL_GetWindowSize(this->game_window.get(), &w, &h);
-	if (w != cam_data.screen.x || h != cam_data.screen.y) {
-		SDL_SetWindowSize(this->game_window.get(), cam_data.screen.x, cam_data.screen.y);
+	if (w != cam.screen.x || h != cam.screen.y) {
+		SDL_SetWindowSize(this->game_window.get(), cam.screen.x, cam.screen.y);
 	}
 
-	vec2 & zoomed_viewport = ctx.zoomed_viewport;
-	vec2 & bar_size = ctx.bar_size;
-	vec2 & render_scale = ctx.render_scale;
+	vec2 & zoomed_viewport = ret_cam.zoomed_viewport;
+	vec2 & bar_size = ret_cam.bar_size;
+	vec2 & render_scale = ret_cam.render_scale;
 
-	zoomed_viewport = cam_data.viewport_size * cam_data.zoom;
-	double screen_aspect = static_cast<double>(cam_data.screen.x) / cam_data.screen.y;
+	zoomed_viewport = cam.viewport_size * cam_data.zoom;
+	double screen_aspect = static_cast<double>(cam.screen.x) / cam.screen.y;
 	double viewport_aspect = zoomed_viewport.x / zoomed_viewport.y;
 
 	// calculate black bars
 	if (screen_aspect > viewport_aspect) {
 		// pillarboxing
-		float scale = cam_data.screen.y / zoomed_viewport.y;
+		float scale = cam.screen.y / zoomed_viewport.y;
 		float adj_width = zoomed_viewport.x * scale;
-		float bar_width = (cam_data.screen.x - adj_width) / 2;
-		this->black_bars[0] = {0, 0, bar_width, (float) cam_data.screen.y};
+		float bar_width = (cam.screen.x - adj_width) / 2;
+		this->black_bars[0] = {0, 0, bar_width, (float) cam.screen.y};
 		this->black_bars[1]
-			= {(cam_data.screen.x - bar_width), 0, bar_width, (float) cam_data.screen.y};
+			= {(cam.screen.x - bar_width), 0, bar_width, (float) cam.screen.y};
 
 		bar_size = {bar_width, 0};
 		render_scale.x = render_scale.y = scale;
 	} else {
 		// letterboxing
-		float scale = cam_data.screen.x / (cam_data.viewport_size.x * cam_data.zoom);
-		float adj_height = cam_data.viewport_size.y * scale;
-		float bar_height = (cam_data.screen.y - adj_height) / 2;
-		this->black_bars[0] = {0, 0, (float) cam_data.screen.x, bar_height};
+		float scale = cam.screen.x / (cam.viewport_size.x * cam_data.zoom);
+		float adj_height = cam.viewport_size.y * scale;
+		float bar_height = (cam.screen.y - adj_height) / 2;
+		this->black_bars[0] = {0, 0, (float) cam.screen.x, bar_height};
 		this->black_bars[1]
-			= {0, (cam_data.screen.y - bar_height), (float) cam_data.screen.x, bar_height};
+			= {0, (cam.screen.y - bar_height), (float) cam.screen.x, bar_height};
 
 		bar_size = {0, bar_height};
 		render_scale.x = render_scale.y = scale;
@@ -203,12 +204,15 @@ void SDLContext::set_camera(const Camera & cam, CameraValues & ctx) {
 	SDL_Rect bg = {
 		.x = 0,
 		.y = 0,
-		.w = cam_data.screen.x,
-		.h = cam_data.screen.y,
+		.w = cam.screen.x,
+		.h = cam.screen.y,
 	};
 
 	// fill bg color
 	SDL_RenderFillRect(this->game_renderer.get(), &bg);
+
+
+	return ret_cam;
 }
 
 uint64_t SDLContext::get_ticks() const { return SDL_GetTicks64(); }
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index a0d1da8..d662bee 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -142,7 +142,7 @@ private:
 	 * \brief sets the background of the camera (will be adjusted in future PR)
 	 * \param camera Reference to the Camera object.
 	 */
-	void set_camera(const Camera & camera, CameraValues & ctx);
+	CameraValues set_camera(const Camera & camera);
 
 private:
 	struct DstRect {
diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp
index e9cdd4c..a2ae529 100644
--- a/src/crepe/system/AnimatorSystem.cpp
+++ b/src/crepe/system/AnimatorSystem.cpp
@@ -22,14 +22,14 @@ void AnimatorSystem::update() {
 
 		int last_frame = ctx.curr_row;
 
-		int cycle_end = (ctx.cycle_end == -1) ? ctx.row : ctx.cycle_end;
+		int cycle_end = (ctx.cycle_end == -1) ? a.row : ctx.cycle_end;
 		int total_frames = cycle_end - ctx.cycle_start;
 
 		int curr_frame = static_cast<int>(elapsed_time / frame_duration) % total_frames;
 
 		ctx.curr_row = ctx.cycle_start + curr_frame;
-		ctx.spritesheet.mask.x = ctx.curr_row * ctx.spritesheet.mask.w;
-		ctx.spritesheet.mask.y = (ctx.curr_col * ctx.spritesheet.mask.h);
+		a.spritesheet.mask.x = ctx.curr_row * a.spritesheet.mask.w;
+		a.spritesheet.mask.y = (ctx.curr_col * a.spritesheet.mask.h);
 
 		if (!ctx.looping && curr_frame == ctx.cycle_start && last_frame == total_frames - 1) {
 			a.active = false;
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index 1bf5f65..b5db45a 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -21,7 +21,7 @@ void RenderSystem::clear_screen() { this->context.clear_screen(); }
 
 void RenderSystem::present_screen() { this->context.present_screen(); }
 
-const Camera & RenderSystem::update_camera() {
+SDLContext::CameraValues RenderSystem::update_camera() {
 	ComponentManager & mgr = this->component_manager;
 
 	RefVector<Camera> cameras = mgr.get_components_by_type<Camera>();
@@ -32,9 +32,9 @@ const Camera & RenderSystem::update_camera() {
 		if (!cam.active) continue;
 		const Transform & transform
 			= mgr.get_components_by_id<Transform>(cam.game_object_id).front().get();
-		this->context.set_camera(cam, this->cam_ctx);
-		this->cam_ctx.cam_pos = transform.position + cam.data.offset;
-		return cam;
+		SDLContext::CameraValues cam_val = this->context.set_camera(cam);
+		cam_val.cam_pos = transform.position + cam.data.offset;
+		return cam_val;
 	}
 	throw std::runtime_error("No active cameras in current scene");
 }
@@ -60,7 +60,7 @@ void RenderSystem::update() {
 	this->present_screen();
 }
 
-bool RenderSystem::render_particle(const Sprite & sprite, const Camera & cam,
+bool RenderSystem::render_particle(const Sprite & sprite, const SDLContext::CameraValues & cam,
 								   const double & scale) {
 
 	ComponentManager & mgr = this->component_manager;
@@ -80,7 +80,7 @@ bool RenderSystem::render_particle(const Sprite & sprite, const Camera & cam,
 
 			this->context.draw(SDLContext::RenderContext{
 				.sprite = sprite,
-				.cam = this->cam_ctx,
+				.cam = cam,
 				.pos = p.position,
 				.angle = p.angle,
 				.scale = scale,
@@ -89,11 +89,10 @@ bool RenderSystem::render_particle(const Sprite & sprite, const Camera & cam,
 	}
 	return rendering_particles;
 }
-void RenderSystem::render_normal(const Sprite & sprite, const Camera & cam,
-								 const Transform & tm) {
+void RenderSystem::render_normal(const Sprite & sprite, const SDLContext::CameraValues & cam, const Transform & tm) {
 	this->context.draw(SDLContext::RenderContext{
 		.sprite = sprite,
-		.cam = this->cam_ctx,
+		.cam = cam,
 		.pos = tm.position,
 		.angle = tm.rotation,
 		.scale = tm.scale,
@@ -102,7 +101,7 @@ void RenderSystem::render_normal(const Sprite & sprite, const Camera & cam,
 
 void RenderSystem::render() {
 	ComponentManager & mgr = this->component_manager;
-	const Camera & cam = this->update_camera();
+	const SDLContext::CameraValues & cam = this->update_camera();
 
 	RefVector<Sprite> sprites = mgr.get_components_by_type<Sprite>();
 	RefVector<Sprite> sorted_sprites = this->sort(sprites);
diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h
index 249f3b8..e779047 100644
--- a/src/crepe/system/RenderSystem.h
+++ b/src/crepe/system/RenderSystem.h
@@ -37,7 +37,7 @@ private:
 	void present_screen();
 
 	//! Updates the active camera used for rendering.
-	const Camera & update_camera();
+	SDLContext::CameraValues update_camera();
 
 	//! Renders the whole screen
 	void render();
@@ -49,7 +49,7 @@ private:
 	 * \param tm the Transform component for scale
 	 * \return true if particles have been rendered
 	 */
-	bool render_particle(const Sprite & sprite, const Camera & cam, const double & scale);
+	bool render_particle(const Sprite & sprite, const SDLContext::CameraValues & cam,  const double & scale);
 
 	/**
 	 * \brief renders a sprite with a Transform component on the screen 
@@ -57,7 +57,7 @@ private:
 	 * \param sprite  the sprite component that holds all the data
 	 * \param tm the Transform component that holds the position,rotation and scale 
 	 */
-	void render_normal(const Sprite & sprite, const Camera & cam, const Transform & tm);
+	void render_normal(const Sprite & sprite, const SDLContext::CameraValues & cam, const Transform & tm);
 
 	/**
 	 * \brief sort a vector sprite objects with
@@ -76,8 +76,6 @@ private:
 
 private:
 	SDLContext & context = SDLContext::get_instance();
-
-	SDLContext::CameraValues cam_ctx;
 };
 
 } // namespace crepe
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index e18c7b7..2e2552d 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -45,8 +45,6 @@ using namespace std;
 
 class TestScene : public Scene {
 public:
-	using Scene::Scene;
-
 	void load_scene() {
 		ComponentManager & mgr = this->component_manager;
 		GameObject game_object = mgr.new_object("", "", vec2{0, 0}, 0, 1);
@@ -63,23 +61,17 @@ public:
 					 .order_in_layer = 2,
 					 .size = {0, 100},
 					 .angle_offset = 0,
-					 .scale = 1,
 				 });
 
-		auto & anim = game_object.add_component<Animator>(Animator::Data{
-			.spritesheet = test_sprite,
-			.col = 4,
-			.row = 4,
+		auto & anim = game_object.add_component<Animator>(test_sprite, 4, 4, Animator::Data{
 			.fps = 1,
 			.looping = false,
 		});
 		anim.set_anim(2);
+		anim.active = false;
 
-		auto & cam = game_object.add_component<Camera>(Camera::Data{
+		auto & cam = game_object.add_component<Camera>(ivec2{1280,720}, vec2{400,400},Camera::Data{
 			.bg_color = Color::WHITE,
-			.screen = ivec2{1280, 720},
-			.viewport_size = vec2{400, 400},
-			.zoom = 1.0,
 		});
 	}
 
-- 
cgit v1.2.3


From 9cde6875186b335c75eafa6402f0957cd4252c76 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Wed, 4 Dec 2024 10:57:20 +0100
Subject: make format

---
 src/crepe/api/Animator.h           |  1 -
 src/crepe/api/Sprite.h             |  1 -
 src/crepe/facade/SDLContext.cpp    | 11 +++++------
 src/crepe/system/RenderSystem.cpp  |  3 ++-
 src/crepe/system/RenderSystem.h    |  6 ++++--
 src/example/rendering_particle.cpp | 16 +++++++++-------
 6 files changed, 20 insertions(+), 18 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index 1fe2b6f..dab6697 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -19,7 +19,6 @@ class Animator : public Component {
 public:
 	struct Data {
 
-
 		//! frames per second for animation
 		int fps = 1;
 
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index d82ae8d..a1230db 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -54,7 +54,6 @@ public:
 
 		//! independent sprite scale multiplier
 		double scale_offset = 1;
-
 	};
 
 public:
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index d3a15d9..86969ed 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -114,9 +114,10 @@ SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
 
 	const Sprite::Data & data = ctx.sprite.data;
 
-	vec2 size = {
-		data.size.x == 0 && data.size.y != 0 ? data.size.y * ctx.sprite.aspect_ratio : data.size.x,
-		data.size.y == 0 && data.size.x != 0 ? data.size.x / ctx.sprite.aspect_ratio : data.size.y};
+	vec2 size = {data.size.x == 0 && data.size.y != 0 ? data.size.y * ctx.sprite.aspect_ratio
+													  : data.size.x,
+				 data.size.y == 0 && data.size.x != 0 ? data.size.x / ctx.sprite.aspect_ratio
+													  : data.size.y};
 
 	const CameraValues & cam = ctx.cam;
 
@@ -180,8 +181,7 @@ SDLContext::CameraValues SDLContext::set_camera(const Camera & cam) {
 		float adj_width = zoomed_viewport.x * scale;
 		float bar_width = (cam.screen.x - adj_width) / 2;
 		this->black_bars[0] = {0, 0, bar_width, (float) cam.screen.y};
-		this->black_bars[1]
-			= {(cam.screen.x - bar_width), 0, bar_width, (float) cam.screen.y};
+		this->black_bars[1] = {(cam.screen.x - bar_width), 0, bar_width, (float) cam.screen.y};
 
 		bar_size = {bar_width, 0};
 		render_scale.x = render_scale.y = scale;
@@ -211,7 +211,6 @@ SDLContext::CameraValues SDLContext::set_camera(const Camera & cam) {
 	// fill bg color
 	SDL_RenderFillRect(this->game_renderer.get(), &bg);
 
-
 	return ret_cam;
 }
 
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index b5db45a..4c618d8 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -89,7 +89,8 @@ bool RenderSystem::render_particle(const Sprite & sprite, const SDLContext::Came
 	}
 	return rendering_particles;
 }
-void RenderSystem::render_normal(const Sprite & sprite, const SDLContext::CameraValues & cam, const Transform & tm) {
+void RenderSystem::render_normal(const Sprite & sprite, const SDLContext::CameraValues & cam,
+								 const Transform & tm) {
 	this->context.draw(SDLContext::RenderContext{
 		.sprite = sprite,
 		.cam = cam,
diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h
index e779047..9c306c5 100644
--- a/src/crepe/system/RenderSystem.h
+++ b/src/crepe/system/RenderSystem.h
@@ -49,7 +49,8 @@ private:
 	 * \param tm the Transform component for scale
 	 * \return true if particles have been rendered
 	 */
-	bool render_particle(const Sprite & sprite, const SDLContext::CameraValues & cam,  const double & scale);
+	bool render_particle(const Sprite & sprite, const SDLContext::CameraValues & cam,
+						 const double & scale);
 
 	/**
 	 * \brief renders a sprite with a Transform component on the screen 
@@ -57,7 +58,8 @@ private:
 	 * \param sprite  the sprite component that holds all the data
 	 * \param tm the Transform component that holds the position,rotation and scale 
 	 */
-	void render_normal(const Sprite & sprite, const SDLContext::CameraValues & cam, const Transform & tm);
+	void render_normal(const Sprite & sprite, const SDLContext::CameraValues & cam,
+					   const Transform & tm);
 
 	/**
 	 * \brief sort a vector sprite objects with
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 2e2552d..07e43a1 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -63,16 +63,18 @@ public:
 					 .angle_offset = 0,
 				 });
 
-		auto & anim = game_object.add_component<Animator>(test_sprite, 4, 4, Animator::Data{
-			.fps = 1,
-			.looping = false,
-		});
+		auto & anim = game_object.add_component<Animator>(test_sprite, 4, 4,
+														  Animator::Data{
+															  .fps = 1,
+															  .looping = false,
+														  });
 		anim.set_anim(2);
 		anim.active = false;
 
-		auto & cam = game_object.add_component<Camera>(ivec2{1280,720}, vec2{400,400},Camera::Data{
-			.bg_color = Color::WHITE,
-		});
+		auto & cam = game_object.add_component<Camera>(ivec2{1280, 720}, vec2{400, 400},
+													   Camera::Data{
+														   .bg_color = Color::WHITE,
+													   });
 	}
 
 	string get_name() const { return "TestScene"; };
-- 
cgit v1.2.3


From d76ab0bf77d0a61712dc25bbe1760995be4c4782 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Wed, 4 Dec 2024 20:11:02 +0100
Subject: make format

---
 src/crepe/Collider.cpp               |   2 +-
 src/crepe/Collider.h                 |   2 +-
 src/crepe/api/BoxCollider.cpp        |   7 +-
 src/crepe/api/BoxCollider.h          |   6 +-
 src/crepe/api/CircleCollider.cpp     |   6 +-
 src/crepe/api/CircleCollider.h       |   3 +-
 src/crepe/api/Event.h                |   4 +-
 src/crepe/api/LoopManager.cpp        |   3 +-
 src/crepe/api/Rigidbody.cpp          |   4 +-
 src/crepe/api/Rigidbody.h            |   4 +-
 src/crepe/system/CollisionSystem.cpp | 514 ++++++++++++++++++++---------------
 src/crepe/system/CollisionSystem.h   | 121 +++++----
 src/crepe/system/PhysicsSystem.cpp   |   9 +-
 src/example/game.cpp                 |  97 ++++---
 src/test/CollisionTest.cpp           | 122 +++++----
 src/test/Profiling.cpp               | 121 +++++----
 16 files changed, 574 insertions(+), 451 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/Collider.cpp b/src/crepe/Collider.cpp
index 9d94152..77e11c8 100644
--- a/src/crepe/Collider.cpp
+++ b/src/crepe/Collider.cpp
@@ -2,4 +2,4 @@
 
 using namespace crepe;
 
-Collider::Collider(game_object_id_t id, const vec2& offset) : Component(id), offset(offset) {}
+Collider::Collider(game_object_id_t id, const vec2 & offset) : Component(id), offset(offset) {}
diff --git a/src/crepe/Collider.h b/src/crepe/Collider.h
index b3a09fb..a08a68e 100644
--- a/src/crepe/Collider.h
+++ b/src/crepe/Collider.h
@@ -7,7 +7,7 @@ namespace crepe {
 
 class Collider : public Component {
 public:
-	Collider(game_object_id_t id, const vec2& offset);
+	Collider(game_object_id_t id, const vec2 & offset);
 
 public:
 	/**
diff --git a/src/crepe/api/BoxCollider.cpp b/src/crepe/api/BoxCollider.cpp
index f94ced7..c097a24 100644
--- a/src/crepe/api/BoxCollider.cpp
+++ b/src/crepe/api/BoxCollider.cpp
@@ -1,7 +1,10 @@
 #include "BoxCollider.h"
 
-#include "../Collider.h" 
+#include "../Collider.h"
 
 using namespace crepe;
 
-BoxCollider::BoxCollider(game_object_id_t game_object_id,const vec2& offset, const vec2& dimensions) : Collider(game_object_id,offset), dimensions(dimensions) {}
+BoxCollider::BoxCollider(game_object_id_t game_object_id, const vec2 & offset,
+						 const vec2 & dimensions)
+	: Collider(game_object_id, offset),
+	  dimensions(dimensions) {}
diff --git a/src/crepe/api/BoxCollider.h b/src/crepe/api/BoxCollider.h
index 1f5f1c1..89e43d8 100644
--- a/src/crepe/api/BoxCollider.h
+++ b/src/crepe/api/BoxCollider.h
@@ -1,7 +1,7 @@
 #pragma once
 
-#include "Vector2.h"
 #include "../Collider.h"
+#include "Vector2.h"
 #include "types.h"
 
 namespace crepe {
@@ -13,9 +13,9 @@ namespace crepe {
  */
 class BoxCollider : public Collider {
 public:
-	BoxCollider(game_object_id_t game_object_id,const vec2& offset, const vec2& dimensions);
+	BoxCollider(game_object_id_t game_object_id, const vec2 & offset, const vec2 & dimensions);
 
-	//! Width and height of the box collider 
+	//! Width and height of the box collider
 	vec2 dimensions;
 };
 
diff --git a/src/crepe/api/CircleCollider.cpp b/src/crepe/api/CircleCollider.cpp
index 473734e..a4271e9 100644
--- a/src/crepe/api/CircleCollider.cpp
+++ b/src/crepe/api/CircleCollider.cpp
@@ -2,5 +2,7 @@
 
 using namespace crepe;
 
-
-CircleCollider::CircleCollider(game_object_id_t game_object_id,const vec2& offset, float radius) : Collider(game_object_id,offset), radius(radius) {}
+CircleCollider::CircleCollider(game_object_id_t game_object_id, const vec2 & offset,
+							   float radius)
+	: Collider(game_object_id, offset),
+	  radius(radius) {}
diff --git a/src/crepe/api/CircleCollider.h b/src/crepe/api/CircleCollider.h
index bbcc330..ebd1cb2 100644
--- a/src/crepe/api/CircleCollider.h
+++ b/src/crepe/api/CircleCollider.h
@@ -13,8 +13,7 @@ namespace crepe {
  */
 class CircleCollider : public Collider {
 public:
-
-	CircleCollider(game_object_id_t game_object_id,const vec2& offset, float radius);
+	CircleCollider(game_object_id_t game_object_id, const vec2 & offset, float radius);
 
 	//! Radius of the circle collider.
 	float radius;
diff --git a/src/crepe/api/Event.h b/src/crepe/api/Event.h
index 259acba..152bc2c 100644
--- a/src/crepe/api/Event.h
+++ b/src/crepe/api/Event.h
@@ -98,8 +98,8 @@ public:
 class CollisionEvent : public Event {
 public:
 	crepe::CollisionSystem::CollisionInfo info;
-	CollisionEvent(const crepe::CollisionSystem::CollisionInfo& collisionInfo)
-        : info(collisionInfo) {}
+	CollisionEvent(const crepe::CollisionSystem::CollisionInfo & collisionInfo)
+		: info(collisionInfo) {}
 };
 
 /**
diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index feb1338..d4819ea 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -1,13 +1,12 @@
 #include "../facade/SDLContext.h"
 
+#include "../system/PhysicsSystem.h"
 #include "../system/AnimatorSystem.h"
 #include "../system/CollisionSystem.h"
 #include "../system/ParticleSystem.h"
 #include "../system/PhysicsSystem.h"
 #include "../system/RenderSystem.h"
 #include "../system/ScriptSystem.h"
-#include "..//system/PhysicsSystem.h"
-#include "../system/CollisionSystem.h"
 
 #include "LoopManager.h"
 #include "LoopTimer.h"
diff --git a/src/crepe/api/Rigidbody.cpp b/src/crepe/api/Rigidbody.cpp
index c4b1d6f..8213afb 100644
--- a/src/crepe/api/Rigidbody.cpp
+++ b/src/crepe/api/Rigidbody.cpp
@@ -10,6 +10,4 @@ void crepe::Rigidbody::add_force_linear(const vec2 & force) {
 	this->data.linear_velocity += force;
 }
 
-void crepe::Rigidbody::add_force_angular(float force) {
-	this->data.angular_velocity += force;
-}
+void crepe::Rigidbody::add_force_angular(float force) { this->data.angular_velocity += force; }
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index 431e000..756cc28 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -78,9 +78,9 @@ public:
 		//! Linear velocity of the object (speed and direction).
 		vec2 linear_velocity;
 		//! Maximum linear velocity of the object. This limits the object's speed.
-		vec2 max_linear_velocity = {INFINITY ,INFINITY};
+		vec2 max_linear_velocity = {INFINITY, INFINITY};
 		//! Linear velocity coefficient. This scales the object's velocity for adjustment or damping.
-		vec2 linear_velocity_coefficient = {1,1};
+		vec2 linear_velocity_coefficient = {1, 1};
 		//! \}
 
 		/**
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 2d5ce9d..34cd125 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -1,23 +1,23 @@
-#include <cmath>
 #include <algorithm>
+#include <cmath>
 #include <cstddef>
 #include <functional>
+#include <optional>
 #include <utility>
 #include <variant>
-#include <optional>
 
-#include "api/Event.h"
-#include "api/EventManager.h"
 #include "api/BoxCollider.h"
 #include "api/CircleCollider.h"
+#include "api/Event.h"
+#include "api/EventManager.h"
 #include "api/Metadata.h"
-#include "api/Vector2.h"
 #include "api/Rigidbody.h"
 #include "api/Transform.h"
+#include "api/Vector2.h"
 
-#include "ComponentManager.h"
-#include "CollisionSystem.h"
 #include "Collider.h"
+#include "CollisionSystem.h"
+#include "ComponentManager.h"
 #include "types.h"
 #include "util/OptionalRef.h"
 
@@ -26,158 +26,191 @@ using namespace crepe;
 void CollisionSystem::update() {
 	std::vector<CollisionInternal> all_colliders;
 	game_object_id_t id = 0;
-	RefVector<Rigidbody> rigidbodies = this->component_manager.get_components_by_type<Rigidbody>();
+	RefVector<Rigidbody> rigidbodies
+		= this->component_manager.get_components_by_type<Rigidbody>();
 	// Collisions can only happen on object with a rigidbody
-	for(Rigidbody& rigidbody : rigidbodies) {
+	for (Rigidbody & rigidbody : rigidbodies) {
 		if (!rigidbody.active) continue;
 		id = rigidbody.game_object_id;
-		Transform& transform = this->component_manager.get_components_by_id<Transform>(id).front().get();
+		Transform & transform
+			= this->component_manager.get_components_by_id<Transform>(id).front().get();
 		// Check if the boxcollider is active and has the same id as the rigidbody.
-		RefVector<BoxCollider> boxcolliders	= this->component_manager.get_components_by_type<BoxCollider>();
-		for (BoxCollider& boxcollider : boxcolliders) {
-			if(boxcollider.game_object_id != id) continue;
-			if(!boxcollider.active) continue;
-			all_colliders.push_back(
-				{
-					.id = id,
-				  .collider = collider_variant{boxcollider},
-					.transform = transform,
-					.rigidbody = rigidbody
-					}
-				);
+		RefVector<BoxCollider> boxcolliders
+			= this->component_manager.get_components_by_type<BoxCollider>();
+		for (BoxCollider & boxcollider : boxcolliders) {
+			if (boxcollider.game_object_id != id) continue;
+			if (!boxcollider.active) continue;
+			all_colliders.push_back({.id = id,
+									 .collider = collider_variant{boxcollider},
+									 .transform = transform,
+									 .rigidbody = rigidbody});
 		}
 		// Check if the circlecollider is active and has the same id as the rigidbody.
-		RefVector<CircleCollider> circlecolliders	= this->component_manager.get_components_by_type<CircleCollider>();
-		for (CircleCollider& circlecollider : circlecolliders) {
-			if(circlecollider.game_object_id != id) continue;
-			if(!circlecollider.active) continue;
-			all_colliders.push_back(
-				{
-					.id = id,
-				  .collider = collider_variant{circlecollider},
-					.transform = transform,
-					.rigidbody = rigidbody
-					}
-				);
+		RefVector<CircleCollider> circlecolliders
+			= this->component_manager.get_components_by_type<CircleCollider>();
+		for (CircleCollider & circlecollider : circlecolliders) {
+			if (circlecollider.game_object_id != id) continue;
+			if (!circlecollider.active) continue;
+			all_colliders.push_back({.id = id,
+									 .collider = collider_variant{circlecollider},
+									 .transform = transform,
+									 .rigidbody = rigidbody});
 		}
 	}
 
 	// Check between all colliders if there is a collision
-	std::vector<std::pair<CollisionInternal,CollisionInternal>> collided = this->gather_collisions(all_colliders);
+	std::vector<std::pair<CollisionInternal, CollisionInternal>> collided
+		= this->gather_collisions(all_colliders);
 
-	// For both objects call the collision handler 
-	for (auto& collision_pair : collided) {
-		this->collision_handler_request(collision_pair.first,collision_pair.second);
-		this->collision_handler_request(collision_pair.second,collision_pair.first);
+	// For both objects call the collision handler
+	for (auto & collision_pair : collided) {
+		this->collision_handler_request(collision_pair.first, collision_pair.second);
+		this->collision_handler_request(collision_pair.second, collision_pair.first);
 	}
 }
 
-void CollisionSystem::collision_handler_request(CollisionInternal& this_data,CollisionInternal& other_data){
+void CollisionSystem::collision_handler_request(CollisionInternal & this_data,
+												CollisionInternal & other_data) {
 
-	CollisionInternalType type = this->get_collider_type(this_data.collider,other_data.collider);
-	std::pair<vec2,CollisionSystem::Direction> resolution_data = this->collision_handler(this_data,other_data,type);
+	CollisionInternalType type
+		= this->get_collider_type(this_data.collider, other_data.collider);
+	std::pair<vec2, CollisionSystem::Direction> resolution_data
+		= this->collision_handler(this_data, other_data, type);
 
-	OptionalRef<Metadata> this_metadata = this->component_manager.get_components_by_id<Metadata>(this_data.id).front().get();
-	OptionalRef<Metadata> other_metadata = this->component_manager.get_components_by_id<Metadata>(other_data.id).front().get();
+	OptionalRef<Metadata> this_metadata
+		= this->component_manager.get_components_by_id<Metadata>(this_data.id).front().get();
+	OptionalRef<Metadata> other_metadata
+		= this->component_manager.get_components_by_id<Metadata>(other_data.id).front().get();
 	OptionalRef<Collider> this_collider;
 	OptionalRef<Collider> other_collider;
 	switch (type) {
-		case CollisionInternalType::BOX_BOX:{
+		case CollisionInternalType::BOX_BOX: {
 			this_collider = std::get<std::reference_wrapper<BoxCollider>>(this_data.collider);
-			other_collider = std::get<std::reference_wrapper<BoxCollider>>(other_data.collider);
+			other_collider
+				= std::get<std::reference_wrapper<BoxCollider>>(other_data.collider);
 			break;
 		}
-		case CollisionInternalType::BOX_CIRCLE:{
+		case CollisionInternalType::BOX_CIRCLE: {
 			this_collider = std::get<std::reference_wrapper<BoxCollider>>(this_data.collider);
-			other_collider = std::get<std::reference_wrapper<CircleCollider>>(other_data.collider);
+			other_collider
+				= std::get<std::reference_wrapper<CircleCollider>>(other_data.collider);
 			break;
 		}
-		case CollisionInternalType::CIRCLE_BOX:{
-			this_collider = std::get<std::reference_wrapper<CircleCollider>>(this_data.collider);
-			other_collider = std::get<std::reference_wrapper<BoxCollider>>(other_data.collider);
+		case CollisionInternalType::CIRCLE_BOX: {
+			this_collider
+				= std::get<std::reference_wrapper<CircleCollider>>(this_data.collider);
+			other_collider
+				= std::get<std::reference_wrapper<BoxCollider>>(other_data.collider);
 			break;
 		}
-		case CollisionInternalType::CIRCLE_CIRCLE:{
-			this_collider = std::get<std::reference_wrapper<CircleCollider>>(this_data.collider);
-			other_collider = std::get<std::reference_wrapper<CircleCollider>>(other_data.collider);
+		case CollisionInternalType::CIRCLE_CIRCLE: {
+			this_collider
+				= std::get<std::reference_wrapper<CircleCollider>>(this_data.collider);
+			other_collider
+				= std::get<std::reference_wrapper<CircleCollider>>(other_data.collider);
 			break;
 		}
 	}
 
 	// collision info
 	crepe::CollisionSystem::CollisionInfo collision_info{
-						.this_collider = this_collider,
-						.this_transform = this_data.transform,
-						.this_rigidbody = this_data.rigidbody,
-						.this_metadata = this_metadata,
-						.other_collider = other_collider,
-						.other_transform = other_data.transform,
-						.other_rigidbody = other_data.rigidbody,
-						.other_metadata = other_metadata,
-						.resolution = resolution_data.first,
-						.resolution_direction = resolution_data.second,
-        };
+		.this_collider = this_collider,
+		.this_transform = this_data.transform,
+		.this_rigidbody = this_data.rigidbody,
+		.this_metadata = this_metadata,
+		.other_collider = other_collider,
+		.other_transform = other_data.transform,
+		.other_rigidbody = other_data.rigidbody,
+		.other_metadata = other_metadata,
+		.resolution = resolution_data.first,
+		.resolution_direction = resolution_data.second,
+	};
 
 	// Determine if static needs to be called
-	this->determine_collision_handler(collision_info);	
+	this->determine_collision_handler(collision_info);
 }
 
-
-std::pair<vec2,CollisionSystem::Direction> CollisionSystem::collision_handler(CollisionInternal& data1,CollisionInternal& data2,CollisionInternalType type) {
+std::pair<vec2, CollisionSystem::Direction>
+CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal & data2,
+								   CollisionInternalType type) {
 	vec2 resolution;
 	switch (type) {
-		case CollisionInternalType::BOX_BOX:	{
-			const BoxCollider & collider1 = std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
-			const BoxCollider & collider2 = std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
-			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, data1.rigidbody);
-			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, data2.rigidbody);
-			resolution = this->get_box_box_resolution(collider1,collider2,collider_pos1,collider_pos2);
+		case CollisionInternalType::BOX_BOX: {
+			const BoxCollider & collider1
+				= std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
+			const BoxCollider & collider2
+				= std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
+			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform,
+															data1.rigidbody);
+			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform,
+															data2.rigidbody);
+			resolution = this->get_box_box_resolution(collider1, collider2, collider_pos1,
+													  collider_pos2);
 			break;
 		}
 		case CollisionInternalType::BOX_CIRCLE: {
-			const BoxCollider & collider1 = std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
-			const CircleCollider & collider2 = std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
-			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, data1.rigidbody);
-			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, data2.rigidbody);
-			resolution = this->get_circle_box_resolution(collider2,collider1,collider_pos2,collider_pos1);
+			const BoxCollider & collider1
+				= std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
+			const CircleCollider & collider2
+				= std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
+			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform,
+															data1.rigidbody);
+			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform,
+															data2.rigidbody);
+			resolution = this->get_circle_box_resolution(collider2, collider1, collider_pos2,
+														 collider_pos1);
 			break;
 		}
-		case CollisionInternalType::CIRCLE_CIRCLE:	{
-			const CircleCollider & collider1 = std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
-			const CircleCollider & collider2 = std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
-			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, data1.rigidbody);
-			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, data2.rigidbody);
-			resolution = this->get_circle_circle_resolution(collider1,collider2,collider_pos1,collider_pos2);
+		case CollisionInternalType::CIRCLE_CIRCLE: {
+			const CircleCollider & collider1
+				= std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
+			const CircleCollider & collider2
+				= std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
+			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform,
+															data1.rigidbody);
+			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform,
+															data2.rigidbody);
+			resolution = this->get_circle_circle_resolution(collider1, collider2,
+															collider_pos1, collider_pos2);
 			break;
 		}
-		case CollisionInternalType::CIRCLE_BOX:	{
-			const CircleCollider & collider1 = std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
-			const BoxCollider & collider2 = std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
-			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, data1.rigidbody);
-			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, data2.rigidbody);
-			resolution = this->get_circle_box_resolution(collider1,collider2,collider_pos1,collider_pos2);
+		case CollisionInternalType::CIRCLE_BOX: {
+			const CircleCollider & collider1
+				= std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
+			const BoxCollider & collider2
+				= std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
+			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform,
+															data1.rigidbody);
+			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform,
+															data2.rigidbody);
+			resolution = this->get_circle_box_resolution(collider1, collider2, collider_pos1,
+														 collider_pos2);
 			break;
 		}
 	}
 
 	Direction resolution_direction = Direction::NONE;
-	if(resolution.x != 0 && resolution.y > 0) {
+	if (resolution.x != 0 && resolution.y > 0) {
 		resolution_direction = Direction::BOTH;
 	} else if (resolution.x != 0) {
 		resolution_direction = Direction::X_DIRECTION;
-		if(data1.rigidbody.data.linear_velocity.y != 0)	
-		resolution.y = data1.rigidbody.data.linear_velocity.y * (resolution.x/data1.rigidbody.data.linear_velocity.x);
+		if (data1.rigidbody.data.linear_velocity.y != 0)
+			resolution.y = data1.rigidbody.data.linear_velocity.y
+						   * (resolution.x / data1.rigidbody.data.linear_velocity.x);
 	} else if (resolution.y != 0) {
 		resolution_direction = Direction::Y_DIRECTION;
-		if(data1.rigidbody.data.linear_velocity.x != 0) 
-		resolution.x = data1.rigidbody.data.linear_velocity.x * (resolution.y/data1.rigidbody.data.linear_velocity.y);
+		if (data1.rigidbody.data.linear_velocity.x != 0)
+			resolution.x = data1.rigidbody.data.linear_velocity.x
+						   * (resolution.y / data1.rigidbody.data.linear_velocity.y);
 	}
 
-	return std::make_pair(resolution,resolution_direction);
+	return std::make_pair(resolution, resolution_direction);
 }
 
-vec2 CollisionSystem::get_box_box_resolution(const BoxCollider& box_collider1,const BoxCollider& box_collider2,const vec2& final_position1,const vec2& final_position2) const
-{
+vec2 CollisionSystem::get_box_box_resolution(const BoxCollider & box_collider1,
+											 const BoxCollider & box_collider2,
+											 const vec2 & final_position1,
+											 const vec2 & final_position2) const {
 	vec2 resolution; // Default resolution vector
 	vec2 delta = final_position2 - final_position1;
 
@@ -210,97 +243,107 @@ vec2 CollisionSystem::get_box_box_resolution(const BoxCollider& box_collider1,co
 	return resolution;
 }
 
-vec2 CollisionSystem::get_circle_circle_resolution(const CircleCollider& circle_collider1, const CircleCollider& circle_collider2, const vec2& final_position1, const vec2& final_position2) const 
-{
-    vec2 delta = final_position2 - final_position1;
+vec2 CollisionSystem::get_circle_circle_resolution(const CircleCollider & circle_collider1,
+												   const CircleCollider & circle_collider2,
+												   const vec2 & final_position1,
+												   const vec2 & final_position2) const {
+	vec2 delta = final_position2 - final_position1;
 
-    // Compute the distance between the two circle centers
-    float distance = std::sqrt(delta.x * delta.x + delta.y * delta.y);
+	// Compute the distance between the two circle centers
+	float distance = std::sqrt(delta.x * delta.x + delta.y * delta.y);
 
-    // Compute the combined radii of the two circles
-    float combined_radius = circle_collider1.radius + circle_collider2.radius;
+	// Compute the combined radii of the two circles
+	float combined_radius = circle_collider1.radius + circle_collider2.radius;
 
-    // Compute the penetration depth
-    float penetration_depth = combined_radius - distance;
+	// Compute the penetration depth
+	float penetration_depth = combined_radius - distance;
 
-    // Normalize the delta vector to get the collision direction
-    vec2 collision_normal = delta / distance;
+	// Normalize the delta vector to get the collision direction
+	vec2 collision_normal = delta / distance;
 
-    // Compute the resolution vector
-    vec2 resolution = collision_normal * penetration_depth;
+	// Compute the resolution vector
+	vec2 resolution = collision_normal * penetration_depth;
 
-    return resolution;
+	return resolution;
 }
 
-vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider& circle_collider, const BoxCollider& box_collider, const vec2& circle_position, const vec2& box_position) const 
-{
-    vec2 delta = circle_position - box_position;
+vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider & circle_collider,
+												const BoxCollider & box_collider,
+												const vec2 & circle_position,
+												const vec2 & box_position) const {
+	vec2 delta = circle_position - box_position;
 
-    // Compute half-dimensions of the box
-    float half_width = box_collider.dimensions.x / 2.0f;
-    float half_height = box_collider.dimensions.y / 2.0f;
+	// Compute half-dimensions of the box
+	float half_width = box_collider.dimensions.x / 2.0f;
+	float half_height = box_collider.dimensions.y / 2.0f;
 
-    // Clamp circle center to the nearest point on the box
-    vec2 closest_point;
-    closest_point.x = std::clamp(delta.x, -half_width, half_width);
-    closest_point.y = std::clamp(delta.y, -half_height, half_height);
+	// Clamp circle center to the nearest point on the box
+	vec2 closest_point;
+	closest_point.x = std::clamp(delta.x, -half_width, half_width);
+	closest_point.y = std::clamp(delta.y, -half_height, half_height);
 
-    // Find the vector from the circle center to the closest point
-    vec2 closest_delta = delta - closest_point;
+	// Find the vector from the circle center to the closest point
+	vec2 closest_delta = delta - closest_point;
 
-    // Normalize the delta to get the collision direction
-    float distance = std::sqrt(closest_delta.x * closest_delta.x + closest_delta.y * closest_delta.y);
-    vec2 collision_normal = closest_delta / distance;
+	// Normalize the delta to get the collision direction
+	float distance
+		= std::sqrt(closest_delta.x * closest_delta.x + closest_delta.y * closest_delta.y);
+	vec2 collision_normal = closest_delta / distance;
 
-    // Compute penetration depth
-    float penetration_depth = circle_collider.radius - distance;
+	// Compute penetration depth
+	float penetration_depth = circle_collider.radius - distance;
 
-    // Compute the resolution vector
-    vec2 resolution = collision_normal * penetration_depth;
+	// Compute the resolution vector
+	vec2 resolution = collision_normal * penetration_depth;
 
-    return resolution;
+	return resolution;
 }
 
-
-void CollisionSystem::determine_collision_handler(CollisionInfo& info){
+void CollisionSystem::determine_collision_handler(CollisionInfo & info) {
 	// Check rigidbody type for static
-	if(info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) return;
+	if (info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) return;
 	// If second body is static perform the static collision handler in this system
-	if(info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC){
+	if (info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) {
 		static_collision_handler(info);
-	}; 
+	};
 	// Call collision event for user
 	CollisionEvent data(info);
-	EventManager::get_instance().trigger_event<CollisionEvent>(data, info.this_collider.game_object_id);
+	EventManager::get_instance().trigger_event<CollisionEvent>(
+		data, info.this_collider.game_object_id);
 }
 
-void CollisionSystem::static_collision_handler(CollisionInfo& info){
-	// Move object back using calculate move back value 
+void CollisionSystem::static_collision_handler(CollisionInfo & info) {
+	// Move object back using calculate move back value
 	info.this_transform.position += info.resolution;
 
 	// If bounce is enabled mirror velocity
-	if(info.this_rigidbody.data.elastisity_coefficient > 0) {
-		if(info.resolution_direction == Direction::BOTH)
-		{
-			info.this_rigidbody.data.linear_velocity.y = -info.this_rigidbody.data.linear_velocity.y * info.this_rigidbody.data.elastisity_coefficient;
-			info.this_rigidbody.data.linear_velocity.x = -info.this_rigidbody.data.linear_velocity.x * info.this_rigidbody.data.elastisity_coefficient;
-		}
-		else if(info.resolution_direction == Direction::Y_DIRECTION) {
-			info.this_rigidbody.data.linear_velocity.y = -info.this_rigidbody.data.linear_velocity.y * info.this_rigidbody.data.elastisity_coefficient;
-		}
-		else if(info.resolution_direction == Direction::X_DIRECTION){
-			info.this_rigidbody.data.linear_velocity.x = -info.this_rigidbody.data.linear_velocity.x * info.this_rigidbody.data.elastisity_coefficient;
+	if (info.this_rigidbody.data.elastisity_coefficient > 0) {
+		if (info.resolution_direction == Direction::BOTH) {
+			info.this_rigidbody.data.linear_velocity.y
+				= -info.this_rigidbody.data.linear_velocity.y
+				  * info.this_rigidbody.data.elastisity_coefficient;
+			info.this_rigidbody.data.linear_velocity.x
+				= -info.this_rigidbody.data.linear_velocity.x
+				  * info.this_rigidbody.data.elastisity_coefficient;
+		} else if (info.resolution_direction == Direction::Y_DIRECTION) {
+			info.this_rigidbody.data.linear_velocity.y
+				= -info.this_rigidbody.data.linear_velocity.y
+				  * info.this_rigidbody.data.elastisity_coefficient;
+		} else if (info.resolution_direction == Direction::X_DIRECTION) {
+			info.this_rigidbody.data.linear_velocity.x
+				= -info.this_rigidbody.data.linear_velocity.x
+				  * info.this_rigidbody.data.elastisity_coefficient;
 		}
 	}
 	// Stop movement if bounce is disabled
 	else {
-		info.this_rigidbody.data.linear_velocity = {0,0};
+		info.this_rigidbody.data.linear_velocity = {0, 0};
 	}
 }
 
-std::vector<std::pair<CollisionSystem::CollisionInternal,CollisionSystem::CollisionInternal>> CollisionSystem::gather_collisions(std::vector<CollisionInternal> & colliders) {
-	
-	
+std::vector<std::pair<CollisionSystem::CollisionInternal, CollisionSystem::CollisionInternal>>
+CollisionSystem::gather_collisions(std::vector<CollisionInternal> & colliders) {
+
 	// TODO:
 	// If no colliders skip
 	// Check if colliders has rigidbody if not skip
@@ -311,83 +354,103 @@ std::vector<std::pair<CollisionSystem::CollisionInternal,CollisionSystem::Collis
 	// Quadtree is placed over the input vector
 
 	// Return data of collided colliders which are variants
-	std::vector<std::pair<CollisionInternal,CollisionInternal>> collisions_ret;
-	//using visit to visit the variant to access the active and id.  
+	std::vector<std::pair<CollisionInternal, CollisionInternal>> collisions_ret;
+	//using visit to visit the variant to access the active and id.
 	for (size_t i = 0; i < colliders.size(); ++i) {
 		for (size_t j = i + 1; j < colliders.size(); ++j) {
-			if(colliders[i].id == colliders[j].id) continue;
-				CollisionInternalType type = get_collider_type(colliders[i].collider,colliders[j].collider);
-				if(!get_collision({
-					.collider = colliders[i].collider,
-					.transform = colliders[i].transform,
-					.rigidbody = colliders[i].rigidbody,
+			if (colliders[i].id == colliders[j].id) continue;
+			CollisionInternalType type
+				= get_collider_type(colliders[i].collider, colliders[j].collider);
+			if (!get_collision(
+					{
+						.collider = colliders[i].collider,
+						.transform = colliders[i].transform,
+						.rigidbody = colliders[i].rigidbody,
 					},
 					{
-					.collider = colliders[j].collider,
-					.transform = colliders[j].transform,
-					.rigidbody = colliders[j].rigidbody,
+						.collider = colliders[j].collider,
+						.transform = colliders[j].transform,
+						.rigidbody = colliders[j].rigidbody,
 					},
-					type)) continue;
-				collisions_ret.emplace_back(colliders[i],colliders[j]);
+					type))
+				continue;
+			collisions_ret.emplace_back(colliders[i], colliders[j]);
 		}
 	}
-	
+
 	return collisions_ret;
 }
 
-CollisionSystem::CollisionInternalType CollisionSystem::get_collider_type(const collider_variant& collider1,const collider_variant& collider2) const{
-	if(std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider1)){
-		if(std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider2))
-		{
+CollisionSystem::CollisionInternalType
+CollisionSystem::get_collider_type(const collider_variant & collider1,
+								   const collider_variant & collider2) const {
+	if (std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider1)) {
+		if (std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider2)) {
 			return CollisionInternalType::CIRCLE_CIRCLE;
-		}
-		else {
+		} else {
 			return CollisionInternalType::CIRCLE_BOX;
 		}
-	}
-	else {
-		if(std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider2))
-		{
+	} else {
+		if (std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider2)) {
 			return CollisionInternalType::BOX_CIRCLE;
-		}
-		else {
+		} else {
 			return CollisionInternalType::BOX_BOX;
 		}
 	}
 }
 
-bool CollisionSystem::get_collision(const CollisionInternal& first_info,const CollisionInternal& second_info, CollisionInternalType type) const{
+bool CollisionSystem::get_collision(const CollisionInternal & first_info,
+									const CollisionInternal & second_info,
+									CollisionInternalType type) const {
 	switch (type) {
-		case CollisionInternalType::BOX_BOX:	{
-			const BoxCollider & box_collider1 = std::get<std::reference_wrapper<BoxCollider>>(first_info.collider);
-			const BoxCollider & box_collider2 = std::get<std::reference_wrapper<BoxCollider>>(second_info.collider);
-			return this->get_box_box_collision(box_collider1,box_collider2,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
+		case CollisionInternalType::BOX_BOX: {
+			const BoxCollider & box_collider1
+				= std::get<std::reference_wrapper<BoxCollider>>(first_info.collider);
+			const BoxCollider & box_collider2
+				= std::get<std::reference_wrapper<BoxCollider>>(second_info.collider);
+			return this->get_box_box_collision(box_collider1, box_collider2,
+											   first_info.transform, second_info.transform,
+											   second_info.rigidbody, second_info.rigidbody);
 		}
 		case CollisionInternalType::BOX_CIRCLE: {
-			const BoxCollider & box_collider = std::get<std::reference_wrapper<BoxCollider>>(first_info.collider);
-			const CircleCollider & circle_collider = std::get<std::reference_wrapper<CircleCollider>>(second_info.collider);
-			return this->get_box_circle_collision(box_collider,circle_collider,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
+			const BoxCollider & box_collider
+				= std::get<std::reference_wrapper<BoxCollider>>(first_info.collider);
+			const CircleCollider & circle_collider
+				= std::get<std::reference_wrapper<CircleCollider>>(second_info.collider);
+			return this->get_box_circle_collision(
+				box_collider, circle_collider, first_info.transform, second_info.transform,
+				second_info.rigidbody, second_info.rigidbody);
 		}
-		case CollisionInternalType::CIRCLE_CIRCLE:	{
-			const CircleCollider & circle_collider1 = std::get<std::reference_wrapper<CircleCollider>>(first_info.collider);
-			const CircleCollider & circle_collider2 = std::get<std::reference_wrapper<CircleCollider>>(second_info.collider);
-			return this->get_circle_circle_collision(circle_collider1,circle_collider2,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
+		case CollisionInternalType::CIRCLE_CIRCLE: {
+			const CircleCollider & circle_collider1
+				= std::get<std::reference_wrapper<CircleCollider>>(first_info.collider);
+			const CircleCollider & circle_collider2
+				= std::get<std::reference_wrapper<CircleCollider>>(second_info.collider);
+			return this->get_circle_circle_collision(
+				circle_collider1, circle_collider2, first_info.transform,
+				second_info.transform, second_info.rigidbody, second_info.rigidbody);
 		}
-		case CollisionInternalType::CIRCLE_BOX:	{
-			const CircleCollider & circle_collider = std::get<std::reference_wrapper<CircleCollider>>(first_info.collider);
-			const BoxCollider & box_collider = std::get<std::reference_wrapper<BoxCollider>>(second_info.collider);
-			return this->get_box_circle_collision(box_collider,circle_collider,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
+		case CollisionInternalType::CIRCLE_BOX: {
+			const CircleCollider & circle_collider
+				= std::get<std::reference_wrapper<CircleCollider>>(first_info.collider);
+			const BoxCollider & box_collider
+				= std::get<std::reference_wrapper<BoxCollider>>(second_info.collider);
+			return this->get_box_circle_collision(
+				box_collider, circle_collider, first_info.transform, second_info.transform,
+				second_info.rigidbody, second_info.rigidbody);
 		}
 	}
 	return false;
 }
 
-
-bool CollisionSystem::get_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) const
-{
+bool CollisionSystem::get_box_box_collision(const BoxCollider & box1, const BoxCollider & box2,
+											const Transform & transform1,
+											const Transform & transform2,
+											const Rigidbody & rigidbody1,
+											const Rigidbody & rigidbody2) const {
 	// Get current positions of colliders
-	vec2 final_position1 = this->get_current_position(box1.offset,transform1,rigidbody1);
-	vec2 final_position2 = this->get_current_position(box2.offset,transform2,rigidbody2);
+	vec2 final_position1 = this->get_current_position(box1.offset, transform1, rigidbody1);
+	vec2 final_position2 = this->get_current_position(box2.offset, transform2, rigidbody2);
 
 	// Calculate half-extents (half width and half height)
 	float half_width1 = box1.dimensions.x / 2.0;
@@ -396,13 +459,18 @@ bool CollisionSystem::get_box_box_collision(const BoxCollider& box1, const BoxCo
 	float half_height2 = box2.dimensions.y / 2.0;
 
 	// Check if the boxes overlap along the X and Y axes
-	return (final_position1.x + half_width1 > final_position2.x - half_width2 &&
-        final_position1.x - half_width1 < final_position2.x + half_width2 &&
-        final_position1.y + half_height1 > final_position2.y - half_height2 &&
-        final_position1.y - half_height1 < final_position2.y + half_height2);
+	return (final_position1.x + half_width1 > final_position2.x - half_width2
+			&& final_position1.x - half_width1 < final_position2.x + half_width2
+			&& final_position1.y + half_height1 > final_position2.y - half_height2
+			&& final_position1.y - half_height1 < final_position2.y + half_height2);
 }
 
-bool CollisionSystem::get_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) const {
+bool CollisionSystem::get_box_circle_collision(const BoxCollider & box1,
+											   const CircleCollider & circle2,
+											   const Transform & transform1,
+											   const Transform & transform2,
+											   const Rigidbody & rigidbody1,
+											   const Rigidbody & rigidbody2) const {
 	// Get current positions of colliders
 	vec2 final_position1 = this->get_current_position(box1.offset, transform1, rigidbody1);
 	vec2 final_position2 = this->get_current_position(circle2.offset, transform2, rigidbody2);
@@ -412,8 +480,10 @@ bool CollisionSystem::get_box_circle_collision(const BoxCollider& box1, const Ci
 	float half_height = box1.dimensions.y / 2.0;
 
 	// Find the closest point on the box to the circle's center
-	float closest_x = std::max(final_position1.x - half_width, std::min(final_position2.x, final_position1.x + half_width));
-	float closest_y = std::max(final_position1.y - half_height, std::min(final_position2.y, final_position1.y + half_height));
+	float closest_x = std::max(final_position1.x - half_width,
+							   std::min(final_position2.x, final_position1.x + half_width));
+	float closest_y = std::max(final_position1.y - half_height,
+							   std::min(final_position2.y, final_position1.y + half_height));
 
 	// Calculate the distance squared between the circle's center and the closest point on the box
 	float distance_x = final_position2.x - closest_x;
@@ -424,10 +494,15 @@ bool CollisionSystem::get_box_circle_collision(const BoxCollider& box1, const Ci
 	return distance_squared <= circle2.radius * circle2.radius;
 }
 
-bool CollisionSystem::get_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) const {
+bool CollisionSystem::get_circle_circle_collision(const CircleCollider & circle1,
+												  const CircleCollider & circle2,
+												  const Transform & transform1,
+												  const Transform & transform2,
+												  const Rigidbody & rigidbody1,
+												  const Rigidbody & rigidbody2) const {
 	// Get current positions of colliders
-	vec2 final_position1 = this->get_current_position(circle1.offset,transform1,rigidbody1);
-	vec2 final_position2 = this->get_current_position(circle2.offset,transform2,rigidbody2);
+	vec2 final_position1 = this->get_current_position(circle1.offset, transform1, rigidbody1);
+	vec2 final_position2 = this->get_current_position(circle2.offset, transform2, rigidbody2);
 
 	float distance_x = final_position1.x - final_position2.x;
 	float distance_y = final_position1.y - final_position2.y;
@@ -440,7 +515,9 @@ bool CollisionSystem::get_circle_circle_collision(const CircleCollider& circle1,
 	return distance_squared <= radius_sum * radius_sum;
 }
 
-vec2 CollisionSystem::get_current_position(const vec2& collider_offset, const Transform& transform, const Rigidbody& rigidbody) const {
+vec2 CollisionSystem::get_current_position(const vec2 & collider_offset,
+										   const Transform & transform,
+										   const Rigidbody & rigidbody) const {
 	// Get the rotation in radians
 	float radians1 = transform.rotation * (M_PI / 180.0);
 
@@ -448,10 +525,11 @@ vec2 CollisionSystem::get_current_position(const vec2& collider_offset, const Tr
 	vec2 total_offset = (rigidbody.data.offset + collider_offset) * transform.scale;
 
 	// Rotate
-	float rotated_total_offset_x1 = total_offset.x * cos(radians1) - total_offset.y * sin(radians1);
-	float rotated_total_offset_y1 = total_offset.x * sin(radians1) + total_offset.y * cos(radians1);
+	float rotated_total_offset_x1
+		= total_offset.x * cos(radians1) - total_offset.y * sin(radians1);
+	float rotated_total_offset_y1
+		= total_offset.x * sin(radians1) + total_offset.y * cos(radians1);
 
 	// Final positions considering scaling and rotation
-	return(transform.position + vec2(rotated_total_offset_x1, rotated_total_offset_y1));
-
+	return (transform.position + vec2(rotated_total_offset_x1, rotated_total_offset_y1));
 }
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 85ae5ad..6b5a4bb 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -1,38 +1,37 @@
 #pragma once
 
-#include <vector>
-#include <variant>
 #include <optional>
+#include <variant>
+#include <vector>
 
-#include "api/Rigidbody.h"
-#include "api/Transform.h"
 #include "api/BoxCollider.h"
 #include "api/CircleCollider.h"
 #include "api/Metadata.h"
+#include "api/Rigidbody.h"
+#include "api/Transform.h"
 #include "api/Vector2.h"
 
 #include "Collider.h"
 #include "System.h"
 
-
 namespace crepe {
 
-
 //! A system responsible for detecting and handling collisions between colliders.
 class CollisionSystem : public System {
 public:
 	using System::System;
+
 private:
-	
 	//! A variant type that can hold either a BoxCollider or a CircleCollider.
-	using collider_variant = std::variant<std::reference_wrapper<BoxCollider>, std::reference_wrapper<CircleCollider>>;
+	using collider_variant = std::variant<std::reference_wrapper<BoxCollider>,
+										  std::reference_wrapper<CircleCollider>>;
 
 	//! Enum representing the types of collider pairs for collision detection.
 	enum class CollisionInternalType {
-    BOX_BOX,
-    CIRCLE_CIRCLE,
-    BOX_CIRCLE,
-    CIRCLE_BOX,
+		BOX_BOX,
+		CIRCLE_CIRCLE,
+		BOX_CIRCLE,
+		CIRCLE_BOX,
 	};
 
 	/**
@@ -45,21 +44,21 @@ private:
 		*/
 	struct CollisionInternal {
 		game_object_id_t id = 0;
-		collider_variant collider; 
-		Transform& transform;
-		Rigidbody& rigidbody;
+		collider_variant collider;
+		Transform & transform;
+		Rigidbody & rigidbody;
 	};
-	
+
 	//! Enum representing movement directions during collision resolution.
 	enum class Direction {
 		//! No movement required.
-    NONE,
+		NONE,
 		//! Movement in the X direction.
-    X_DIRECTION,
+		X_DIRECTION,
 		//! Movement in the Y direction.
-    Y_DIRECTION,
+		Y_DIRECTION,
 		//! Movement in both X and Y directions.
-    BOTH
+		BOTH
 	};
 
 public:
@@ -68,15 +67,15 @@ public:
 		* 
 		* Includes information about the colliding objects and the resolution data for handling the collision.
 		*/
-	struct CollisionInfo{
-    Collider& this_collider;
-		Transform& this_transform;
-		Rigidbody& this_rigidbody;
-		Metadata& this_metadata;
-    Collider& other_collider;
-		Transform& other_transform;
-		Rigidbody& other_rigidbody;
-		Metadata& other_metadata;
+	struct CollisionInfo {
+		Collider & this_collider;
+		Transform & this_transform;
+		Rigidbody & this_rigidbody;
+		Metadata & this_metadata;
+		Collider & other_collider;
+		Transform & other_transform;
+		Rigidbody & other_rigidbody;
+		Metadata & other_metadata;
 		//! The resolution vector for the collision.
 		vec2 resolution;
 		//! The direction of movement for resolving the collision.
@@ -84,11 +83,10 @@ public:
 	};
 
 public:
-
 	//! Updates the collision system by checking for collisions between colliders and handling them.
 	void update() override;
-private:
 
+private:
 	/**
 		* \brief Determines the type of collider pair from two colliders.
 		* 
@@ -98,7 +96,8 @@ private:
 		* \param collider2 Second collider variant (BoxCollider or CircleCollider).
 		* \return The combined type of the two colliders.
 		*/
-	CollisionInternalType get_collider_type(const collider_variant& collider1,const collider_variant& collider2) const;
+	CollisionInternalType get_collider_type(const collider_variant & collider1,
+											const collider_variant & collider2) const;
 
 	/**
 		* \brief Calculates the current position of a collider.
@@ -110,10 +109,10 @@ private:
 		* \param rigidbody The Rigidbody of the associated game object.
 		* \return The calculated position of the collider.
 		*/
-	vec2 get_current_position(const vec2& collider_offset, const Transform& transform, const Rigidbody& rigidbody) const;
+	vec2 get_current_position(const vec2 & collider_offset, const Transform & transform,
+							  const Rigidbody & rigidbody) const;
 
 private:
-
 	/**
 		* \brief Handles collision resolution between two colliders.
 		* 
@@ -122,7 +121,7 @@ private:
 		* \param data1 Collision data for the first collider.
 		* \param data2 Collision data for the second collider.
 		*/
-	void collision_handler_request(CollisionInternal& data1,CollisionInternal& data2);
+	void collision_handler_request(CollisionInternal & data1, CollisionInternal & data2);
 
 	/**
 		* \brief Resolves collision between two colliders and calculates the movement required.
@@ -134,7 +133,9 @@ private:
 		* \param type The type of collider pair.
 		* \return A pair containing the resolution vector and direction for the first collider.
 		*/
-	std::pair<vec2,Direction> collision_handler(CollisionInternal& data1,CollisionInternal& data2 ,CollisionInternalType type);
+	std::pair<vec2, Direction> collision_handler(CollisionInternal & data1,
+												 CollisionInternal & data2,
+												 CollisionInternalType type);
 
 	/**
 		* \brief Calculates the resolution vector for two BoxColliders.
@@ -147,7 +148,9 @@ private:
 		* \param position2 The position of the second BoxCollider.
 		* \return The resolution vector for the collision.
 		*/
-	vec2 get_box_box_resolution(const BoxCollider& box_collider1,const BoxCollider& box_collider2,const vec2& position1,const vec2& position2) const;
+	vec2 get_box_box_resolution(const BoxCollider & box_collider1,
+								const BoxCollider & box_collider2, const vec2 & position1,
+								const vec2 & position2) const;
 
 	/**
 		* \brief Calculates the resolution vector for two CircleCollider.
@@ -160,7 +163,10 @@ private:
 		* \param position2 The position of the second CircleCollider.
 		* \return The resolution vector for the collision.
 		*/
-	vec2 get_circle_circle_resolution(const CircleCollider& circle_collider1, const CircleCollider& circle_collider2, const vec2& final_position1, const vec2& final_position2) const;
+	vec2 get_circle_circle_resolution(const CircleCollider & circle_collider1,
+									  const CircleCollider & circle_collider2,
+									  const vec2 & final_position1,
+									  const vec2 & final_position2) const;
 
 	/**
 		* \brief Calculates the resolution vector for two CircleCollider.
@@ -173,7 +179,10 @@ private:
 		* \param box_position The position of the BocCollider.
 		* \return The resolution vector for the collision.
 		*/
-	vec2 get_circle_box_resolution(const CircleCollider& circle_collider, const BoxCollider& box_collider, const vec2& circle_position, const vec2& box_position) const;
+	vec2 get_circle_box_resolution(const CircleCollider & circle_collider,
+								   const BoxCollider & box_collider,
+								   const vec2 & circle_position,
+								   const vec2 & box_position) const;
 
 	/**
 		* \brief Determines the appropriate collision handler for a collision.
@@ -182,7 +191,7 @@ private:
 		* 
 		* \param info Collision information containing data about both colliders.
 		*/
-	void determine_collision_handler(CollisionInfo& info);
+	void determine_collision_handler(CollisionInfo & info);
 
 	/**
 		* \brief Handles collisions involving static objects.
@@ -191,9 +200,9 @@ private:
 		* 
 		* \param info Collision information containing data about both colliders.
 		*/
-	void static_collision_handler(CollisionInfo& info);
+	void static_collision_handler(CollisionInfo & info);
+
 private:
-	
 	/**
 		* \brief Checks for collisions between colliders.
 		* 
@@ -202,7 +211,8 @@ private:
 		* \param colliders A collection of all active colliders.
 		* \return A list of collision pairs with their associated data.
 		*/
-	std::vector<std::pair<CollisionInternal,CollisionInternal>> gather_collisions(std::vector<CollisionInternal> & colliders);
+	std::vector<std::pair<CollisionInternal, CollisionInternal>>
+	gather_collisions(std::vector<CollisionInternal> & colliders);
 
 	/**
 		* \brief Checks for collision between two colliders.
@@ -214,8 +224,10 @@ private:
 		* \param type The type of collider pair.
 		* \return True if a collision is detected, otherwise false.
 		*/
-	bool get_collision(const CollisionInternal& first_info,const CollisionInternal& second_info, CollisionInternalType type) const;
-	
+	bool get_collision(const CollisionInternal & first_info,
+					   const CollisionInternal & second_info,
+					   CollisionInternalType type) const;
+
 	/**
 		* \brief Detects collisions between two BoxColliders.
 		* 
@@ -227,8 +239,11 @@ private:
 		* \param rigidbody2 Rigidbody of the second object.
 		* \return True if a collision is detected, otherwise false.
 		*/
-	bool get_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) const;
-	
+	bool get_box_box_collision(const BoxCollider & box1, const BoxCollider & box2,
+							   const Transform & transform1, const Transform & transform2,
+							   const Rigidbody & rigidbody1,
+							   const Rigidbody & rigidbody2) const;
+
 	/**
 	 * \brief Check collision for box on circle collider
 	 *
@@ -240,7 +255,10 @@ private:
 	 * \param rigidbody2 Rigidbody of the second object.
 	 * \return True if a collision is detected, otherwise false.
 	 */
-	bool get_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) const;
+	bool get_box_circle_collision(const BoxCollider & box1, const CircleCollider & circle2,
+								  const Transform & transform1, const Transform & transform2,
+								  const Rigidbody & rigidbody1,
+								  const Rigidbody & rigidbody2) const;
 
 	/**
 	 * \brief Check collision for circle on circle collider
@@ -255,7 +273,12 @@ private:
 	 *
 	 * \return status of collision
 	 */
-	bool get_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) const;
+	bool get_circle_circle_collision(const CircleCollider & circle1,
+									 const CircleCollider & circle2,
+									 const Transform & transform1,
+									 const Transform & transform2,
+									 const Rigidbody & rigidbody1,
+									 const Rigidbody & rigidbody2) const;
 };
 
 } // namespace crepe
diff --git a/src/crepe/system/PhysicsSystem.cpp b/src/crepe/system/PhysicsSystem.cpp
index b5da042..b3adfa1 100644
--- a/src/crepe/system/PhysicsSystem.cpp
+++ b/src/crepe/system/PhysicsSystem.cpp
@@ -32,10 +32,13 @@ void PhysicsSystem::update() {
 						}
 						// Add damping
 						if (rigidbody.data.angular_velocity_coefficient > 0) {
-							rigidbody.data.angular_velocity *= rigidbody.data.angular_velocity_coefficient;
+							rigidbody.data.angular_velocity
+								*= rigidbody.data.angular_velocity_coefficient;
 						}
-						if (rigidbody.data.linear_velocity_coefficient.x > 0 && rigidbody.data.linear_velocity_coefficient.y > 0) {
-							rigidbody.data.linear_velocity *= rigidbody.data.linear_velocity_coefficient;
+						if (rigidbody.data.linear_velocity_coefficient.x > 0
+							&& rigidbody.data.linear_velocity_coefficient.y > 0) {
+							rigidbody.data.linear_velocity
+								*= rigidbody.data.linear_velocity_coefficient;
 						}
 
 						// Max velocity check
diff --git a/src/example/game.cpp b/src/example/game.cpp
index de08a22..70c562e 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -1,77 +1,84 @@
-#include <crepe/api/GameObject.h>
-#include <crepe/api/Transform.h>
-#include <crepe/api/Rigidbody.h>
 #include <crepe/api/BoxCollider.h>
 #include <crepe/api/Camera.h>
-#include <crepe/api/Script.h>
 #include <crepe/api/Color.h>
-#include <crepe/api/Sprite.h>
-#include <crepe/api/Texture.h>
-#include <crepe/api/Vector2.h>
 #include <crepe/api/Event.h>
 #include <crepe/api/EventManager.h>
+#include <crepe/api/GameObject.h>
 #include <crepe/api/LoopManager.h>
+#include <crepe/api/Rigidbody.h>
+#include <crepe/api/Script.h>
+#include <crepe/api/Sprite.h>
+#include <crepe/api/Texture.h>
+#include <crepe/api/Transform.h>
+#include <crepe/api/Vector2.h>
 
 using namespace crepe;
 
 using namespace std;
 
 class MyScript : public Script {
-	bool oncollision(const CollisionEvent& test) {
+	bool oncollision(const CollisionEvent & test) {
 		Log::logf("Box {} script on_collision()", test.info.this_collider.game_object_id);
 		return true;
 	}
 	void init() {
-		subscribe<CollisionEvent>([this](const CollisionEvent& ev) -> bool {
-			return this->oncollision(ev);
-		});
+		subscribe<CollisionEvent>(
+			[this](const CollisionEvent & ev) -> bool { return this->oncollision(ev); });
 	}
 	void update() {
 		// Retrieve component from the same GameObject this script is on
 	}
 };
 
-
 class ConcreteScene1 : public Scene {
 public:
 	using Scene::Scene;
 
 	void load_scene() {
-	ComponentManager & mgr = this->component_manager;
-	Color color(0, 0, 0, 255);
+		ComponentManager & mgr = this->component_manager;
+		Color color(0, 0, 0, 255);
 
-	float screen_size_width = 640;
-	float screen_size_height = 480;
-	float world_collider = 1000;
-	//define playable world 
-	GameObject world = mgr.new_object("Name", "Tag", vec2{screen_size_width/2, screen_size_height/2}, 0, 1);
-	world.add_component<Rigidbody>(Rigidbody::Data{
-		.mass = 0,
-		.gravity_scale = 0,
-		.body_type = Rigidbody::BodyType::STATIC,
-		.constraints = {0, 0, 0},
-		.offset = {0,0}
-	});
-	world.add_component<BoxCollider>(vec2{0, 0-(screen_size_height/2+world_collider/2)}, vec2{world_collider, world_collider});;	// Top
-	world.add_component<BoxCollider>(vec2{0, screen_size_height/2+world_collider/2}, vec2{world_collider, world_collider}); // Bottom
-	world.add_component<BoxCollider>(vec2{0-(screen_size_width/2+world_collider/2), 0}, vec2{world_collider, world_collider}); // Left
-	world.add_component<BoxCollider>(vec2{screen_size_width/2+world_collider/2, 0}, vec2{world_collider, world_collider}); // right
-	world.add_component<Camera>(Color::WHITE, ivec2{640, 480},vec2{640, 480}, 1.0f);
+		float screen_size_width = 640;
+		float screen_size_height = 480;
+		float world_collider = 1000;
+		//define playable world
+		GameObject world = mgr.new_object(
+			"Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1);
+		world.add_component<Rigidbody>(
+			Rigidbody::Data{.mass = 0,
+							.gravity_scale = 0,
+							.body_type = Rigidbody::BodyType::STATIC,
+							.constraints = {0, 0, 0},
+							.offset = {0, 0}});
+		world.add_component<BoxCollider>(
+			vec2{0, 0 - (screen_size_height / 2 + world_collider / 2)},
+			vec2{world_collider, world_collider});
+		; // Top
+		world.add_component<BoxCollider>(vec2{0, screen_size_height / 2 + world_collider / 2},
+										 vec2{world_collider, world_collider}); // Bottom
+		world.add_component<BoxCollider>(
+			vec2{0 - (screen_size_width / 2 + world_collider / 2), 0},
+			vec2{world_collider, world_collider}); // Left
+		world.add_component<BoxCollider>(vec2{screen_size_width / 2 + world_collider / 2, 0},
+										 vec2{world_collider, world_collider}); // right
+		world.add_component<Camera>(Color::WHITE, ivec2{640, 480}, vec2{640, 480}, 1.0f);
 
-	GameObject game_object1 = mgr.new_object("Name", "Tag", vec2{screen_size_width/2, screen_size_height/2}, 0, 1);
-	game_object1.add_component<Rigidbody>(Rigidbody::Data{
-		.mass = 1,
-		.gravity_scale = 0.01,
-		.body_type = Rigidbody::BodyType::DYNAMIC,
-		.linear_velocity = {1,1},
-		.constraints = {0, 0, 0},
-		.elastisity_coefficient = 1,
-		.offset = {0,0},
-	});
-	game_object1.add_component<BoxCollider>(vec2{0, 0}, vec2{20, 20});
-	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
-	auto img = Texture("asset/texture/green_square.png");
-	game_object1.add_component<Sprite>(img, color, Sprite::FlipSettings{false, false}, 1, 1, 20);
+		GameObject game_object1 = mgr.new_object(
+			"Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1);
+		game_object1.add_component<Rigidbody>(Rigidbody::Data{
+			.mass = 1,
+			.gravity_scale = 0.01,
+			.body_type = Rigidbody::BodyType::DYNAMIC,
+			.linear_velocity = {1, 1},
+			.constraints = {0, 0, 0},
+			.elastisity_coefficient = 1,
+			.offset = {0, 0},
+		});
+		game_object1.add_component<BoxCollider>(vec2{0, 0}, vec2{20, 20});
+		game_object1.add_component<BehaviorScript>().set_script<MyScript>();
+		auto img = Texture("asset/texture/green_square.png");
+		game_object1.add_component<Sprite>(img, color, Sprite::FlipSettings{false, false}, 1,
+										   1, 20);
 	}
 
 	string get_name() const { return "scene1"; }
diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp
index fec42f3..74edaf7 100644
--- a/src/test/CollisionTest.cpp
+++ b/src/test/CollisionTest.cpp
@@ -26,22 +26,19 @@ using namespace testing;
 class CollisionHandler : public Script {
 public:
 	int box_id;
-	function<void(const CollisionEvent& ev)> test_fn = [](const CollisionEvent & ev) { };
+	function<void(const CollisionEvent & ev)> test_fn = [](const CollisionEvent & ev) {};
 
-	CollisionHandler(int box_id) {
-		this->box_id = box_id;
-	}
+	CollisionHandler(int box_id) { this->box_id = box_id; }
 
-	bool on_collision(const CollisionEvent& ev) {
+	bool on_collision(const CollisionEvent & ev) {
 		//Log::logf("Box {} script on_collision()", box_id);
 		test_fn(ev);
 		return true;
 	}
 
 	void init() {
-		subscribe<CollisionEvent>([this](const CollisionEvent& ev) -> bool {
-			return this->on_collision(ev);
-		});
+		subscribe<CollisionEvent>(
+			[this](const CollisionEvent & ev) -> bool { return this->on_collision(ev); });
 	}
 	void update() {
 		// Retrieve component from the same GameObject this script is on
@@ -54,18 +51,18 @@ public:
 	CollisionSystem collision_sys{mgr};
 	ScriptSystem script_sys{mgr};
 
-	GameObject world = mgr.new_object("world","",{50,50});
-	GameObject game_object1 = mgr.new_object("object1", "", { 50, 50});
-	GameObject game_object2 = mgr.new_object("object2", "", { 50, 30});
+	GameObject world = mgr.new_object("world", "", {50, 50});
+	GameObject game_object1 = mgr.new_object("object1", "", {50, 50});
+	GameObject game_object2 = mgr.new_object("object2", "", {50, 30});
 
 	CollisionHandler * script_object1_ref = nullptr;
 	CollisionHandler * script_object2_ref = nullptr;
-	
+
 	void SetUp() override {
 		world.add_component<Rigidbody>(Rigidbody::Data{
 			// TODO: remove unrelated properties:
 			.body_type = Rigidbody::BodyType::STATIC,
-			.offset = {0,0},
+			.offset = {0, 0},
 		});
 		// Create a box with an inner size of 10x10 units
 		world.add_component<BoxCollider>(vec2{0, -100}, vec2{100, 100}); // Top
@@ -77,28 +74,30 @@ public:
 			.mass = 1,
 			.gravity_scale = 0.01,
 			.body_type = Rigidbody::BodyType::DYNAMIC,
-			.linear_velocity = {0,0},
+			.linear_velocity = {0, 0},
 			.constraints = {0, 0, 0},
 			.elastisity_coefficient = 1,
-			.offset = {0,0},
+			.offset = {0, 0},
 		});
 		game_object1.add_component<BoxCollider>(vec2{0, 0}, vec2{10, 10});
-		BehaviorScript & script_object1 = game_object1.add_component<BehaviorScript>().set_script<CollisionHandler>(1);
-		script_object1_ref = static_cast<CollisionHandler*>(script_object1.script.get());
+		BehaviorScript & script_object1
+			= game_object1.add_component<BehaviorScript>().set_script<CollisionHandler>(1);
+		script_object1_ref = static_cast<CollisionHandler *>(script_object1.script.get());
 		ASSERT_NE(script_object1_ref, nullptr);
-		
+
 		game_object2.add_component<Rigidbody>(Rigidbody::Data{
 			.mass = 1,
 			.gravity_scale = 0.01,
 			.body_type = Rigidbody::BodyType::DYNAMIC,
-			.linear_velocity = {0,0},
+			.linear_velocity = {0, 0},
 			.constraints = {0, 0, 0},
 			.elastisity_coefficient = 1,
-			.offset = {0,0},
+			.offset = {0, 0},
 		});
 		game_object2.add_component<BoxCollider>(vec2{0, 0}, vec2{10, 10});
-		BehaviorScript & script_object2 = game_object2.add_component<BehaviorScript>().set_script<CollisionHandler>(2);
-		script_object2_ref = static_cast<CollisionHandler*>(script_object2.script.get());
+		BehaviorScript & script_object2
+			= game_object2.add_component<BehaviorScript>().set_script<CollisionHandler>(2);
+		script_object2_ref = static_cast<CollisionHandler *>(script_object2.script.get());
 		ASSERT_NE(script_object2_ref, nullptr);
 
 		// Ensure Script::init() is called on all BehaviorScript instances
@@ -139,7 +138,7 @@ TEST_F(CollisionTest, collision_box_box_dynamic_both_no_velocity) {
 	};
 	EXPECT_FALSE(collision_happend);
 	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
-	tf.position = {50,30};
+	tf.position = {50, 30};
 	collision_sys.update();
 	EXPECT_TRUE(collision_happend);
 }
@@ -151,18 +150,20 @@ TEST_F(CollisionTest, collision_box_box_dynamic_x_direction_no_velocity) {
 		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
 		EXPECT_EQ(ev.info.resolution.x, -5);
 		EXPECT_EQ(ev.info.resolution.y, 0);
-		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::X_DIRECTION);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::X_DIRECTION);
 	};
 	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
 		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
 		EXPECT_EQ(ev.info.resolution.x, 5);
 		EXPECT_EQ(ev.info.resolution.y, 0);
-		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::X_DIRECTION);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::X_DIRECTION);
 	};
 	EXPECT_FALSE(collision_happend);
 	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
-	tf.position = {45,30};
+	tf.position = {45, 30};
 	collision_sys.update();
 	EXPECT_TRUE(collision_happend);
 }
@@ -174,18 +175,20 @@ TEST_F(CollisionTest, collision_box_box_dynamic_y_direction_no_velocity) {
 		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
 		EXPECT_EQ(ev.info.resolution.x, 0);
 		EXPECT_EQ(ev.info.resolution.y, -5);
-		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::Y_DIRECTION);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::Y_DIRECTION);
 	};
 	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
 		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
 		EXPECT_EQ(ev.info.resolution.x, 0);
 		EXPECT_EQ(ev.info.resolution.y, 5);
-		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::Y_DIRECTION);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::Y_DIRECTION);
 	};
 	EXPECT_FALSE(collision_happend);
 	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
-	tf.position = {50,25};
+	tf.position = {50, 25};
 	collision_sys.update();
 	EXPECT_TRUE(collision_happend);
 }
@@ -208,11 +211,11 @@ TEST_F(CollisionTest, collision_box_box_dynamic_both) {
 	};
 	EXPECT_FALSE(collision_happend);
 	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
-	tf.position = {50,30};
+	tf.position = {50, 30};
 	Rigidbody & rg1 = this->mgr.get_components_by_id<Rigidbody>(1).front().get();
-	rg1.data.linear_velocity = {10,10};
+	rg1.data.linear_velocity = {10, 10};
 	Rigidbody & rg2 = this->mgr.get_components_by_id<Rigidbody>(2).front().get();
-	rg2.data.linear_velocity = {10,10};
+	rg2.data.linear_velocity = {10, 10};
 	collision_sys.update();
 	EXPECT_TRUE(collision_happend);
 }
@@ -224,22 +227,24 @@ TEST_F(CollisionTest, collision_box_box_dynamic_x_direction) {
 		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
 		EXPECT_EQ(ev.info.resolution.x, -5);
 		EXPECT_EQ(ev.info.resolution.y, -5);
-		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::X_DIRECTION);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::X_DIRECTION);
 	};
 	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
 		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
 		EXPECT_EQ(ev.info.resolution.x, 5);
 		EXPECT_EQ(ev.info.resolution.y, 5);
-		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::X_DIRECTION);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::X_DIRECTION);
 	};
 	EXPECT_FALSE(collision_happend);
 	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
-	tf.position = {45,30};
+	tf.position = {45, 30};
 	Rigidbody & rg1 = this->mgr.get_components_by_id<Rigidbody>(1).front().get();
-	rg1.data.linear_velocity = {10,10};
+	rg1.data.linear_velocity = {10, 10};
 	Rigidbody & rg2 = this->mgr.get_components_by_id<Rigidbody>(2).front().get();
-	rg2.data.linear_velocity = {10,10};
+	rg2.data.linear_velocity = {10, 10};
 	collision_sys.update();
 	EXPECT_TRUE(collision_happend);
 }
@@ -251,27 +256,28 @@ TEST_F(CollisionTest, collision_box_box_dynamic_y_direction) {
 		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
 		EXPECT_EQ(ev.info.resolution.x, -5);
 		EXPECT_EQ(ev.info.resolution.y, -5);
-		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::Y_DIRECTION);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::Y_DIRECTION);
 	};
 	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		collision_happend = true;
 		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
 		EXPECT_EQ(ev.info.resolution.x, 5);
 		EXPECT_EQ(ev.info.resolution.y, 5);
-		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::Y_DIRECTION);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::Y_DIRECTION);
 	};
 	EXPECT_FALSE(collision_happend);
 	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
-	tf.position = {50,25};
+	tf.position = {50, 25};
 	Rigidbody & rg1 = this->mgr.get_components_by_id<Rigidbody>(1).front().get();
-	rg1.data.linear_velocity = {10,10};
+	rg1.data.linear_velocity = {10, 10};
 	Rigidbody & rg2 = this->mgr.get_components_by_id<Rigidbody>(2).front().get();
-	rg2.data.linear_velocity = {10,10};
+	rg2.data.linear_velocity = {10, 10};
 	collision_sys.update();
 	EXPECT_TRUE(collision_happend);
 }
 
-
 TEST_F(CollisionTest, collision_box_box_static_both) {
 	bool collision_happend = false;
 	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
@@ -287,7 +293,7 @@ TEST_F(CollisionTest, collision_box_box_static_both) {
 	};
 	EXPECT_FALSE(collision_happend);
 	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
-	tf.position = {50,30};
+	tf.position = {50, 30};
 	Rigidbody & rg2 = this->mgr.get_components_by_id<Rigidbody>(2).front().get();
 	rg2.data.body_type = crepe::Rigidbody::BodyType::STATIC;
 	collision_sys.update();
@@ -301,7 +307,8 @@ TEST_F(CollisionTest, collision_box_box_static_x_direction) {
 		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
 		EXPECT_EQ(ev.info.resolution.x, -5);
 		EXPECT_EQ(ev.info.resolution.y, -5);
-		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::X_DIRECTION);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::X_DIRECTION);
 	};
 	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		// is static should not be called
@@ -309,9 +316,9 @@ TEST_F(CollisionTest, collision_box_box_static_x_direction) {
 	};
 	EXPECT_FALSE(collision_happend);
 	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
-	tf.position = {45,30};
+	tf.position = {45, 30};
 	Rigidbody & rg1 = this->mgr.get_components_by_id<Rigidbody>(1).front().get();
-	rg1.data.linear_velocity = {10,10};
+	rg1.data.linear_velocity = {10, 10};
 	Rigidbody & rg2 = this->mgr.get_components_by_id<Rigidbody>(2).front().get();
 	rg2.data.body_type = crepe::Rigidbody::BodyType::STATIC;
 	collision_sys.update();
@@ -325,7 +332,8 @@ TEST_F(CollisionTest, collision_box_box_static_y_direction) {
 		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
 		EXPECT_EQ(ev.info.resolution.x, -5);
 		EXPECT_EQ(ev.info.resolution.y, -5);
-		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::Y_DIRECTION);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::Y_DIRECTION);
 	};
 	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
 		// is static should not be called
@@ -333,24 +341,24 @@ TEST_F(CollisionTest, collision_box_box_static_y_direction) {
 	};
 	EXPECT_FALSE(collision_happend);
 	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
-	tf.position = {50,25};
+	tf.position = {50, 25};
 	Rigidbody & rg1 = this->mgr.get_components_by_id<Rigidbody>(1).front().get();
-	rg1.data.linear_velocity = {10,10};
+	rg1.data.linear_velocity = {10, 10};
 	Rigidbody & rg2 = this->mgr.get_components_by_id<Rigidbody>(2).front().get();
 	rg2.data.body_type = crepe::Rigidbody::BodyType::STATIC;
 	collision_sys.update();
 	EXPECT_TRUE(collision_happend);
 }
 
-TEST_F(CollisionTest, collision_box_box_static_multiple) {//todo check visually
+TEST_F(CollisionTest, collision_box_box_static_multiple) { //todo check visually
 	bool collision_happend = false;
 	float offset_value = 0;
 	float resolution = 0;
 	script_object1_ref->test_fn = [&](const CollisionEvent & ev) {
 		collision_happend = true;
 		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
-		EXPECT_EQ(ev.info.this_collider.offset.x , offset_value);
-		EXPECT_EQ(ev.info.resolution.x , resolution);
+		EXPECT_EQ(ev.info.this_collider.offset.x, offset_value);
+		EXPECT_EQ(ev.info.resolution.x, resolution);
 	};
 	script_object2_ref->test_fn = [&](const CollisionEvent & ev) {
 		// is static should not be called
@@ -358,20 +366,20 @@ TEST_F(CollisionTest, collision_box_box_static_multiple) {//todo check visually
 	};
 	EXPECT_FALSE(collision_happend);
 	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
-	tf.position = {45,30};
+	tf.position = {45, 30};
 	Rigidbody & rg1 = this->mgr.get_components_by_id<Rigidbody>(1).front().get();
-	rg1.data.linear_velocity = {10,10};
+	rg1.data.linear_velocity = {10, 10};
 	Rigidbody & rg2 = this->mgr.get_components_by_id<Rigidbody>(2).front().get();
 	rg2.data.body_type = crepe::Rigidbody::BodyType::STATIC;
 	BoxCollider & bxc = this->mgr.get_components_by_id<BoxCollider>(1).front().get();
-	bxc.offset = {5,0};
+	bxc.offset = {5, 0};
 	this->game_object1.add_component<BoxCollider>(vec2{-5, 0}, vec2{10, 10});
 	offset_value = 5;
 	resolution = 10;
 	collision_sys.update();
 	offset_value = -5;
 	resolution = 10;
-	tf.position = {55,30};
+	tf.position = {55, 30};
 	collision_sys.update();
 	EXPECT_TRUE(collision_happend);
 }
diff --git a/src/test/Profiling.cpp b/src/test/Profiling.cpp
index fa0f5f3..d2f219e 100644
--- a/src/test/Profiling.cpp
+++ b/src/test/Profiling.cpp
@@ -1,8 +1,8 @@
 #include "system/ParticleSystem.h"
 #include "system/PhysicsSystem.h"
 #include "system/RenderSystem.h"
-#include <cmath>
 #include <chrono>
+#include <cmath>
 #include <gtest/gtest.h>
 
 #define private public
@@ -12,10 +12,10 @@
 #include <crepe/api/Event.h>
 #include <crepe/api/EventManager.h>
 #include <crepe/api/GameObject.h>
+#include <crepe/api/ParticleEmitter.h>
 #include <crepe/api/Rigidbody.h>
 #include <crepe/api/Script.h>
 #include <crepe/api/Transform.h>
-#include <crepe/api/ParticleEmitter.h>
 #include <crepe/system/CollisionSystem.h>
 #include <crepe/system/ScriptSystem.h>
 #include <crepe/types.h>
@@ -27,14 +27,13 @@ using namespace crepe;
 using namespace testing;
 
 class TestScript : public Script {
-	bool oncollision(const CollisionEvent& test) {
+	bool oncollision(const CollisionEvent & test) {
 		Log::logf("Box {} script on_collision()", test.info.this_collider.game_object_id);
 		return true;
 	}
 	void init() {
-		subscribe<CollisionEvent>([this](const CollisionEvent& ev) -> bool {
-			return this->oncollision(ev);
-		});
+		subscribe<CollisionEvent>(
+			[this](const CollisionEvent & ev) -> bool { return this->oncollision(ev); });
 	}
 	void update() {
 		// Retrieve component from the same GameObject this script is on
@@ -52,10 +51,9 @@ public:
 	const int average = 5;
 	// Maximum duration to stop test
 	const std::chrono::microseconds duration = 16000us;
-	
 
 	ComponentManager mgr;
-	// Add system used for profling tests 
+	// Add system used for profling tests
 	CollisionSystem collision_sys{mgr};
 	PhysicsSystem physics_sys{mgr};
 	ParticleSystem particle_sys{mgr};
@@ -67,12 +65,11 @@ public:
 	int game_object_count = 0;
 	std::chrono::microseconds total_time = 0us;
 
-	
 	void SetUp() override {
-		
-		GameObject do_not_use = mgr.new_object("DO_NOT_USE","",{0,0});
-		do_not_use.add_component<Camera>(Color::WHITE, ivec2{1080, 720},
-												   vec2{2000, 2000}, 1.0f);
+
+		GameObject do_not_use = mgr.new_object("DO_NOT_USE", "", {0, 0});
+		do_not_use.add_component<Camera>(Color::WHITE, ivec2{1080, 720}, vec2{2000, 2000},
+										 1.0f);
 		// initialize systems here:
 		//calls init
 		script_sys.update();
@@ -82,11 +79,12 @@ public:
 
 	// Helper function to time an update call and store its duration
 	template <typename Func>
-	std::chrono::microseconds time_function(const std::string& name, Func&& func) {
+	std::chrono::microseconds time_function(const std::string & name, Func && func) {
 		auto start = std::chrono::steady_clock::now();
 		func();
 		auto end = std::chrono::steady_clock::now();
-		std::chrono::microseconds duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+		std::chrono::microseconds duration
+			= std::chrono::duration_cast<std::chrono::microseconds>(end - start);
 		timings[name] += duration;
 		return duration;
 	}
@@ -95,8 +93,10 @@ public:
 	std::chrono::microseconds run_all_systems() {
 		std::chrono::microseconds total_microseconds = 0us;
 		total_microseconds += time_function("PhysicsSystem", [&]() { physics_sys.update(); });
-		total_microseconds += time_function("CollisionSystem", [&]() { collision_sys.update(); });
-		total_microseconds += time_function("ParticleSystem", [&]() { particle_sys.update(); });
+		total_microseconds
+			+= time_function("CollisionSystem", [&]() { collision_sys.update(); });
+		total_microseconds
+			+= time_function("ParticleSystem", [&]() { particle_sys.update(); });
 		total_microseconds += time_function("RenderSystem", [&]() { render_sys.update(); });
 		return total_microseconds;
 	}
@@ -104,34 +104,33 @@ public:
 	// Print timings of all functions
 	void log_timings() const {
 		std::string result = "\nFunction timings:\n";
-    
-    for (const auto& [name, duration] : timings) {
-        result += name + " took " + std::to_string(duration.count() / 1000.0 / average) + " ms (" +
-                  std::to_string(duration.count() / average) + " µs).\n";
-    }
-
-    result += "Total time: " + std::to_string(this->total_time.count() / 1000.0 / average) + " ms (" +
-              std::to_string(this->total_time.count() / average) + " µs)\n";
-    
-    result += "Amount of gameobjects: " + std::to_string(game_object_count) + "\n";
-
-    GTEST_LOG_(INFO) << result;
+
+		for (const auto & [name, duration] : timings) {
+			result += name + " took " + std::to_string(duration.count() / 1000.0 / average)
+					  + " ms (" + std::to_string(duration.count() / average) + " µs).\n";
+		}
+
+		result += "Total time: " + std::to_string(this->total_time.count() / 1000.0 / average)
+				  + " ms (" + std::to_string(this->total_time.count() / average) + " µs)\n";
+
+		result += "Amount of gameobjects: " + std::to_string(game_object_count) + "\n";
+
+		GTEST_LOG_(INFO) << result;
 	}
 
 	void clear_timings() {
-		for (auto& [key, value] : timings) {
-    	value = std::chrono::microseconds(0);
+		for (auto & [key, value] : timings) {
+			value = std::chrono::microseconds(0);
 		}
 	}
 };
 
 TEST_F(Profiling, Profiling_1) {
-	while (this->total_time/this->average < this->duration) {
-		
+	while (this->total_time / this->average < this->duration) {
 
 		{
 			//define gameobject used for testing
-			GameObject gameobject = mgr.new_object("gameobject","",{0,0});
+			GameObject gameobject = mgr.new_object("gameobject", "", {0, 0});
 		}
 
 		this->game_object_count++;
@@ -143,18 +142,19 @@ TEST_F(Profiling, Profiling_1) {
 			this->total_time += run_all_systems();
 		}
 
-		if(this->game_object_count >= this->max_gameobject_count) break;
+		if (this->game_object_count >= this->max_gameobject_count) break;
 	}
 	log_timings();
 	EXPECT_GE(this->game_object_count, this->min_gameobject_count);
 }
 
 TEST_F(Profiling, Profiling_2) {
-	while (this->total_time/this->average < this->duration) {
-	
+	while (this->total_time / this->average < this->duration) {
+
 		{
 			//define gameobject used for testing
-			GameObject gameobject = mgr.new_object("gameobject","",{static_cast<float>(game_object_count*2),0});
+			GameObject gameobject = mgr.new_object(
+				"gameobject", "", {static_cast<float>(game_object_count * 2), 0});
 			gameobject.add_component<Rigidbody>(Rigidbody::Data{
 				.gravity_scale = 0.0,
 				.body_type = Rigidbody::BodyType::STATIC,
@@ -163,7 +163,8 @@ TEST_F(Profiling, Profiling_2) {
 			gameobject.add_component<BehaviorScript>().set_script<TestScript>();
 			Color color(0, 0, 0, 0);
 			auto img = Texture("asset/texture/green_square.png");
-			Sprite & test_sprite = gameobject.add_component<Sprite>(img, color, Sprite::FlipSettings{false, false}, 1, 1, 500);
+			Sprite & test_sprite = gameobject.add_component<Sprite>(
+				img, color, Sprite::FlipSettings{false, false}, 1, 1, 500);
 		}
 
 		this->game_object_count++;
@@ -174,50 +175,52 @@ TEST_F(Profiling, Profiling_2) {
 			this->total_time += run_all_systems();
 		}
 
-		if(this->game_object_count >= this->max_gameobject_count) break;
+		if (this->game_object_count >= this->max_gameobject_count) break;
 	}
 	log_timings();
 	EXPECT_GE(this->game_object_count, this->min_gameobject_count);
 }
 
 TEST_F(Profiling, Profiling_3) {
-	while (this->total_time/this->average < this->duration) {
-	
+	while (this->total_time / this->average < this->duration) {
+
 		{
 			//define gameobject used for testing
-			GameObject gameobject = mgr.new_object("gameobject","",{static_cast<float>(game_object_count*2),0});
+			GameObject gameobject = mgr.new_object(
+				"gameobject", "", {static_cast<float>(game_object_count * 2), 0});
 			gameobject.add_component<Rigidbody>(Rigidbody::Data{
-			.gravity_scale = 0,
-			.body_type = Rigidbody::BodyType::STATIC,
+				.gravity_scale = 0,
+				.body_type = Rigidbody::BodyType::STATIC,
 			});
 			gameobject.add_component<BoxCollider>(vec2{0, 0}, 1, 1);
 			gameobject.add_component<BehaviorScript>().set_script<TestScript>();
 			Color color(0, 0, 0, 0);
 			auto img = Texture("asset/texture/green_square.png");
-			Sprite & test_sprite = gameobject.add_component<Sprite>(img, color, Sprite::FlipSettings{false, false}, 1, 1, 500);
+			Sprite & test_sprite = gameobject.add_component<Sprite>(
+				img, color, Sprite::FlipSettings{false, false}, 1, 1, 500);
 			auto & test = gameobject.add_component<ParticleEmitter>(ParticleEmitter::Data{
-			.max_particles = 10,
-			.emission_rate = 100,
-			.end_lifespan = 100000,
-			.boundary{
-				.width = 1000,
-				.height = 1000,
-				.offset = vec2{0, 0},
-				.reset_on_exit = false,
-			},
-			.sprite = test_sprite,
-	});
+				.max_particles = 10,
+				.emission_rate = 100,
+				.end_lifespan = 100000,
+				.boundary{
+					.width = 1000,
+					.height = 1000,
+					.offset = vec2{0, 0},
+					.reset_on_exit = false,
+				},
+				.sprite = test_sprite,
+			});
 		}
 		render_sys.update();
 		this->game_object_count++;
-		
+
 		this->total_time = 0us;
 		clear_timings();
 		for (int amount = 0; amount < this->average; amount++) {
 			this->total_time += run_all_systems();
 		}
 
-		if(this->game_object_count >= this->max_gameobject_count) break;
+		if (this->game_object_count >= this->max_gameobject_count) break;
 	}
 	log_timings();
 	EXPECT_GE(this->game_object_count, this->min_gameobject_count);
-- 
cgit v1.2.3


From 24246e115c3b7829d2981a2f60ac77da657f2ed5 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Wed, 4 Dec 2024 20:42:53 +0100
Subject: added collision layers

---
 src/crepe/api/Rigidbody.h            | 10 ++++++++++
 src/crepe/system/CollisionSystem.cpp | 12 ++++++++++++
 src/crepe/system/CollisionSystem.h   | 16 ++++++++++++++++
 3 files changed, 38 insertions(+)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index 756cc28..5c9f6df 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -130,6 +130,16 @@ public:
 		* 
 		*/
 		vec2 offset;
+
+		/**
+		 * \brief Defines the collision layers of a GameObject.
+		 *
+		 * The `collision_layers` vector specifies the layers that the GameObject will collide with.
+		 * Each element in the vector represents a layer ID, and the GameObject will only detect 
+		 * collisions with other GameObjects that belong to these layers.
+		 */
+		std::vector<int> collision_layers;
+
 	};
 
 public:
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 34cd125..3c103e9 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -359,6 +359,7 @@ CollisionSystem::gather_collisions(std::vector<CollisionInternal> & colliders) {
 	for (size_t i = 0; i < colliders.size(); ++i) {
 		for (size_t j = i + 1; j < colliders.size(); ++j) {
 			if (colliders[i].id == colliders[j].id) continue;
+			if(!have_common_layer(colliders[i].rigidbody.data.collision_layers,colliders[j].rigidbody.data.collision_layers)) continue;
 			CollisionInternalType type
 				= get_collider_type(colliders[i].collider, colliders[j].collider);
 			if (!get_collision(
@@ -381,6 +382,17 @@ CollisionSystem::gather_collisions(std::vector<CollisionInternal> & colliders) {
 	return collisions_ret;
 }
 
+bool CollisionSystem::have_common_layer(const std::vector<int>& layers1, const std::vector<int>& layers2) {
+    // Iterate through each layer in the first vector
+    for (int layer : layers1) {
+        // Check if the current layer is present in the second vector
+        if (std::find(layers2.begin(), layers2.end(), layer) != layers2.end()) {
+            return true; // Common layer found
+        }
+    }
+    return false; // No common layers found
+}
+
 CollisionSystem::CollisionInternalType
 CollisionSystem::get_collider_type(const collider_variant & collider1,
 								   const collider_variant & collider2) const {
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 6b5a4bb..a22baf2 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -214,6 +214,22 @@ private:
 	std::vector<std::pair<CollisionInternal, CollisionInternal>>
 	gather_collisions(std::vector<CollisionInternal> & colliders);
 
+	/**
+	 * \brief Checks if two collision layers have at least one common layer.
+	 * 
+	 * This function checks if there is any overlapping layer between the two input 
+	 * collision layer vectors. It compares each layer from the first vector to see 
+	 * if it exists in the second vector. If at least one common layer is found, 
+	 * the function returns true, indicating that the two colliders share a common 
+	 * collision layer.
+	 * 
+	 * \param layers1 A vector of collision layers for the first collider.
+	 * \param layers2 A vector of collision layers for the second collider.
+	 * \return Returns true if there is at least one common layer, false otherwise.
+	 */
+
+	bool have_common_layer(const std::vector<int>& layers1, const std::vector<int>& layers2);
+
 	/**
 		* \brief Checks for collision between two colliders.
 		* 
-- 
cgit v1.2.3


From 018a451051669506be447aa925ecb6a9f5aaf418 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Wed, 4 Dec 2024 20:49:37 +0100
Subject: make format

---
 src/crepe/api/LoopManager.cpp        |  1 -
 src/crepe/api/Rigidbody.h            |  1 -
 src/crepe/system/CollisionSystem.cpp | 23 +++++++++++++----------
 src/crepe/system/CollisionSystem.h   |  2 +-
 4 files changed, 14 insertions(+), 13 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index d4819ea..478c8ba 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -1,6 +1,5 @@
 #include "../facade/SDLContext.h"
 
-#include "../system/PhysicsSystem.h"
 #include "../system/AnimatorSystem.h"
 #include "../system/CollisionSystem.h"
 #include "../system/ParticleSystem.h"
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index 5c9f6df..293b1a4 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -139,7 +139,6 @@ public:
 		 * collisions with other GameObjects that belong to these layers.
 		 */
 		std::vector<int> collision_layers;
-
 	};
 
 public:
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 3c103e9..e3b2eca 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -359,7 +359,9 @@ CollisionSystem::gather_collisions(std::vector<CollisionInternal> & colliders) {
 	for (size_t i = 0; i < colliders.size(); ++i) {
 		for (size_t j = i + 1; j < colliders.size(); ++j) {
 			if (colliders[i].id == colliders[j].id) continue;
-			if(!have_common_layer(colliders[i].rigidbody.data.collision_layers,colliders[j].rigidbody.data.collision_layers)) continue;
+			if (!have_common_layer(colliders[i].rigidbody.data.collision_layers,
+								   colliders[j].rigidbody.data.collision_layers))
+				continue;
 			CollisionInternalType type
 				= get_collider_type(colliders[i].collider, colliders[j].collider);
 			if (!get_collision(
@@ -382,15 +384,16 @@ CollisionSystem::gather_collisions(std::vector<CollisionInternal> & colliders) {
 	return collisions_ret;
 }
 
-bool CollisionSystem::have_common_layer(const std::vector<int>& layers1, const std::vector<int>& layers2) {
-    // Iterate through each layer in the first vector
-    for (int layer : layers1) {
-        // Check if the current layer is present in the second vector
-        if (std::find(layers2.begin(), layers2.end(), layer) != layers2.end()) {
-            return true; // Common layer found
-        }
-    }
-    return false; // No common layers found
+bool CollisionSystem::have_common_layer(const std::vector<int> & layers1,
+										const std::vector<int> & layers2) {
+	// Iterate through each layer in the first vector
+	for (int layer : layers1) {
+		// Check if the current layer is present in the second vector
+		if (std::find(layers2.begin(), layers2.end(), layer) != layers2.end()) {
+			return true; // Common layer found
+		}
+	}
+	return false; // No common layers found
 }
 
 CollisionSystem::CollisionInternalType
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index a22baf2..eb361b8 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -228,7 +228,7 @@ private:
 	 * \return Returns true if there is at least one common layer, false otherwise.
 	 */
 
-	bool have_common_layer(const std::vector<int>& layers1, const std::vector<int>& layers2);
+	bool have_common_layer(const std::vector<int> & layers1, const std::vector<int> & layers2);
 
 	/**
 		* \brief Checks for collision between two colliders.
-- 
cgit v1.2.3


From 3fbe1a5c72e7512a330111665482a5babf21cc15 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Fri, 6 Dec 2024 11:25:14 +0100
Subject: added animatorsystem update

---
 src/crepe/api/LoopManager.cpp | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index 3e9a88e..d316051 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -66,6 +66,7 @@ void LoopManager::setup() {
 void LoopManager::render() {
 	if (!this->game_running) return;
 
+	this->get_system<AnimatorSystem>().update();
 	this->get_system<RenderSystem>().update();
 }
 
-- 
cgit v1.2.3


From 27a5332ee8e905d346a088ac7f4d1d1bb30025c4 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Fri, 6 Dec 2024 15:32:31 +0100
Subject: review feedback

---
 src/crepe/api/LoopManager.cpp        |  1 +
 src/crepe/api/Rigidbody.h            |  4 ++--
 src/crepe/api/Script.h               |  2 +-
 src/crepe/system/CollisionSystem.cpp | 10 +++++-----
 src/crepe/system/CollisionSystem.h   | 12 ++++++------
 src/test/Profiling.cpp               |  4 ++--
 6 files changed, 17 insertions(+), 16 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index b9e91dd..2c12895 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -34,6 +34,7 @@ void LoopManager::start() {
 void LoopManager::set_running(bool running) { this->game_running = running; }
 
 void LoopManager::fixed_update() {
+	// TODO: retrieve EventManager from direct member after singleton refactor
 	EventManager & ev = this->mediator.event_manager;
 	ev.dispatch_events();
 	this->get_system<ScriptSystem>().update();
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index b0a24f7..a6aab26 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -136,8 +136,8 @@ public:
 		/**
 		 * \brief Defines the collision layers of a GameObject.
 		 *
-		 * The `collision_layers` vector specifies the layers that the GameObject will collide with.
-		 * Each element in the vector represents a layer ID, and the GameObject will only detect 
+		 * The `collision_layers` specifies the layers that the GameObject will collide with.
+		 * Each element represents a layer ID, and the GameObject will only detect 
 		 * collisions with other GameObjects that belong to these layers.
 		 */
 		std::set<int> collision_layers;
diff --git a/src/crepe/api/Script.h b/src/crepe/api/Script.h
index 1474a09..3d416a1 100644
--- a/src/crepe/api/Script.h
+++ b/src/crepe/api/Script.h
@@ -3,7 +3,7 @@
 #include <vector>
 
 #include "../manager/EventManager.h"
-#include "system/CollisionSystem.h"
+#include "../system/CollisionSystem.h"
 #include "../manager/Mediator.h"
 #include "../types.h"
 #include "../util/OptionalRef.h"
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 44ea7ee..e196e10 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -158,8 +158,8 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal
 															data1.rigidbody);
 			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform,
 															data2.rigidbody);
-			resolution = this->get_circle_box_resolution(collider2, collider1, collider_pos2,
-														 collider_pos1,true);
+			resolution = -this->get_circle_box_resolution(collider2, collider1, collider_pos2,
+														 collider_pos1);
 			break;
 		}
 		case CollisionInternalType::CIRCLE_CIRCLE: {
@@ -185,7 +185,7 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal
 			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform,
 															data2.rigidbody);
 			resolution = this->get_circle_box_resolution(collider1, collider2, collider_pos1,
-														 collider_pos2,false);
+														 collider_pos2);
 			break;
 		}
 	}
@@ -272,7 +272,7 @@ vec2 CollisionSystem::get_circle_circle_resolution(const CircleCollider & circle
 vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider & circle_collider,
 												const BoxCollider & box_collider,
 												const vec2 & circle_position,
-												const vec2 & box_position,bool inverse) const {
+												const vec2 & box_position) const {
 	vec2 delta = circle_position - box_position;
 
 	// Compute half-dimensions of the box
@@ -294,7 +294,7 @@ vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider & circle_co
 
 	// Compute penetration depth
 	float penetration_depth = circle_collider.radius - distance;
-	if(inverse) collision_normal = -collision_normal;
+
 	// Compute the resolution vector
 	vec2 resolution = collision_normal * penetration_depth;
 
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index b978dbb..6216af9 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -184,7 +184,7 @@ private:
 	vec2 get_circle_box_resolution(const CircleCollider & circle_collider,
 								   const BoxCollider & box_collider,
 								   const vec2 & circle_position,
-								   const vec2 & box_position,bool inverse) const;
+								   const vec2 & box_position) const;
 
 	/**
 		* \brief Determines the appropriate collision handler for a collision.
@@ -219,14 +219,14 @@ private:
 	/**
 	 * \brief Checks if two collision layers have at least one common layer.
 	 * 
-	 * This function checks if there is any overlapping layer between the two input 
-	 * collision layer vectors. It compares each layer from the first vector to see 
-	 * if it exists in the second vector. If at least one common layer is found, 
+	 * This function checks if there is any overlapping layer between the two inputs.
+	 * It compares each layer from the first input to see 
+	 * if it exists in the second input. If at least one common layer is found, 
 	 * the function returns true, indicating that the two colliders share a common 
 	 * collision layer.
 	 * 
-	 * \param layers1 A vector of collision layers for the first collider.
-	 * \param layers2 A vector of collision layers for the second collider.
+	 * \param layers1 all collision layers for the first collider.
+	 * \param layers2 all collision layers for the second collider.
 	 * \return Returns true if there is at least one common layer, false otherwise.
 	 */
 
diff --git a/src/test/Profiling.cpp b/src/test/Profiling.cpp
index 91be769..6a6c29f 100644
--- a/src/test/Profiling.cpp
+++ b/src/test/Profiling.cpp
@@ -165,7 +165,7 @@ TEST_F(Profiling, Profiling_2) {
 			
 			gameobject.add_component<BehaviorScript>().set_script<TestScript>();
 			Color color(0, 0, 0, 0);
-			auto img = Texture("asset/texture/green_square.png");
+			auto img = Texture("asset/texture/square.png");
 			Sprite & test_sprite = gameobject.add_component<Sprite>(
 				img, color, Sprite::FlipSettings{false, false}, 1, 1, 500);
 		}
@@ -198,7 +198,7 @@ TEST_F(Profiling, Profiling_3) {
 			gameobject.add_component<BoxCollider>(vec2{0, 0}, vec2{1, 1});
 			gameobject.add_component<BehaviorScript>().set_script<TestScript>();
 			Color color(0, 0, 0, 0);
-			auto img = Texture("asset/texture/green_square.png");
+			auto img = Texture("asset/texture/square.png");
 			Sprite & test_sprite = gameobject.add_component<Sprite>(
 				img, color, Sprite::FlipSettings{false, false}, 1, 1, 500);
 			auto & test = gameobject.add_component<ParticleEmitter>(ParticleEmitter::Data{
-- 
cgit v1.2.3


From 7ec1fcfcff0c01d204ccbf1bac9919ba610b8606 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Fri, 6 Dec 2024 15:42:25 +0100
Subject: implemented final max feedback

---
 src/crepe/api/Animator.cpp         |  2 +-
 src/crepe/api/Animator.h           | 26 ++++++++++++++------------
 src/crepe/api/Camera.h             |  2 +-
 src/crepe/api/Sprite.h             | 12 +++++++++---
 src/crepe/facade/SDLContext.cpp    |  2 +-
 src/crepe/manager/Mediator.h       |  2 ++
 src/crepe/system/InputSystem.cpp   |  4 ++--
 src/crepe/system/RenderSystem.cpp  |  2 +-
 src/crepe/system/RenderSystem.h    |  3 +--
 src/example/rendering_particle.cpp |  1 +
 10 files changed, 33 insertions(+), 23 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp
index dc99fd4..8b91859 100644
--- a/src/crepe/api/Animator.cpp
+++ b/src/crepe/api/Animator.cpp
@@ -7,7 +7,7 @@
 
 using namespace crepe;
 
-Animator::Animator(uint32_t id, Sprite & ss, int max_row, int max_col,
+Animator::Animator(uint32_t id, Sprite & ss, unsigned int max_row, unsigned int max_col,
 				   const Animator::Data & ctx)
 	: Component(id),
 	  spritesheet(ss),
diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index dab6697..e0399a8 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -2,6 +2,8 @@
 
 #include "Component.h"
 #include "Sprite.h"
+#include "types.h"
+#include <sys/types.h>
 
 namespace crepe {
 
@@ -20,26 +22,26 @@ public:
 	struct Data {
 
 		//! frames per second for animation
-		int fps = 1;
+		unsigned int fps = 1;
 
 		//! The current col being animated.
-		int curr_col = 0;
+		unsigned int curr_col = 0;
 
 		//! The current row being animated.
-		int curr_row = 0;
+		unsigned int curr_row = 0;
 
 		//! should the animation loop
 		bool looping = false;
 
 		//! starting frame for cycling
-		int cycle_start = 0;
+		unsigned int cycle_start = 0;
 
 		//! end frame for cycling (-1 --> use last frame)
 		int cycle_end = -1;
 
 		//! offset in pixels.
 		// TODO implement
-		int offset_x = 0;
+		unsigned int white_space = 0;
 	};
 
 public:
@@ -100,12 +102,15 @@ public:
 	 * \brief Constructs an Animator object that will control animations for a sprite sheet.
 	 *
 	 * \param id The unique identifier for the component, typically assigned automatically.
-	 * \param ctx animator data
+	 * \param ss the reference to the spritesheet
+	 * \param max_row maximum of rows inside the given spritesheet
+	 * \param max_col maximum of columns inside the given spritesheet
+	 * \param ctx extra animation data for more control
 	 *
 	 * This constructor sets up the Animator with the given parameters, and initializes the
 	 * animation system.
 	 */
-	Animator(uint32_t id, Sprite & ss, int max_row, int max_col, const Animator::Data & ctx);
+	Animator(game_object_id_t id, Sprite & ss, unsigned int max_row, unsigned int max_col, const Animator::Data & ctx);
 	~Animator(); // dbg_trace
 
 public:
@@ -113,16 +118,13 @@ public:
 	Sprite & spritesheet;
 
 	//! The maximum number of columns in the sprite sheet.
-	const int col;
+	const unsigned int col;
 
 	//! The maximum number of rows in the sprite sheet.
-	const int row;
+	const unsigned int row;
 
 	Animator::Data data;
 
-private:
-	//! AnimatorSystem adjust the private member parameters of Animator;
-	friend class AnimatorSystem;
 };
 } // namespace crepe
 //
diff --git a/src/crepe/api/Camera.h b/src/crepe/api/Camera.h
index f626379..84ca9e1 100644
--- a/src/crepe/api/Camera.h
+++ b/src/crepe/api/Camera.h
@@ -23,7 +23,7 @@ public:
 		double zoom = 1;
 
 		//! offset postion from the game object transform component
-		vec2 offset;
+		vec2 postion_offset;
 	};
 
 public:
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index a1230db..0ccc296 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -20,11 +20,14 @@ class AnimatorSystem;
  */
 class Sprite : public Component {
 public:
+	//! settings to flip the image
 	struct FlipSettings {
+		//! horizantal flip
 		bool flip_x = false;
+		//! vertical flip
 		bool flip_y = false;
 	};
-
+	
 	struct Data {
 		//! Color tint of the sprite
 		Color color = Color::WHITE;
@@ -50,10 +53,13 @@ public:
 		vec2 size;
 
 		//! independent sprite angle. rotating clockwise direction in degrees
-		double angle_offset = 0;
+		float angle_offset = 0;
 
 		//! independent sprite scale multiplier
-		double scale_offset = 1;
+		float scale_offset = 1;
+
+		//! independent sprite offset position 
+		vec2 position_offset;
 	};
 
 public:
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 0097070..9533b8a 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -243,7 +243,7 @@ SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
 
 	size *= cam.render_scale * ctx.img_scale * data.scale_offset;
 
-	vec2 screen_pos = (ctx.pos - cam.cam_pos + (cam.zoomed_viewport) / 2) * cam.render_scale
+	vec2 screen_pos = (ctx.pos + data.position_offset - cam.cam_pos + (cam.zoomed_viewport) / 2) * cam.render_scale
 					  - size / 2 + cam.bar_size;
 
 	return SDL_FRect{
diff --git a/src/crepe/manager/Mediator.h b/src/crepe/manager/Mediator.h
index 71bd1c9..5b53bcc 100644
--- a/src/crepe/manager/Mediator.h
+++ b/src/crepe/manager/Mediator.h
@@ -5,6 +5,7 @@
 // TODO: remove these singletons:
 #include "EventManager.h"
 #include "SaveManager.h"
+#include "../facade/SDLContext.h"
 
 namespace crepe {
 
@@ -28,6 +29,7 @@ struct Mediator {
 	OptionalRef<SceneManager> scene_manager;
 	OptionalRef<SaveManager> save_manager = SaveManager::get_instance();
 	OptionalRef<EventManager> event_manager = EventManager::get_instance();
+	OptionalRef<SDLContext> sdl_context = SDLContext::get_instance();
 };
 
 } // namespace crepe
diff --git a/src/crepe/system/InputSystem.cpp b/src/crepe/system/InputSystem.cpp
index 20da644..aaa8bdf 100644
--- a/src/crepe/system/InputSystem.cpp
+++ b/src/crepe/system/InputSystem.cpp
@@ -24,9 +24,9 @@ void InputSystem::update() {
 	RefVector<Transform> transform_vec
 		= mgr.get_components_by_id<Transform>(current_cam.game_object_id);
 	Transform & cam_transform = transform_vec.front().get();
-	int camera_origin_x = cam_transform.position.x + current_cam.data.offset.x
+	int camera_origin_x = cam_transform.position.x + current_cam.data.postion_offset.x
 						  - (current_cam.viewport_size.x / 2);
-	int camera_origin_y = cam_transform.position.y + current_cam.data.offset.y
+	int camera_origin_y = cam_transform.position.y + current_cam.data.postion_offset.y
 						  - (current_cam.viewport_size.y / 2);
 
 	for (const SDLContext::EventData & event : event_list) {
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index 111ad7d..0ba71ec 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -33,7 +33,7 @@ SDLContext::CameraValues RenderSystem::update_camera() {
 		const Transform & transform
 			= mgr.get_components_by_id<Transform>(cam.game_object_id).front().get();
 		SDLContext::CameraValues cam_val = this->context.set_camera(cam);
-		cam_val.cam_pos = transform.position + cam.data.offset;
+		cam_val.cam_pos = transform.position + cam.data.postion_offset;
 		return cam_val;
 	}
 	throw std::runtime_error("No active cameras in current scene");
diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h
index eaf1213..91b386f 100644
--- a/src/crepe/system/RenderSystem.h
+++ b/src/crepe/system/RenderSystem.h
@@ -79,8 +79,7 @@ private:
 	 */
 
 private:
-	// FIXME: retrieve sdlcontext via mediator after #PR57
-	SDLContext & context = SDLContext::get_instance();
+	SDLContext & context = this->mediator.sdl_context;
 };
 
 } // namespace crepe
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 9d6b537..145bc5e 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -57,6 +57,7 @@ public:
 					 .order_in_layer = 2,
 					 .size = {0, 100},
 					 .angle_offset = 0,
+					 .position_offset = {100,0},
 				 });
 
 		auto & anim = game_object.add_component<Animator>(test_sprite, 4, 4,
-- 
cgit v1.2.3


From 70c1cd14ec4c4aca185d5a7e4a3749169f6425f4 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Fri, 6 Dec 2024 15:42:52 +0100
Subject: make format

---
 src/crepe/api/LoopManager.cpp        |  4 +-
 src/crepe/api/Rigidbody.h            |  1 -
 src/crepe/api/Script.h               |  2 +-
 src/crepe/system/CollisionSystem.cpp | 33 +++++--------
 src/crepe/system/CollisionSystem.h   |  2 +-
 src/example/game.cpp                 | 94 +++++++++++++++++-------------------
 src/test/CollisionTest.cpp           |  6 +--
 src/test/Profiling.cpp               |  6 +--
 8 files changed, 66 insertions(+), 82 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index 2c12895..a76c167 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -48,13 +48,13 @@ void LoopManager::loop() {
 
 	while (game_running) {
 		timer.update();
-		
+
 		while (timer.get_lag() >= timer.get_fixed_delta_time()) {
 			this->process_input();
 			this->fixed_update();
 			timer.advance_fixed_update();
 		}
-		
+
 		this->update();
 		this->render();
 
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index a6aab26..8265ba5 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -7,7 +7,6 @@
 
 #include "types.h"
 
-
 namespace crepe {
 
 /**
diff --git a/src/crepe/api/Script.h b/src/crepe/api/Script.h
index 3d416a1..d1be1dc 100644
--- a/src/crepe/api/Script.h
+++ b/src/crepe/api/Script.h
@@ -3,8 +3,8 @@
 #include <vector>
 
 #include "../manager/EventManager.h"
-#include "../system/CollisionSystem.h"
 #include "../manager/Mediator.h"
+#include "../system/CollisionSystem.h"
 #include "../types.h"
 #include "../util/OptionalRef.h"
 
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index e196e10..44a0431 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -6,6 +6,8 @@
 #include <utility>
 #include <variant>
 
+#include "../manager/ComponentManager.h"
+#include "../manager/EventManager.h"
 #include "api/BoxCollider.h"
 #include "api/CircleCollider.h"
 #include "api/Event.h"
@@ -13,8 +15,6 @@
 #include "api/Rigidbody.h"
 #include "api/Transform.h"
 #include "api/Vector2.h"
-#include "../manager/ComponentManager.h"
-#include "../manager/EventManager.h"
 
 #include "Collider.h"
 #include "CollisionSystem.h"
@@ -27,17 +27,14 @@ void CollisionSystem::update() {
 	std::vector<CollisionInternal> all_colliders;
 	game_object_id_t id = 0;
 	ComponentManager & mgr = this->mediator.component_manager;
-	RefVector<Rigidbody> rigidbodies
-		= mgr.get_components_by_type<Rigidbody>();
+	RefVector<Rigidbody> rigidbodies = mgr.get_components_by_type<Rigidbody>();
 	// Collisions can only happen on object with a rigidbody
 	for (Rigidbody & rigidbody : rigidbodies) {
 		if (!rigidbody.active) continue;
 		id = rigidbody.game_object_id;
-		Transform & transform
-			= mgr.get_components_by_id<Transform>(id).front().get();
+		Transform & transform = mgr.get_components_by_id<Transform>(id).front().get();
 		// Check if the boxcollider is active and has the same id as the rigidbody.
-		RefVector<BoxCollider> boxcolliders
-			= mgr.get_components_by_type<BoxCollider>();
+		RefVector<BoxCollider> boxcolliders = mgr.get_components_by_type<BoxCollider>();
 		for (BoxCollider & boxcollider : boxcolliders) {
 			if (boxcollider.game_object_id != id) continue;
 			if (!boxcollider.active) continue;
@@ -159,7 +156,7 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal
 			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform,
 															data2.rigidbody);
 			resolution = -this->get_circle_box_resolution(collider2, collider1, collider_pos2,
-														 collider_pos1);
+														  collider_pos1);
 			break;
 		}
 		case CollisionInternalType::CIRCLE_CIRCLE: {
@@ -261,7 +258,6 @@ vec2 CollisionSystem::get_circle_circle_resolution(const CircleCollider & circle
 
 	// Normalize the delta vector to get the collision direction
 	vec2 collision_normal = delta / distance;
-	
 
 	// Compute the resolution vector
 	vec2 resolution = -collision_normal * penetration_depth;
@@ -311,8 +307,7 @@ void CollisionSystem::determine_collision_handler(CollisionInfo & info) {
 	// Call collision event for user
 	CollisionEvent data(info);
 	EventManager & emgr = this->mediator.event_manager;
-	emgr.trigger_event<CollisionEvent>(
-		data, info.this_collider.game_object_id);
+	emgr.trigger_event<CollisionEvent>(data, info.this_collider.game_object_id);
 }
 
 void CollisionSystem::static_collision_handler(CollisionInfo & info) {
@@ -389,14 +384,14 @@ CollisionSystem::gather_collisions(std::vector<CollisionInternal> & colliders) {
 
 bool CollisionSystem::have_common_layer(const std::set<int> & layers1,
 										const std::set<int> & layers2) {
-	
+
 	// Check if any number is equal in the layers
 	for (int num : layers1) {
-			if (layers2.contains(num)) {
-					// Common layer found
-					return true;
-					break;
-			}
+		if (layers2.contains(num)) {
+			// Common layer found
+			return true;
+			break;
+		}
 	}
 	// No common layer found
 	return false;
@@ -554,5 +549,3 @@ vec2 CollisionSystem::get_current_position(const vec2 & collider_offset,
 	// Final positions considering scaling and rotation
 	return (transform.position + vec2(rotated_total_offset_x1, rotated_total_offset_y1));
 }
-
-
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 6216af9..7e893c8 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -6,11 +6,11 @@
 
 #include "api/BoxCollider.h"
 #include "api/CircleCollider.h"
+#include "api/Event.h"
 #include "api/Metadata.h"
 #include "api/Rigidbody.h"
 #include "api/Transform.h"
 #include "api/Vector2.h"
-#include "api/Event.h"
 
 #include "Collider.h"
 #include "System.h"
diff --git a/src/example/game.cpp b/src/example/game.cpp
index be756bd..4239c15 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -1,6 +1,6 @@
 #include "api/CircleCollider.h"
-#include "manager/ComponentManager.h"
 #include "api/Scene.h"
+#include "manager/ComponentManager.h"
 #include "manager/Mediator.h"
 #include <crepe/api/BoxCollider.h>
 #include <crepe/api/Camera.h>
@@ -28,66 +28,60 @@ class MyScript1 : public Script {
 	bool keypressed(const KeyPressEvent & test) {
 		Log::logf("Box script keypressed()");
 		switch (test.key) {
-			case Keycode::A:
-			{
+			case Keycode::A: {
 				Transform & tf = this->get_component<Transform>();
 				tf.position.x -= 1;
 				break;
 			}
-			case Keycode::W:
-			{
+			case Keycode::W: {
 				Transform & tf = this->get_component<Transform>();
 				tf.position.y -= 1;
 				break;
 			}
-			case Keycode::S:
-			{
+			case Keycode::S: {
 				Transform & tf = this->get_component<Transform>();
 				tf.position.y += 1;
 				break;
 			}
-			case Keycode::D:
-			{
+			case Keycode::D: {
 				Transform & tf = this->get_component<Transform>();
 				tf.position.x += 1;
 				break;
 			}
-			case Keycode::E:
-			{
-				if(flip){
+			case Keycode::E: {
+				if (flip) {
 					flip = false;
 					this->get_component<BoxCollider>().active = true;
 					this->get_components<Sprite>()[0].get().active = true;
 					this->get_component<CircleCollider>().active = false;
 					this->get_components<Sprite>()[1].get().active = false;
-				}
-				else {
+				} else {
 					flip = true;
 					this->get_component<BoxCollider>().active = false;
 					this->get_components<Sprite>()[0].get().active = false;
 					this->get_component<CircleCollider>().active = true;
 					this->get_components<Sprite>()[1].get().active = true;
 				}
-				
-				
+
 				//add collider switch
 				break;
 			}
 			default:
-			break;
+				break;
 		}
 		return false;
-	} 
+	}
 
 	void init() {
 		Log::logf("init");
-		subscribe<CollisionEvent>([this](const CollisionEvent & ev) -> bool { return this->oncollision(ev); });
-		subscribe<KeyPressEvent>([this](const KeyPressEvent & ev) -> bool { return this->keypressed(ev); });
+		subscribe<CollisionEvent>(
+			[this](const CollisionEvent & ev) -> bool { return this->oncollision(ev); });
+		subscribe<KeyPressEvent>(
+			[this](const KeyPressEvent & ev) -> bool { return this->keypressed(ev); });
 	}
 	void update() {
 		// Retrieve component from the same GameObject this script is on
 	}
-	
 };
 
 class MyScript2 : public Script {
@@ -99,74 +93,68 @@ class MyScript2 : public Script {
 	bool keypressed(const KeyPressEvent & test) {
 		Log::logf("Box script keypressed()");
 		switch (test.key) {
-			case Keycode::LEFT:
-			{
+			case Keycode::LEFT: {
 				Transform & tf = this->get_component<Transform>();
 				tf.position.x -= 1;
 				break;
 			}
-			case Keycode::UP:
-			{
+			case Keycode::UP: {
 				Transform & tf = this->get_component<Transform>();
 				tf.position.y -= 1;
 				break;
 			}
-			case Keycode::DOWN:
-			{
+			case Keycode::DOWN: {
 				Transform & tf = this->get_component<Transform>();
 				tf.position.y += 1;
 				break;
 			}
-			case Keycode::RIGHT:
-			{
+			case Keycode::RIGHT: {
 				Transform & tf = this->get_component<Transform>();
 				tf.position.x += 1;
 				break;
 			}
-			case Keycode::PAUSE:
-			{
-				if(flip){
+			case Keycode::PAUSE: {
+				if (flip) {
 					flip = false;
 					this->get_component<BoxCollider>().active = true;
 					this->get_components<Sprite>()[0].get().active = true;
 					this->get_component<CircleCollider>().active = false;
 					this->get_components<Sprite>()[1].get().active = false;
-				}
-				else {
+				} else {
 					flip = true;
 					this->get_component<BoxCollider>().active = false;
 					this->get_components<Sprite>()[0].get().active = false;
 					this->get_component<CircleCollider>().active = true;
 					this->get_components<Sprite>()[1].get().active = true;
 				}
-				
-				
+
 				//add collider switch
 				break;
 			}
 			default:
-			break;
+				break;
 		}
 		return false;
-	} 
+	}
 
 	void init() {
 		Log::logf("init");
-		subscribe<CollisionEvent>([this](const CollisionEvent & ev) -> bool { return this->oncollision(ev); });
-		subscribe<KeyPressEvent>([this](const KeyPressEvent & ev) -> bool { return this->keypressed(ev); });
+		subscribe<CollisionEvent>(
+			[this](const CollisionEvent & ev) -> bool { return this->oncollision(ev); });
+		subscribe<KeyPressEvent>(
+			[this](const KeyPressEvent & ev) -> bool { return this->keypressed(ev); });
 	}
 	void update() {
 		// Retrieve component from the same GameObject this script is on
 	}
-	
 };
 
 class ConcreteScene1 : public Scene {
 public:
 	using Scene::Scene;
-	
+
 	void load_scene() {
-		
+
 		Mediator & m = this->mediator;
 		ComponentManager & mgr = m.component_manager;
 		Color color(0, 0, 0, 255);
@@ -195,7 +183,10 @@ public:
 			vec2{world_collider, world_collider}); // Left
 		world.add_component<BoxCollider>(vec2{screen_size_width / 2 + world_collider / 2, 0},
 										 vec2{world_collider, world_collider}); // right
-		world.add_component<Camera>(Color::WHITE, ivec2{static_cast<int>(screen_size_width), static_cast<int>(screen_size_height)}, vec2{screen_size_width, screen_size_height}, 1.0f);
+		world.add_component<Camera>(
+			Color::WHITE,
+			ivec2{static_cast<int>(screen_size_width), static_cast<int>(screen_size_height)},
+			vec2{screen_size_width, screen_size_height}, 1.0f);
 
 		GameObject game_object1 = mgr.new_object(
 			"Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1);
@@ -219,10 +210,10 @@ public:
 		//add circle with cirlcecollider deactiveated
 		game_object1.add_component<CircleCollider>(vec2{0, 0}, 10).active = false;
 		auto img2 = Texture("asset/texture/circle.png");
-		game_object1.add_component<Sprite>(img2, color, Sprite::FlipSettings{false, false}, 1,
-										   1, 20).active = false;
-
-
+		game_object1
+			.add_component<Sprite>(img2, color, Sprite::FlipSettings{false, false}, 1, 1, 20)
+			.active
+			= false;
 
 		GameObject game_object2 = mgr.new_object(
 			"Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1);
@@ -246,9 +237,10 @@ public:
 		//add circle with cirlcecollider deactiveated
 		game_object2.add_component<CircleCollider>(vec2{0, 0}, 10).active = false;
 		auto img4 = Texture("asset/texture/circle.png");
-		game_object2.add_component<Sprite>(img4, color, Sprite::FlipSettings{false, false}, 1,
-										   1, 20).active = false;
-
+		game_object2
+			.add_component<Sprite>(img4, color, Sprite::FlipSettings{false, false}, 1, 1, 20)
+			.active
+			= false;
 	}
 
 	string get_name() const { return "scene1"; }
diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp
index a683b1f..dd45eb6 100644
--- a/src/test/CollisionTest.cpp
+++ b/src/test/CollisionTest.cpp
@@ -7,14 +7,14 @@
 #define private public
 #define protected public
 
-#include <crepe/manager/ComponentManager.h>
-#include <crepe/manager/Mediator.h>
 #include <crepe/api/Event.h>
-#include <crepe/manager/EventManager.h>
 #include <crepe/api/GameObject.h>
 #include <crepe/api/Rigidbody.h>
 #include <crepe/api/Script.h>
 #include <crepe/api/Transform.h>
+#include <crepe/manager/ComponentManager.h>
+#include <crepe/manager/EventManager.h>
+#include <crepe/manager/Mediator.h>
 #include <crepe/system/CollisionSystem.h>
 #include <crepe/system/ScriptSystem.h>
 #include <crepe/types.h>
diff --git a/src/test/Profiling.cpp b/src/test/Profiling.cpp
index 6a6c29f..24ac494 100644
--- a/src/test/Profiling.cpp
+++ b/src/test/Profiling.cpp
@@ -9,14 +9,14 @@
 #define private public
 #define protected public
 
-#include <crepe/manager/ComponentManager.h>
 #include <crepe/api/Event.h>
-#include <crepe/manager/EventManager.h>
 #include <crepe/api/GameObject.h>
 #include <crepe/api/ParticleEmitter.h>
 #include <crepe/api/Rigidbody.h>
 #include <crepe/api/Script.h>
 #include <crepe/api/Transform.h>
+#include <crepe/manager/ComponentManager.h>
+#include <crepe/manager/EventManager.h>
 #include <crepe/system/CollisionSystem.h>
 #include <crepe/system/ScriptSystem.h>
 #include <crepe/types.h>
@@ -162,7 +162,7 @@ TEST_F(Profiling, Profiling_2) {
 				.body_type = Rigidbody::BodyType::STATIC,
 			});
 			gameobject.add_component<BoxCollider>(vec2{0, 0}, vec2{1, 1});
-			
+
 			gameobject.add_component<BehaviorScript>().set_script<TestScript>();
 			Color color(0, 0, 0, 0);
 			auto img = Texture("asset/texture/square.png");
-- 
cgit v1.2.3


From 83ee80ea439fc6a9042307a25b214b3efcf28d91 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Fri, 6 Dec 2024 15:42:52 +0100
Subject: make format

---
 src/crepe/api/Animator.h           | 4 ++--
 src/crepe/api/Sprite.h             | 4 ++--
 src/crepe/facade/SDLContext.cpp    | 6 ++++--
 src/crepe/manager/Mediator.h       | 2 +-
 src/example/rendering_particle.cpp | 2 +-
 5 files changed, 10 insertions(+), 8 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index e0399a8..2a0a889 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -110,7 +110,8 @@ public:
 	 * This constructor sets up the Animator with the given parameters, and initializes the
 	 * animation system.
 	 */
-	Animator(game_object_id_t id, Sprite & ss, unsigned int max_row, unsigned int max_col, const Animator::Data & ctx);
+	Animator(game_object_id_t id, Sprite & ss, unsigned int max_row, unsigned int max_col,
+			 const Animator::Data & ctx);
 	~Animator(); // dbg_trace
 
 public:
@@ -124,7 +125,6 @@ public:
 	const unsigned int row;
 
 	Animator::Data data;
-
 };
 } // namespace crepe
 //
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index 0ccc296..78ed7ad 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -27,7 +27,7 @@ public:
 		//! vertical flip
 		bool flip_y = false;
 	};
-	
+
 	struct Data {
 		//! Color tint of the sprite
 		Color color = Color::WHITE;
@@ -58,7 +58,7 @@ public:
 		//! independent sprite scale multiplier
 		float scale_offset = 1;
 
-		//! independent sprite offset position 
+		//! independent sprite offset position
 		vec2 position_offset;
 	};
 
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 9533b8a..cf9f7d5 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -243,8 +243,10 @@ SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
 
 	size *= cam.render_scale * ctx.img_scale * data.scale_offset;
 
-	vec2 screen_pos = (ctx.pos + data.position_offset - cam.cam_pos + (cam.zoomed_viewport) / 2) * cam.render_scale
-					  - size / 2 + cam.bar_size;
+	vec2 screen_pos
+		= (ctx.pos + data.position_offset - cam.cam_pos + (cam.zoomed_viewport) / 2)
+			  * cam.render_scale
+		  - size / 2 + cam.bar_size;
 
 	return SDL_FRect{
 		.x = screen_pos.x,
diff --git a/src/crepe/manager/Mediator.h b/src/crepe/manager/Mediator.h
index 5b53bcc..f8517a3 100644
--- a/src/crepe/manager/Mediator.h
+++ b/src/crepe/manager/Mediator.h
@@ -3,9 +3,9 @@
 #include "../util/OptionalRef.h"
 
 // TODO: remove these singletons:
+#include "../facade/SDLContext.h"
 #include "EventManager.h"
 #include "SaveManager.h"
-#include "../facade/SDLContext.h"
 
 namespace crepe {
 
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 145bc5e..29d475d 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -57,7 +57,7 @@ public:
 					 .order_in_layer = 2,
 					 .size = {0, 100},
 					 .angle_offset = 0,
-					 .position_offset = {100,0},
+					 .position_offset = {100, 0},
 				 });
 
 		auto & anim = game_object.add_component<Animator>(test_sprite, 4, 4,
-- 
cgit v1.2.3


From 05e099c03a2242bf5194d06191a0ff667d404817 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Fri, 6 Dec 2024 19:21:56 +0100
Subject: implemented feedback

---
 src/crepe/api/Animator.cpp          | 30 +++++++++++++++---------------
 src/crepe/api/Animator.h            | 25 +++++++++++++++----------
 src/crepe/api/Camera.cpp            |  6 +++---
 src/crepe/api/Camera.h              | 22 +++++++++++++++++-----
 src/crepe/api/Config.h              |  2 +-
 src/crepe/api/Sprite.cpp            |  4 ++--
 src/crepe/api/Sprite.h              | 30 +++++++++++++++++++-----------
 src/crepe/api/Transform.h           |  4 ++--
 src/crepe/facade/SDLContext.cpp     | 21 ++++++++++++---------
 src/crepe/facade/SDLContext.h       | 32 ++++++++++++++++++++++++++------
 src/crepe/manager/Mediator.h        |  2 ++
 src/crepe/system/AnimatorSystem.cpp | 18 +++++++++---------
 src/crepe/system/AnimatorSystem.h   |  3 ---
 src/crepe/system/RenderSystem.cpp   | 20 ++++++++++++++------
 src/crepe/system/RenderSystem.h     |  3 ---
 15 files changed, 137 insertions(+), 85 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp
index 8b91859..154135f 100644
--- a/src/crepe/api/Animator.cpp
+++ b/src/crepe/api/Animator.cpp
@@ -8,18 +8,18 @@
 using namespace crepe;
 
 Animator::Animator(uint32_t id, Sprite & ss, unsigned int max_row, unsigned int max_col,
-				   const Animator::Data & ctx)
+				   const Animator::Data & data)
 	: Component(id),
 	  spritesheet(ss),
-	  row(max_row),
-	  col(max_col),
-	  data(ctx) {
+	  max_rows(max_row),
+	  max_columns(max_col),
+	  data(data) {
 	dbg_trace();
 
-	this->spritesheet.mask.h /= this->col;
-	this->spritesheet.mask.w /= this->row;
-	this->spritesheet.mask.x = this->data.curr_row * this->spritesheet.mask.w;
-	this->spritesheet.mask.y = this->data.curr_col * this->spritesheet.mask.h;
+	this->spritesheet.mask.h /= this->max_columns;
+	this->spritesheet.mask.w /= this->max_rows;
+	this->spritesheet.mask.x = this->data.row * this->spritesheet.mask.w;
+	this->spritesheet.mask.y = this->data.col * this->spritesheet.mask.h;
 
 	// need to do this for to get the aspect ratio for a single clipping in the spritesheet
 	this->spritesheet.aspect_ratio
@@ -36,8 +36,8 @@ void Animator::pause() { this->active = false; }
 
 void Animator::stop() {
 	this->active = false;
-	this->data.curr_col = 0;
-	this->data.curr_row = 0;
+	this->data.col = 0;
+	this->data.row = 0;
 }
 void Animator::set_fps(int fps) { this->data.fps = fps; }
 
@@ -47,13 +47,13 @@ void Animator::set_cycle_range(int start, int end) {
 
 void Animator::set_anim(int col) {
 	Animator::Data & ctx = this->data;
-	this->spritesheet.mask.x = ctx.curr_row = 0;
-	ctx.curr_col = col;
-	this->spritesheet.mask.y = ctx.curr_col * this->spritesheet.mask.h;
+	this->spritesheet.mask.x = ctx.row = 0;
+	ctx.col = col;
+	this->spritesheet.mask.y = ctx.col * this->spritesheet.mask.h;
 }
 
 void Animator::next_anim() {
 	Animator::Data & ctx = this->data;
-	ctx.curr_row = ctx.curr_row++ % this->row;
-	this->spritesheet.mask.x = ctx.curr_row * this->spritesheet.mask.w;
+	ctx.row = ctx.row++ % this->max_rows;
+	this->spritesheet.mask.x = ctx.row * this->spritesheet.mask.w;
 }
diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index 2a0a889..23d29f6 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -1,9 +1,10 @@
 #pragma once
 
+#include <sys/types.h>
+
 #include "Component.h"
 #include "Sprite.h"
 #include "types.h"
-#include <sys/types.h>
 
 namespace crepe {
 
@@ -25,10 +26,10 @@ public:
 		unsigned int fps = 1;
 
 		//! The current col being animated.
-		unsigned int curr_col = 0;
+		unsigned int col = 0;
 
 		//! The current row being animated.
-		unsigned int curr_row = 0;
+		unsigned int row = 0;
 
 		//! should the animation loop
 		bool looping = false;
@@ -105,26 +106,30 @@ public:
 	 * \param ss the reference to the spritesheet
 	 * \param max_row maximum of rows inside the given spritesheet
 	 * \param max_col maximum of columns inside the given spritesheet
-	 * \param ctx extra animation data for more control
+	 * \param data extra animation data for more control
 	 *
 	 * This constructor sets up the Animator with the given parameters, and initializes the
 	 * animation system.
 	 */
 	Animator(game_object_id_t id, Sprite & ss, unsigned int max_row, unsigned int max_col,
-			 const Animator::Data & ctx);
+			 const Animator::Data & data);
 	~Animator(); // dbg_trace
 
 public:
-	//! A reference to the Sprite sheet containing.
-	Sprite & spritesheet;
-
 	//! The maximum number of columns in the sprite sheet.
-	const unsigned int col;
+	const unsigned int max_columns;
 
 	//! The maximum number of rows in the sprite sheet.
-	const unsigned int row;
+	const unsigned int max_rows;
 
 	Animator::Data data;
+
+private:
+	//! A reference to the Sprite sheet containing.
+	Sprite & spritesheet;
+
+	// uses the spritesheet
+	friend AnimatorSystem;
 };
 } // namespace crepe
 //
diff --git a/src/crepe/api/Camera.cpp b/src/crepe/api/Camera.cpp
index b042c35..179dc18 100644
--- a/src/crepe/api/Camera.cpp
+++ b/src/crepe/api/Camera.cpp
@@ -1,17 +1,17 @@
-#include "types.h"
 #include "util/Log.h"
 
 #include "Camera.h"
 #include "Component.h"
+#include "types.h"
 
 using namespace crepe;
 
 Camera::Camera(game_object_id_t id, const ivec2 & screen, const vec2 & viewport_size,
-			   const Data & ctx)
+			   const Data & data)
 	: Component(id),
 	  screen(screen),
 	  viewport_size(viewport_size),
-	  data(ctx) {
+	  data(data) {
 	dbg_trace();
 }
 
diff --git a/src/crepe/api/Camera.h b/src/crepe/api/Camera.h
index 84ca9e1..54d9a73 100644
--- a/src/crepe/api/Camera.h
+++ b/src/crepe/api/Camera.h
@@ -16,10 +16,20 @@ namespace crepe {
 class Camera : public Component {
 public:
 	struct Data {
-		//! Background color of the camera view.
-		const Color bg_color = Color::WHITE;
+		/**
+		 * \bg_color background color of the game
+		 *
+		 * This will make the background the same color as the given value.
+		 */
+		const Color bg_color = Color::BLACK;
 
-		//! Zoom level of the camera view.
+		/**
+		 * \zoom Zooming level of the game
+		 *
+		 * zoom = 1 --> no zoom.
+		 * zoom < 1 --> zoom out
+		 * zoom > 1 --> zoom in
+		 */
 		double zoom = 1;
 
 		//! offset postion from the game object transform component
@@ -30,10 +40,12 @@ public:
 	/**
 	 * \brief Constructs a Camera with the specified ID and background color.
 	 * \param id Unique identifier for the camera component.
-	 * \param ctx the camera component data
+	 * \param screen is the actual screen size in pixels
+	 * \param viewport_size is the view of the world in game units
+	 * \param data the camera component data
 	 */
 	Camera(game_object_id_t id, const ivec2 & screen, const vec2 & viewport_size,
-		   const Data & ctx);
+		   const Camera::Data & data);
 	~Camera(); // dbg_trace only
 
 public:
diff --git a/src/crepe/api/Config.h b/src/crepe/api/Config.h
index 200a3b0..f1bca62 100644
--- a/src/crepe/api/Config.h
+++ b/src/crepe/api/Config.h
@@ -66,7 +66,7 @@ public:
 
 	//! default window settings
 	struct {
-		//TODO make this constexpr because this will never change
+		//! default screen size in pixels
 		ivec2 default_size = {1280, 720};
 		std::string window_title = "Jetpack joyride clone";
 
diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp
index b52a344..cc0e20a 100644
--- a/src/crepe/api/Sprite.cpp
+++ b/src/crepe/api/Sprite.cpp
@@ -11,10 +11,10 @@
 using namespace std;
 using namespace crepe;
 
-Sprite::Sprite(game_object_id_t id, Texture & texture, const Sprite::Data & ctx)
+Sprite::Sprite(game_object_id_t id, Texture & texture, const Sprite::Data & data)
 	: Component(id),
 	  texture(std::move(texture)),
-	  data(ctx) {
+	  data(data) {
 
 	dbg_trace();
 
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index 78ed7ad..ea8104c 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -28,8 +28,15 @@ public:
 		bool flip_y = false;
 	};
 
+	//! Sprite data that does not have to be set in the constructor
 	struct Data {
-		//! Color tint of the sprite
+		/**
+		 * \color tint of the sprite 
+		 *
+		 * the default value is white because of the color multiplier.
+		 * this means that the orginal image will be shown. if color is BLACK for example
+		 * then it turns the image black because of the Color channels being 0.
+		 */
 		Color color = Color::WHITE;
 
 		//! Flip settings for the sprite
@@ -44,10 +51,10 @@ public:
 		/**
 	 	* \size width and height of the sprite in game units
 	 	*
-	 	* if height is filled in and not width it will multiply width by aspect_ratio.
-	 	* if width is filled in and not height it will multiply height by aspect_ratio.
-	 	* if neither is filled it will not show sprite because size will be zero
-	 	* if both are filled will it use the width and height without making sure the aspect_ratio
+	 	* - if height is filled in and not width it will multiply width by aspect_ratio.
+	 	* - if width is filled in and not height it will multiply height by aspect_ratio.
+	 	* - if neither is filled it will not show sprite because size will be zero
+	 	* - if both are filled will it use the width and height without making sure the aspect_ratio
 	 	* is correct
 	 	*/
 		vec2 size;
@@ -69,7 +76,7 @@ public:
 	 * \param texture asset of the image
 	 * \param ctx all the sprite data
 	 */
-	Sprite(game_object_id_t id, Texture & texture, const Data & ctx);
+	Sprite(game_object_id_t id, Texture & texture, const Data & data);
 	~Sprite();
 
 	//! Texture used for the sprite
@@ -79,11 +86,12 @@ public:
 
 private:
 	/**
-		* \aspect_ratio ratio of the img so that scaling will not become weird
-		*
-		* cannot be const because if Animator component is addded then ratio becomes scuffed and
-		* does it need to be calculated again in the Animator
-		*/
+	* \aspect_ratio ratio of the img
+	* 
+	*  - This will multiply one of \c size variable if it is 0.
+	*  - Will be adjusted if \c Animator component is added to an GameObject
+	*  that is why this value cannot be const. 
+	*/
 	float aspect_ratio;
 
 	//! Reads the mask of sprite
diff --git a/src/crepe/api/Transform.h b/src/crepe/api/Transform.h
index 34ac70a..3ef0fb5 100644
--- a/src/crepe/api/Transform.h
+++ b/src/crepe/api/Transform.h
@@ -16,9 +16,9 @@ public:
 	//! Translation (shift)
 	vec2 position = {0, 0};
 	//! Rotation, in degrees clockwise
-	double rotation = 0;
+	float rotation = 0;
 	//! Multiplication factor
-	double scale = 0;
+	float scale = 0;
 
 protected:
 	/**
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index cf9f7d5..4cc2206 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -15,13 +15,13 @@
 #include <stdexcept>
 
 #include "../api/Camera.h"
+#include "../api/Color.h"
 #include "../api/Config.h"
 #include "../api/Sprite.h"
 #include "../api/Texture.h"
 #include "../util/Log.h"
 
 #include "SDLContext.h"
-#include "api/Color.h"
 #include "types.h"
 
 using namespace crepe;
@@ -230,14 +230,17 @@ SDL_Rect SDLContext::get_src_rect(const Sprite & sprite) const {
 	};
 }
 
-SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
+SDL_FRect SDLContext::get_dst_rect(const DestinationRectangleData & ctx) const {
 
 	const Sprite::Data & data = ctx.sprite.data;
 
-	vec2 size = {data.size.x == 0 && data.size.y != 0 ? data.size.y * ctx.sprite.aspect_ratio
-													  : data.size.x,
-				 data.size.y == 0 && data.size.x != 0 ? data.size.x / ctx.sprite.aspect_ratio
-													  : data.size.y};
+	vec2 size;
+	if (data.size.x == 0 && data.size.y != 0) {
+		size.x = data.size.y * ctx.sprite.aspect_ratio;
+	}
+	if (data.size.y == 0 && data.size.x != 0) {
+		size.y = data.size.x / ctx.sprite.aspect_ratio;
+	}
 
 	const CameraValues & cam = ctx.cam;
 
@@ -264,7 +267,7 @@ void SDLContext::draw(const RenderContext & ctx) {
 							  | (SDL_FLIP_VERTICAL * data.flip.flip_y));
 
 	SDL_Rect srcrect = this->get_src_rect(ctx.sprite);
-	SDL_FRect dstrect = this->get_dst_rect(SDLContext::DstRect{
+	SDL_FRect dstrect = this->get_dst_rect(SDLContext::DestinationRectangleData{
 		.sprite = ctx.sprite,
 		.cam = ctx.cam,
 		.pos = ctx.pos,
@@ -294,8 +297,8 @@ SDLContext::CameraValues SDLContext::set_camera(const Camera & cam) {
 	vec2 & render_scale = ret_cam.render_scale;
 
 	zoomed_viewport = cam.viewport_size * cam_data.zoom;
-	double screen_aspect = static_cast<double>(cam.screen.x) / cam.screen.y;
-	double viewport_aspect = zoomed_viewport.x / zoomed_viewport.y;
+	float screen_aspect = static_cast<float>(cam.screen.x) / cam.screen.y;
+	float viewport_aspect = zoomed_viewport.x / zoomed_viewport.y;
 
 	// calculate black bars
 	if (screen_aspect > viewport_aspect) {
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index dfdaa56..bbe87c3 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -9,11 +9,9 @@
 #include <functional>
 #include <memory>
 #include <string>
-#include <utility>
 
 #include "api/Camera.h"
 #include "api/Color.h"
-#include "api/Event.h"
 #include "api/KeyCodes.h"
 #include "api/Sprite.h"
 #include "api/Texture.h"
@@ -35,12 +33,33 @@ class SDLContext {
 public:
 	//! data that the camera component cannot hold
 	struct CameraValues {
+
+		//! zoomed in viewport in game_units
 		vec2 zoomed_viewport;
+
+		/**
+		 * \render_scale scaling factor
+		 *
+		 * depending on the black bars type will the scaling be different.
+		 * - lettorboxing --> scaling on the y-as 
+		 * - pillarboxing --> scaling on the x-as 
+		 */
 		vec2 render_scale;
+
+		/**
+		 * \bar_size size of calculated black bars
+		 *
+		 * depending on the black bars type will the size be different
+		 * - lettorboxing --> {0, bar_height}
+		 * - pillarboxing --> {bar_width , 0}
+		 */
 		vec2 bar_size;
+
+		//! Calculated camera position
 		vec2 cam_pos;
 	};
-
+	
+	//! rendering data needed to render on screen
 	struct RenderContext {
 		const Sprite & sprite;
 		const CameraValues & cam;
@@ -192,7 +211,8 @@ private:
 	CameraValues set_camera(const Camera & camera);
 
 private:
-	struct DstRect {
+	//! the data needed to construct a sdl dst rectangle
+	struct DestinationRectangleData {
 		const Sprite & sprite;
 		const CameraValues & cam;
 		const vec2 & pos;
@@ -216,7 +236,7 @@ private:
 	 * \param img_scale the image multiplier for increasing img size 
 	 * \return sdl rectangle to draw a dst image to draw on the screen
 	 */
-	SDL_FRect get_dst_rect(const DstRect & ctx) const;
+	SDL_FRect get_dst_rect(const DestinationRectangleData & data) const;
 	/**
 	 * \brief Set an additional color value multiplied into render copy operations.
 	 *
@@ -233,7 +253,7 @@ private:
 	std::unique_ptr<SDL_Renderer, std::function<void(SDL_Renderer *)>> game_renderer;
 
 	//! black bars rectangle to draw
-	SDL_FRect black_bars[2];
+	SDL_FRect black_bars[2] = {};
 };
 
 } // namespace crepe
diff --git a/src/crepe/manager/Mediator.h b/src/crepe/manager/Mediator.h
index f8517a3..8094d80 100644
--- a/src/crepe/manager/Mediator.h
+++ b/src/crepe/manager/Mediator.h
@@ -6,6 +6,7 @@
 #include "../facade/SDLContext.h"
 #include "EventManager.h"
 #include "SaveManager.h"
+#include "api/LoopTimer.h"
 
 namespace crepe {
 
@@ -30,6 +31,7 @@ struct Mediator {
 	OptionalRef<SaveManager> save_manager = SaveManager::get_instance();
 	OptionalRef<EventManager> event_manager = EventManager::get_instance();
 	OptionalRef<SDLContext> sdl_context = SDLContext::get_instance();
+	OptionalRef<LoopTimer> timer = LoopTimer::get_instance();
 };
 
 } // namespace crepe
diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp
index 9aede7f..549c35d 100644
--- a/src/crepe/system/AnimatorSystem.cpp
+++ b/src/crepe/system/AnimatorSystem.cpp
@@ -1,8 +1,8 @@
 
 
 #include "../api/Animator.h"
-#include "../facade/SDLContext.h"
 #include "../manager/ComponentManager.h"
+#include "api/LoopTimer.h"
 
 #include "AnimatorSystem.h"
 
@@ -10,27 +10,27 @@ using namespace crepe;
 
 void AnimatorSystem::update() {
 	ComponentManager & mgr = this->mediator.component_manager;
-
+	LoopTimer & timer = this->mediator.timer;
 	RefVector<Animator> animations = mgr.get_components_by_type<Animator>();
 
-	double elapsed_time = this->timer.get_current_time();
+	double elapsed_time = timer.get_current_time();
 
 	for (Animator & a : animations) {
 		if (!a.active) continue;
 
 		Animator::Data & ctx = a.data;
-		double frame_duration = 1.0f / ctx.fps;
+		float frame_duration = 1.0f / ctx.fps;
 
-		int last_frame = ctx.curr_row;
+		int last_frame = ctx.row;
 
-		int cycle_end = (ctx.cycle_end == -1) ? a.row : ctx.cycle_end;
+		int cycle_end = (ctx.cycle_end == -1) ? a.max_rows : ctx.cycle_end;
 		int total_frames = cycle_end - ctx.cycle_start;
 
 		int curr_frame = static_cast<int>(elapsed_time / frame_duration) % total_frames;
 
-		ctx.curr_row = ctx.cycle_start + curr_frame;
-		a.spritesheet.mask.x = ctx.curr_row * a.spritesheet.mask.w;
-		a.spritesheet.mask.y = (ctx.curr_col * a.spritesheet.mask.h);
+		ctx.row = ctx.cycle_start + curr_frame;
+		a.spritesheet.mask.x = ctx.row * a.spritesheet.mask.w;
+		a.spritesheet.mask.y = (ctx.col * a.spritesheet.mask.h);
 
 		if (!ctx.looping && curr_frame == ctx.cycle_start && last_frame == total_frames - 1) {
 			a.active = false;
diff --git a/src/crepe/system/AnimatorSystem.h b/src/crepe/system/AnimatorSystem.h
index e8a5158..1e8cd7d 100644
--- a/src/crepe/system/AnimatorSystem.h
+++ b/src/crepe/system/AnimatorSystem.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "System.h"
-#include "api/LoopTimer.h"
 
 namespace crepe {
 
@@ -25,8 +24,6 @@ public:
 	 */
 	void update() override;
 
-private:
-	LoopTimer & timer = LoopTimer::get_instance();
 };
 
 } // namespace crepe
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index 0ba71ec..241e833 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -17,13 +17,19 @@
 using namespace crepe;
 using namespace std;
 
-void RenderSystem::clear_screen() { this->context.clear_screen(); }
+void RenderSystem::clear_screen() {
+	SDLContext & ctx = this->mediator.sdl_context;
+	ctx.clear_screen();
+}
 
-void RenderSystem::present_screen() { this->context.present_screen(); }
+void RenderSystem::present_screen() {
+	SDLContext & ctx = this->mediator.sdl_context;
+	ctx.present_screen();
+}
 
 SDLContext::CameraValues RenderSystem::update_camera() {
 	ComponentManager & mgr = this->mediator.component_manager;
-
+	SDLContext & ctx = this->mediator.sdl_context;
 	RefVector<Camera> cameras = mgr.get_components_by_type<Camera>();
 
 	if (cameras.size() == 0) throw std::runtime_error("No cameras in current scene");
@@ -32,7 +38,7 @@ SDLContext::CameraValues RenderSystem::update_camera() {
 		if (!cam.active) continue;
 		const Transform & transform
 			= mgr.get_components_by_id<Transform>(cam.game_object_id).front().get();
-		SDLContext::CameraValues cam_val = this->context.set_camera(cam);
+		SDLContext::CameraValues cam_val = ctx.set_camera(cam);
 		cam_val.cam_pos = transform.position + cam.data.postion_offset;
 		return cam_val;
 	}
@@ -64,6 +70,7 @@ bool RenderSystem::render_particle(const Sprite & sprite, const SDLContext::Came
 								   const double & scale) {
 
 	ComponentManager & mgr = this->mediator.component_manager;
+	SDLContext & ctx = this->mediator.sdl_context;
 
 	vector<reference_wrapper<ParticleEmitter>> emitters
 		= mgr.get_components_by_id<ParticleEmitter>(sprite.game_object_id);
@@ -78,7 +85,7 @@ bool RenderSystem::render_particle(const Sprite & sprite, const SDLContext::Came
 		for (const Particle & p : em.data.particles) {
 			if (!p.active) continue;
 
-			this->context.draw(SDLContext::RenderContext{
+			ctx.draw(SDLContext::RenderContext{
 				.sprite = sprite,
 				.cam = cam,
 				.pos = p.position,
@@ -91,7 +98,8 @@ bool RenderSystem::render_particle(const Sprite & sprite, const SDLContext::Came
 }
 void RenderSystem::render_normal(const Sprite & sprite, const SDLContext::CameraValues & cam,
 								 const Transform & tm) {
-	this->context.draw(SDLContext::RenderContext{
+	SDLContext & ctx = this->mediator.sdl_context;
+	ctx.draw(SDLContext::RenderContext{
 		.sprite = sprite,
 		.cam = cam,
 		.pos = tm.position,
diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h
index 91b386f..de76229 100644
--- a/src/crepe/system/RenderSystem.h
+++ b/src/crepe/system/RenderSystem.h
@@ -77,9 +77,6 @@ private:
 	 * \todo Implement a text component and a button component.
 	 * \todo Consider adding text input functionality.
 	 */
-
-private:
-	SDLContext & context = this->mediator.sdl_context;
 };
 
 } // namespace crepe
-- 
cgit v1.2.3


From fdb4c99e139a264d4e15e6913a3756fc6cccb2f2 Mon Sep 17 00:00:00 2001
From: Loek Le Blansch <loek@pipeframe.xyz>
Date: Fri, 6 Dec 2024 20:07:24 +0100
Subject: nitpick #59

---
 src/crepe/Collider.h                 |  2 +-
 src/crepe/Component.h                |  2 +-
 src/crepe/api/Animator.cpp           |  6 ++--
 src/crepe/api/Animator.h             | 58 ++++++++------------------------
 src/crepe/api/AssetManager.h         |  6 ++--
 src/crepe/api/BoxCollider.h          |  2 +-
 src/crepe/api/Button.h               |  6 ++--
 src/crepe/api/CMakeLists.txt         |  4 +--
 src/crepe/api/CircleCollider.h       |  2 +-
 src/crepe/api/Config.h               |  5 +--
 src/crepe/api/EventHandler.h         | 34 +++++++++----------
 src/crepe/api/GameObject.h           | 12 +++----
 src/crepe/api/Metadata.h             |  2 +-
 src/crepe/api/Rigidbody.h            | 28 ++++++++--------
 src/crepe/api/Scene.h                |  4 +--
 src/crepe/api/Script.h               |  2 +-
 src/crepe/api/Sprite.h               | 38 ++++++++++-----------
 src/crepe/api/Transform.h            |  2 +-
 src/crepe/facade/SDLContext.h        | 28 ++++++++--------
 src/crepe/facade/Sound.h             |  2 +-
 src/crepe/manager/ComponentManager.h | 30 ++++++++---------
 src/crepe/manager/EventManager.h     | 28 ++++++++--------
 src/crepe/system/CollisionSystem.h   | 65 ++++++++++++++++++------------------
 src/crepe/system/ParticleSystem.h    | 10 +++---
 src/crepe/system/PhysicsSystem.h     |  4 +--
 src/crepe/system/RenderSystem.cpp    |  3 +-
 src/crepe/system/RenderSystem.h      |  8 ++---
 src/crepe/system/ScriptSystem.h      |  2 +-
 src/test/Profiling.cpp               | 25 ++++++++++----
 29 files changed, 200 insertions(+), 220 deletions(-)

(limited to 'src/crepe/api')

diff --git a/src/crepe/Collider.h b/src/crepe/Collider.h
index a08a68e..42ccfd4 100644
--- a/src/crepe/Collider.h
+++ b/src/crepe/Collider.h
@@ -15,7 +15,7 @@ public:
 	*
 	* The `offset` defines the positional shift applied to the collider relative to the position of the rigidbody it is attached to.
 	* This allows the collider to be placed at a different position than the rigidbody.
-	* 
+	*
 	*/
 	vec2 offset;
 };
diff --git a/src/crepe/Component.h b/src/crepe/Component.h
index dc17721..c30419d 100644
--- a/src/crepe/Component.h
+++ b/src/crepe/Component.h
@@ -8,7 +8,7 @@ class ComponentManager;
 
 /**
  * \brief Base class for all components
- * 
+ *
  * This class is the base class for all components. It provides a common interface for all
  * components.
  */
diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp
index 154135f..b8a91dc 100644
--- a/src/crepe/api/Animator.cpp
+++ b/src/crepe/api/Animator.cpp
@@ -7,10 +7,10 @@
 
 using namespace crepe;
 
-Animator::Animator(uint32_t id, Sprite & ss, unsigned int max_row, unsigned int max_col,
-				   const Animator::Data & data)
+Animator::Animator(game_object_id_t id, Sprite & spritesheet, unsigned int max_row,
+				   unsigned int max_col, const Animator::Data & data)
 	: Component(id),
-	  spritesheet(ss),
+	  spritesheet(spritesheet),
 	  max_rows(max_row),
 	  max_columns(max_col),
 	  data(data) {
diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index 23d29f6..7c850b8 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -1,10 +1,9 @@
 #pragma once
 
-#include <sys/types.h>
+#include "../types.h"
 
 #include "Component.h"
 #include "Sprite.h"
-#include "types.h"
 
 namespace crepe {
 
@@ -21,55 +20,31 @@ class SDLContext;
 class Animator : public Component {
 public:
 	struct Data {
-
 		//! frames per second for animation
 		unsigned int fps = 1;
-
 		//! The current col being animated.
 		unsigned int col = 0;
-
 		//! The current row being animated.
 		unsigned int row = 0;
-
 		//! should the animation loop
 		bool looping = false;
-
 		//! starting frame for cycling
 		unsigned int cycle_start = 0;
-
-		//! end frame for cycling (-1 --> use last frame)
+		//! end frame for cycling (-1 = use last frame)
 		int cycle_end = -1;
-
-		//! offset in pixels.
-		// TODO implement
-		unsigned int white_space = 0;
 	};
 
 public:
-	/**
-	 * \brief Animator will repeat the animation 
-	 *
-	 */
+	//! Animator will repeat the animation
 	void loop();
-
-	/**
-	 * \brief starts the animation
-	 *
-	 */
+	//! starts the animation
 	void play();
-	/**
-	 * \brief pauses the animation
-	 *
-	 * sets the active false
-	 *
-	 */
+	//! pauses the animation
 	void pause();
-
 	/**
 	 * \brief stops the animation
 	 *
 	 * sets the active on false and resets all the current rows and columns
-	 *
 	 */
 	void stop();
 	/**
@@ -81,8 +56,8 @@ public:
 	/**
 	 * \brief set the range in the row
 	 *
-	 * \param  start of row animation
-	 * \param  end of row animation	
+	 * \param start of row animation
+	 * \param end of row animation
 	 */
 	void set_cycle_range(int start, int end);
 	/**
@@ -91,11 +66,7 @@ public:
 	 * \param col animation column
 	 */
 	void set_anim(int col);
-
-	/**
-	 * \brief will go to the next animaiton of current row 
-	 *
-	 */
+	//! will go to the next animaiton of current row
 	void next_anim();
 
 public:
@@ -103,7 +74,7 @@ public:
 	 * \brief Constructs an Animator object that will control animations for a sprite sheet.
 	 *
 	 * \param id The unique identifier for the component, typically assigned automatically.
-	 * \param ss the reference to the spritesheet
+	 * \param spritesheet the reference to the spritesheet
 	 * \param max_row maximum of rows inside the given spritesheet
 	 * \param max_col maximum of columns inside the given spritesheet
 	 * \param data extra animation data for more control
@@ -111,25 +82,22 @@ public:
 	 * This constructor sets up the Animator with the given parameters, and initializes the
 	 * animation system.
 	 */
-	Animator(game_object_id_t id, Sprite & ss, unsigned int max_row, unsigned int max_col,
-			 const Animator::Data & data);
+	Animator(game_object_id_t id, Sprite & spritesheet, unsigned int max_row,
+			 unsigned int max_col, const Animator::Data & data);
 	~Animator(); // dbg_trace
 
 public:
 	//! The maximum number of columns in the sprite sheet.
 	const unsigned int max_columns;
-
 	//! The maximum number of rows in the sprite sheet.
 	const unsigned int max_rows;
-
 	Animator::Data data;
 
 private:
 	//! A reference to the Sprite sheet containing.
 	Sprite & spritesheet;
-
-	// uses the spritesheet
+	//! Uses the spritesheet
 	friend AnimatorSystem;
 };
+
 } // namespace crepe
-//
diff --git a/src/crepe/api/AssetManager.h b/src/crepe/api/AssetManager.h
index fee6780..3b1cc4b 100644
--- a/src/crepe/api/AssetManager.h
+++ b/src/crepe/api/AssetManager.h
@@ -9,7 +9,7 @@ namespace crepe {
 
 /**
  * \brief The AssetManager is responsible for storing and managing assets over multiple scenes.
- * 
+ *
  * The AssetManager ensures that assets are loaded once and can be accessed across different
  * scenes. It caches assets to avoid reloading them every time a scene is loaded. Assets are
  * retained in memory until the AssetManager is destroyed, at which point the cached assets are
@@ -46,9 +46,9 @@ public:
 	 * \param reload If true, the asset will be reloaded from the file, even if it is already
 	 * cached.
 	 * \tparam T The type of asset to cache (e.g., texture, sound, etc.).
-	 * 
+	 *
 	 * \return A shared pointer to the cached asset.
-	 * 
+	 *
 	 * This template function caches the asset at the given file path. If the asset is already
 	 * cached and `reload` is false, the existing cached version will be returned. Otherwise, the
 	 * asset will be reloaded and added to the cache.
diff --git a/src/crepe/api/BoxCollider.h b/src/crepe/api/BoxCollider.h
index 89e43d8..1ac4d46 100644
--- a/src/crepe/api/BoxCollider.h
+++ b/src/crepe/api/BoxCollider.h
@@ -8,7 +8,7 @@ namespace crepe {
 
 /**
  * \brief A class representing a box-shaped collider.
- * 
+ *
  * This class is used for collision detection with other colliders (e.g., CircleCollider).
  */
 class BoxCollider : public Collider {
diff --git a/src/crepe/api/Button.h b/src/crepe/api/Button.h
index 26e7526..61b18d7 100644
--- a/src/crepe/api/Button.h
+++ b/src/crepe/api/Button.h
@@ -11,7 +11,7 @@ class Button : public UIObject {
 public:
 	/**
 	 * \brief Constructs a Button with the specified game object ID and dimensions.
-	 * 
+	 *
 	 * \param id The unique ID of the game object associated with this button.
 	 * \param dimensions The width and height of the UIObject
 	 * \param offset The offset relative this GameObjects Transform
@@ -23,7 +23,7 @@ public:
 
 	/**
 	 * \brief Indicates if the button is a toggle button (can be pressed and released).
-	 * 
+	 *
 	 * A toggle button allows for a pressed/released state, whereas a regular button
 	 * typically only has an on-click state.
 	 */
@@ -31,7 +31,7 @@ public:
 	// TODO: create separate toggle button class
 	/**
 	 * \brief The callback function to be executed when the button is clicked.
-	 * 
+	 *
 	 * This function is invoked whenever the button is clicked. It can be set to any
 	 * function that matches the signature `void()`.
 	 */
diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt
index b2e3df8..593c4e6 100644
--- a/src/crepe/api/CMakeLists.txt
+++ b/src/crepe/api/CMakeLists.txt
@@ -39,8 +39,8 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	Vector2.h
 	Vector2.hpp
 	Color.h
-	Texture.h 
-	AssetManager.h 
+	Texture.h
+	AssetManager.h
 	AssetManager.hpp
 	Scene.h
 	Metadata.h
diff --git a/src/crepe/api/CircleCollider.h b/src/crepe/api/CircleCollider.h
index ebd1cb2..c7bf66e 100644
--- a/src/crepe/api/CircleCollider.h
+++ b/src/crepe/api/CircleCollider.h
@@ -8,7 +8,7 @@ namespace crepe {
 
 /**
  * \brief A class representing a circle-shaped collider.
- * 
+ *
  * This class is used for collision detection with other colliders (e.g., BoxCollider).
  */
 class CircleCollider : public Collider {
diff --git a/src/crepe/api/Config.h b/src/crepe/api/Config.h
index f1bca62..a9745c3 100644
--- a/src/crepe/api/Config.h
+++ b/src/crepe/api/Config.h
@@ -1,8 +1,10 @@
 #pragma once
 
+#include <string>
+
 #include "../util/Log.h"
+
 #include "types.h"
-#include <string>
 
 namespace crepe {
 
@@ -69,7 +71,6 @@ public:
 		//! default screen size in pixels
 		ivec2 default_size = {1280, 720};
 		std::string window_title = "Jetpack joyride clone";
-
 	} window_settings;
 
 	//! Asset loading options
diff --git a/src/crepe/api/EventHandler.h b/src/crepe/api/EventHandler.h
index 7bdd9a3..7bb501b 100644
--- a/src/crepe/api/EventHandler.h
+++ b/src/crepe/api/EventHandler.h
@@ -8,12 +8,12 @@
 namespace crepe {
 /**
  * \brief A type alias for an event handler function.
- * 
- * The EventHandler is a std::function that takes an EventType reference and returns a boolean value 
+ *
+ * The EventHandler is a std::function that takes an EventType reference and returns a boolean value
  * indicating whether the event is handled.
- * 
+ *
  * \tparam EventType The type of event this handler will handle.
- * 
+ *
  * Returning \c false from an event handler results in the event being propogated to other listeners for the same event type, while returning \c true stops propogation altogether.
  */
 template <typename EventType>
@@ -22,7 +22,7 @@ using EventHandler = std::function<bool(const EventType & e)>;
 /**
  * \class IEventHandlerWrapper
  * \brief An abstract base class for event handler wrappers.
- * 
+ *
  * This class provides the interface for handling events. Derived classes must implement the
  * `call()` method to process events
  */
@@ -35,9 +35,9 @@ public:
 
 	/**
 	 * \brief Executes the handler with the given event.
-	 * 
+	 *
 	 * This method calls the `call()` method of the derived class, passing the event to the handler.
-	 * 
+	 *
 	 * \param e The event to be processed.
 	 * \return A boolean value indicating whether the event is handled.
 	 */
@@ -46,9 +46,9 @@ public:
 private:
 	/**
 	 * \brief The method responsible for handling the event.
-	 * 
+	 *
 	 * This method is implemented by derived classes to process the event.
-	 * 
+	 *
 	 * \param e The event to be processed.
 	 * \return A boolean value indicating whether the event is handled.
 	 */
@@ -58,11 +58,11 @@ private:
 /**
  * \class EventHandlerWrapper
  * \brief A wrapper for event handler functions.
- * 
- * This class wraps an event handler function of a specific event type. It implements the 
- * `call()` and `get_type()` methods to allow the handler to be executed and its type to be 
+ *
+ * This class wraps an event handler function of a specific event type. It implements the
+ * `call()` and `get_type()` methods to allow the handler to be executed and its type to be
  * queried.
- * 
+ *
  * \tparam EventType The type of event this handler will handle.
  */
 template <typename EventType>
@@ -70,9 +70,9 @@ 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);
@@ -80,9 +80,9 @@ public:
 private:
 	/**
 	 * \brief Calls the stored event handler with the event.
-	 * 
+	 *
 	 * This method casts the event to the appropriate type and calls the handler.
-	 * 
+	 *
 	 * \param e The event to be handled.
 	 * \return A boolean value indicating whether the event is handled.
 	 */
diff --git a/src/crepe/api/GameObject.h b/src/crepe/api/GameObject.h
index 4cd2bc0..ff80f49 100644
--- a/src/crepe/api/GameObject.h
+++ b/src/crepe/api/GameObject.h
@@ -10,7 +10,7 @@ class ComponentManager;
 
 /**
  * \brief Represents a GameObject
- * 
+ *
  * This class represents a GameObject. The GameObject class is only used as an interface for
  * the game programmer. The actual implementation is done in the ComponentManager.
  */
@@ -19,7 +19,7 @@ private:
 	/**
 	 * This constructor creates a new GameObject. It creates a new Transform and Metadata
 	 * component and adds them to the ComponentManager.
-	 * 
+	 *
 	 * \param component_manager Reference to component_manager
 	 * \param id The id of the GameObject
 	 * \param name The name of the GameObject
@@ -37,20 +37,20 @@ private:
 public:
 	/**
 	 * \brief Set the parent of this GameObject
-	 * 
+	 *
 	 * This method sets the parent of this GameObject. It sets the parent in the Metadata
 	 * component of this GameObject and adds this GameObject to the children list of the parent
 	 * GameObject.
-	 * 
+	 *
 	 * \param parent The parent GameObject
 	 */
 	void set_parent(const GameObject & parent);
 	/**
 	 * \brief Add a component to the GameObject
-	 * 
+	 *
 	 * This method adds a component to the GameObject. It forwards the arguments to the
 	 * ComponentManager.
-	 * 
+	 *
 	 * \tparam T The type of the component
 	 * \tparam Args The types of the arguments
 	 * \param args The arguments to create the component
diff --git a/src/crepe/api/Metadata.h b/src/crepe/api/Metadata.h
index 235d42f..f404703 100644
--- a/src/crepe/api/Metadata.h
+++ b/src/crepe/api/Metadata.h
@@ -9,7 +9,7 @@ namespace crepe {
 
 /**
  * \brief Metadata component
- * 
+ *
  * This class represents the Metadata component. It stores the name, tag, parent and children
  * of a GameObject.
  */
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index 8265ba5..40c6bf1 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -11,7 +11,7 @@ namespace crepe {
 
 /**
  * \brief Rigidbody class
- * 
+ *
  * This class is used by the physics sytem and collision system. It configures how to system
  * interact with the gameobject for movement and collisions.
  */
@@ -19,7 +19,7 @@ class Rigidbody : public Component {
 public:
 	/**
 	 * \brief BodyType enum
-	 * 
+	 *
 	 * This enum provides three bodytypes the physics sytem and collision system use.
 	 */
 	enum class BodyType {
@@ -32,7 +32,7 @@ public:
 	};
 	/**
 	 * \brief PhysicsConstraints to constrain movement
-	 * 
+	 *
 	 * This struct configures the movement constraint for this object. If a constraint is enabled
 	 * the systems will not move the object.
 	 */
@@ -46,9 +46,9 @@ public:
 	};
 
 public:
-	/** 
+	/**
 	 * \brief struct for Rigidbody data
-	 * 
+	 *
 	 * This struct holds the data for the Rigidbody.
 	 */
 	struct Data {
@@ -59,7 +59,7 @@ public:
 		*
 		* The `gravity_scale` controls how much gravity affects the object. It is a multiplier applied to the default
 		* gravity force, allowing for fine-grained control over how the object responds to gravity.
-		* 
+		*
 		*/
 		float gravity_scale = 0;
 
@@ -108,7 +108,7 @@ public:
 		* The `PhysicsConstraints` struct defines the constraints that restrict an object's movement
 		* in certain directions or prevent rotation. These constraints effect only the physics system
 		* to prevent the object from moving or rotating in specified ways.
-		* 
+		*
 		*/
 		PhysicsConstraints constraints;
 
@@ -128,7 +128,7 @@ public:
 		* The `offset` defines a positional shift applied to all colliders associated with the object, relative to the object's
 		* transform position. This allows for the colliders to be placed at a different position than the object's actual
 		* position, without modifying the object's transform itself.
-		* 
+		*
 		*/
 		vec2 offset;
 
@@ -136,14 +136,14 @@ public:
 		 * \brief Defines the collision layers of a GameObject.
 		 *
 		 * The `collision_layers` specifies the layers that the GameObject will collide with.
-		 * Each element represents a layer ID, and the GameObject will only detect 
+		 * Each element represents a layer ID, and the GameObject will only detect
 		 * collisions with other GameObjects that belong to these layers.
 		 */
 		std::set<int> collision_layers;
 	};
 
 public:
-	/** 
+	/**
 	 * \param game_object_id id of the gameobject the rigibody is added to.
 	 * \param data struct to configure the rigidbody.
 	 */
@@ -152,15 +152,15 @@ public:
 	Data data;
 
 public:
-	/** 
+	/**
 	 * \brief add a linear force to the Rigidbody.
-	 * 
+	 *
 	 * \param force Vector2 that is added to the linear force.
 	 */
 	void add_force_linear(const vec2 & force);
-	/** 
+	/**
 	 * \brief add a angular force to the Rigidbody.
-	 * 
+	 *
 	 * \param force Vector2 that is added to the angular force.
 	 */
 	void add_force_angular(float force);
diff --git a/src/crepe/api/Scene.h b/src/crepe/api/Scene.h
index 9f1e8ce..ba9bb76 100644
--- a/src/crepe/api/Scene.h
+++ b/src/crepe/api/Scene.h
@@ -12,7 +12,7 @@ class ComponentManager;
 
 /**
  * \brief Represents a Scene
- * 
+ *
  * This class represents a Scene. The Scene class is only used as an interface for the game
  * programmer.
  */
@@ -41,7 +41,7 @@ public:
 protected:
 	/**
 	 * \name Late references
-	 * 
+	 *
 	 * These references are set by SceneManager immediately after calling the constructor of Scene.
 	 *
 	 * \note Scene must have a constructor without arguments so the game programmer doesn't need to
diff --git a/src/crepe/api/Script.h b/src/crepe/api/Script.h
index d1be1dc..d99ab0e 100644
--- a/src/crepe/api/Script.h
+++ b/src/crepe/api/Script.h
@@ -20,7 +20,7 @@ class ComponentManager;
  * This class is used as a base class for user-defined scripts that can be added to game
  * objects using the \c BehaviorScript component.
  *
- * \info Additional *events* (like Unity's OnDisable and OnEnable) should be implemented as
+ * \note Additional *events* (like Unity's OnDisable and OnEnable) should be implemented as
  * member or lambda methods in derivative user script classes and registered in \c init().
  *
  * \warning Concrete scripts are allowed do create a custom constructor, but the utility
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index ea8104c..dbf41e4 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -31,11 +31,10 @@ public:
 	//! Sprite data that does not have to be set in the constructor
 	struct Data {
 		/**
-		 * \color tint of the sprite 
+		 * \brief Sprite tint (multiplied)
 		 *
-		 * the default value is white because of the color multiplier.
-		 * this means that the orginal image will be shown. if color is BLACK for example
-		 * then it turns the image black because of the Color channels being 0.
+		 * The sprite texture's pixels are multiplied by this color before being displayed
+		 * (including alpha channel for transparency).
 		 */
 		Color color = Color::WHITE;
 
@@ -49,15 +48,15 @@ public:
 		const int order_in_layer = 0;
 
 		/**
-	 	* \size width and height of the sprite in game units
-	 	*
-	 	* - if height is filled in and not width it will multiply width by aspect_ratio.
-	 	* - if width is filled in and not height it will multiply height by aspect_ratio.
-	 	* - if neither is filled it will not show sprite because size will be zero
-	 	* - if both are filled will it use the width and height without making sure the aspect_ratio
-	 	* is correct
-	 	*/
-		vec2 size;
+		 * \brief width and height of the sprite in game units
+		 *
+		 * - if exclusively width is specified, the height is calculated using the texture's aspect
+		 *   ratio
+		 * - if exclusively height is specified, the width is calculated using the texture's aspect
+		 *   ratio
+		 * - if both are specified the texture is streched to fit the specified size
+		 */
+		vec2 size = {0, 0};
 
 		//! independent sprite angle. rotating clockwise direction in degrees
 		float angle_offset = 0;
@@ -71,7 +70,6 @@ public:
 
 public:
 	/**
-	 * \brief Constructs a Sprite with specified parameters.
 	 * \param game_id Unique identifier for the game object this sprite belongs to.
 	 * \param texture asset of the image
 	 * \param ctx all the sprite data
@@ -86,12 +84,12 @@ public:
 
 private:
 	/**
-	* \aspect_ratio ratio of the img
-	* 
-	*  - This will multiply one of \c size variable if it is 0.
-	*  - Will be adjusted if \c Animator component is added to an GameObject
-	*  that is why this value cannot be const. 
-	*/
+	 * \brief ratio of the img
+	 *
+	 * - This will multiply one of \c size variable if it is 0.
+	 * - Will be adjusted if \c Animator component is added to an GameObject that is why this
+	 *   value cannot be const.
+	 */
 	float aspect_ratio;
 
 	//! Reads the mask of sprite
diff --git a/src/crepe/api/Transform.h b/src/crepe/api/Transform.h
index 3ef0fb5..7ee6d65 100644
--- a/src/crepe/api/Transform.h
+++ b/src/crepe/api/Transform.h
@@ -7,7 +7,7 @@ namespace crepe {
 
 /**
  * \brief Transform component
- * 
+ *
  * This class represents the Transform component. It stores the position, rotation and scale of
  * a GameObject.
  */
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index 81a8a34..e232511 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -25,7 +25,7 @@ class InputSystem;
 /**
  * \class SDLContext
  * \brief Facade for the SDL library
- * 
+ *
  * SDLContext is a singleton that handles the SDL window and renderer, provides methods for
  * event handling, and rendering to the screen. It is never used directly by the user
  */
@@ -38,16 +38,16 @@ public:
 		vec2 zoomed_viewport;
 
 		/**
-		 * \render_scale scaling factor
+		 * \brief scaling factor
 		 *
 		 * depending on the black bars type will the scaling be different.
-		 * - lettorboxing --> scaling on the y-as 
-		 * - pillarboxing --> scaling on the x-as 
+		 * - letterboxing --> scaling on the y-as
+		 * - pillarboxing --> scaling on the x-as
 		 */
 		vec2 render_scale;
 
 		/**
-		 * \bar_size size of calculated black bars
+		 * \brief size of calculated black bars
 		 *
 		 * depending on the black bars type will the size be different
 		 * - lettorboxing --> {0, bar_height}
@@ -108,21 +108,21 @@ private:
 	friend class InputSystem;
 	/**
 	 * \brief Retrieves a list of all events from the SDL context.
-	 * 
+	 *
 	 * This method retrieves all the events from the SDL context that are currently
 	 * available. It is primarily used by the InputSystem to process various
 	 * input events such as mouse clicks, mouse movements, and keyboard presses.
-	 * 
+	 *
 	 * \return Events that occurred since last call to `get_events()`
 	 */
 	std::vector<SDLContext::EventData> get_events();
 
 	/**
 	 * \brief Converts an SDL key code to the custom Keycode type.
-	 * 
+	 *
 	 * This method maps an SDL key code to the corresponding `Keycode` enum value,
 	 * which is used internally by the system to identify the keys.
-	 * 
+	 *
 	 * \param sdl_key The SDL key code to convert.
 	 * \return The corresponding `Keycode` value or `Keycode::NONE` if the key is unrecognized.
 	 */
@@ -130,10 +130,10 @@ private:
 
 	/**
 	 * \brief Converts an SDL mouse button code to the custom MouseButton type.
-	 * 
-	 * This method maps an SDL mouse button code to the corresponding `MouseButton` 
+	 *
+	 * This method maps an SDL mouse button code to the corresponding `MouseButton`
 	 * enum value, which is used internally by the system to identify mouse buttons.
-	 * 
+	 *
 	 * \param sdl_button The SDL mouse button code to convert.
 	 * \return The corresponding `MouseButton` value or `MouseButton::NONE` if the key is unrecognized
 	 */
@@ -233,14 +233,14 @@ private:
 	 * \param pos the pos in world units
 	 * \param cam the camera of the current scene
 	 * \param cam_pos the current postion of the camera
-	 * \param img_scale the image multiplier for increasing img size 
+	 * \param img_scale the image multiplier for increasing img size
 	 * \return sdl rectangle to draw a dst image to draw on the screen
 	 */
 	SDL_FRect get_dst_rect(const DestinationRectangleData & data) const;
 	/**
 	 * \brief Set an additional color value multiplied into render copy operations.
 	 *
-	 * \param  texture the given texture to adjust 
+	 * \param  texture the given texture to adjust
 	 * \param  color the color data for the texture
 	 */
 	void set_color_texture(const Texture & texture, const Color & color);
diff --git a/src/crepe/facade/Sound.h b/src/crepe/facade/Sound.h
index 4c68f32..ee43d94 100644
--- a/src/crepe/facade/Sound.h
+++ b/src/crepe/facade/Sound.h
@@ -35,7 +35,7 @@ public:
 	void play();
 	/**
 	 * \brief Reset playhead position
-	 * 
+	 *
 	 * Resets the playhead position so that calling \c play() after this function makes it play
 	 * from the start of the sample. If the sound is not paused before calling this function,
 	 * this function will stop playback.
diff --git a/src/crepe/manager/ComponentManager.h b/src/crepe/manager/ComponentManager.h
index ad37586..44429d9 100644
--- a/src/crepe/manager/ComponentManager.h
+++ b/src/crepe/manager/ComponentManager.h
@@ -16,7 +16,7 @@ class GameObject;
 
 /**
  * \brief Manages all components
- * 
+ *
  * This class manages all components. It provides methods to add, delete and get components.
  */
 class ComponentManager : public Manager {
@@ -56,10 +56,10 @@ protected:
 	friend class GameObject;
 	/**
 	 * \brief Add a component to the ComponentManager
-	 * 
+	 *
 	 * This method adds a component to the ComponentManager. The component is created with the
 	 * given arguments and added to the ComponentManager.
-	 * 
+	 *
 	 * \tparam T The type of the component
 	 * \tparam Args The types of the arguments
 	 * \param id The id of the GameObject this component belongs to
@@ -70,9 +70,9 @@ protected:
 	T & add_component(game_object_id_t id, Args &&... args);
 	/**
 	 * \brief Delete all components of a specific type and id
-	 * 
+	 *
 	 * This method deletes all components of a specific type and id.
-	 * 
+	 *
 	 * \tparam T The type of the component
 	 * \param id The id of the GameObject this component belongs to
 	 */
@@ -80,24 +80,24 @@ protected:
 	void delete_components_by_id(game_object_id_t id);
 	/**
 	 * \brief Delete all components of a specific type
-	 * 
+	 *
 	 * This method deletes all components of a specific type.
-	 * 
+	 *
 	 * \tparam T The type of the component
 	 */
 	template <typename T>
 	void delete_components();
 	/**
 	 * \brief Delete all components of a specific id
-	 * 
+	 *
 	 * This method deletes all components of a specific id.
-	 * 
+	 *
 	 * \param id The id of the GameObject this component belongs to
 	 */
 	void delete_all_components_of_id(game_object_id_t id);
 	/**
 	 * \brief Delete all components
-	 * 
+	 *
 	 * This method deletes all components.
 	 */
 	void delete_all_components();
@@ -115,9 +115,9 @@ protected:
 public:
 	/**
 	 * \brief Get all components of a specific type and id
-	 * 
+	 *
 	 * This method gets all components of a specific type and id.
-	 * 
+	 *
 	 * \tparam T The type of the component
 	 * \param id The id of the GameObject this component belongs to
 	 * \return A vector of all components of the specific type and id
@@ -126,9 +126,9 @@ public:
 	RefVector<T> get_components_by_id(game_object_id_t id) const;
 	/**
 	 * \brief Get all components of a specific type
-	 * 
+	 *
 	 * This method gets all components of a specific type.
-	 * 
+	 *
 	 * \tparam T The type of the component
 	 * \return A vector of all components of the specific type
 	 */
@@ -138,7 +138,7 @@ public:
 private:
 	/**
 	 * \brief The components
-	 * 
+	 *
 	 * This unordered_map stores all components. The key is the type of the component and the
 	 * value is a vector of vectors of unique pointers to the components.
 	 *
diff --git a/src/crepe/manager/EventManager.h b/src/crepe/manager/EventManager.h
index d634f54..ba5e98b 100644
--- a/src/crepe/manager/EventManager.h
+++ b/src/crepe/manager/EventManager.h
@@ -24,7 +24,7 @@ typedef size_t event_channel_t;
 /**
  * \class EventManager
  * \brief Manages event subscriptions, triggers, and queues, enabling decoupled event handling.
- * 
+ *
  * The `EventManager` acts as a centralized event system. It allows for registering callbacks
  * for specific event types, triggering events synchronously, queueing events for later
  * processing, and managing subscriptions via unique identifiers.
@@ -35,20 +35,20 @@ public:
 
 	/**
 	 * \brief Get the singleton instance of the EventManager.
-	 * 
+	 *
 	 * This method returns the unique instance of the EventManager, creating it if it
 	 * doesn't already exist. Ensures only one instance is active in the program.
-	 * 
+	 *
 	 * \return Reference to the singleton instance of the EventManager.
 	 */
 	static EventManager & get_instance();
 
 	/**
 	 * \brief Subscribe to a specific event type.
-	 * 
+	 *
 	 * Registers a callback for a given event type and optional channel. Each callback
 	 * is assigned a unique subscription ID that can be used for later unsubscription.
-	 * 
+	 *
 	 * \tparam EventType The type of the event to subscribe to.
 	 * \param callback The callback function to be invoked when the event is triggered.
 	 * \param channel The channel number to subscribe to (default is CHANNEL_ALL, which listens to all channels).
@@ -60,18 +60,18 @@ public:
 
 	/**
 	 * \brief Unsubscribe a previously registered callback.
-	 * 
+	 *
 	 * Removes a callback from the subscription list based on its unique subscription ID.
-	 * 
+	 *
 	 * \param event_id The unique subscription ID of the callback to remove.
 	 */
 	void unsubscribe(subscription_t event_id);
 
 	/**
 	 * \brief Trigger an event immediately.
-	 * 
+	 *
 	 * Synchronously invokes all registered callbacks for the given event type on the specified channel.
-	 * 
+	 *
 	 * \tparam EventType The type of the event to trigger.
 	 * \param event The event instance to pass to the callbacks.
 	 * \param channel The channel to trigger the event on (default is CHANNEL_ALL, which triggers on all channels).
@@ -81,9 +81,9 @@ public:
 
 	/**
 	 * \brief Queue an event for later processing.
-	 * 
+	 *
 	 * Adds an event to the event queue to be processed during the next call to `dispatch_events`.
-	 * 
+	 *
 	 * \tparam EventType The type of the event to queue.
 	 * \param event The event instance to queue.
 	 * \param channel The channel to associate with the event (default is CHANNEL_ALL).
@@ -93,7 +93,7 @@ public:
 
 	/**
 	 * \brief Process all queued events.
-	 * 
+	 *
 	 * Iterates through the event queue and triggers callbacks for each queued event.
 	 * Events are removed from the queue once processed.
 	 */
@@ -101,7 +101,7 @@ public:
 
 	/**
 	 * \brief Clear all subscriptions.
-	 * 
+	 *
 	 * Removes all registered event handlers and clears the subscription list.
 	 */
 	void clear();
@@ -109,7 +109,7 @@ public:
 private:
 	/**
 	 * \brief Default constructor for the EventManager.
-	 * 
+	 *
 	 * Constructor is private to enforce the singleton pattern.
 	 */
 	EventManager() = default;
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 7e893c8..5b136c6 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -37,7 +37,7 @@ private:
 
 	/**
 		* \brief A structure to store the collision data of a single collider.
-		* 
+		*
 		* This structure all components and id that are for needed within this system when calculating or handeling collisions.
 		* The transform and rigidbody are mostly needed for location and rotation.
 		* In rigidbody additional info is written about what the body of the object is,
@@ -65,7 +65,7 @@ private:
 public:
 	/**
 		* \brief Structure representing detailed collision information between two colliders.
-		* 
+		*
 		* Includes information about the colliding objects and the resolution data for handling the collision.
 		*/
 	struct CollisionInfo {
@@ -90,9 +90,9 @@ public:
 private:
 	/**
 		* \brief Determines the type of collider pair from two colliders.
-		* 
+		*
 		* Uses std::holds_alternative to identify the types of the provided colliders.
-		* 
+		*
 		* \param collider1 First collider variant (BoxCollider or CircleCollider).
 		* \param collider2 Second collider variant (BoxCollider or CircleCollider).
 		* \return The combined type of the two colliders.
@@ -102,9 +102,9 @@ private:
 
 	/**
 		* \brief Calculates the current position of a collider.
-		* 
+		*
 		* Combines the Collider offset, Transform position, and Rigidbody offset to compute the position of the collider.
-		* 
+		*
 		* \param collider_offset The offset of the collider.
 		* \param transform The Transform of the associated game object.
 		* \param rigidbody The Rigidbody of the associated game object.
@@ -116,9 +116,9 @@ private:
 private:
 	/**
 		* \brief Handles collision resolution between two colliders.
-		* 
+		*
 		* Processes collision data and adjusts objects to resolve collisions and/or calls the user oncollision script function.
-		* 
+		*
 		* \param data1 Collision data for the first collider.
 		* \param data2 Collision data for the second collider.
 		*/
@@ -126,9 +126,9 @@ private:
 
 	/**
 		* \brief Resolves collision between two colliders and calculates the movement required.
-		* 
+		*
 		* Determines the displacement and direction needed to separate colliders based on their types.
-		* 
+		*
 		* \param data1 Collision data for the first collider.
 		* \param data2 Collision data for the second collider.
 		* \param type The type of collider pair.
@@ -140,9 +140,9 @@ private:
 
 	/**
 		* \brief Calculates the resolution vector for two BoxColliders.
-		* 
+		*
 		* Computes the displacement required to separate two overlapping BoxColliders.
-		* 
+		*
 		* \param box_collider1 The first BoxCollider.
 		* \param box_collider2 The second BoxCollider.
 		* \param position1 The position of the first BoxCollider.
@@ -155,13 +155,13 @@ private:
 
 	/**
 		* \brief Calculates the resolution vector for two CircleCollider.
-		* 
+		*
 		* Computes the displacement required to separate two overlapping CircleCollider.
-		* 
+		*
 		* \param circle_collider1 The first CircleCollider.
 		* \param circle_collider2 The second CircleCollider.
-		* \param position1 The position of the first CircleCollider.
-		* \param position2 The position of the second CircleCollider.
+		* \param final_position1 The position of the first CircleCollider.
+		* \param final_position2 The position of the second CircleCollider.
 		* \return The resolution vector for the collision.
 		*/
 	vec2 get_circle_circle_resolution(const CircleCollider & circle_collider1,
@@ -171,14 +171,13 @@ private:
 
 	/**
 		* \brief Calculates the resolution vector for two CircleCollider.
-		* 
+		*
 		* Computes the displacement required to separate two overlapping CircleCollider.
-		* 
+		*
 		* \param circle_collider The first CircleCollider.
 		* \param box_collider The second CircleCollider.
 		* \param circle_position The position of the CircleCollider.
 		* \param box_position The position of the BoxCollider.
-		* \param inverse Inverted true if box circle collision, false if circle box collision (inverts the direction).
 		* \return The resolution vector for the collision.
 		*/
 	vec2 get_circle_box_resolution(const CircleCollider & circle_collider,
@@ -188,18 +187,18 @@ private:
 
 	/**
 		* \brief Determines the appropriate collision handler for a collision.
-		* 
+		*
 		* Decides the correct resolution process based on the dynamic or static nature of the colliders involved.
-		* 
+		*
 		* \param info Collision information containing data about both colliders.
 		*/
 	void determine_collision_handler(CollisionInfo & info);
 
 	/**
 		* \brief Handles collisions involving static objects.
-		* 
+		*
 		* Resolves collisions by adjusting positions and modifying velocities if bounce is enabled.
-		* 
+		*
 		* \param info Collision information containing data about both colliders.
 		*/
 	void static_collision_handler(CollisionInfo & info);
@@ -207,9 +206,9 @@ private:
 private:
 	/**
 		* \brief Checks for collisions between colliders.
-		* 
+		*
 		* Identifies collisions and generates pairs of colliding objects for further processing.
-		* 
+		*
 		* \param colliders A collection of all active colliders.
 		* \return A list of collision pairs with their associated data.
 		*/
@@ -218,13 +217,13 @@ private:
 
 	/**
 	 * \brief Checks if two collision layers have at least one common layer.
-	 * 
+	 *
 	 * This function checks if there is any overlapping layer between the two inputs.
-	 * It compares each layer from the first input to see 
-	 * if it exists in the second input. If at least one common layer is found, 
-	 * the function returns true, indicating that the two colliders share a common 
+	 * It compares each layer from the first input to see
+	 * if it exists in the second input. If at least one common layer is found,
+	 * the function returns true, indicating that the two colliders share a common
 	 * collision layer.
-	 * 
+	 *
 	 * \param layers1 all collision layers for the first collider.
 	 * \param layers2 all collision layers for the second collider.
 	 * \return Returns true if there is at least one common layer, false otherwise.
@@ -234,9 +233,9 @@ private:
 
 	/**
 		* \brief Checks for collision between two colliders.
-		* 
+		*
 		* Calls the appropriate collision detection function based on the collider types.
-		* 
+		*
 		* \param first_info Collision data for the first collider.
 		* \param second_info Collision data for the second collider.
 		* \param type The type of collider pair.
@@ -248,7 +247,7 @@ private:
 
 	/**
 		* \brief Detects collisions between two BoxColliders.
-		* 
+		*
 		* \param box1 The first BoxCollider.
 		* \param box2 The second BoxCollider.
 		* \param transform1 Transform of the first object.
diff --git a/src/crepe/system/ParticleSystem.h b/src/crepe/system/ParticleSystem.h
index c647284..068f01c 100644
--- a/src/crepe/system/ParticleSystem.h
+++ b/src/crepe/system/ParticleSystem.h
@@ -25,7 +25,7 @@ public:
 private:
 	/**
 	 * \brief Emits a particle from the specified emitter based on its emission properties.
-	 * 
+	 *
 	 * \param emitter Reference to the ParticleEmitter.
 	 * \param transform Const reference to the Transform component associated with the emitter.
 	 */
@@ -34,7 +34,7 @@ private:
 	/**
 	 * \brief Calculates the number of times particles should be emitted based on emission rate
 	 * and update count.
-	 * 
+	 *
 	 * \param count Current update count.
 	 * \param emission Emission rate.
 	 * \return The number of particles to emit.
@@ -44,7 +44,7 @@ private:
 	/**
 	 * \brief Checks whether particles are within the emitter’s boundary, resets or stops
 	 * particles if they exit.
-	 * 
+	 *
 	 * \param emitter Reference to the ParticleEmitter.
 	 * \param transform Const reference to the Transform component associated with the emitter.
 	 */
@@ -52,7 +52,7 @@ private:
 
 	/**
 	 * \brief Generates a random angle for particle emission within the specified range.
-	 * 
+	 *
 	 * \param min_angle Minimum emission angle in degrees.
 	 * \param max_angle Maximum emission angle in degrees.
 	 * \return Random angle in degrees.
@@ -61,7 +61,7 @@ private:
 
 	/**
 	 * \brief Generates a random speed for particle emission within the specified range.
-	 * 
+	 *
 	 * \param min_speed Minimum emission speed.
 	 * \param max_speed Maximum emission speed.
 	 * \return Random speed.
diff --git a/src/crepe/system/PhysicsSystem.h b/src/crepe/system/PhysicsSystem.h
index 227ab69..26152a5 100644
--- a/src/crepe/system/PhysicsSystem.h
+++ b/src/crepe/system/PhysicsSystem.h
@@ -6,7 +6,7 @@ namespace crepe {
 
 /**
  * \brief System that controls all physics
- * 
+ *
  * This class is a physics system that uses a rigidbody and transform to add physics to a game
  * object.
  */
@@ -15,7 +15,7 @@ public:
 	using System::System;
 	/**
 	 * \brief updates the physics system.
-	 * 
+	 *
 	 * It calculates new velocties and changes the postion in the transform.
 	 */
 	void update() override;
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index 830d380..26f2c85 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -46,7 +46,8 @@ SDLContext::CameraValues RenderSystem::update_camera() {
 }
 
 bool sorting_comparison(const Sprite & a, const Sprite & b) {
-	if (a.data.sorting_in_layer != b.data.sorting_in_layer) return a.data.sorting_in_layer < b.data.sorting_in_layer;
+	if (a.data.sorting_in_layer != b.data.sorting_in_layer)
+		return a.data.sorting_in_layer < b.data.sorting_in_layer;
 	if (a.data.order_in_layer != b.data.order_in_layer)
 		return a.data.order_in_layer < b.data.order_in_layer;
 
diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h
index de76229..e270a6b 100644
--- a/src/crepe/system/RenderSystem.h
+++ b/src/crepe/system/RenderSystem.h
@@ -18,7 +18,7 @@ class Transform;
  * \brief Manages rendering operations for all game objects.
  *
  * RenderSystem is responsible for rendering, clearing and presenting the screen, and
- * managing the active camera. 
+ * managing the active camera.
  */
 class RenderSystem : public System {
 public:
@@ -56,10 +56,10 @@ private:
 						 const double & scale);
 
 	/**
-	 * \brief renders a sprite with a Transform component on the screen 
+	 * \brief renders a sprite with a Transform component on the screen
 	 *
 	 * \param sprite  the sprite component that holds all the data
-	 * \param tm the Transform component that holds the position,rotation and scale 
+	 * \param tm the Transform component that holds the position,rotation and scale
 	 */
 	void render_normal(const Sprite & sprite, const SDLContext::CameraValues & cam,
 					   const Transform & tm);
@@ -67,7 +67,7 @@ private:
 	/**
 	 * \brief sort a vector sprite objects with
 	 *
-	 * \param objs the vector that will do a sorting algorithm on 
+	 * \param objs the vector that will do a sorting algorithm on
 	 * \return returns a sorted reference vector
 	 */
 	RefVector<Sprite> sort(RefVector<Sprite> & objs) const;
diff --git a/src/crepe/system/ScriptSystem.h b/src/crepe/system/ScriptSystem.h
index 936e9ca..3db1b1e 100644
--- a/src/crepe/system/ScriptSystem.h
+++ b/src/crepe/system/ScriptSystem.h
@@ -8,7 +8,7 @@ class Script;
 
 /**
  * \brief Script system
- * 
+ *
  * The script system is responsible for all \c BehaviorScript components, and
  * calls the methods on classes derived from \c Script.
  */
diff --git a/src/test/Profiling.cpp b/src/test/Profiling.cpp
index bd99614..c753bca 100644
--- a/src/test/Profiling.cpp
+++ b/src/test/Profiling.cpp
@@ -70,8 +70,11 @@ public:
 	void SetUp() override {
 
 		GameObject do_not_use = mgr.new_object("DO_NOT_USE", "", {0, 0});
-		do_not_use.add_component<Camera>(Color::WHITE, ivec2{1080, 720}, vec2{2000, 2000},
-										 1.0f);
+		do_not_use.add_component<Camera>(ivec2{1080, 720}, vec2{2000, 2000},
+										 Camera::Data{
+											 .bg_color = Color::WHITE,
+											 .zoom = 1.0f,
+										 });
 		// initialize systems here:
 		//calls init
 		script_sys.update();
@@ -164,10 +167,15 @@ TEST_F(DISABLED_ProfilingTest, Profiling_2) {
 			gameobject.add_component<BoxCollider>(vec2{0, 0}, vec2{1, 1});
 
 			gameobject.add_component<BehaviorScript>().set_script<TestScript>();
-			Color color(0, 0, 0, 0);
 			auto img = Texture("asset/texture/square.png");
 			Sprite & test_sprite = gameobject.add_component<Sprite>(
-				img, color, Sprite::FlipSettings{false, false}, 1, 1, 500);
+				img, Sprite::Data{
+						 .color = {0, 0, 0, 0},
+						 .flip = {.flip_x = false, .flip_y = false},
+						 .sorting_in_layer = 1,
+						 .order_in_layer = 1,
+						 .size = {.y = 500},
+					 });
 		}
 
 		this->game_object_count++;
@@ -197,10 +205,15 @@ TEST_F(DISABLED_ProfilingTest, Profiling_3) {
 			});
 			gameobject.add_component<BoxCollider>(vec2{0, 0}, vec2{1, 1});
 			gameobject.add_component<BehaviorScript>().set_script<TestScript>();
-			Color color(0, 0, 0, 0);
 			auto img = Texture("asset/texture/square.png");
 			Sprite & test_sprite = gameobject.add_component<Sprite>(
-				img, color, Sprite::FlipSettings{false, false}, 1, 1, 500);
+				img, Sprite::Data{
+						 .color = {0, 0, 0, 0},
+						 .flip = {.flip_x = false, .flip_y = false},
+						 .sorting_in_layer = 1,
+						 .order_in_layer = 1,
+						 .size = {.y = 500},
+					 });
 			auto & test = gameobject.add_component<ParticleEmitter>(ParticleEmitter::Data{
 				.max_particles = 10,
 				.emission_rate = 100,
-- 
cgit v1.2.3