From 9b7be419c9dcc6ebd1e504713c7b2676ca3d2fdf Mon Sep 17 00:00:00 2001
From: Loek Le Blansch <loek@pipeframe.xyz>
Date: Wed, 23 Oct 2024 21:54:28 +0200
Subject: `clang-format`

---
 src/crepe/api/Force.cpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

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

diff --git a/src/crepe/api/Force.cpp b/src/crepe/api/Force.cpp
index 1b4c81a..ff82afa 100644
--- a/src/crepe/api/Force.cpp
+++ b/src/crepe/api/Force.cpp
@@ -3,12 +3,14 @@
 
 namespace crepe::api {
 
-Force::Force(uint32_t gameObjectId, uint32_t forceMagnitude, uint32_t direction): Component(gameObjectId)
-{ 
+Force::Force(uint32_t gameObjectId, uint32_t forceMagnitude, uint32_t direction)
+	: Component(gameObjectId) {
 	// Convert direction from degrees to radians
-    float radian_direction = static_cast<float>(direction) * (M_PI / 180.0f);
-    force_x = static_cast<int32_t>(std::round(forceMagnitude * std::cos(radian_direction)));
-    force_y = static_cast<int32_t>(std::round(forceMagnitude * std::sin(radian_direction)));
+	float radian_direction = static_cast<float>(direction) * (M_PI / 180.0f);
+	force_x = static_cast<int32_t>(
+		std::round(forceMagnitude * std::cos(radian_direction)));
+	force_y = static_cast<int32_t>(
+		std::round(forceMagnitude * std::sin(radian_direction)));
 }
 
 } // namespace crepe::api
-- 
cgit v1.2.3


From 6e2c5e1b57210b10f8781f103e5c46308544339f Mon Sep 17 00:00:00 2001
From: Loek Le Blansch <loek@pipeframe.xyz>
Date: Wed, 23 Oct 2024 22:23:36 +0200
Subject: more nitpicking

---
 contributing.md                   |  2 ++
 src/crepe/Collider.h              |  2 +-
 src/crepe/CollisionSystem.cpp     |  2 --
 src/crepe/CollisionSystem.h       |  5 +---
 src/crepe/Component.h             |  1 +
 src/crepe/ComponentManager.h      |  1 -
 src/crepe/ParticleSystem.cpp      | 46 ++++++++++++++++++------------------
 src/crepe/ParticleSystem.h        |  3 +--
 src/crepe/PhysicsSystem.cpp       |  8 ++++---
 src/crepe/PhysicsSystem.h         |  5 +---
 src/crepe/RenderSystem.cpp        | 12 +++++-----
 src/crepe/RenderSystem.h          |  1 -
 src/crepe/SDLApp.cpp              | 10 ++++----
 src/crepe/SDLApp.h                | 11 ++++-----
 src/crepe/ScriptSystem.cpp        |  5 ++--
 src/crepe/SdlContext.cpp          | 49 ++++++++++++++++++++-------------------
 src/crepe/SdlContext.h            | 12 ++++++----
 src/crepe/Sound.h                 |  3 +--
 src/crepe/api/AssetManager.cpp    |  3 +--
 src/crepe/api/AssetManager.h      |  1 +
 src/crepe/api/AudioSource.cpp     |  5 ++--
 src/crepe/api/BehaviorScript.hpp  |  1 +
 src/crepe/api/CircleCollider.h    |  4 ++--
 src/crepe/api/Color.cpp           |  2 --
 src/crepe/api/Force.cpp           | 11 +++++----
 src/crepe/api/Force.h             |  6 ++---
 src/crepe/api/ParticleEmitter.cpp | 35 ++++++++++++++--------------
 src/crepe/api/ParticleEmitter.h   | 44 +++++++++++++++++++++--------------
 src/crepe/api/Rigidbody.cpp       |  4 ++--
 src/crepe/api/Rigidbody.h         | 16 ++++++++-----
 src/crepe/api/Sprite.cpp          | 11 ++++-----
 src/crepe/api/Sprite.h            |  9 ++++---
 src/crepe/api/Texture.cpp         | 19 ++++++++-------
 src/crepe/api/Texture.h           |  5 ++--
 src/crepe/api/Transform.cpp       |  8 +++----
 src/crepe/api/Transform.h         |  9 +++++--
 src/example/particle.cpp          |  2 +-
 37 files changed, 193 insertions(+), 180 deletions(-)

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

diff --git a/contributing.md b/contributing.md
index 59adefb..a6e5074 100644
--- a/contributing.md
+++ b/contributing.md
@@ -71,6 +71,8 @@
   possible (i.e. if you only need a reference or pointer type).
 - Template functions are only declared in a `.h` header, and defined in a
   matching `.hpp` header.
+- Where possible, end (initializer) lists with a trailing comma (e.g. with
+  structs, enums)
 
 ## CMakeLists specific
 
diff --git a/src/crepe/Collider.h b/src/crepe/Collider.h
index cfc044c..68a7d1d 100644
--- a/src/crepe/Collider.h
+++ b/src/crepe/Collider.h
@@ -6,7 +6,7 @@ namespace crepe {
 
 class Collider : public Component {
 public:
-	Collider(uint32_t gameObjectId);
+	Collider(uint32_t game_object_id);
 
 	int size;
 };
diff --git a/src/crepe/CollisionSystem.cpp b/src/crepe/CollisionSystem.cpp
index 77110a2..55e0fdc 100644
--- a/src/crepe/CollisionSystem.cpp
+++ b/src/crepe/CollisionSystem.cpp
@@ -1,6 +1,4 @@
 #include "CollisionSystem.h"
-#include "ComponentManager.h"
-#include <iostream>
 
 using namespace crepe;
 
diff --git a/src/crepe/CollisionSystem.h b/src/crepe/CollisionSystem.h
index 4a222eb..1e9f1aa 100644
--- a/src/crepe/CollisionSystem.h
+++ b/src/crepe/CollisionSystem.h
@@ -3,11 +3,8 @@
 namespace crepe {
 
 class CollisionSystem {
-private:
-	/* data */
-
 public:
-	CollisionSystem(/* args */);
+	CollisionSystem();
 	void update();
 };
 
diff --git a/src/crepe/Component.h b/src/crepe/Component.h
index 9e10c42..bc44865 100644
--- a/src/crepe/Component.h
+++ b/src/crepe/Component.h
@@ -1,4 +1,5 @@
 #pragma once
+
 #include <cstdint>
 
 namespace crepe {
diff --git a/src/crepe/ComponentManager.h b/src/crepe/ComponentManager.h
index 38f32e4..2b5e1df 100644
--- a/src/crepe/ComponentManager.h
+++ b/src/crepe/ComponentManager.h
@@ -4,7 +4,6 @@
 #include <memory>
 #include <typeindex>
 #include <unordered_map>
-#include <utility>
 #include <vector>
 
 #include "Component.h"
diff --git a/src/crepe/ParticleSystem.cpp b/src/crepe/ParticleSystem.cpp
index f0220a1..af6c550 100644
--- a/src/crepe/ParticleSystem.cpp
+++ b/src/crepe/ParticleSystem.cpp
@@ -1,14 +1,14 @@
-#include "ParticleSystem.h"
-#include "ComponentManager.h"
-#include "Particle.h"
-#include "api/ParticleEmitter.h"
 #include <cmath>
 #include <ctime>
 
+#include "api/ParticleEmitter.h"
+
+#include "ComponentManager.h"
+#include "ParticleSystem.h"
+
 using namespace crepe;
 
-ParticleSystem::ParticleSystem()
-	: m_elapsed_time(0.0f) {} // Initialize m_elapsedTime to 0
+ParticleSystem::ParticleSystem() : elapsed_time(0.0f) {}
 
 void ParticleSystem::update() {
 	ComponentManager & mgr = ComponentManager::get_instance();
@@ -16,7 +16,7 @@ void ParticleSystem::update() {
 		= mgr.get_components_by_type<ParticleEmitter>();
 	float delta_time = 0.10;
 	for (ParticleEmitter & emitter : emitters) {
-		float update_amount = 1 / static_cast<float>(emitter.m_emission_rate);
+		float update_amount = 1 / static_cast<float>(emitter.emission_rate);
 		for (float i = 0; i < delta_time; i += update_amount) {
 			emit_particle(emitter);
 		}
@@ -29,32 +29,32 @@ void ParticleSystem::update() {
 }
 
 void ParticleSystem::emit_particle(ParticleEmitter & emitter) {
-	Position initial_position = {emitter.m_position.x, emitter.m_position.y};
+	Position initial_position = {emitter.position.x, emitter.position.y};
 	float random_angle = 0.0f;
-	if (emitter.m_max_angle < emitter.m_min_angle) {
-		random_angle = ((emitter.m_min_angle
-						+ (std::rand()
-						   % (static_cast<uint32_t>(emitter.m_max_angle + 360
-													- emitter.m_min_angle + 1))))
-					   % 360);
+	if (emitter.max_angle < emitter.min_angle) {
+		random_angle = ((emitter.min_angle
+						 + (std::rand()
+							% (static_cast<uint32_t>(emitter.max_angle + 360
+													 - emitter.min_angle + 1))))
+						% 360);
 	} else {
-		random_angle = emitter.m_min_angle
-					  + (std::rand()
-						 % (static_cast<uint32_t>(emitter.m_max_angle
-												  - emitter.m_min_angle + 1)));
+		random_angle = emitter.min_angle
+					   + (std::rand()
+						  % (static_cast<uint32_t>(emitter.max_angle
+												   - emitter.min_angle + 1)));
 	}
 	float angle_in_radians = random_angle * (M_PI / 180.0f);
 	float random_speed_offset = (static_cast<float>(std::rand()) / RAND_MAX)
-								  * (2 * emitter.m_speed_offset)
-							  - emitter.m_speed_offset;
+									* (2 * emitter.speed_offset)
+								- emitter.speed_offset;
 	float velocity_x
-		= (emitter.m_speed + random_speed_offset) * std::cos(angle_in_radians);
+		= (emitter.speed + random_speed_offset) * std::cos(angle_in_radians);
 	float velocity_y
-		= (emitter.m_speed + random_speed_offset) * std::sin(angle_in_radians);
+		= (emitter.speed + random_speed_offset) * std::sin(angle_in_radians);
 	Position initial_velocity = {velocity_x, velocity_y};
 	for (size_t i = 0; i < emitter.particles.size(); i++) {
 		if (!emitter.particles[i].active) {
-			emitter.particles[i].reset(emitter.m_end_lifespan, initial_position,
+			emitter.particles[i].reset(emitter.end_lifespan, initial_position,
 									   initial_velocity);
 			break;
 		}
diff --git a/src/crepe/ParticleSystem.h b/src/crepe/ParticleSystem.h
index 071eec4..ad96eb0 100644
--- a/src/crepe/ParticleSystem.h
+++ b/src/crepe/ParticleSystem.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "api/ParticleEmitter.h"
-#include <vector>
 
 namespace crepe {
 
@@ -13,7 +12,7 @@ public:
 private:
 	void emit_particle(ParticleEmitter & emitter); //emits a new particle
 
-	float m_elapsed_time; //elapsed time since the last emission
+	float elapsed_time; //elapsed time since the last emission
 };
 
 } // namespace crepe
diff --git a/src/crepe/PhysicsSystem.cpp b/src/crepe/PhysicsSystem.cpp
index 4bb931d..16f4c10 100644
--- a/src/crepe/PhysicsSystem.cpp
+++ b/src/crepe/PhysicsSystem.cpp
@@ -1,9 +1,11 @@
-#include "PhysicsSystem.h"
-#include "ComponentManager.h"
+#include <iostream>
+
 #include "api/Force.h"
 #include "api/Rigidbody.h"
 #include "api/Transform.h"
-#include <iostream>
+
+#include "ComponentManager.h"
+#include "PhysicsSystem.h"
 
 using namespace crepe;
 using namespace crepe::api;
diff --git a/src/crepe/PhysicsSystem.h b/src/crepe/PhysicsSystem.h
index dd242c7..33b4072 100644
--- a/src/crepe/PhysicsSystem.h
+++ b/src/crepe/PhysicsSystem.h
@@ -3,11 +3,8 @@
 namespace crepe {
 
 class PhysicsSystem {
-private:
-	/* data */
-
 public:
-	PhysicsSystem(/* args */);
+	PhysicsSystem();
 	void update();
 };
 
diff --git a/src/crepe/RenderSystem.cpp b/src/crepe/RenderSystem.cpp
index b8789fc..1139359 100644
--- a/src/crepe/RenderSystem.cpp
+++ b/src/crepe/RenderSystem.cpp
@@ -1,13 +1,13 @@
+#include <functional>
+#include <vector>
 
-
-#include "RenderSystem.h"
-#include "ComponentManager.h"
-#include "SdlContext.h"
 #include "api/Sprite.h"
 #include "api/Transform.h"
 #include "util/log.h"
-#include <functional>
-#include <vector>
+
+#include "ComponentManager.h"
+#include "RenderSystem.h"
+#include "SdlContext.h"
 
 using namespace crepe;
 using namespace crepe::api;
diff --git a/src/crepe/RenderSystem.h b/src/crepe/RenderSystem.h
index 5e86dce..4b910a4 100644
--- a/src/crepe/RenderSystem.h
+++ b/src/crepe/RenderSystem.h
@@ -1,4 +1,3 @@
-
 #pragma once
 
 #include "System.h"
diff --git a/src/crepe/SDLApp.cpp b/src/crepe/SDLApp.cpp
index 198c0d0..f408595 100644
--- a/src/crepe/SDLApp.cpp
+++ b/src/crepe/SDLApp.cpp
@@ -1,8 +1,6 @@
-#include "SDLApp.h"
-#include "Particle.h"
-#include "api/ParticleEmitter.h"
 #include <iostream>
-#include <vector>
+
+#include "SDLApp.h"
 
 SDLApp::SDLApp(int window_width, int window_height)
 	: window_width(window_width), window_height(window_height), window(nullptr),
@@ -18,8 +16,8 @@ bool SDLApp::initialize() {
 	}
 
 	window = SDL_CreateWindow("Particle System", SDL_WINDOWPOS_CENTERED,
-							  SDL_WINDOWPOS_CENTERED, window_width, window_height,
-							  SDL_WINDOW_SHOWN);
+							  SDL_WINDOWPOS_CENTERED, window_width,
+							  window_height, SDL_WINDOW_SHOWN);
 	if (!window) {
 		std::cerr << "Window Creation Error: " << SDL_GetError() << std::endl;
 		return false;
diff --git a/src/crepe/SDLApp.h b/src/crepe/SDLApp.h
index cdba4c3..e67947b 100644
--- a/src/crepe/SDLApp.h
+++ b/src/crepe/SDLApp.h
@@ -1,13 +1,12 @@
-#ifndef SDLAPP_HPP
-#define SDLAPP_HPP
+#pragma once
 
-#include "Particle.h"
-#include "api/ParticleEmitter.h"
 #include <SDL2/SDL.h>
 
+#include "api/ParticleEmitter.h"
+
 class SDLApp {
 public:
-	SDLApp(int windowWidth, int windowHeight);
+	SDLApp(int window_width, int window_height);
 	~SDLApp();
 
 	bool initialize();
@@ -25,5 +24,3 @@ private:
 	SDL_Window * window;
 	SDL_Renderer * renderer;
 };
-
-#endif
diff --git a/src/crepe/ScriptSystem.cpp b/src/crepe/ScriptSystem.cpp
index 5d882be..d00d474 100644
--- a/src/crepe/ScriptSystem.cpp
+++ b/src/crepe/ScriptSystem.cpp
@@ -2,12 +2,13 @@
 #include <functional>
 #include <vector>
 
-#include "ComponentManager.h"
-#include "ScriptSystem.h"
 #include "api/BehaviorScript.h"
 #include "api/Script.h"
 #include "util/log.h"
 
+#include "ComponentManager.h"
+#include "ScriptSystem.h"
+
 using namespace std;
 using namespace crepe;
 using namespace crepe::api;
diff --git a/src/crepe/SdlContext.cpp b/src/crepe/SdlContext.cpp
index f00dade..2b49283 100644
--- a/src/crepe/SdlContext.cpp
+++ b/src/crepe/SdlContext.cpp
@@ -1,11 +1,3 @@
-
-
-#include "SdlContext.h"
-
-#include "api/Sprite.h"
-#include "api/Texture.h"
-#include "api/Transform.h"
-#include "util/log.h"
 #include <SDL2/SDL.h>
 #include <SDL2/SDL_image.h>
 #include <SDL2/SDL_render.h>
@@ -15,6 +7,13 @@
 #include <cstddef>
 #include <iostream>
 
+#include "api/Sprite.h"
+#include "api/Texture.h"
+#include "api/Transform.h"
+#include "util/log.h"
+
+#include "SdlContext.h"
+
 using namespace crepe;
 
 SdlContext & SdlContext::get_instance() {
@@ -34,17 +33,18 @@ void SdlContext::handle_events(bool & running) {
 SdlContext::~SdlContext() {
 	dbg_trace();
 
-	if (m_game_renderer != nullptr) SDL_DestroyRenderer(m_game_renderer);
+	if (this->game_renderer != nullptr)
+		SDL_DestroyRenderer(this->game_renderer);
 
-	if (m_game_window != nullptr) {
-		SDL_DestroyWindow(m_game_window);
+	if (this->game_window != nullptr) {
+		SDL_DestroyWindow(this->game_window);
 	}
 
 	IMG_Quit();
 	SDL_Quit();
 }
 
-void SdlContext::clear_screen() { SDL_RenderClear(this->m_game_renderer); }
+void SdlContext::clear_screen() { SDL_RenderClear(this->game_renderer); }
 
 SdlContext::SdlContext() {
 	dbg_trace();
@@ -55,20 +55,20 @@ SdlContext::SdlContext() {
 		return;
 	}
 
-	m_game_window = SDL_CreateWindow(
+	this->game_window = SDL_CreateWindow(
 		"Crepe Game Engine", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
 		1920, 1080, SDL_WINDOW_SHOWN);
-	if (!m_game_window) {
+	if (!this->game_window) {
 		std::cerr << "Window could not be created! SDL_Error: "
 				  << SDL_GetError() << std::endl;
 	}
 
-	m_game_renderer
-		= SDL_CreateRenderer(m_game_window, -1, SDL_RENDERER_ACCELERATED);
-	if (!m_game_renderer) {
+	this->game_renderer
+		= SDL_CreateRenderer(this->game_window, -1, SDL_RENDERER_ACCELERATED);
+	if (!this->game_renderer) {
 		std::cerr << "Renderer could not be created! SDL_Error: "
 				  << SDL_GetError() << std::endl;
-		SDL_DestroyWindow(m_game_window);
+		SDL_DestroyWindow(this->game_window);
 		return;
 	}
 
@@ -78,7 +78,8 @@ SdlContext::SdlContext() {
 				  << IMG_GetError() << std::endl;
 	}
 }
-void SdlContext::present_screen() { SDL_RenderPresent(this->m_game_renderer); }
+
+void SdlContext::present_screen() { SDL_RenderPresent(this->game_renderer); }
 
 void SdlContext::draw(const api::Sprite & sprite,
 					  const api::Transform & transform) {
@@ -88,7 +89,7 @@ void SdlContext::draw(const api::Sprite & sprite,
 							  | (SDL_FLIP_VERTICAL * sprite.flip.flip_y));
 
 	int w, h;
-	SDL_QueryTexture(sprite.sprite_image->m_texture, NULL, NULL, &w, &h);
+	SDL_QueryTexture(sprite.sprite_image->texture, NULL, NULL, &w, &h);
 	// needs maybe camera for position
 	SDL_Rect dstrect = {
 		.x = static_cast<int>(transform.position.x),
@@ -98,8 +99,8 @@ void SdlContext::draw(const api::Sprite & sprite,
 	};
 
 	double degrees = transform.rotation * 180 / M_PI;
-	SDL_RenderCopyEx(this->m_game_renderer, sprite.sprite_image->m_texture,
-					 NULL, &dstrect, degrees, NULL, render_flip);
+	SDL_RenderCopyEx(this->game_renderer, sprite.sprite_image->texture, NULL,
+					 &dstrect, degrees, NULL, render_flip);
 }
 
 /*
@@ -117,7 +118,7 @@ SDL_Texture * SdlContext::setTextureFromPath(const char * path, SDL_Rect & clip,
 	clip.h = tmp->h / row;
 
 	SDL_Texture * CreatedTexture
-		= SDL_CreateTextureFromSurface(m_game_renderer, tmp);
+		= SDL_CreateTextureFromSurface(this->game_renderer, tmp);
 
 	if (!CreatedTexture) {
 		std::cerr << "Error could not create texture " << IMG_GetError
@@ -137,7 +138,7 @@ SDL_Texture * SdlContext::texture_from_path(const char * path) {
 		std::cerr << "Error surface " << IMG_GetError << std::endl;
 	}
 	SDL_Texture * created_texture
-		= SDL_CreateTextureFromSurface(m_game_renderer, tmp);
+		= SDL_CreateTextureFromSurface(this->game_renderer, tmp);
 
 	if (!created_texture) {
 		std::cerr << "Error could not create texture " << IMG_GetError
diff --git a/src/crepe/SdlContext.h b/src/crepe/SdlContext.h
index 97adfa2..31ba3a6 100644
--- a/src/crepe/SdlContext.h
+++ b/src/crepe/SdlContext.h
@@ -1,11 +1,13 @@
 #pragma once
 
-#include "RenderSystem.h"
-#include "api/Sprite.h"
-#include "api/Transform.h"
 #include <SDL2/SDL_render.h>
 #include <SDL2/SDL_video.h>
 
+#include "api/Sprite.h"
+#include "api/Transform.h"
+
+#include "RenderSystem.h"
+
 namespace crepe::api {
 class Texture;
 }
@@ -43,8 +45,8 @@ private:
 	void present_screen();
 
 private:
-	SDL_Window * m_game_window = nullptr;
-	SDL_Renderer * m_game_renderer = nullptr;
+	SDL_Window * game_window = nullptr;
+	SDL_Renderer * game_renderer = nullptr;
 };
 
 } // namespace crepe
diff --git a/src/crepe/Sound.h b/src/crepe/Sound.h
index b7cfbb8..917b57e 100644
--- a/src/crepe/Sound.h
+++ b/src/crepe/Sound.h
@@ -1,10 +1,9 @@
 #pragma once
 
+#include <memory>
 #include <soloud/soloud.h>
 #include <soloud/soloud_wav.h>
 
-#include <memory>
-
 #include "Asset.h"
 
 namespace crepe {
diff --git a/src/crepe/api/AssetManager.cpp b/src/crepe/api/AssetManager.cpp
index bf4217f..560df6c 100644
--- a/src/crepe/api/AssetManager.cpp
+++ b/src/crepe/api/AssetManager.cpp
@@ -1,7 +1,6 @@
-
+#include "util/log.h"
 
 #include "AssetManager.h"
-#include "util/log.h"
 
 using namespace crepe::api;
 
diff --git a/src/crepe/api/AssetManager.h b/src/crepe/api/AssetManager.h
index f3f1307..d9d9b44 100644
--- a/src/crepe/api/AssetManager.h
+++ b/src/crepe/api/AssetManager.h
@@ -43,4 +43,5 @@ public:
 		return new_asset;
 	}
 };
+
 } // namespace crepe::api
diff --git a/src/crepe/api/AudioSource.cpp b/src/crepe/api/AudioSource.cpp
index 10b3b49..35b8d83 100644
--- a/src/crepe/api/AudioSource.cpp
+++ b/src/crepe/api/AudioSource.cpp
@@ -1,9 +1,8 @@
 #include <memory>
 
-#include "AudioSource.h"
-
 #include "../Sound.h"
-#include <memory>
+
+#include "AudioSource.h"
 
 using namespace crepe::api;
 
diff --git a/src/crepe/api/BehaviorScript.hpp b/src/crepe/api/BehaviorScript.hpp
index a6bd81c..6fdf605 100644
--- a/src/crepe/api/BehaviorScript.hpp
+++ b/src/crepe/api/BehaviorScript.hpp
@@ -3,6 +3,7 @@
 #include <type_traits>
 
 #include "../util/log.h"
+
 #include "BehaviorScript.h"
 
 namespace crepe::api {
diff --git a/src/crepe/api/CircleCollider.h b/src/crepe/api/CircleCollider.h
index 96d98ed..762574b 100644
--- a/src/crepe/api/CircleCollider.h
+++ b/src/crepe/api/CircleCollider.h
@@ -5,8 +5,8 @@ namespace crepe::api {
 
 class CircleCollider : public Collider {
 public:
-	CircleCollider(uint32_t gameObjectId, int radius)
-		: Collider(gameObjectId), radius(radius) {}
+	CircleCollider(uint32_t game_object_id, int radius)
+		: Collider(game_object_id), radius(radius) {}
 	int radius;
 };
 
diff --git a/src/crepe/api/Color.cpp b/src/crepe/api/Color.cpp
index 5c7d8cc..71592da 100644
--- a/src/crepe/api/Color.cpp
+++ b/src/crepe/api/Color.cpp
@@ -1,5 +1,3 @@
-
-
 #include "Color.h"
 
 using namespace crepe::api;
diff --git a/src/crepe/api/Force.cpp b/src/crepe/api/Force.cpp
index ff82afa..98649c1 100644
--- a/src/crepe/api/Force.cpp
+++ b/src/crepe/api/Force.cpp
@@ -1,16 +1,17 @@
-#include "Force.h"
 #include <cmath>
 
+#include "Force.h"
+
 namespace crepe::api {
 
-Force::Force(uint32_t gameObjectId, uint32_t forceMagnitude, uint32_t direction)
-	: Component(gameObjectId) {
+Force::Force(uint32_t game_object_id, uint32_t magnitude, uint32_t direction)
+	: Component(game_object_id) {
 	// Convert direction from degrees to radians
 	float radian_direction = static_cast<float>(direction) * (M_PI / 180.0f);
 	force_x = static_cast<int32_t>(
-		std::round(forceMagnitude * std::cos(radian_direction)));
+		std::round(magnitude * std::cos(radian_direction)));
 	force_y = static_cast<int32_t>(
-		std::round(forceMagnitude * std::sin(radian_direction)));
+		std::round(magnitude * std::sin(radian_direction)));
 }
 
 } // namespace crepe::api
diff --git a/src/crepe/api/Force.h b/src/crepe/api/Force.h
index 1d30af4..8da9a00 100644
--- a/src/crepe/api/Force.h
+++ b/src/crepe/api/Force.h
@@ -1,14 +1,14 @@
 #pragma once
 
-#include "../Component.h"
 #include <cstdint>
-#include <utility>
+
+#include "../Component.h"
 
 namespace crepe::api {
 
 class Force : public Component {
 public:
-	Force(uint32_t gameObjectId, uint32_t forceMagnitude, uint32_t direction);
+	Force(uint32_t game_object_id, uint32_t magnitude, uint32_t direction);
 
 	int32_t force_x;
 	int32_t force_y;
diff --git a/src/crepe/api/ParticleEmitter.cpp b/src/crepe/api/ParticleEmitter.cpp
index 298a5ec..2e07562 100644
--- a/src/crepe/api/ParticleEmitter.cpp
+++ b/src/crepe/api/ParticleEmitter.cpp
@@ -1,29 +1,28 @@
-#include "ParticleEmitter.h"
-#include "Particle.h"
 #include <ctime>
 #include <iostream>
 
+#include "Particle.h"
+#include "ParticleEmitter.h"
+
 using namespace crepe;
 
-ParticleEmitter::ParticleEmitter(uint32_t gameObjectId, uint32_t max_particles,
-								 uint32_t emission_rate, uint32_t speed,
-								 uint32_t speed_offset, uint32_t angle,
-								 uint32_t angleOffset, float m_begin_lifespan,
-								 float m_end_lifespan)
-	: Component(gameObjectId), m_max_particles(max_particles),
-	  m_emission_rate(emission_rate), m_speed(speed), m_speed_offset(speed_offset),
-	  m_position{0, 0}, m_begin_lifespan(m_begin_lifespan),
-	  m_end_lifespan(m_end_lifespan) {
+ParticleEmitter::ParticleEmitter(uint32_t game_object_id,
+								 uint32_t max_particles, uint32_t emission_rate,
+								 uint32_t speed, uint32_t speed_offset,
+								 uint32_t angle, uint32_t angleOffset,
+								 float begin_lifespan, float end_lifespan)
+	: Component(game_object_id), max_particles(max_particles),
+	  emission_rate(emission_rate), speed(speed), speed_offset(speed_offset),
+	  position{0, 0}, begin_lifespan(begin_lifespan),
+	  end_lifespan(end_lifespan) {
 	std::srand(
 		static_cast<uint32_t>(std::time(nullptr))); // initialize random seed
 	std::cout << "Create emitter" << std::endl;
-	m_min_angle
-		= (360 + angle - (angleOffset % 360)) % 360; // calculate minAngle
-	m_max_angle
-		= (360 + angle + (angleOffset % 360)) % 360; // calculate maxAngle
-	m_position.x = 400;
-	m_position.y = 400;
-	for (size_t i = 0; i < m_max_particles; i++) {
+	min_angle = (360 + angle - (angleOffset % 360)) % 360; // calculate minAngle
+	max_angle = (360 + angle + (angleOffset % 360)) % 360; // calculate maxAngle
+	position.x = 400;
+	position.y = 400;
+	for (size_t i = 0; i < max_particles; i++) {
 		this->particles.emplace_back();
 	}
 }
diff --git a/src/crepe/api/ParticleEmitter.h b/src/crepe/api/ParticleEmitter.h
index 23f02f6..2e2e95b 100644
--- a/src/crepe/api/ParticleEmitter.h
+++ b/src/crepe/api/ParticleEmitter.h
@@ -1,32 +1,42 @@
 #pragma once
 
-#include "Component.h"
-#include "Particle.h"
 #include <cstdint>
 #include <vector>
-#
+
+#include "Component.h"
+#include "Particle.h"
 
 namespace crepe {
 
 class ParticleEmitter : public Component {
 public:
-	ParticleEmitter(uint32_t gameObjectId, uint32_t maxParticles,
-					uint32_t emissionRate, uint32_t speed, uint32_t speedOffset,
-					uint32_t angle, uint32_t angleOffset, float m_beginLifespan,
-					float m_endLifespan);
+	ParticleEmitter(uint32_t game_object_id, uint32_t max_particles,
+					uint32_t emission_rate, uint32_t speed,
+					uint32_t speed_offset, uint32_t angle, uint32_t angleOffset,
+					float begin_lifespan, float end_lifespan);
 	~ParticleEmitter();
 
-	Position m_position; //position of the emitter
-	uint32_t m_max_particles; //maximum number of particles
-	uint32_t m_emission_rate; //rate of particle emission
-	uint32_t m_speed; //base speed of the particles
-	uint32_t m_speed_offset; //offset for random speed variation
-	uint32_t m_min_angle; //min angle of particle emission
-	uint32_t m_max_angle; //max angle of particle emission
-	float m_begin_lifespan; //begin Lifespan of particle (only visual)
-	float m_end_lifespan; //begin Lifespan of particle
+	//! position of the emitter
+	Position position;
+	//! maximum number of particles
+	uint32_t max_particles;
+	//! rate of particle emission
+	uint32_t emission_rate;
+	//! base speed of the particles
+	uint32_t speed;
+	//! offset for random speed variation
+	uint32_t speed_offset;
+	//! min angle of particle emission
+	uint32_t min_angle;
+	//! max angle of particle emission
+	uint32_t max_angle;
+	//! begin Lifespan of particle (only visual)
+	float begin_lifespan;
+	//! begin Lifespan of particle
+	float end_lifespan;
 
-	std::vector<Particle> particles; //collection of particles
+	//! collection of particles
+	std::vector<Particle> particles;
 };
 
 } // namespace crepe
diff --git a/src/crepe/api/Rigidbody.cpp b/src/crepe/api/Rigidbody.cpp
index b35d5b8..ebf9fb9 100644
--- a/src/crepe/api/Rigidbody.cpp
+++ b/src/crepe/api/Rigidbody.cpp
@@ -2,7 +2,7 @@
 
 using namespace crepe::api;
 
-Rigidbody::Rigidbody(uint32_t gameObjectId, int mass, int gravityScale,
+Rigidbody::Rigidbody(uint32_t game_object_id, int mass, int gravity_scale,
 					 BodyType bodyType)
-	: Component(gameObjectId), mass(mass), gravity_scale(gravityScale),
+	: Component(game_object_id), mass(mass), gravity_scale(gravity_scale),
 	  body_type(bodyType) {}
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index dc242c1..05cbb03 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -1,20 +1,24 @@
 #pragma once
 
-#include "../Component.h"
 #include <cstdint>
 
+#include "../Component.h"
+
 namespace crepe::api {
 
 enum class BodyType {
-	STATIC, // Does not move (e.g. walls, ground ...)
-	DYNAMIC, // Moves and responds to forces (e.g. player, physics objects ...)
-	KINEMATIC // Moves but does not respond to forces (e.g. moving platforms ...)
+	//! Does not move (e.g. walls, ground ...)
+	STATIC,
+	//! Moves and responds to forces (e.g. player, physics objects ...)
+	DYNAMIC,
+	//! Moves but does not respond to forces (e.g. moving platforms ...)
+	KINEMATIC,
 };
 
 class Rigidbody : public Component {
 public:
-	Rigidbody(uint32_t gameObjectId, int mass, int gravityScale,
-			  BodyType bodyType);
+	Rigidbody(uint32_t game_object_id, int mass, int gravity_scale,
+			  BodyType body_type);
 	int32_t velocity_x;
 	int32_t velocity_y;
 	int mass;
diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp
index cdece28..806f147 100644
--- a/src/crepe/api/Sprite.cpp
+++ b/src/crepe/api/Sprite.cpp
@@ -1,12 +1,11 @@
+#include <cstdint>
+#include <memory>
 
-
-#include "Sprite.h"
-#include "Component.h"
 #include "api/Texture.h"
 #include "util/log.h"
-#include <cstdint>
-#include <memory>
-#include <utility>
+
+#include "Component.h"
+#include "Sprite.h"
 
 using namespace std;
 using namespace crepe;
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index 7a701e3..b06125e 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -1,18 +1,21 @@
 #pragma once
 
-#include "Component.h"
-#include "api/Color.h"
-#include "api/Texture.h"
 #include <SDL2/SDL_rect.h>
 #include <cstdint>
 #include <memory>
 
+#include "api/Color.h"
+#include "api/Texture.h"
+
+#include "Component.h"
+
 namespace crepe::api {
 
 struct FlipSettings {
 	bool flip_x = 1;
 	bool flip_y = 1;
 };
+
 class Sprite : public Component {
 
 public:
diff --git a/src/crepe/api/Texture.cpp b/src/crepe/api/Texture.cpp
index c755fa9..7791b5b 100644
--- a/src/crepe/api/Texture.cpp
+++ b/src/crepe/api/Texture.cpp
@@ -1,31 +1,32 @@
+#include <SDL2/SDL_render.h>
 
+#include "util/log.h"
 
 #include "Asset.h"
 #include "SdlContext.h"
-#include "util/log.h"
-
 #include "Texture.h"
-#include <SDL2/SDL_render.h>
 
 using namespace crepe::api;
+using namespace std;
 
-Texture::Texture(std::unique_ptr<Asset> res) {
+Texture::Texture(unique_ptr<Asset> res) {
 	dbg_trace();
 	this->load(std::move(res));
 }
 
 Texture::Texture(const char * src) {
 	dbg_trace();
-	this->load(std::make_unique<Asset>(src));
+	this->load(make_unique<Asset>(src));
 }
 
 Texture::~Texture() {
 	dbg_trace();
-	if (this->m_texture != nullptr) {
-		SDL_DestroyTexture(m_texture);
+	if (this->texture != nullptr) {
+		SDL_DestroyTexture(this->texture);
 	}
 }
-void Texture::load(std::unique_ptr<Asset> res) {
+
+void Texture::load(unique_ptr<Asset> res) {
 	SdlContext & ctx = SdlContext::get_instance();
-	m_texture = ctx.texture_from_path(res->canonical());
+	this->texture = ctx.texture_from_path(res->canonical());
 }
diff --git a/src/crepe/api/Texture.h b/src/crepe/api/Texture.h
index 6d3fb40..993f72b 100644
--- a/src/crepe/api/Texture.h
+++ b/src/crepe/api/Texture.h
@@ -1,9 +1,10 @@
 #pragma once
 
-#include "Asset.h"
 #include <SDL2/SDL_render.h>
 #include <memory>
 
+#include "Asset.h"
+
 namespace crepe {
 class SdlContext;
 }
@@ -21,7 +22,7 @@ private:
 	void load(std::unique_ptr<Asset> res);
 
 private:
-	SDL_Texture * m_texture = nullptr;
+	SDL_Texture * texture = nullptr;
 
 	friend class crepe::SdlContext;
 };
diff --git a/src/crepe/api/Transform.cpp b/src/crepe/api/Transform.cpp
index 4f22843..626cd67 100644
--- a/src/crepe/api/Transform.cpp
+++ b/src/crepe/api/Transform.cpp
@@ -1,10 +1,10 @@
+#include <cstdint>
 
-
-#include "Transform.h"
-#include "Component.h"
 #include "api/Point.h"
 #include "util/log.h"
-#include <cstdint>
+
+#include "Component.h"
+#include "Transform.h"
 
 using namespace crepe::api;
 
diff --git a/src/crepe/api/Transform.h b/src/crepe/api/Transform.h
index c9d46c5..7b74e43 100644
--- a/src/crepe/api/Transform.h
+++ b/src/crepe/api/Transform.h
@@ -1,11 +1,15 @@
 #pragma once
 
-#include "Component.h"
-#include "api/Point.h"
 #include <cstdint>
+
+#include "api/Point.h"
+
+#include "Component.h"
+
 namespace crepe::api {
 
 class Transform : public Component {
+
 public:
 	Transform(uint32_t id, Point &, double, double);
 	~Transform();
@@ -13,4 +17,5 @@ public:
 	double rotation; // Rotation, in radians
 	double scale; // Multiplication factoh
 };
+
 } // namespace crepe::api
diff --git a/src/example/particle.cpp b/src/example/particle.cpp
index 66b1441..943f83b 100644
--- a/src/example/particle.cpp
+++ b/src/example/particle.cpp
@@ -83,7 +83,7 @@ int main(int argc, char * argv[]) {
 			for (const Particle & particle : emitter.particles) {
 				if (particle.active)
 					app.draw_square(particle.position.x, particle.position.y,
-								   5); // draw each particle
+									5); // draw each particle
 			}
 		}
 
-- 
cgit v1.2.3


From 5447ddd896eb49ea9fd9f9191a277fd1d5730aa3 Mon Sep 17 00:00:00 2001
From: Loek Le Blansch <loek@pipeframe.xyz>
Date: Thu, 24 Oct 2024 10:46:32 +0200
Subject: add PR #9 comments as code comments

---
 src/crepe/Asset.cpp               |  3 ++-
 src/crepe/Particle.h              |  2 ++
 src/crepe/SDLApp.cpp              |  4 ++++
 src/crepe/SDLContext.cpp          |  8 ++++++++
 src/crepe/api/Color.cpp           |  1 +
 src/crepe/api/Color.h             |  2 ++
 src/crepe/api/Force.cpp           |  4 ++++
 src/crepe/api/ParticleEmitter.cpp |  8 +++++---
 src/crepe/api/Rigidbody.h         |  1 +
 src/crepe/api/Texture.h           |  3 +++
 src/crepe/api/Transform.h         | 13 +++++++++----
 src/example/asset_manager.cpp     |  8 +++++++-
 src/example/particle.cpp          |  1 +
 13 files changed, 49 insertions(+), 9 deletions(-)

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

diff --git a/src/crepe/Asset.cpp b/src/crepe/Asset.cpp
index 3cbed0b..8a2a11c 100644
--- a/src/crepe/Asset.cpp
+++ b/src/crepe/Asset.cpp
@@ -5,7 +5,8 @@
 using namespace crepe;
 
 Asset::Asset(const std::string & src) {
-	//this->src = std::filesystem::canonical(src);
+	// FIXME: restore this
+	// this->src = std::filesystem::canonical(src);
 	this->src = src;
 	this->file = std::ifstream(this->src, std::ios::in | std::ios::binary);
 }
diff --git a/src/crepe/Particle.h b/src/crepe/Particle.h
index 6f689bd..21e691d 100644
--- a/src/crepe/Particle.h
+++ b/src/crepe/Particle.h
@@ -7,6 +7,8 @@ namespace crepe {
 class Particle {
 public:
 	Position position;
+	// FIXME: `Position` is an awkward name for a 2D vector. See FIXME comment in
+	// api/Transform.h for fix proposal.
 	Position velocity;
 	float lifespan;
 	bool active;
diff --git a/src/crepe/SDLApp.cpp b/src/crepe/SDLApp.cpp
index f408595..c6ddeaa 100644
--- a/src/crepe/SDLApp.cpp
+++ b/src/crepe/SDLApp.cpp
@@ -6,10 +6,12 @@ SDLApp::SDLApp(int window_width, int window_height)
 	: window_width(window_width), window_height(window_height), window(nullptr),
 	  renderer(nullptr) {}
 
+// FIXME: why is there clean_up and ~SDLApp?
 SDLApp::~SDLApp() { clean_up(); }
 
 bool SDLApp::initialize() {
 	if (SDL_Init(SDL_INIT_VIDEO) != 0) {
+		// FIXME: throw exception
 		std::cerr << "SDL Initialization Error: " << SDL_GetError()
 				  << std::endl;
 		return false;
@@ -19,12 +21,14 @@ bool SDLApp::initialize() {
 							  SDL_WINDOWPOS_CENTERED, window_width,
 							  window_height, SDL_WINDOW_SHOWN);
 	if (!window) {
+		// FIXME: throw exception
 		std::cerr << "Window Creation Error: " << SDL_GetError() << std::endl;
 		return false;
 	}
 
 	renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
 	if (!renderer) {
+		// FIXME: throw exception
 		std::cerr << "Renderer Creation Error: " << SDL_GetError() << std::endl;
 		return false;
 	}
diff --git a/src/crepe/SDLContext.cpp b/src/crepe/SDLContext.cpp
index 5a93679..8bc5bc6 100644
--- a/src/crepe/SDLContext.cpp
+++ b/src/crepe/SDLContext.cpp
@@ -40,6 +40,9 @@ SDLContext::~SDLContext() {
 		SDL_DestroyWindow(this->game_window);
 	}
 
+	// TODO: how are we going to ensure that these are called from the same
+	// thread that SDL_Init() was called on? This has caused problems for me
+	// before.
 	IMG_Quit();
 	SDL_Quit();
 }
@@ -48,8 +51,10 @@ void SDLContext::clear_screen() { SDL_RenderClear(this->game_renderer); }
 
 SDLContext::SDLContext() {
 	dbg_trace();
+	// FIXME: read window defaults from config manager
 
 	if (SDL_Init(SDL_INIT_VIDEO) < 0) {
+		// FIXME: throw exception
 		std::cerr << "SDL could not initialize! SDL_Error: " << SDL_GetError()
 				  << std::endl;
 		return;
@@ -59,6 +64,7 @@ SDLContext::SDLContext() {
 		"Crepe Game Engine", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
 		1920, 1080, SDL_WINDOW_SHOWN);
 	if (!this->game_window) {
+		// FIXME: throw exception
 		std::cerr << "Window could not be created! SDL_Error: "
 				  << SDL_GetError() << std::endl;
 	}
@@ -66,6 +72,7 @@ SDLContext::SDLContext() {
 	this->game_renderer
 		= SDL_CreateRenderer(this->game_window, -1, SDL_RENDERER_ACCELERATED);
 	if (!this->game_renderer) {
+		// FIXME: throw exception
 		std::cerr << "Renderer could not be created! SDL_Error: "
 				  << SDL_GetError() << std::endl;
 		SDL_DestroyWindow(this->game_window);
@@ -74,6 +81,7 @@ SDLContext::SDLContext() {
 
 	int img_flags = IMG_INIT_PNG;
 	if (!(IMG_Init(img_flags) & img_flags)) {
+		// FIXME: throw exception
 		std::cout << "SDL_image could not initialize! SDL_image Error: "
 				  << IMG_GetError() << std::endl;
 	}
diff --git a/src/crepe/api/Color.cpp b/src/crepe/api/Color.cpp
index 71592da..fb5bd1a 100644
--- a/src/crepe/api/Color.cpp
+++ b/src/crepe/api/Color.cpp
@@ -11,6 +11,7 @@ Color Color::cyan = Color(0, 255, 255, 0);
 Color Color::yellow = Color(255, 255, 0, 0);
 Color Color::magenta = Color(255, 0, 255, 0);
 
+// FIXME: do we really need double precision for color values?
 Color::Color(double red, double green, double blue, double alpha) {
 	this->a = alpha;
 	this->r = red;
diff --git a/src/crepe/api/Color.h b/src/crepe/api/Color.h
index 207434e..36d91ef 100644
--- a/src/crepe/api/Color.h
+++ b/src/crepe/api/Color.h
@@ -4,6 +4,8 @@ namespace crepe::api {
 
 class Color {
 
+	// FIXME: can't these colors be defined as a `static constexpr const Color`
+	// instead?
 public:
 	Color(double red, double green, double blue, double alpha);
 	static const Color & get_white();
diff --git a/src/crepe/api/Force.cpp b/src/crepe/api/Force.cpp
index 98649c1..e359adc 100644
--- a/src/crepe/api/Force.cpp
+++ b/src/crepe/api/Force.cpp
@@ -6,6 +6,10 @@ namespace crepe::api {
 
 Force::Force(uint32_t game_object_id, uint32_t magnitude, uint32_t direction)
 	: Component(game_object_id) {
+	// TODO: A standard angle unit should be established for the entire engine
+	// and assumed to be the default everywhere. Only conversion functions should
+	// explicitly contain the unit (i.e. `deg_to_rad()` & `rad_to_deg()`)
+
 	// Convert direction from degrees to radians
 	float radian_direction = static_cast<float>(direction) * (M_PI / 180.0f);
 	force_x = static_cast<int32_t>(
diff --git a/src/crepe/api/ParticleEmitter.cpp b/src/crepe/api/ParticleEmitter.cpp
index 2e07562..0b3a9ee 100644
--- a/src/crepe/api/ParticleEmitter.cpp
+++ b/src/crepe/api/ParticleEmitter.cpp
@@ -18,9 +18,11 @@ ParticleEmitter::ParticleEmitter(uint32_t game_object_id,
 	std::srand(
 		static_cast<uint32_t>(std::time(nullptr))); // initialize random seed
 	std::cout << "Create emitter" << std::endl;
-	min_angle = (360 + angle - (angleOffset % 360)) % 360; // calculate minAngle
-	max_angle = (360 + angle + (angleOffset % 360)) % 360; // calculate maxAngle
-	position.x = 400;
+	// FIXME: Why do these expressions start with `360 +`, only to be `% 360`'d
+	// right after? This does not make any sense to me.
+	min_angle = (360 + angle - (angleOffset % 360)) % 360;
+	max_angle = (360 + angle + (angleOffset % 360)) % 360;
+	position.x = 400; // FIXME: what are these magic values?
 	position.y = 400;
 	for (size_t i = 0; i < max_particles; i++) {
 		this->particles.emplace_back();
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index 05cbb03..6079a76 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -6,6 +6,7 @@
 
 namespace crepe::api {
 
+// FIXME: can't this enum be defined inside the class declaration of Rigidbody?
 enum class BodyType {
 	//! Does not move (e.g. walls, ground ...)
 	STATIC,
diff --git a/src/crepe/api/Texture.h b/src/crepe/api/Texture.h
index 7a2c755..f8481e3 100644
--- a/src/crepe/api/Texture.h
+++ b/src/crepe/api/Texture.h
@@ -1,5 +1,8 @@
 #pragma once
 
+// FIXME: this header can't be included because this is an API header, and SDL2
+// development headers won't be bundled with crepe. Why is this facade in the
+// API namespace?
 #include <SDL2/SDL_render.h>
 #include <memory>
 
diff --git a/src/crepe/api/Transform.h b/src/crepe/api/Transform.h
index 7b74e43..c17ae34 100644
--- a/src/crepe/api/Transform.h
+++ b/src/crepe/api/Transform.h
@@ -9,13 +9,18 @@
 namespace crepe::api {
 
 class Transform : public Component {
-
+	// FIXME: What's the difference between the `Point` and `Position`
+	// classes/structs? How about we replace both with a universal `Vec2` that
+	// works similar (or the same) as those found in GLSL?
 public:
 	Transform(uint32_t id, Point &, double, double);
 	~Transform();
-	Point position; // Translation (shift)
-	double rotation; // Rotation, in radians
-	double scale; // Multiplication factoh
+	//! Translation (shift)
+	Point position;
+	//! Rotation, in radians
+	double rotation;
+	//! Multiplication factor
+	double scale;
 };
 
 } // namespace crepe::api
diff --git a/src/example/asset_manager.cpp b/src/example/asset_manager.cpp
index 7aa4ffe..7e15d1f 100644
--- a/src/example/asset_manager.cpp
+++ b/src/example/asset_manager.cpp
@@ -8,12 +8,18 @@ using namespace crepe;
 using namespace crepe::api;
 int main() {
 
-	// this needs to be called before the asset manager otherwise the destructor of sdl is not in the right order
+	// this needs to be called before the asset manager otherwise the destructor
+	// of sdl is not in the right order
 	{ Texture test("../asset/texture/img.png"); }
+	// FIXME: make it so the issue described by the above comment is not possible
+	// (i.e. the order in which internal classes are instantiated should not
+	// impact the way the engine works).
 
 	auto & mgr = AssetManager::get_instance();
 
 	{
+		// TODO: [design] the Sound class can't be directly included by the user as
+		// it includes SoLoud headers.
 		auto bgm = mgr.cache<Sound>("../mwe/audio/bgm.ogg");
 		auto sfx1 = mgr.cache<Sound>("../mwe/audio/sfx1.wav");
 		auto sfx2 = mgr.cache<Sound>("../mwe/audio/sfx2.wav");
diff --git a/src/example/particle.cpp b/src/example/particle.cpp
index 943f83b..53fa213 100644
--- a/src/example/particle.cpp
+++ b/src/example/particle.cpp
@@ -27,6 +27,7 @@ int main(int argc, char * argv[]) {
 	GameObject * game_object[1];
 	game_object[0] = new GameObject(0, "Name", "Tag", 0);
 
+	// FIXME: all systems are singletons, so this shouldn't even compile.
 	ParticleSystem particle_system;
 
 	unsigned int max_particles = 100; // maximum number of particles
-- 
cgit v1.2.3