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/Sprite.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/crepe/api/Sprite.cpp')

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),
-- 
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/Sprite.cpp')

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 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/Sprite.cpp')

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 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/Sprite.cpp')

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 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/Sprite.cpp')

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