From 9288e4964526f1ce6b7d0aca0f075a04f56ede32 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Mon, 18 Nov 2024 17:50:17 +0100
Subject: first version world postions with camera

---
 src/crepe/api/Vector2.h | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'src/crepe/api/Vector2.h')

diff --git a/src/crepe/api/Vector2.h b/src/crepe/api/Vector2.h
index 2fb6136..2a5db1d 100644
--- a/src/crepe/api/Vector2.h
+++ b/src/crepe/api/Vector2.h
@@ -18,9 +18,16 @@ struct Vector2 {
 	//! Multiplies this vector by a scalar and returns the result.
 	Vector2 operator*(double scalar) const;
 
+	Vector2 operator*(const Vector2 & other) const;
+
 	//! Multiplies this vector by another vector element-wise and updates this vector.
 	Vector2 & operator*=(const Vector2 & other);
 
+	//! Multiplies a scalar value to both components of this vector and updates this vector.
+	Vector2 & operator*=(const double & other);
+
+	Vector2 operator/(const Vector2 & other) const;
+
 	//! Adds another vector to this vector and updates this vector.
 	Vector2 & operator+=(const Vector2 & other);
 
-- 
cgit v1.2.3


From bdc81e355e5bee5d2a3e29346ba08f7bc55196ca Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Wed, 20 Nov 2024 12:07:07 +0100
Subject: adjusted branch based on feedback

---
 mwe/events/include/event.h          |  2 +-
 src/crepe/api/Animator.cpp          |  2 +-
 src/crepe/api/Camera.h              | 18 +++++-------------
 src/crepe/api/Vector2.cpp           |  4 +++-
 src/crepe/api/Vector2.h             |  2 ++
 src/crepe/facade/SDLContext.cpp     |  7 ++-----
 src/crepe/system/AnimatorSystem.cpp |  2 +-
 src/crepe/system/RenderSystem.cpp   |  1 +
 src/example/rendering.cpp           | 10 +++++-----
 9 files changed, 21 insertions(+), 27 deletions(-)

(limited to 'src/crepe/api/Vector2.h')

diff --git a/mwe/events/include/event.h b/mwe/events/include/event.h
index ee1bf52..e1b220b 100644
--- a/mwe/events/include/event.h
+++ b/mwe/events/include/event.h
@@ -148,7 +148,7 @@ private:
 };
 class ShutDownEvent : public Event {
 public:
-	ShutDownEvent() : Event("ShutDownEvent") {};
+	ShutDownEvent() : Event("ShutDownEvent"){};
 
 	REGISTER_EVENT_TYPE(ShutDownEvent)
 
diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp
index f3d809c..d206428 100644
--- a/src/crepe/api/Animator.cpp
+++ b/src/crepe/api/Animator.cpp
@@ -18,7 +18,7 @@ Animator::Animator(game_object_id_t id, Sprite & ss, int row, int col, int col_a
 	animator_rect.h /= col;
 	animator_rect.w /= row;
 	animator_rect.x = 0;
-	animator_rect.y = (col_animator - 1)* animator_rect.h;
+	animator_rect.y = (col_animator - 1) * animator_rect.h;
 	this->active = false;
 }
 Animator::~Animator() { dbg_trace(); }
diff --git a/src/crepe/api/Camera.h b/src/crepe/api/Camera.h
index dfccd24..d7292ef 100644
--- a/src/crepe/api/Camera.h
+++ b/src/crepe/api/Camera.h
@@ -28,25 +28,17 @@ public:
 	//! Background color of the camera view.
 	Color bg_color;
 
-	/**
-	 * \pos The position of the camera in world units 
-	 */
+	//! pos The position of the camera in world units
 	Vector2 pos = {0, 0};
 
-	/**
-	 * \screen the display size in pixels ( output resolution )
-	 */
+	//! screen the display size in pixels ( output resolution )
 	Vector2 screen = {640, 480};
 
-	/**
-	 * \viewport is the area of the world visible through the camera (in world units)
-	 */
+	//! viewport is the area of the world visible through the camera (in world units)
 	Vector2 viewport = {500, 500};
 
-	/**
-	 * \scale scaling factor from world units to pixel coordinates
-	 */
-	Vector2 scale = {0,0};
+	//! scale scaling factor from world units to pixel coordinates
+	Vector2 scale = {0, 0};
 
 	//! Zoom level of the camera view.
 	double zoom = 1.0f;
diff --git a/src/crepe/api/Vector2.cpp b/src/crepe/api/Vector2.cpp
index c3a49b7..8658c00 100644
--- a/src/crepe/api/Vector2.cpp
+++ b/src/crepe/api/Vector2.cpp
@@ -8,14 +8,16 @@ Vector2 Vector2::operator+(const Vector2 & other) const { return {x + other.x, y
 
 Vector2 Vector2::operator*(double scalar) const { return {x * scalar, y * scalar}; }
 
-Vector2 Vector2::operator*(const Vector2 & other) const{
+Vector2 Vector2::operator*(const Vector2 & other) const {
 	return {this->x * other.x, this->y * other.y};
 }
+
 Vector2 & Vector2::operator*=(const Vector2 & other) {
 	x *= other.x;
 	y *= other.y;
 	return *this;
 }
+
 Vector2 & Vector2::operator*=(const double & other) {
 	x *= other;
 	y *= other;
diff --git a/src/crepe/api/Vector2.h b/src/crepe/api/Vector2.h
index 2a5db1d..790160d 100644
--- a/src/crepe/api/Vector2.h
+++ b/src/crepe/api/Vector2.h
@@ -18,6 +18,7 @@ struct Vector2 {
 	//! Multiplies this vector by a scalar and returns the result.
 	Vector2 operator*(double scalar) const;
 
+	//! Multiplies this vector by another vector element-wise and updates this vector.
 	Vector2 operator*(const Vector2 & other) const;
 
 	//! Multiplies this vector by another vector element-wise and updates this vector.
@@ -26,6 +27,7 @@ struct Vector2 {
 	//! Multiplies a scalar value to both components of this vector and updates this vector.
 	Vector2 & operator*=(const double & other);
 
+	//! Divides this vector by another vector element-wise and updates this vector.
 	Vector2 operator/(const Vector2 & other) const;
 
 	//! Adds another vector to this vector and updates this vector.
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 785b285..0cb7be9 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -38,7 +38,7 @@ SDLContext::SDLContext() {
 	}
 	SDL_Window * tmp_window
 		= SDL_CreateWindow("Crepe Game Engine", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
-						   this->viewport.w, this->viewport.h, SDL_WINDOW_RESIZABLE);
+						   this->viewport.w, this->viewport.h, 0);
 	if (!tmp_window) {
 		// FIXME: throw exception
 		std::cerr << "Window could not be created! SDL_Error: " << SDL_GetError() << std::endl;
@@ -104,13 +104,11 @@ void SDLContext::handle_events(bool & running) {
 void SDLContext::clear_screen() { SDL_RenderClear(this->game_renderer.get()); }
 void SDLContext::present_screen() { SDL_RenderPresent(this->game_renderer.get()); }
 
-
 void SDLContext::draw(const Sprite & sprite, const Transform & transform, const Camera & cam) {
 
 	SDL_RendererFlip render_flip
 		= (SDL_RendererFlip) ((SDL_FLIP_HORIZONTAL * sprite.flip.flip_x)
 							  | (SDL_FLIP_VERTICAL * sprite.flip.flip_y));
-	
 
 	Vector2 pixel_coord = (transform.position - cam.pos) * cam.scale;
 	double pixel_w = sprite.sprite_rect.w * transform.scale * cam.scale.x;
@@ -148,11 +146,10 @@ void SDLContext::camera(Camera & cam) {
 		cam.scale.y = cam.scale.x = cam.screen.y / zoomed_viewport.y;
 	}
 
-
 	if (this->viewport.w != cam.screen.x && this->viewport.h != cam.screen.y) {
 		this->viewport.w = cam.screen.x;
 		this->viewport.h = cam.screen.y;
-		SDL_SetWindowSize(this->game_window.get(), cam.screen.x	, cam.screen.y);
+		SDL_SetWindowSize(this->game_window.get(), cam.screen.x, cam.screen.y);
 	}
 
 	SDL_SetRenderDrawColor(this->game_renderer.get(), cam.bg_color.r, cam.bg_color.g,
diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp
index ceb5bfd..efe0e48 100644
--- a/src/crepe/system/AnimatorSystem.cpp
+++ b/src/crepe/system/AnimatorSystem.cpp
@@ -3,8 +3,8 @@
 #include <vector>
 
 #include "api/Animator.h"
-
 #include "facade/SDLContext.h"
+
 #include "AnimatorSystem.h"
 #include "ComponentManager.h"
 
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index 989a82f..7538e20 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -13,6 +13,7 @@ using namespace crepe;
 void RenderSystem::clear_screen() const { SDLContext::get_instance().clear_screen(); }
 
 void RenderSystem::present_screen() const { SDLContext::get_instance().present_screen(); }
+
 void RenderSystem::update_camera() {
 	ComponentManager & mgr = this->component_manager;
 
diff --git a/src/example/rendering.cpp b/src/example/rendering.cpp
index 1db57e5..418e03d 100644
--- a/src/example/rendering.cpp
+++ b/src/example/rendering.cpp
@@ -24,7 +24,7 @@ int main() {
 
 	ComponentManager mgr{};
 	RenderSystem sys{mgr};
-	AnimatorSystem anim_sys {mgr};
+	AnimatorSystem anim_sys{mgr};
 
 	GameObject obj = mgr.new_object("name", "tag", Vector2{250, 0}, 0, 1);
 	GameObject obj1 = mgr.new_object("name", "tag", Vector2{500, 0}, 1, 0.1);
@@ -33,10 +33,11 @@ int main() {
 	// Normal adding components
 	{
 		Color color(0, 0, 0, 0);
-		Sprite & sprite = obj.add_component<Sprite>(make_shared<Texture>("../asset/spritesheet/spritesheet_test.png"), color,
-								  FlipSettings{false, false});
+		Sprite & sprite = obj.add_component<Sprite>(
+			make_shared<Texture>("../asset/spritesheet/spritesheet_test.png"), color,
+			FlipSettings{false, false});
 		Camera & cam = obj.add_component<Camera>(Color::get_red());
-		obj.add_component<Animator>(sprite, 4,1,1).active = true;
+		obj.add_component<Animator>(sprite, 4, 1, 1).active = true;
 	}
 	/*
 	{
@@ -54,7 +55,6 @@ int main() {
 	}
 	*/
 
-
 	auto start = std::chrono::steady_clock::now();
 	while (std::chrono::steady_clock::now() - start < std::chrono::seconds(5)) {
 		anim_sys.update();
-- 
cgit v1.2.3


From adbd81d3937a1363af312202c7e4b5ec0bf3458d Mon Sep 17 00:00:00 2001
From: max-001 <maxsmits21@kpnmail.nl>
Date: Thu, 21 Nov 2024 17:04:37 +0100
Subject: Made Vector2 templated

---
 src/crepe/api/Vector2.cpp | 33 ---------------------------------
 src/crepe/api/Vector2.h   |  7 +++++--
 src/crepe/api/Vector2.hpp | 44 ++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 49 insertions(+), 35 deletions(-)
 delete mode 100644 src/crepe/api/Vector2.cpp
 create mode 100644 src/crepe/api/Vector2.hpp

(limited to 'src/crepe/api/Vector2.h')

diff --git a/src/crepe/api/Vector2.cpp b/src/crepe/api/Vector2.cpp
deleted file mode 100644
index 30b968e..0000000
--- a/src/crepe/api/Vector2.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#include "Vector2.h"
-
-using namespace crepe;
-
-Vector2 Vector2::operator-(const Vector2 & other) const { return {x - other.x, y - other.y}; }
-
-Vector2 Vector2::operator+(const Vector2 & other) const { return {x + other.x, y + other.y}; }
-
-Vector2 Vector2::operator*(double scalar) const { return {x * scalar, y * scalar}; }
-
-Vector2 & Vector2::operator*=(const Vector2 & other) {
-	x *= other.x;
-	y *= other.y;
-	return *this;
-}
-
-Vector2 & Vector2::operator+=(const Vector2 & other) {
-	x += other.x;
-	y += other.y;
-	return *this;
-}
-
-Vector2 & Vector2::operator+=(double other) {
-	x += other;
-	y += other;
-	return *this;
-}
-
-Vector2 Vector2::operator-() const { return {-x, -y}; }
-
-bool Vector2::operator==(const Vector2 & other) const { return x == other.x && y == other.y; }
-
-bool Vector2::operator!=(const Vector2 & other) const { return !(*this == other); }
diff --git a/src/crepe/api/Vector2.h b/src/crepe/api/Vector2.h
index 2fb6136..0e41936 100644
--- a/src/crepe/api/Vector2.h
+++ b/src/crepe/api/Vector2.h
@@ -3,11 +3,12 @@
 namespace crepe {
 
 //! 2D vector
+template <class T>
 struct Vector2 {
 	//! X component of the vector
-	double x = 0;
+	T x = 0;
 	//! Y component of the vector
-	double y = 0;
+	T y = 0;
 
 	//! Subtracts another vector from this vector and returns the result.
 	Vector2 operator-(const Vector2 & other) const;
@@ -38,3 +39,5 @@ struct Vector2 {
 };
 
 } // namespace crepe
+
+#include "Vector2.hpp"
diff --git a/src/crepe/api/Vector2.hpp b/src/crepe/api/Vector2.hpp
new file mode 100644
index 0000000..e0ac3d4
--- /dev/null
+++ b/src/crepe/api/Vector2.hpp
@@ -0,0 +1,44 @@
+#include "Vector2.h"
+
+namespace crepe {
+
+template <class T>
+Vector2<T> Vector2<T>::operator-(const Vector2<T> & other) const { return {x - other.x, y - other.y}; }
+
+template <class T>
+Vector2<T> Vector2<T>::operator+(const Vector2<T> & other) const { return {x + other.x, y + other.y}; }
+
+template <class T>
+Vector2<T> Vector2<T>::operator*(double scalar) const { return {x * scalar, y * scalar}; }
+
+template <class T>
+Vector2<T> & Vector2<T>::operator*=(const Vector2<T> & other) {
+	x *= other.x;
+	y *= other.y;
+	return *this;
+}
+
+template <class T>
+Vector2<T> & Vector2<T>::operator+=(const Vector2<T> & other) {
+	x += other.x;
+	y += other.y;
+	return *this;
+}
+
+template <class T>
+Vector2<T> & Vector2<T>::operator+=(double other) {
+	x += other;
+	y += other;
+	return *this;
+}
+
+template <class T>
+Vector2<T> Vector2<T>::operator-() const { return {-x, -y}; }
+
+template <class T>
+bool Vector2<T>::operator==(const Vector2<T> & other) const { return x == other.x && y == other.y; }
+
+template <class T>
+bool Vector2<T>::operator!=(const Vector2<T> & other) const { return !(*this == other); }
+
+} // namespace crepe
-- 
cgit v1.2.3


From c3b558b6b622c16badf2f325b5422f3b042009b4 Mon Sep 17 00:00:00 2001
From: max-001 <maxsmits21@kpnmail.nl>
Date: Thu, 21 Nov 2024 17:32:04 +0100
Subject: Extended Vector2

---
 src/crepe/api/Vector2.h   | 38 +++++++++++++++++--
 src/crepe/api/Vector2.hpp | 94 +++++++++++++++++++++++++++++++++++++++++------
 2 files changed, 117 insertions(+), 15 deletions(-)

(limited to 'src/crepe/api/Vector2.h')

diff --git a/src/crepe/api/Vector2.h b/src/crepe/api/Vector2.h
index 0e41936..b682d28 100644
--- a/src/crepe/api/Vector2.h
+++ b/src/crepe/api/Vector2.h
@@ -13,20 +13,50 @@ struct Vector2 {
 	//! Subtracts another vector from this vector and returns the result.
 	Vector2 operator-(const Vector2 & other) const;
 
+	//! Subtracts a scalar value from both components of this vector and returns the result.
+	Vector2 operator-(T scalar) const;
+
 	//! Adds another vector to this vector and returns the result.
 	Vector2 operator+(const Vector2 & other) const;
 
+	//! Adds a scalar value to both components of this vector and returns the result.
+	Vector2 operator+(T scalar) const;
+
+	//! Multiplies this vector by another vector element-wise and returns the result.
+	Vector2 operator*(const Vector2 & other) const;
+
 	//! Multiplies this vector by a scalar and returns the result.
-	Vector2 operator*(double scalar) const;
+	Vector2 operator*(T scalar) const;
 
-	//! Multiplies this vector by another vector element-wise and updates this vector.
-	Vector2 & operator*=(const Vector2 & other);
+	//! Divides this vector by another vector element-wise and returns the result.
+	Vector2 operator/(const Vector2 & other) const;
+
+	//! Divides this vector by a scalar and returns the result.
+	Vector2 operator/(T scalar) const;
 
 	//! Adds another vector to this vector and updates this vector.
 	Vector2 & operator+=(const Vector2 & other);
 
 	//! Adds a scalar value to both components of this vector and updates this vector.
-	Vector2 & operator+=(double other);
+	Vector2 & operator+=(T other);
+
+	//! Subtracts another vector from this vector and updates this vector.
+	Vector2 & operator-=(const Vector2 & other);
+
+	//! Subtracts a scalar value from both components of this vector and updates this vector.
+	Vector2 & operator-=(T other);
+
+	//! Multiplies this vector by another vector element-wise and updates this vector.
+	Vector2 & operator*=(const Vector2 & other);
+
+	//! Multiplies this vector by a scalar and updates this vector.
+	Vector2 & operator*=(T other);
+
+	//! Divides this vector by another vector element-wise and updates this vector.
+	Vector2 & operator/=(const Vector2 & other);
+
+	//! Divides this vector by a scalar and updates this vector.
+	Vector2 & operator/=(T other);
 
 	//! Returns the negation of this vector.
 	Vector2 operator-() const;
diff --git a/src/crepe/api/Vector2.hpp b/src/crepe/api/Vector2.hpp
index e0ac3d4..46553f9 100644
--- a/src/crepe/api/Vector2.hpp
+++ b/src/crepe/api/Vector2.hpp
@@ -3,19 +3,43 @@
 namespace crepe {
 
 template <class T>
-Vector2<T> Vector2<T>::operator-(const Vector2<T> & other) const { return {x - other.x, y - other.y}; }
+Vector2<T> Vector2<T>::operator-(const Vector2<T> & other) const {
+	return {x - other.x, y - other.y};
+}
 
 template <class T>
-Vector2<T> Vector2<T>::operator+(const Vector2<T> & other) const { return {x + other.x, y + other.y}; }
+Vector2<T> Vector2<T>::operator-(T scalar) const {
+	return {x - scalar, y - scalar};
+}
 
 template <class T>
-Vector2<T> Vector2<T>::operator*(double scalar) const { return {x * scalar, y * scalar}; }
+Vector2<T> Vector2<T>::operator+(const Vector2<T> & other) const {
+	return {x + other.x, y + other.y};
+}
 
 template <class T>
-Vector2<T> & Vector2<T>::operator*=(const Vector2<T> & other) {
-	x *= other.x;
-	y *= other.y;
-	return *this;
+Vector2<T> Vector2<T>::operator+(T scalar) const {
+	return {x + scalar, y + scalar};
+}
+
+template <class T>
+Vector2<T> Vector2<T>::operator*(const Vector2<T> & other) const {
+	return {x * other.x, y * other.y};
+}
+
+template <class T>
+Vector2<T> Vector2<T>::operator*(T scalar) const {
+	return {x * scalar, y * scalar};
+}
+
+template <class T>
+Vector2<T> Vector2<T>::operator/(const Vector2<T> & other) const {
+	return {x / other.x, y / other.y};
+}
+
+template <class T>
+Vector2<T> Vector2<T>::operator/(T scalar) const {
+	return {x / scalar, y / scalar};
 }
 
 template <class T>
@@ -26,19 +50,67 @@ Vector2<T> & Vector2<T>::operator+=(const Vector2<T> & other) {
 }
 
 template <class T>
-Vector2<T> & Vector2<T>::operator+=(double other) {
+Vector2<T> & Vector2<T>::operator+=(T other) {
 	x += other;
 	y += other;
 	return *this;
 }
 
 template <class T>
-Vector2<T> Vector2<T>::operator-() const { return {-x, -y}; }
+Vector2<T> & Vector2<T>::operator-=(const Vector2<T> & other) {
+	x -= other.x;
+	y -= other.y;
+	return *this;
+}
 
 template <class T>
-bool Vector2<T>::operator==(const Vector2<T> & other) const { return x == other.x && y == other.y; }
+Vector2<T> & Vector2<T>::operator-=(T other) {
+	x -= other;
+	y -= other;
+	return *this;
+}
 
 template <class T>
-bool Vector2<T>::operator!=(const Vector2<T> & other) const { return !(*this == other); }
+Vector2<T> & Vector2<T>::operator*=(const Vector2<T> & other) {
+	x *= other.x;
+	y *= other.y;
+	return *this;
+}
+
+template <class T>
+Vector2<T> & Vector2<T>::operator*=(T other) {
+	x *= other;
+	y *= other;
+	return *this;
+}
+
+template <class T>
+Vector2<T> & Vector2<T>::operator/=(const Vector2<T> & other) {
+	x /= other.x;
+	y /= other.y;
+	return *this;
+}
+
+template <class T>
+Vector2<T> & Vector2<T>::operator/=(T other) {
+	x /= other;
+	y /= other;
+	return *this;
+}
+
+template <class T>
+Vector2<T> Vector2<T>::operator-() const {
+	return {-x, -y};
+}
+
+template <class T>
+bool Vector2<T>::operator==(const Vector2<T> & other) const {
+	return x == other.x && y == other.y;
+}
+
+template <class T>
+bool Vector2<T>::operator!=(const Vector2<T> & other) const {
+	return !(*this == other);
+}
 
 } // namespace crepe
-- 
cgit v1.2.3


From a7e39f06b034b6f174997a0f62d93d47fbd64ad9 Mon Sep 17 00:00:00 2001
From: max-001 <maxsmits21@kpnmail.nl>
Date: Fri, 22 Nov 2024 08:52:00 +0100
Subject: Added <T> to arguments

---
 src/crepe/api/Vector2.h | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

(limited to 'src/crepe/api/Vector2.h')

diff --git a/src/crepe/api/Vector2.h b/src/crepe/api/Vector2.h
index b682d28..c278c87 100644
--- a/src/crepe/api/Vector2.h
+++ b/src/crepe/api/Vector2.h
@@ -11,49 +11,49 @@ struct Vector2 {
 	T y = 0;
 
 	//! Subtracts another vector from this vector and returns the result.
-	Vector2 operator-(const Vector2 & other) const;
+	Vector2 operator-(const Vector2<T> & other) const;
 
 	//! Subtracts a scalar value from both components of this vector and returns the result.
 	Vector2 operator-(T scalar) const;
 
 	//! Adds another vector to this vector and returns the result.
-	Vector2 operator+(const Vector2 & other) const;
+	Vector2 operator+(const Vector2<T> & other) const;
 
 	//! Adds a scalar value to both components of this vector and returns the result.
 	Vector2 operator+(T scalar) const;
 
 	//! Multiplies this vector by another vector element-wise and returns the result.
-	Vector2 operator*(const Vector2 & other) const;
+	Vector2 operator*(const Vector2<T> & other) const;
 
 	//! Multiplies this vector by a scalar and returns the result.
 	Vector2 operator*(T scalar) const;
 
 	//! Divides this vector by another vector element-wise and returns the result.
-	Vector2 operator/(const Vector2 & other) const;
+	Vector2 operator/(const Vector2<T> & other) const;
 
 	//! Divides this vector by a scalar and returns the result.
 	Vector2 operator/(T scalar) const;
 
 	//! Adds another vector to this vector and updates this vector.
-	Vector2 & operator+=(const Vector2 & other);
+	Vector2 & operator+=(const Vector2<T> & other);
 
 	//! Adds a scalar value to both components of this vector and updates this vector.
 	Vector2 & operator+=(T other);
 
 	//! Subtracts another vector from this vector and updates this vector.
-	Vector2 & operator-=(const Vector2 & other);
+	Vector2 & operator-=(const Vector2<T> & other);
 
 	//! Subtracts a scalar value from both components of this vector and updates this vector.
 	Vector2 & operator-=(T other);
 
 	//! Multiplies this vector by another vector element-wise and updates this vector.
-	Vector2 & operator*=(const Vector2 & other);
+	Vector2 & operator*=(const Vector2<T> & other);
 
 	//! Multiplies this vector by a scalar and updates this vector.
 	Vector2 & operator*=(T other);
 
 	//! Divides this vector by another vector element-wise and updates this vector.
-	Vector2 & operator/=(const Vector2 & other);
+	Vector2 & operator/=(const Vector2<T> & other);
 
 	//! Divides this vector by a scalar and updates this vector.
 	Vector2 & operator/=(T other);
@@ -62,10 +62,10 @@ struct Vector2 {
 	Vector2 operator-() const;
 
 	//! Checks if this vector is equal to another vector.
-	bool operator==(const Vector2 & other) const;
+	bool operator==(const Vector2<T> & other) const;
 
 	//! Checks if this vector is not equal to another vector.
-	bool operator!=(const Vector2 & other) const;
+	bool operator!=(const Vector2<T> & other) const;
 };
 
 } // namespace crepe
-- 
cgit v1.2.3


From 4ce924b1b1322ee4da3ba50d6da856ad13a2190b Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Fri, 22 Nov 2024 16:16:27 +0100
Subject: working scaling image with scaling world to screen

---
 src/crepe/api/Camera.h             |  4 +-
 src/crepe/api/Sprite.cpp           |  4 +-
 src/crepe/api/Sprite.h             |  8 ++++
 src/crepe/api/Vector2.cpp          |  4 ++
 src/crepe/api/Vector2.h            |  3 ++
 src/crepe/facade/SDLContext.cpp    | 86 ++++++++++++++------------------------
 src/crepe/facade/SDLContext.h      | 10 ++---
 src/crepe/system/RenderSystem.cpp  |  7 ++--
 src/crepe/system/RenderSystem.h    |  5 +++
 src/example/rendering_particle.cpp |  4 +-
 10 files changed, 65 insertions(+), 70 deletions(-)

(limited to 'src/crepe/api/Vector2.h')

diff --git a/src/crepe/api/Camera.h b/src/crepe/api/Camera.h
index c42ed0d..083dc19 100644
--- a/src/crepe/api/Camera.h
+++ b/src/crepe/api/Camera.h
@@ -38,10 +38,8 @@ public:
 	Vector2 viewport = {2000, 1000};
 
 	//! scale scaling factor from world units to pixel coordinates
-	Vector2 scale = {0, 0};
-
 	//! Zoom level of the camera view.
-	double zoom = 1.0f;
+	double zoom = 1.5f;
 
 public:
 	/**
diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp
index bd2d5cf..3853aab 100644
--- a/src/crepe/api/Sprite.cpp
+++ b/src/crepe/api/Sprite.cpp
@@ -15,7 +15,9 @@ Sprite::Sprite(game_object_id_t id, const shared_ptr<Texture> image, const Color
 	: Component(id),
 	  color(color),
 	  flip(flip),
-	  sprite_image(image) {
+	  sprite_image(image),
+	  aspect_ratio(sprite_image->get_width() / sprite_image->get_height())
+{
 	dbg_trace();
 
 	this->sprite_rect.w = sprite_image->get_width();
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index 74a55d4..66599c9 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <memory>
+#include <sys/types.h>
 
 #include "../Component.h"
 
@@ -62,6 +63,13 @@ public:
 	//! Order within the sorting layer
 	uint8_t order_in_layer = 0;
 
+	//! width in world units
+	int width = 0;
+	//! height in world units
+	int height = 0;
+
+	const double aspect_ratio;
+
 public:
 	/**
 	 * \brief Gets the maximum number of instances allowed for this sprite.
diff --git a/src/crepe/api/Vector2.cpp b/src/crepe/api/Vector2.cpp
index 8658c00..c8253d7 100644
--- a/src/crepe/api/Vector2.cpp
+++ b/src/crepe/api/Vector2.cpp
@@ -40,6 +40,10 @@ Vector2 Vector2::operator/(const Vector2 & other) const {
 	return {this->x / other.x, this->y / other.y};
 }
 
+Vector2 Vector2::operator/(const double & other) const {
+	return {this->x / other, this->y / other};
+}
+
 Vector2 Vector2::operator-() const { return {-x, -y}; }
 
 bool Vector2::operator==(const Vector2 & other) const { return x == other.x && y == other.y; }
diff --git a/src/crepe/api/Vector2.h b/src/crepe/api/Vector2.h
index 790160d..5a23699 100644
--- a/src/crepe/api/Vector2.h
+++ b/src/crepe/api/Vector2.h
@@ -30,6 +30,9 @@ struct Vector2 {
 	//! Divides this vector by another vector element-wise and updates this vector.
 	Vector2 operator/(const Vector2 & other) const;
 
+	//! Divides a scalar value to both components of this vector and updates this vector.
+	Vector2 operator/(const double & other) const;
+
 	//! Adds another vector to this vector and updates this vector.
 	Vector2 & operator+=(const Vector2 & other);
 
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index e187d67..f49539c 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -9,6 +9,7 @@
 #include <cmath>
 #include <cstddef>
 #include <functional>
+#include <iostream>
 #include <memory>
 #include <stdexcept>
 
@@ -109,48 +110,60 @@ SDL_Rect SDLContext::get_src_rect(const Sprite & sprite) const {
 	};
 }
 SDL_Rect SDLContext::get_dst_rect(const Sprite & sprite, const Vector2 & pos,
-								  const double & scale, const Camera & cam) const {
+								  const Vector2 & scale) const {
+
+	int pixel_width, pixel_height;
+
+	if (sprite.sprite_rect.w > sprite.sprite_rect.h) {
+		pixel_width = static_cast<int>(sprite.width * scale.x);
+		pixel_height = static_cast<int>(pixel_width / sprite.aspect_ratio);
+	} else {
+		pixel_height = static_cast<int>(sprite.height * scale.y);
+		pixel_width = static_cast<int>(pixel_height * sprite.aspect_ratio);
+	}
+
+	int pixel_x = static_cast<int>((pos.x - pixel_width / 2));
+	int pixel_y = static_cast<int>((pos.y - pixel_height / 2));
 
 	return SDL_Rect{
-		.x = static_cast<int>(sprite.sprite_rect.x - 400 / 2),
-		.y = static_cast<int>(sprite.sprite_rect.y - 300 / 2),
-		.w = static_cast<int>(400),
-		.h = static_cast<int>(300),
+		.x = pixel_x,
+		.y = pixel_y,
+		.w = pixel_width,
+		.h = pixel_height,
 	};
 }
 
 void SDLContext::draw_particle(const Sprite & sprite, const Vector2 & pos,
-							   const double & angle, const double & scale,
-							   const Camera & camera) {
+							   const double & angle, const Vector2 & scale) {
 
 	SDL_RendererFlip render_flip
 		= (SDL_RendererFlip) ((SDL_FLIP_HORIZONTAL * sprite.flip.flip_x)
 							  | (SDL_FLIP_VERTICAL * sprite.flip.flip_y));
 
 	SDL_Rect srcrect = this->get_src_rect(sprite);
-	SDL_Rect dstrect = this->get_dst_rect(sprite, pos, scale, camera);
+	SDL_Rect dstrect = this->get_dst_rect(sprite, pos, scale);
 
 	SDL_RenderCopyEx(this->game_renderer.get(), sprite.sprite_image->texture.get(), &srcrect,
 					 &dstrect, angle, NULL, render_flip);
 }
 
-void SDLContext::draw(const Sprite & sprite, const Transform & transform, const Camera & cam) {
+void SDLContext::draw(const Sprite & sprite, const Transform & transform, const Vector2 & scale) {
 
 	SDL_RendererFlip render_flip
 		= (SDL_RendererFlip) ((SDL_FLIP_HORIZONTAL * sprite.flip.flip_x)
 							  | (SDL_FLIP_VERTICAL * sprite.flip.flip_y));
 
 	SDL_Rect srcrect = this->get_src_rect(sprite);
-	SDL_Rect dstrect = this->get_dst_rect(sprite, transform.position, transform.scale, cam);
+	SDL_Rect dstrect = this->get_dst_rect(sprite, transform.position, scale);
 
 	SDL_RenderCopyEx(this->game_renderer.get(), sprite.sprite_image->texture.get(), &srcrect,
 					 &dstrect, transform.rotation, NULL, render_flip);
 }
 
-void SDLContext::set_camera(Camera & cam) {
+void SDLContext::set_camera(const Camera & cam, Vector2 & scale) {
 
-	if (this->viewport.w != (int)cam.screen.x && this->viewport.h != (int)cam.screen.y) {
-		SDL_SetWindowSize(this->game_window.get(), (int)cam.screen.x, (int)cam.screen.y);
+	if (this->viewport.w != (int) cam.screen.x && this->viewport.h != (int) cam.screen.y) {
+		SDL_SetWindowSize(this->game_window.get(), (int) cam.screen.x, (int) cam.screen.y);
 		this->viewport.h = cam.screen.y;
 		this->viewport.w = cam.screen.x;
 	}
@@ -158,16 +171,18 @@ void SDLContext::set_camera(Camera & cam) {
 	double screen_aspect = cam.screen.x / cam.screen.y;
 	double viewport_aspect = cam.viewport.x / cam.viewport.y;
 
+	scale = cam.screen / cam.viewport * cam.zoom;
+
 	SDL_Rect view;
 
 	if (screen_aspect > viewport_aspect) {
-		view.h = static_cast<int>(cam.screen.y);
+		view.h = static_cast<int>(cam.screen.y / cam.zoom);
 		view.w = static_cast<int>(cam.screen.y * viewport_aspect);
 		view.x = static_cast<int>(cam.screen.x - view.w) / 2;
 		view.y = 0;
 	} else {
-		view.w = static_cast<int>(cam.screen.x);
 		view.h = static_cast<int>(cam.screen.x / viewport_aspect);
+		view.w = static_cast<int>(cam.screen.x / cam.zoom);
 		view.x = 0;
 		view.y = static_cast<int>(cam.screen.y - view.h) / 2;
 	}
@@ -175,7 +190,7 @@ void SDLContext::set_camera(Camera & cam) {
 
 	SDL_RenderSetLogicalSize(this->game_renderer.get(), cam.viewport.x, cam.viewport.y);
 	SDL_SetRenderDrawColor(this->game_renderer.get(), cam.bg_color.r, cam.bg_color.g,
-						cam.bg_color.b, cam.bg_color.a);
+						   cam.bg_color.b, cam.bg_color.a);
 	SDL_Rect bg = {
 		.x = 0,
 		.y = 0,
@@ -183,45 +198,6 @@ void SDLContext::set_camera(Camera & cam) {
 		.h = static_cast<int>(cam.viewport.y),
 	};
 	SDL_RenderFillRect(this->game_renderer.get(), &bg);
-
-	/*
-	float offset_x = 0, offset_y = 0;
-
-
-	double scale_factor = min(cam.screen.x / cam.viewport.x, cam.screen.y / cam.viewport.y);
-	cam.scale.x = scale_factor * cam.viewport.x;
-	cam.scale.y = scale_factor * cam.viewport.y;
-
-	offset_x = (cam.screen.x - cam.scale.x) / 2;
-	offset_y = (cam.screen.y - cam.scale.y) / 2;
-
-	float bar_w = cam.screen.x - cam.scale.x;
-	float bar_h = cam.screen.y - cam.scale.y;
-
-	SDL_SetRenderDrawColor(this->game_renderer.get(), 0, 0, 0, 255);
-	if (bar_w > 0) {
-		SDL_Rect left_bar = {0, 0, static_cast<int>(offset_x), static_cast<int>(cam.screen.y)};
-		SDL_RenderDrawRect(this->game_renderer.get(), &left_bar);
-
-		SDL_Rect right_bar = {static_cast<int>(offset_x + cam.scale.x), 0,
-							  static_cast<int>(offset_x), static_cast<int>(cam.screen.y)};
-		SDL_RenderDrawRect(this->game_renderer.get(), &right_bar);
-	}
-
-	if (screen_aspect > viewport_aspect) {
-		// pillarboxing
-		cam.scale.x = cam.scale.y = cam.screen.x / cam.viewport.x;
-		offset_y = (cam.screen.y - (cam.viewport.y * cam.scale.y)) / 2;
-	} else if (screen_aspect < viewport_aspect) {
-		// lettor boxing
-		cam.scale.y = cam.scale.x = cam.screen.y / zoomed_viewport.y;
-		offset_x = (cam.screen.x - (cam.viewport.x * cam.scale.x)) / 2;
-	} else {
-		// screen ration is even
-		offset_y = (cam.screen.y - (cam.viewport.y * cam.scale.y)) / 2;
-		offset_x = (cam.screen.x - (cam.viewport.x * cam.scale.x)) / 2;
-	}
-	*/
 }
 
 uint64_t SDLContext::get_ticks() const { return SDL_GetTicks64(); }
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index 45bbda6..68d1630 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -118,10 +118,9 @@ private:
 	 * \param transform Reference to the Transform for positioning.
 	 * \param camera Reference to the Camera for view adjustments.
 	 */
-	void draw(const Sprite & sprite, const Transform & transform, const Camera & camera);
+	void draw(const Sprite & sprite, const Transform & transform, const Vector2 & scale);
 
-	void draw_particle(const Sprite & sprite, const Vector2 & pos, const double & angle,
-					   const double & scale, const Camera & camera);
+	void draw_particle(const Sprite & sprite, const Vector2 & pos, const double & angle, const Vector2 & scale);
 
 	//! Clears the screen, preparing for a new frame.
 	void clear_screen();
@@ -133,7 +132,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(Camera & camera);
+	void set_camera(const Camera & camera, Vector2 & scale);
 
 private:
 	/**
@@ -153,8 +152,7 @@ private:
 	 * on the camera 
 	 * \return sdl rectangle to draw a dst image to draw on the screen
 	 */
-	SDL_Rect get_dst_rect(const Sprite & sprite, const Vector2 & pos, const double & scale,
-						  const Camera & cam) const;
+	SDL_Rect get_dst_rect(const Sprite & sprite, const Vector2 & pos, const Vector2 & scale) const;
 
 private:
 	//! sdl Window
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index ad510f5..a16fbb5 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -30,7 +30,7 @@ void RenderSystem::update_camera() {
 
 	for (Camera & cam : cameras) {
 		if (!cam.active) continue;
-		this->context.set_camera(cam);
+		this->context.set_camera(cam, this->scale);
 		this->curr_cam_ref = &cam;
 	}
 }
@@ -72,14 +72,13 @@ bool RenderSystem::render_particle(const Sprite & sprite, const double & scale)
 
 		for (const Particle & p : em.data.particles) {
 			if (!p.active) continue;
-			this->context.draw_particle(sprite, p.position, p.angle, scale,
-										*this->curr_cam_ref);
+			this->context.draw_particle(sprite, p.position, p.angle, this->scale * scale);
 		}
 	}
 	return rendering_particles;
 }
 void RenderSystem::render_normal(const Sprite & sprite, const Transform & tm) {
-	this->context.draw(sprite, tm, *this->curr_cam_ref);
+	this->context.draw(sprite, tm, this->scale * tm.scale);
 }
 
 void RenderSystem::render() {
diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h
index 30b41cf..19edc02 100644
--- a/src/crepe/system/RenderSystem.h
+++ b/src/crepe/system/RenderSystem.h
@@ -3,6 +3,7 @@
 #include <functional>
 #include <vector>
 
+#include "api/Vector2.h"
 #include "facade/SDLContext.h"
 
 #include "System.h"
@@ -80,8 +81,12 @@ private:
 	//! Pointer to the current active camera for rendering
 	Camera * curr_cam_ref = nullptr;
 	// TODO: needs a better solution
+	
+	Vector2 scale;	
 
 	SDLContext & context = SDLContext::get_instance();
+
+
 };
 
 } // namespace crepe
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 96ef3df..741c985 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -23,7 +23,7 @@ using namespace std;
 
 int main(int argc, char * argv[]) {
 	ComponentManager mgr;
-	GameObject game_object = mgr.new_object("", "", Vector2{400, 300}, 0, 0.1);
+	GameObject game_object = mgr.new_object("", "", Vector2{1000, 500}, 0, 2);
 	RenderSystem sys{mgr};
 	ParticleSystem psys{mgr};
 
@@ -32,6 +32,8 @@ int main(int argc, char * argv[]) {
 	Sprite & test_sprite = game_object.add_component<Sprite>(
 		make_shared<Texture>("asset/texture/test_ap43.png"), color, FlipSettings{false, false});
 	test_sprite.order_in_layer = 5;
+	test_sprite.width = 1000;
+	test_sprite.height = 500;
 
 
 	/*
-- 
cgit v1.2.3


From 8cfb59093ce7b18c2b81cc8429a7568a3ba21a73 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Tue, 26 Nov 2024 10:03:06 +0100
Subject: adjusted vector2 to vec2

---
 src/crepe/api/Camera.h             | 13 +++++++------
 src/crepe/api/Vector2.h            | 11 ++---------
 src/crepe/facade/SDLContext.cpp    | 20 +++++++++-----------
 src/crepe/facade/SDLContext.h      | 16 ++++++++--------
 src/crepe/system/RenderSystem.h    |  8 +++-----
 src/example/rendering_particle.cpp |  5 ++---
 6 files changed, 31 insertions(+), 42 deletions(-)

(limited to 'src/crepe/api/Vector2.h')

diff --git a/src/crepe/api/Camera.h b/src/crepe/api/Camera.h
index 137c8ed..eea1b28 100644
--- a/src/crepe/api/Camera.h
+++ b/src/crepe/api/Camera.h
@@ -2,7 +2,8 @@
 
 #include "Color.h"
 #include "Component.h"
-#include "api/Vector2.h"
+
+#include "types.h"
 
 namespace crepe {
 
@@ -29,15 +30,15 @@ public:
 	Color bg_color;
 
 	//! pos The position of the camera in world units
-	Vector2 pos = {0, 0};
+	vec2 pos = {0, 0};
 
 	//! screen the display size in pixels ( output resolution )
-	//Vector2 screen = {720, 480};
-	Vector2 screen = {1080, 720};
+	//vec2 screen = {720, 480};
+	vec2 screen = {1080, 720};
 
 	//! viewport is the area of the world visible through the camera (in world units)
-	//Vector2 viewport = {720, 480};
-	Vector2 viewport = {2000, 1000};
+	//vec2 viewport = {720, 480};
+	vec2 viewport = {2000, 1000};
 
 	//! scale scaling factor from world units to pixel coordinates
 	//! Zoom level of the camera view.
diff --git a/src/crepe/api/Vector2.h b/src/crepe/api/Vector2.h
index 019d849..0688fac 100644
--- a/src/crepe/api/Vector2.h
+++ b/src/crepe/api/Vector2.h
@@ -34,15 +34,11 @@ struct Vector2 {
 	//! Multiplies this vector by another vector element-wise and updates this vector.
 	Vector2 & operator*=(const Vector2<T> & other);
 
-	//! Multiplies a scalar value to both components of this vector and updates this vector.
-	Vector2 & operator*=(const Vector2<T> & other);
-
-	//! Divides this vector by another vector element-wise and updates this vector.
-	Vector2 operator/(const Vector2<T> & other) const;
-
 	//! Divides a scalar value to both components of this vector and updates this vector.
 	Vector2 operator/(const T & other) const;
 
+	Vector2 operator/(T other) const;
+
 	//! Adds another vector to this vector and updates this vector.
 	Vector2 & operator+=(const Vector2<T> & other);
 
@@ -55,9 +51,6 @@ struct Vector2 {
 	//! Subtracts a scalar value from both components of this vector and updates this vector.
 	Vector2 & operator-=(T other);
 
-	//! Multiplies this vector by another vector element-wise and updates this vector.
-	Vector2 & operator*=(const Vector2<T> & other);
-
 	//! Multiplies this vector by a scalar and updates this vector.
 	Vector2 & operator*=(T other);
 
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index de7d08f..fc59d84 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>
 
@@ -16,10 +15,9 @@
 #include "../api/Sprite.h"
 #include "../api/Texture.h"
 #include "../api/Transform.h"
-#include "../api/Vector2.h"
 #include "../util/Log.h"
-#include "api/Vector2.h"
 
+#include "types.h"
 #include "SDLContext.h"
 
 using namespace crepe;
@@ -108,9 +106,9 @@ SDL_Rect SDLContext::get_src_rect(const Sprite & sprite) const {
 		.h = sprite.sprite_rect.h,
 	};
 }
-SDL_Rect SDLContext::get_dst_rect(const Sprite & sprite, const Vector2 & pos,
-								  const Vector2 & cam_pos, const double & img_scale,
-								  const Vector2 & cam_scale) const {
+SDL_Rect SDLContext::get_dst_rect(const Sprite & sprite, const vec2 & pos,
+								  const vec2 & cam_pos, const double & img_scale,
+								  const vec2 & cam_scale) const {
 
 	int pixel_width, pixel_height;
 
@@ -136,9 +134,9 @@ SDL_Rect SDLContext::get_dst_rect(const Sprite & sprite, const Vector2 & pos,
 	};
 }
 
-void SDLContext::draw_particle(const Sprite & sprite, const Vector2 & pos,
-							   const double & angle, const Vector2 & cam_pos,
-							   const double & img_scale, const Vector2 & cam_scale) {
+void SDLContext::draw_particle(const Sprite & sprite, const vec2 & pos,
+							   const double & angle, const vec2 & cam_pos,
+							   const double & img_scale, const vec2 & cam_scale) {
 
 	SDL_RendererFlip render_flip
 		= (SDL_RendererFlip) ((SDL_FLIP_HORIZONTAL * sprite.flip.flip_x)
@@ -152,7 +150,7 @@ void SDLContext::draw_particle(const Sprite & sprite, const Vector2 & pos,
 }
 
 void SDLContext::draw(const Sprite & sprite, const Transform & transform,
-					  const Vector2 & cam_pos, const Vector2 & cam_scale) {
+					  const vec2 & cam_pos, const vec2 & cam_scale) {
 
 	SDL_RendererFlip render_flip
 		= (SDL_RendererFlip) ((SDL_FLIP_HORIZONTAL * sprite.flip.flip_x)
@@ -166,7 +164,7 @@ void SDLContext::draw(const Sprite & sprite, const Transform & transform,
 					 &dstrect, transform.rotation, NULL, render_flip);
 }
 
-void SDLContext::set_camera(const Camera & cam, Vector2 & scale) {
+void SDLContext::set_camera(const Camera & cam, vec2 & scale) {
 
 	// resize window
 	if (this->viewport.w != (int) cam.screen.x || this->viewport.h != (int) cam.screen.y) {
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index aed5797..c9f3299 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -120,8 +120,8 @@ private:
 	 * \param cam_pos position of the current camera in the scene
 	 * \param cam_scale multiplier for the world to screen
 	 */
-	void draw(const Sprite & sprite, const Transform & transform, const Vector2 & cam_pos,
-			  const Vector2 & cam_scale);
+	void draw(const Sprite & sprite, const Transform & transform, const vec2 & cam_pos,
+			  const vec2 & cam_scale);
 
 	/**
 	 * \brief Draws a particle to the screen using the specified parameters
@@ -133,9 +133,9 @@ private:
 	 * \param  img_scale scalar multiplier to increase image size 
 	 * \param  cam_scale camera scalar for world to screen
 	 */
-	void draw_particle(const Sprite & sprite, const Vector2 & pos, const double & angle,
-					   const Vector2 & cam_pos, const double & img_scale,
-					   const Vector2 & cam_scale);
+	void draw_particle(const Sprite & sprite, const vec2 & pos, const double & angle,
+					   const vec2 & cam_pos, const double & img_scale,
+					   const vec2 & cam_scale);
 
 	//! Clears the screen, preparing for a new frame.
 	void clear_screen();
@@ -147,7 +147,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, Vector2 & scale);
+	void set_camera(const Camera & camera, vec2 & scale);
 
 private:
 	/**
@@ -168,8 +168,8 @@ private:
 	 * \param scale the multiplier for world to screen 
 	 * \return sdl rectangle to draw a dst image to draw on the screen
 	 */
-	SDL_Rect get_dst_rect(const Sprite & sprite, const Vector2 & pos, const Vector2 & cam_pos,
-						  const double & img_scale, const Vector2 & scale) const;
+	SDL_Rect get_dst_rect(const Sprite & sprite, const vec2 & pos, const vec2 & cam_pos,
+						  const double & img_scale, const vec2 & scale) const;
 
 private:
 	//! sdl Window
diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h
index f010a83..97222f3 100644
--- a/src/crepe/system/RenderSystem.h
+++ b/src/crepe/system/RenderSystem.h
@@ -1,13 +1,11 @@
 #pragma once
 
-#include <functional>
-#include <vector>
+#include <cmath>
 
-#include "api/Vector2.h"
 #include "facade/SDLContext.h"
 
 #include "System.h"
-#include <cmath>
+#include "types.h"
 
 namespace crepe {
 
@@ -82,7 +80,7 @@ private:
 	Camera * curr_cam_ref = nullptr;
 	// TODO: needs a better solution
 
-	Vector2 scale;
+	vec2 scale;
 
 	SDLContext & context = SDLContext::get_instance();
 };
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 49e8e9d..80726bc 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -2,7 +2,6 @@
 #include "api/Camera.h"
 #include "system/AnimatorSystem.h"
 #include "system/ParticleSystem.h"
-#include "types.h"
 #include <SDL2/SDL_timer.h>
 #include <crepe/ComponentManager.h>
 
@@ -14,7 +13,7 @@
 #include <crepe/api/Sprite.h>
 #include <crepe/api/Texture.h>
 #include <crepe/api/Transform.h>
-#include <crepe/api/Vector2.h>
+#include <crepe/types.h>
 #include <crepe/system/RenderSystem.h>
 
 #include <chrono>
@@ -25,7 +24,7 @@ using namespace std;
 
 int main(int argc, char * argv[]) {
 	ComponentManager mgr;
-	GameObject game_object = mgr.new_object("", "", Vector2{0, 0}, 0, 1);
+	GameObject game_object = mgr.new_object("", "", vec2{0, 0}, 0, 1);
 	RenderSystem sys{mgr};
 	ParticleSystem psys{mgr};
 	AnimatorSystem asys{mgr};
-- 
cgit v1.2.3


From ddb5bde6e5dd4d89faf419630086ece66690d6b5 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Wed, 27 Nov 2024 19:57:16 +0100
Subject: implemented feedback. biggest changes are teh camera_ref removed

---
 src/crepe/api/Animator.h           |  5 -----
 src/crepe/api/Camera.cpp           |  8 ++++++--
 src/crepe/api/Camera.h             | 12 ++++++------
 src/crepe/api/Config.h             |  4 +---
 src/crepe/api/Sprite.cpp           |  8 ++++++--
 src/crepe/api/Sprite.h             | 18 +++++++++++-------
 src/crepe/api/Vector2.h            |  1 +
 src/crepe/facade/SDLContext.cpp    |  3 +--
 src/crepe/system/RenderSystem.cpp  | 28 ++++++++++++++++------------
 src/crepe/system/RenderSystem.h    | 13 ++++---------
 src/example/rendering_particle.cpp |  8 +++-----
 11 files changed, 55 insertions(+), 53 deletions(-)

(limited to 'src/crepe/api/Vector2.h')

diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index 53f4b91..7a5ef03 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -40,11 +40,6 @@ public:
 	Animator(uint32_t id, Sprite & spritesheet, int row, int col, int col_animate);
 
 	~Animator(); // dbg_trace
-	Animator(const Animator &) = delete;
-	Animator(Animator &&) = delete;
-	Animator & operator=(const Animator &) = delete;
-	Animator & operator=(Animator &&) = delete;
-
 private:
 	//! A reference to the Sprite sheet containing the animation frames.
 	Sprite & spritesheet;
diff --git a/src/crepe/api/Camera.cpp b/src/crepe/api/Camera.cpp
index 5835bdd..4397ac7 100644
--- a/src/crepe/api/Camera.cpp
+++ b/src/crepe/api/Camera.cpp
@@ -6,9 +6,13 @@
 
 using namespace crepe;
 
-Camera::Camera(game_object_id_t id, const Color & bg_color)
+Camera::Camera(game_object_id_t id, const Color & bg_color, const ivec2 & screen,
+			   const ivec2 & viewport, const double & zoom)
 	: Component(id),
-	  bg_color(bg_color) {
+	  bg_color(bg_color),
+	  screen(screen),
+	  viewport(viewport),
+	  zoom(zoom) {
 	dbg_trace();
 }
 
diff --git a/src/crepe/api/Camera.h b/src/crepe/api/Camera.h
index 1505107..2ba37fc 100644
--- a/src/crepe/api/Camera.h
+++ b/src/crepe/api/Camera.h
@@ -21,12 +21,12 @@ public:
 	 * \param id Unique identifier for the camera component.
 	 * \param bg_color Background color for the camera view.
 	 */
-	Camera(game_object_id_t id, const Color & bg_color);
+	Camera(game_object_id_t id, const Color & bg_color, const ivec2 & screen, const ivec2 & viewport, const double & zoom);
 	~Camera(); // dbg_trace only
 
 public:
 	//! Background color of the camera view.
-	Color bg_color;
+	const Color bg_color;
 
 	//! offset postion from the game object transform component
 	vec2 offset = {0, 0};
@@ -36,19 +36,19 @@ public:
 	vec2 pos = {0, 0};
 
 	//! screen the display size in pixels ( output resolution )
-	ivec2 screen = {1080, 720};
+	const ivec2 screen = {1080, 720};
 
 	//! viewport is the area of the world visible through the camera (in world units)
-	ivec2 viewport = {500, 1000};
+	const ivec2 viewport = {500, 1000};
 
 	//! Zoom level of the camera view.
-	double zoom = 1.0f;
+	const double zoom = 1.0f;
 
 public:
 	/**
 	 * \brief Gets the maximum number of camera instances allowed.
 	 * \return Maximum instance count as an integer.
 	 */
-	virtual int get_instances_max() const { return 10; }
+	virtual int get_instances_max() const { return 1; }
 };
 } // namespace crepe
diff --git a/src/crepe/api/Config.h b/src/crepe/api/Config.h
index 2723461..9b43cdf 100644
--- a/src/crepe/api/Config.h
+++ b/src/crepe/api/Config.h
@@ -66,9 +66,7 @@ public:
 	//! default window settings
 	struct {
 		//TODO make this constexpr because this will never change
-		ivec2 def_size = {1080, 720};
-		vec2 pos = {0, 0};
-		float zoom = 1.0f;
+		const ivec2 def_size = {1080, 720};
 	} win_set;
 
 	//! Asset loading options
diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp
index 2c2ca65..21c8377 100644
--- a/src/crepe/api/Sprite.cpp
+++ b/src/crepe/api/Sprite.cpp
@@ -10,16 +10,20 @@ using namespace std;
 using namespace crepe;
 
 Sprite::Sprite(game_object_id_t id, const Texture & image, const Color & color,
-			   const FlipSettings & flip)
+			   const FlipSettings & flip, uint8_t sort_layer, uint8_t order_layer, int height)
 	: Component(id),
 	  color(color),
 	  flip(flip),
 	  sprite_image(image),
-	  aspect_ratio(static_cast<double>(sprite_image.get_width()) / sprite_image.get_height()) {
+	  sorting_in_layer(sort_layer),
+	  order_in_layer(order_layer),
+	  height(height) {
+
 	dbg_trace();
 
 	this->sprite_rect.w = sprite_image.get_width();
 	this->sprite_rect.h = sprite_image.get_height();
+	this->aspect_ratio = static_cast<double>(this->sprite_rect.w) / this->sprite_rect.h;
 }
 
 Sprite::~Sprite() { dbg_trace(); }
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index 82dc4a7..1c40501 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -1,12 +1,10 @@
 #pragma once
 
-#include <memory>
-#include <sys/types.h>
-
 #include "../Component.h"
 
 #include "Color.h"
 #include "Texture.h"
+#include <cstdint>
 
 namespace crepe {
 
@@ -43,9 +41,12 @@ public:
 	 * \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, const Texture & image, const Color & color,
-		   const FlipSettings & flip);
+		   const FlipSettings & flip, uint8_t sort_layer, uint8_t order_layer, int height);
 
 	/**
 	 * \brief Destroys the Sprite instance.
@@ -54,17 +55,20 @@ public:
 
 	//! 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
-	uint8_t sorting_in_layer = 0;
+	const uint8_t sorting_in_layer;
 	//! Order within the sorting layer
-	uint8_t order_in_layer = 0;
+	const uint8_t order_in_layer;
 
 	//! height in world units
-	int height = 0;
+	const int height;
 
 	/**
 	 * \aspect_ratio ratio of the img so that scaling will not become weird
diff --git a/src/crepe/api/Vector2.h b/src/crepe/api/Vector2.h
index 0688fac..2b31d90 100644
--- a/src/crepe/api/Vector2.h
+++ b/src/crepe/api/Vector2.h
@@ -37,6 +37,7 @@ struct Vector2 {
 	//! Divides a scalar value to both components of this vector and updates this vector.
 	Vector2 operator/(const T & other) const;
 
+	//! Divides a scalar value to both components of this vector and updates this vector.
 	Vector2 operator/(T other) const;
 
 	//! Adds another vector to this vector and updates this vector.
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 4887d35..6c6af55 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>
 
@@ -16,10 +15,10 @@
 #include "../api/Sprite.h"
 #include "../api/Texture.h"
 #include "../api/Transform.h"
+#include "../api/Config.h"
 #include "../util/Log.h"
 
 #include "SDLContext.h"
-#include "api/Config.h"
 #include "types.h"
 
 using namespace crepe;
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index 9a8c1ba..a1443cd 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -10,6 +10,7 @@
 #include "../api/Sprite.h"
 #include "../api/Transform.h"
 #include "../facade/SDLContext.h"
+#include "api/Camera.h"
 
 #include "RenderSystem.h"
 
@@ -19,7 +20,8 @@ using namespace std;
 void RenderSystem::clear_screen() { this->context.clear_screen(); }
 
 void RenderSystem::present_screen() { this->context.present_screen(); }
-void RenderSystem::update_camera() {
+
+const Camera & RenderSystem::update_camera() {
 	ComponentManager & mgr = this->component_manager;
 
 	RefVector<Camera> cameras = mgr.get_components_by_type<Camera>();
@@ -31,9 +33,10 @@ void RenderSystem::update_camera() {
 		const Transform & transform
 			= mgr.get_components_by_id<Transform>(cam.game_object_id).front().get();
 		this->context.set_camera(cam);
-		this->curr_cam_ref = &cam;
-		this->curr_cam_ref->pos = transform.position + this->curr_cam_ref->offset;
+		cam.pos = transform.position + cam.offset;
+		return cam;
 	}
+	throw std::runtime_error("No active cameras in current scene");
 }
 
 bool sorting_comparison(const Sprite & a, const Sprite & b) {
@@ -52,12 +55,12 @@ RefVector<Sprite> RenderSystem::sort(RefVector<Sprite> & objs) const {
 
 void RenderSystem::update() {
 	this->clear_screen();
-	this->update_camera();
 	this->render();
 	this->present_screen();
 }
 
-bool RenderSystem::render_particle(const Sprite & sprite, const double & scale) {
+bool RenderSystem::render_particle(const Sprite & sprite, const Camera & cam,
+								   const double & scale) {
 
 	ComponentManager & mgr = this->component_manager;
 
@@ -73,19 +76,20 @@ bool RenderSystem::render_particle(const Sprite & sprite, const double & scale)
 
 		for (const Particle & p : em.data.particles) {
 			if (!p.active) continue;
-			this->context.draw_particle(sprite, p.position, p.angle, scale,
-										*this->curr_cam_ref);
+			this->context.draw_particle(sprite, p.position, p.angle, scale, cam);
 		}
 	}
 	return rendering_particles;
 }
-void RenderSystem::render_normal(const Sprite & sprite, const Transform & tm) {
-	this->context.draw(sprite, tm, *this->curr_cam_ref);
+void RenderSystem::render_normal(const Sprite & sprite, const Camera & cam,
+								 const Transform & tm) {
+	this->context.draw(sprite, tm, cam);
 }
 
 void RenderSystem::render() {
-
 	ComponentManager & mgr = this->component_manager;
+	const Camera & cam = this->update_camera();
+
 	RefVector<Sprite> sprites = mgr.get_components_by_type<Sprite>();
 	RefVector<Sprite> sorted_sprites = this->sort(sprites);
 
@@ -94,10 +98,10 @@ void RenderSystem::render() {
 		const Transform & transform
 			= mgr.get_components_by_id<Transform>(sprite.game_object_id).front().get();
 
-		bool rendered_particles = this->render_particle(sprite, transform.scale);
+		bool rendered_particles = this->render_particle(sprite, cam, transform.scale);
 
 		if (rendered_particles) continue;
 
-		this->render_normal(sprite, transform);
+		this->render_normal(sprite, cam, transform);
 	}
 }
diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h
index 08930b0..264dc4c 100644
--- a/src/crepe/system/RenderSystem.h
+++ b/src/crepe/system/RenderSystem.h
@@ -36,7 +36,7 @@ private:
 	void present_screen();
 
 	//! Updates the active camera used for rendering.
-	void update_camera();
+	const Camera & update_camera();
 
 	//! Renders the whole screen
 	void render();
@@ -48,7 +48,7 @@ private:
 	 * \param tm the Transform component for scale
 	 * \return true if particles have been rendered
 	 */
-	bool render_particle(const Sprite & sprite, const double & scale);
+	bool render_particle(const Sprite & sprite, const Camera & cam, const double & scale);
 
 	/**
 	 * \brief renders a sprite with a Transform component on the screen 
@@ -56,7 +56,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 Transform & tm);
+	void render_normal(const Sprite & sprite, const Camera & cam, const Transform & tm);
 
 	/**
 	 * \brief sort a vector sprite objects with
@@ -70,17 +70,12 @@ private:
 	 * \todo Include color handling for sprites.
 	 * \todo Add text rendering using SDL_ttf for text components.
 	 * \todo Implement a text component and a button component.
-	 * \todo Ensure each sprite is checked for active status before rendering.
-	 * \todo Sort all layers by order before rendering.
 	 * \todo Consider adding text input functionality.
 	 */
 
 private:
-	//! Pointer to the current active camera for rendering
-	// TODO: needs a better solution
-	Camera * curr_cam_ref = nullptr;
-
 	SDLContext & context = SDLContext::get_instance();
+	
 };
 
 } // namespace crepe
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index ec71260..6e426cf 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -33,9 +33,7 @@ int main(int argc, char * argv[]) {
 
 	auto img = Texture("asset/texture/test_ap43.png");
 	Sprite & test_sprite
-		= game_object.add_component<Sprite>(img, color, FlipSettings{true, true});
-	test_sprite.order_in_layer = 5;
-	test_sprite.height = 195;
+		= game_object.add_component<Sprite>(img, color, 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;
@@ -62,8 +60,8 @@ int main(int argc, char * argv[]) {
 	});
 	*/
 
-	auto & cam = game_object.add_component<Camera>(Color::WHITE);
-	cam.pos = {0, 0};
+	auto & cam = game_object.add_component<Camera>(Color::WHITE, ivec2{1080, 720},
+												   ivec2{2000, 2000}, 1.0f);
 
 	/*
 	game_object
-- 
cgit v1.2.3


From 5fa57ab2d8f809b8cb6bd72f54567a01f3e63b95 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Thu, 28 Nov 2024 08:51:20 +0100
Subject: making test work again

---
 src/crepe/api/Config.h        |  2 +-
 src/crepe/api/Vector2.h       | 13 ++++------
 src/test/ParticleTest.cpp     |  7 +++---
 src/test/RenderSystemTest.cpp | 58 +++++++++++++++++++------------------------
 4 files changed, 35 insertions(+), 45 deletions(-)

(limited to 'src/crepe/api/Vector2.h')

diff --git a/src/crepe/api/Config.h b/src/crepe/api/Config.h
index 2525120..d73e488 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
-		const ivec2 def_size = {1080, 720};
+		ivec2 def_size = {1080, 720};
 	} win_set;
 
 	//! Asset loading options
diff --git a/src/crepe/api/Vector2.h b/src/crepe/api/Vector2.h
index 2b31d90..c278c87 100644
--- a/src/crepe/api/Vector2.h
+++ b/src/crepe/api/Vector2.h
@@ -31,14 +31,8 @@ struct Vector2 {
 	//! Divides this vector by another vector element-wise and returns the result.
 	Vector2 operator/(const Vector2<T> & other) const;
 
-	//! Multiplies this vector by another vector element-wise and updates this vector.
-	Vector2 & operator*=(const Vector2<T> & other);
-
-	//! Divides a scalar value to both components of this vector and updates this vector.
-	Vector2 operator/(const T & other) const;
-
-	//! Divides a scalar value to both components of this vector and updates this vector.
-	Vector2 operator/(T other) const;
+	//! Divides this vector by a scalar and returns the result.
+	Vector2 operator/(T scalar) const;
 
 	//! Adds another vector to this vector and updates this vector.
 	Vector2 & operator+=(const Vector2<T> & other);
@@ -52,6 +46,9 @@ struct Vector2 {
 	//! Subtracts a scalar value from both components of this vector and updates this vector.
 	Vector2 & operator-=(T other);
 
+	//! Multiplies this vector by another vector element-wise and updates this vector.
+	Vector2 & operator*=(const Vector2<T> & other);
+
 	//! Multiplies this vector by a scalar and updates this vector.
 	Vector2 & operator*=(T other);
 
diff --git a/src/test/ParticleTest.cpp b/src/test/ParticleTest.cpp
index 8b81e74..ea3652a 100644
--- a/src/test/ParticleTest.cpp
+++ b/src/test/ParticleTest.cpp
@@ -1,4 +1,4 @@
-#include "api/Vector2.h"
+#include "api/Texture.h"
 #include <crepe/ComponentManager.h>
 #include <crepe/Particle.h>
 #include <crepe/api/Config.h>
@@ -28,9 +28,10 @@ public:
 			GameObject game_object = mgr.new_object("", "", vec2{0, 0}, 0, 0);
 
 			Color color(0, 0, 0, 0);
+			auto s1 = Texture("asset/texture/img.png");
 			Sprite & test_sprite = game_object.add_component<Sprite>(
-				make_shared<Texture>("asset/texture/img.png"), color,
-				FlipSettings{true, true});
+				s1, color,
+				FlipSettings{true, true}, 1,1,100);
 
 			game_object.add_component<ParticleEmitter>(ParticleEmitter::Data{
 				.position = {0, 0},
diff --git a/src/test/RenderSystemTest.cpp b/src/test/RenderSystemTest.cpp
index f37fb56..2c4f21c 100644
--- a/src/test/RenderSystemTest.cpp
+++ b/src/test/RenderSystemTest.cpp
@@ -1,4 +1,4 @@
-#include "api/Camera.h"
+#include "types.h"
 #include <functional>
 #include <gtest/gtest.h>
 #include <memory>
@@ -12,6 +12,7 @@
 #include <crepe/api/GameObject.h>
 #include <crepe/api/Sprite.h>
 #include <crepe/api/Texture.h>
+#include "crepe/api/Camera.h"
 
 #include <crepe/system/RenderSystem.h>
 
@@ -29,40 +30,30 @@ public:
 	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;
+		auto s1 = Texture("asset/texture/img.png");
+		auto s2 = Texture("asset/texture/img.png");
+		auto s3 = Texture("asset/texture/img.png");
+		auto s4 = Texture("asset/texture/img.png");
+		auto & sprite1 = entity1.add_component<Sprite>(s1, Color(0, 0, 0, 0),
+													   FlipSettings{false, false}, 5, 5, 100);
+		ASSERT_NE(sprite1.sprite_image.texture.get(), nullptr);
 		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;
-
+		auto & sprite2 = entity2.add_component<Sprite>(s2, Color(0, 0, 0, 0),
+													   FlipSettings{false, false}, 2, 1, 100);
+		ASSERT_NE(sprite2.sprite_image.texture.get(), nullptr);
 		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;
-
+		auto & sprite3 = entity3.add_component<Sprite>(s3, Color(0, 0, 0, 0),
+													   FlipSettings{false, false}, 1, 2, 100);
+		ASSERT_NE(sprite3.sprite_image.texture.get(), nullptr);
 		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;
+		auto & sprite4 = entity4.add_component<Sprite>(s4, Color(0, 0, 0, 0),
+													   FlipSettings{false, false}, 1, 1, 100);
+		ASSERT_NE(sprite4.sprite_image.texture.get(), nullptr);
 		EXPECT_EQ(sprite4.sorting_in_layer, 1);
 		EXPECT_EQ(sprite4.order_in_layer, 1);
 	}
@@ -73,8 +64,9 @@ TEST_F(RenderSystemTest, expected_throws) {
 
 	// no texture img
 	EXPECT_ANY_THROW({
-		entity1.add_component<Sprite>(make_shared<Texture>("NO_IMAGE"), Color(0, 0, 0, 0),
-									  FlipSettings{false, false});
+		auto test = Texture("");
+		entity1.add_component<Sprite>(test, Color(0, 0, 0, 0),
+									  FlipSettings{false, false},1,1,100);
 	});
 
 	// No camera
@@ -121,7 +113,7 @@ TEST_F(RenderSystemTest, sorting_sprites) {
 }
 
 TEST_F(RenderSystemTest, Update) {
-	entity1.add_component<Camera>(Color::WHITE);
+	entity1.add_component<Camera>(Color::WHITE, ivec2{1080, 720}, ivec2{2000, 2000}, 1.0f);
 	{
 		vector<reference_wrapper<Sprite>> sprites = this->mgr.get_components_by_type<Sprite>();
 		ASSERT_EQ(sprites.size(), 4);
@@ -149,7 +141,7 @@ TEST_F(RenderSystemTest, Camera) {
 		EXPECT_NE(cameras.size(), 1);
 	}
 	{
-		entity1.add_component<Camera>(Color::WHITE);
+		entity1.add_component<Camera>(Color::WHITE, ivec2{1080, 720}, ivec2{2000, 2000}, 1.0f);
 		auto cameras = this->mgr.get_components_by_type<Camera>();
 		EXPECT_EQ(cameras.size(), 1);
 	}
@@ -157,9 +149,9 @@ TEST_F(RenderSystemTest, Camera) {
 	//TODO improve with newer version
 }
 TEST_F(RenderSystemTest, Color) {
-	entity1.add_component<Camera>(Color::WHITE);
+	entity1.add_component<Camera>(Color::WHITE, ivec2{1080, 720}, ivec2{2000, 2000}, 1.0f);
 	auto & sprite = this->mgr.get_components_by_id<Sprite>(entity1.id).front().get();
-	ASSERT_NE(sprite.sprite_image.get(), nullptr);
+	ASSERT_NE(sprite.sprite_image.texture.get(), nullptr);
 
 	sprite.color = Color::GREEN;
 	EXPECT_EQ(sprite.color.r, Color::GREEN.r);
-- 
cgit v1.2.3