merge `origin/master` into `master`

75 files changed, 1639 insertions, 276 deletions

diff --git a/src/crepe/Asset.cpp b/src/crepe/Asset.cpp
index 15ddc27..8a2a11c 100644
--- a/src/crepe/Asset.cpp
+++ b/src/crepe/Asset.cpp
@@ -5,7 +5,9 @@
 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/CMakeLists.txt b/src/crepe/CMakeLists.txt
index d85aef0..d938eb8 100644
--- a/src/crepe/CMakeLists.txt
+++ b/src/crepe/CMakeLists.txt
@@ -2,30 +2,35 @@ target_sources(crepe PUBLIC
 	Asset.cpp
 	Sound.cpp
 	SoundContext.cpp
+	Particle.cpp
+	ParticleSystem.cpp
+	SDLApp.cpp
 	ComponentManager.cpp
 	Component.cpp
-	GameObject.cpp
-	Collider.cpp
-	Rigidbody.cpp
-	Sprite.cpp
 	ScriptSystem.cpp
-	Script.cpp
+	PhysicsSystem.cpp
+	CollisionSystem.cpp
+	Collider.cpp
+	SDLContext.cpp
+
+	RenderSystem.cpp
 )
 
 target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	Asset.h
 	Sound.h
 	SoundContext.h
+	SDLContext.h
 	ComponentManager.h
 	ComponentManager.hpp
 	Component.h
-	GameObject.h
-	GameObject.hpp
-	Collider.h
-	Rigidbody.h
-	Sprite.h
 	System.h
 	ScriptSystem.h
+	PhysicsSystem.h
+	CollisionSystem.h
+	Collider.h
+	SDLContext.h
+	RenderSystem.h
 )
 
 add_subdirectory(api)
diff --git a/src/crepe/Collider.cpp b/src/crepe/Collider.cpp
index 3f12afd..13a3f33 100644
--- a/src/crepe/Collider.cpp
+++ b/src/crepe/Collider.cpp
@@ -2,4 +2,4 @@
 
 using namespace crepe;
 
-Collider::Collider(int size) : size(size) {}
+Collider::Collider(uint32_t gameObjectId) : Component(gameObjectId) {}
diff --git a/src/crepe/Collider.h b/src/crepe/Collider.h
index 120da05..68a7d1d 100644
--- a/src/crepe/Collider.h
+++ b/src/crepe/Collider.h
@@ -6,7 +6,7 @@ namespace crepe {
 
 class Collider : public Component {
 public:
-	Collider(int size);
+	Collider(uint32_t game_object_id);
 
 	int size;
 };
diff --git a/src/crepe/CollisionSystem.cpp b/src/crepe/CollisionSystem.cpp
new file mode 100644
index 0000000..55e0fdc
--- /dev/null
+++ b/src/crepe/CollisionSystem.cpp
@@ -0,0 +1,7 @@
+#include "CollisionSystem.h"
+
+using namespace crepe;
+
+CollisionSystem::CollisionSystem() {}
+
+void CollisionSystem::update() {}
diff --git a/src/crepe/CollisionSystem.h b/src/crepe/CollisionSystem.h
new file mode 100644
index 0000000..1e9f1aa
--- /dev/null
+++ b/src/crepe/CollisionSystem.h
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace crepe {
+
+class CollisionSystem {
+public:
+	CollisionSystem();
+	void update();
+};
+
+} // namespace crepe
diff --git a/src/crepe/Component.cpp b/src/crepe/Component.cpp
index d14159c..358ce31 100644
--- a/src/crepe/Component.cpp
+++ b/src/crepe/Component.cpp
@@ -2,4 +2,4 @@
 
 using namespace crepe;
 
-Component::Component() : active(true) {}
+Component::Component(uint32_t id) : game_object_id(id), active(true) {}
diff --git a/src/crepe/Component.h b/src/crepe/Component.h
index 16a4ce5..bc44865 100644
--- a/src/crepe/Component.h
+++ b/src/crepe/Component.h
@@ -1,13 +1,21 @@
 #pragma once
 
+#include <cstdint>
+
 namespace crepe {
 
+class ComponentManager;
+
 class Component {
+protected:
+	friend class crepe::ComponentManager;
+	Component(uint32_t id);
+
 public:
-	Component();
-	// TODO: shouldn't this constructor be deleted because this class will never
-	// directly be instantiated?
+	virtual ~Component() = default;
 
+public:
+	uint32_t game_object_id;
 	bool active;
 };
 
diff --git a/src/crepe/ComponentManager.cpp b/src/crepe/ComponentManager.cpp
index 9a3fec7..8bde33a 100644
--- a/src/crepe/ComponentManager.cpp
+++ b/src/crepe/ComponentManager.cpp
@@ -1,4 +1,5 @@
 #include "ComponentManager.h"
+#include "util/log.h"
 
 using namespace crepe;
 
@@ -20,5 +21,9 @@ void ComponentManager::delete_all_components_of_id(uint32_t id) {
 
 void ComponentManager::delete_all_components() {
 	// Clear the whole unordered_map<>
-	components.clear();
+	this->components.clear();
 }
+
+ComponentManager::ComponentManager() { dbg_trace(); }
+
+ComponentManager::~ComponentManager() { dbg_trace(); }
diff --git a/src/crepe/ComponentManager.h b/src/crepe/ComponentManager.h
index 2ab9dc8..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"
@@ -23,7 +22,7 @@ public:
 public:
 	//! Add a component of a specific type
 	template <typename T, typename... Args>
-	void add_component(uint32_t id, Args &&... args);
+	T & add_component(uint32_t id, Args &&... args);
 	//! Deletes all components of a specific type and id
 	template <typename T>
 	void delete_components_by_id(uint32_t id);
@@ -44,7 +43,8 @@ public:
 	std::vector<std::reference_wrapper<T>> get_components_by_type() const;
 
 private:
-	ComponentManager() = default;
+	ComponentManager();
+	virtual ~ComponentManager();
 
 	/*
 	 * The std::unordered_map<std::type_index, std::vector<std::vector<std::unique_ptr<Component>>>> below might seem a bit strange, let me explain this structure:
diff --git a/src/crepe/ComponentManager.hpp b/src/crepe/ComponentManager.hpp
index 084cd33..9b07f13 100644
--- a/src/crepe/ComponentManager.hpp
+++ b/src/crepe/ComponentManager.hpp
@@ -7,10 +7,11 @@
 namespace crepe {
 
 template <class T, typename... Args>
-void ComponentManager::add_component(uint32_t id, Args &&... args) {
+T & ComponentManager::add_component(uint32_t id, Args &&... args) {
 	using namespace std;
 
-	static_assert(is_base_of<Component, T>::value, "add_component must recieve a derivative class of Component");
+	static_assert(is_base_of<Component, T>::value,
+				  "add_component must recieve a derivative class of Component");
 
 	// Determine the type of T (this is used as the key of the unordered_map<>)
 	type_index type = typeid(T);
@@ -29,9 +30,11 @@ void ComponentManager::add_component(uint32_t id, Args &&... args) {
 
 	// Create a new component of type T (arguments directly forwarded). The
 	// constructor must be called by ComponentManager.
-	T * instance = new T(forward<Args>(args)...);
+	T * instance = new T(id, forward<Args>(args)...);
 	// store its unique_ptr in the vector<>
 	components[type][id].push_back(unique_ptr<T>(instance));
+
+	return *instance;
 }
 
 template <typename T>
@@ -60,11 +63,9 @@ void ComponentManager::delete_components() {
 	// Determine the type of T (this is used as the key of the unordered_map<>)
 	std::type_index type = typeid(T);
 
-	// Find the type (in the unordered_map<>)
-	if (components.find(type) != components.end()) {
-		// Clear the whole vector<> of this specific type
-		components[type].clear();
-	}
+	if (components.find(type) == components.end()) return;
+
+	components[type].clear();
 }
 
 template <typename T>
@@ -78,30 +79,26 @@ ComponentManager::get_components_by_id(uint32_t id) const {
 	// Create an empty vector<>
 	vector<reference_wrapper<T>> component_vector;
 
-	// Find the type (in the unordered_map<>)
-	if (components.find(type) != components.end()) {
-		// Get the correct vector<>
-		const vector<vector<unique_ptr<Component>>> & component_array
-			= components.at(type);
+	if (components.find(type) == components.end()) return component_vector;
 
-		// Make sure that the id (that we are looking for) is within the boundaries of the vector<>
-		if (id < component_array.size()) {
-			// Loop trough the whole vector<>
-			for (const unique_ptr<Component> & component_ptr :
-				 component_array[id]) {
-				// Cast the unique_ptr to a raw pointer
-				T * casted_component = static_cast<T *>(component_ptr.get());
-
-				// Ensure that the cast was successful
-				if (casted_component) {
-					// Add the dereferenced raw pointer to the vector<>
-					component_vector.push_back(*casted_component);
-				}
-			}
-		}
+	// Get the correct vector<>
+	const vector<vector<unique_ptr<Component>>> & component_array
+		= components.at(type);
+
+	// Make sure that the id (that we are looking for) is within the boundaries of the vector<>
+	if (id >= component_array.size()) return component_vector;
+
+	// Loop trough the whole vector<>
+	for (const unique_ptr<Component> & component_ptr : component_array[id]) {
+		// Cast the unique_ptr to a raw pointer
+		T * casted_component = static_cast<T *>(component_ptr.get());
+
+		if (casted_component == nullptr) continue;
+
+		// Add the dereferenced raw pointer to the vector<>
+		component_vector.push_back(*casted_component);
 	}
 
-	// Return the vector<>
 	return component_vector;
 }
 
@@ -119,30 +116,28 @@ ComponentManager::get_components_by_type() const {
 	// uint32_t id = 0;
 
 	// Find the type (in the unordered_map<>)
-	if (components.find(type) != components.end()) {
+	if (components.find(type) == components.end()) return component_vector;
 
-		// Get the correct vector<>
-		const vector<vector<unique_ptr<Component>>> & component_array
-			= components.at(type);
-
-		// Loop through the whole vector<>
-		for (const vector<unique_ptr<Component>> & component :
-			 component_array) {
-			// Loop trough the whole vector<>
-			for (const unique_ptr<Component> & component_ptr : component) {
-				// Cast the unique_ptr to a raw pointer
-				T * casted_component = static_cast<T *>(component_ptr.get());
-
-				// Ensure that the cast was successful
-				if (casted_component) {
-					// Pair the dereferenced raw pointer and the id and add it to the vector<>
-					component_vector.emplace_back(ref(*casted_component));
-				}
-			}
-
-			// Increase the id (the id will also be stored in the returned vector<>)
-			//++id;
+	// Get the correct vector<>
+	const vector<vector<unique_ptr<Component>>> & component_array
+		= components.at(type);
+
+	// Loop through the whole vector<>
+	for (const vector<unique_ptr<Component>> & component : component_array) {
+		// Loop trough the whole vector<>
+		for (const unique_ptr<Component> & component_ptr : component) {
+			// Cast the unique_ptr to a raw pointer
+			T * casted_component = static_cast<T *>(component_ptr.get());
+
+			// Ensure that the cast was successful
+			if (casted_component == nullptr) continue;
+
+			// Pair the dereferenced raw pointer and the id and add it to the vector<>
+			component_vector.emplace_back(ref(*casted_component));
 		}
+
+		// Increase the id (the id will also be stored in the returned vector<>)
+		//++id;
 	}
 
 	// Return the vector<>
diff --git a/src/crepe/GameObject.cpp b/src/crepe/GameObject.cpp
deleted file mode 100644
index de3beb6..0000000
--- a/src/crepe/GameObject.cpp
+++ /dev/null
@@ -1,7 +0,0 @@
-#include "GameObject.h"
-
-using namespace crepe;
-
-GameObject::GameObject(uint32_t id, std::string name, std::string tag,
-					   int layer)
-	: id(id), name(name), tag(tag), active(true), layer(layer) {}
diff --git a/src/crepe/GameObject.hpp b/src/crepe/GameObject.hpp
deleted file mode 100644
index 5966fbf..0000000
--- a/src/crepe/GameObject.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#include "GameObject.h"
-
-#include "ComponentManager.h"
-
-namespace crepe {
-
-template <typename T, typename... Args>
-void GameObject::add_component(Args &&... args) {
-	auto & mgr = ComponentManager::get_instance();
-	mgr.add_component<T>(id, std::forward<Args>(args)...);
-}
-
-} // namespace crepe
diff --git a/src/crepe/Particle.cpp b/src/crepe/Particle.cpp
new file mode 100644
index 0000000..4810e80
--- /dev/null
+++ b/src/crepe/Particle.cpp
@@ -0,0 +1,20 @@
+#include "Particle.h"
+
+using namespace crepe;
+
+Particle::Particle() { this->active = false; }
+
+void Particle::reset(float lifespan, Position position, Position velocity) {
+	this->time_in_life = 0;
+	this->lifespan = lifespan;
+	this->position = position;
+	this->velocity = velocity;
+	this->active = true;
+}
+
+void Particle::update(float deltaTime) {
+	time_in_life += deltaTime;
+	position.x += velocity.x * deltaTime;
+	position.y += velocity.y * deltaTime;
+	if (time_in_life >= lifespan) this->active = false;
+}
diff --git a/src/crepe/Particle.h b/src/crepe/Particle.h
new file mode 100644
index 0000000..21e691d
--- /dev/null
+++ b/src/crepe/Particle.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "Position.h"
+
+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;
+
+	Particle();
+	void reset(float lifespan, Position position, Position velocity);
+	void update(float deltaTime);
+	float time_in_life;
+};
+
+} // namespace crepe
diff --git a/src/crepe/ParticleSystem.cpp b/src/crepe/ParticleSystem.cpp
new file mode 100644
index 0000000..af6c550
--- /dev/null
+++ b/src/crepe/ParticleSystem.cpp
@@ -0,0 +1,62 @@
+#include <cmath>
+#include <ctime>
+
+#include "api/ParticleEmitter.h"
+
+#include "ComponentManager.h"
+#include "ParticleSystem.h"
+
+using namespace crepe;
+
+ParticleSystem::ParticleSystem() : elapsed_time(0.0f) {}
+
+void ParticleSystem::update() {
+	ComponentManager & mgr = ComponentManager::get_instance();
+	std::vector<std::reference_wrapper<ParticleEmitter>> emitters
+		= mgr.get_components_by_type<ParticleEmitter>();
+	float delta_time = 0.10;
+	for (ParticleEmitter & emitter : emitters) {
+		float update_amount = 1 / static_cast<float>(emitter.emission_rate);
+		for (float i = 0; i < delta_time; i += update_amount) {
+			emit_particle(emitter);
+		}
+		for (size_t j = 0; j < emitter.particles.size(); j++) {
+			if (emitter.particles[j].active) {
+				emitter.particles[j].update(delta_time);
+			}
+		}
+	}
+}
+
+void ParticleSystem::emit_particle(ParticleEmitter & emitter) {
+	Position initial_position = {emitter.position.x, emitter.position.y};
+	float random_angle = 0.0f;
+	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.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.speed_offset)
+								- emitter.speed_offset;
+	float velocity_x
+		= (emitter.speed + random_speed_offset) * std::cos(angle_in_radians);
+	float velocity_y
+		= (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.end_lifespan, initial_position,
+									   initial_velocity);
+			break;
+		}
+	}
+}
diff --git a/src/crepe/ParticleSystem.h b/src/crepe/ParticleSystem.h
new file mode 100644
index 0000000..ad96eb0
--- /dev/null
+++ b/src/crepe/ParticleSystem.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "api/ParticleEmitter.h"
+
+namespace crepe {
+
+class ParticleSystem {
+public:
+	ParticleSystem();
+	void update();
+
+private:
+	void emit_particle(ParticleEmitter & emitter); //emits a new particle
+
+	float elapsed_time; //elapsed time since the last emission
+};
+
+} // namespace crepe
diff --git a/src/crepe/PhysicsSystem.cpp b/src/crepe/PhysicsSystem.cpp
new file mode 100644
index 0000000..16f4c10
--- /dev/null
+++ b/src/crepe/PhysicsSystem.cpp
@@ -0,0 +1,62 @@
+#include <iostream>
+
+#include "api/Force.h"
+#include "api/Rigidbody.h"
+#include "api/Transform.h"
+
+#include "ComponentManager.h"
+#include "PhysicsSystem.h"
+
+using namespace crepe;
+using namespace crepe::api;
+
+PhysicsSystem::PhysicsSystem() {}
+
+void PhysicsSystem::update() {
+	ComponentManager & mgr = ComponentManager::get_instance();
+	std::vector<std::reference_wrapper<Rigidbody>> rigidbodies
+		= mgr.get_components_by_type<Rigidbody>();
+	std::vector<std::reference_wrapper<Transform>> transforms
+		= mgr.get_components_by_type<Transform>();
+
+	for (Rigidbody & rigidbody : rigidbodies) {
+
+		switch (rigidbody.body_type) {
+			case BodyType::DYNAMIC:
+				for (Transform & transform : transforms) {
+					if (transform.game_object_id == rigidbody.game_object_id) {
+						rigidbody.velocity_x = 0;
+						rigidbody.velocity_y = 0;
+						std::vector<std::reference_wrapper<Force>> forces
+							= mgr.get_components_by_id<Force>(
+								rigidbody.game_object_id);
+						rigidbody.velocity_y
+							+= rigidbody.gravity_scale * 1 * rigidbody.mass;
+
+						for (Force & force : forces) {
+							rigidbody.velocity_x += force.force_x;
+							rigidbody.velocity_y += force.force_y;
+						}
+
+						std::cout << "before transform.postion.x "
+								  << transform.position.x << std::endl;
+						std::cout << "before transform.postion.y "
+								  << transform.position.y << std::endl;
+						transform.position.x += rigidbody.velocity_x;
+						transform.position.y += rigidbody.velocity_y;
+						std::cout << "after transform.postion.x "
+								  << transform.position.x << std::endl;
+						std::cout << "after transform.postion.y "
+								  << transform.position.y << std::endl;
+					}
+				}
+				break;
+			case BodyType::KINEMATIC:
+				break; //(scripts)
+			case BodyType::STATIC:
+				break; //(unmoveable objects)
+			default:
+				break;
+		}
+	}
+}
diff --git a/src/crepe/PhysicsSystem.h b/src/crepe/PhysicsSystem.h
new file mode 100644
index 0000000..33b4072
--- /dev/null
+++ b/src/crepe/PhysicsSystem.h
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace crepe {
+
+class PhysicsSystem {
+public:
+	PhysicsSystem();
+	void update();
+};
+
+} // namespace crepe
diff --git a/src/crepe/Position.h b/src/crepe/Position.h
new file mode 100644
index 0000000..f84b63d
--- /dev/null
+++ b/src/crepe/Position.h
@@ -0,0 +1,10 @@
+#pragma once
+
+namespace crepe {
+
+struct Position {
+	float x = 0.0;
+	float y = 0.0;
+};
+
+} // namespace crepe
diff --git a/src/crepe/RenderSystem.cpp b/src/crepe/RenderSystem.cpp
new file mode 100644
index 0000000..fae93f0
--- /dev/null
+++ b/src/crepe/RenderSystem.cpp
@@ -0,0 +1,42 @@
+#include <functional>
+#include <vector>
+
+#include "api/Sprite.h"
+#include "api/Transform.h"
+#include "util/log.h"
+
+#include "ComponentManager.h"
+#include "RenderSystem.h"
+#include "SDLContext.h"
+
+using namespace crepe;
+using namespace crepe::api;
+
+RenderSystem::RenderSystem() { dbg_trace(); }
+
+RenderSystem::~RenderSystem() { dbg_trace(); }
+
+RenderSystem & RenderSystem::get_instance() {
+	static RenderSystem instance;
+	return instance;
+}
+
+void RenderSystem::update() {
+
+	ComponentManager & mgr = ComponentManager::get_instance();
+
+	std::vector<std::reference_wrapper<Sprite>> sprites
+		= mgr.get_components_by_type<Sprite>();
+
+	SDLContext & render = SDLContext::get_instance();
+	render.clear_screen();
+
+	for (const Sprite & sprite : sprites) {
+		std::vector<std::reference_wrapper<Transform>> transforms
+			= mgr.get_components_by_id<Transform>(sprite.game_object_id);
+		for (const Transform & transform : transforms) {
+			render.draw(sprite, transform);
+		}
+	}
+	render.present_screen();
+}
diff --git a/src/crepe/RenderSystem.h b/src/crepe/RenderSystem.h
new file mode 100644
index 0000000..4b910a4
--- /dev/null
+++ b/src/crepe/RenderSystem.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "System.h"
+
+namespace crepe {
+
+class RenderSystem : public System {
+
+public:
+	static RenderSystem & get_instance();
+	void update();
+
+private:
+	RenderSystem();
+	~RenderSystem();
+};
+} // namespace crepe
diff --git a/src/crepe/Rigidbody.cpp b/src/crepe/Rigidbody.cpp
deleted file mode 100644
index 495d908..0000000
--- a/src/crepe/Rigidbody.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "Rigidbody.h"
-
-using namespace crepe;
-
-Rigidbody::Rigidbody(int mass, int gravityScale, int bodyType)
-	: mass(mass), gravity_scale(gravityScale), body_type(bodyType) {}
diff --git a/src/crepe/Rigidbody.h b/src/crepe/Rigidbody.h
deleted file mode 100644
index 63a8877..0000000
--- a/src/crepe/Rigidbody.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-#include "Component.h"
-
-namespace crepe {
-
-class Rigidbody : public Component {
-public:
-	Rigidbody(int mass, int gravityScale, int bodyType);
-
-	int mass;
-	int gravity_scale;
-	int body_type;
-};
-
-} // namespace crepe
diff --git a/src/crepe/SDLApp.cpp b/src/crepe/SDLApp.cpp
new file mode 100644
index 0000000..c6ddeaa
--- /dev/null
+++ b/src/crepe/SDLApp.cpp
@@ -0,0 +1,71 @@
+#include <iostream>
+
+#include "SDLApp.h"
+
+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;
+	}
+
+	window = SDL_CreateWindow("Particle System", SDL_WINDOWPOS_CENTERED,
+							  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;
+	}
+
+	return true;
+}
+
+void SDLApp::handle_events(bool & running) {
+	SDL_Event event;
+	while (SDL_PollEvent(&event)) {
+		if (event.type == SDL_QUIT) {
+			running = false;
+		}
+	}
+}
+
+void SDLApp::clear_screen() {
+	SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
+	SDL_RenderClear(renderer);
+}
+
+void SDLApp::present_screen() { SDL_RenderPresent(renderer); }
+
+void SDLApp::draw_square(int x, int y, int size) {
+	SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
+	SDL_Rect rect = {x, y, size, size};
+	SDL_RenderFillRect(renderer, &rect);
+}
+
+SDL_Texture * square_texture = nullptr; // Load this with an image or create it
+
+void SDLApp::clean_up() {
+	if (renderer) {
+		SDL_DestroyRenderer(renderer);
+	}
+	if (window) {
+		SDL_DestroyWindow(window);
+	}
+	SDL_Quit();
+}
diff --git a/src/crepe/SDLApp.h b/src/crepe/SDLApp.h
new file mode 100644
index 0000000..e67947b
--- /dev/null
+++ b/src/crepe/SDLApp.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <SDL2/SDL.h>
+
+#include "api/ParticleEmitter.h"
+
+class SDLApp {
+public:
+	SDLApp(int window_width, int window_height);
+	~SDLApp();
+
+	bool initialize();
+	void handle_events(bool & running);
+	void clear_screen();
+	void present_screen();
+	void draw_square(int x, int y, int size);
+	void clean_up();
+	void draw_particles(const std::vector<crepe::ParticleEmitter> & emitters);
+	void draw_multiple_squares(const std::vector<SDL_Rect> & squares);
+
+private:
+	int window_width;
+	int window_height;
+	SDL_Window * window;
+	SDL_Renderer * renderer;
+};
diff --git a/src/crepe/SDLContext.cpp b/src/crepe/SDLContext.cpp
new file mode 100644
index 0000000..8bc5bc6
--- /dev/null
+++ b/src/crepe/SDLContext.cpp
@@ -0,0 +1,158 @@
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_image.h>
+#include <SDL2/SDL_render.h>
+#include <SDL2/SDL_surface.h>
+#include <SDL2/SDL_video.h>
+#include <cmath>
+#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() {
+	static SDLContext instance;
+	return instance;
+}
+
+void SDLContext::handle_events(bool & running) {
+	SDL_Event event;
+	while (SDL_PollEvent(&event)) {
+		if (event.type == SDL_QUIT) {
+			running = false;
+		}
+	}
+}
+
+SDLContext::~SDLContext() {
+	dbg_trace();
+
+	if (this->game_renderer != nullptr)
+		SDL_DestroyRenderer(this->game_renderer);
+
+	if (this->game_window != nullptr) {
+		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();
+}
+
+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;
+	}
+
+	this->game_window = SDL_CreateWindow(
+		"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;
+	}
+
+	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);
+		return;
+	}
+
+	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;
+	}
+}
+
+void SDLContext::present_screen() { SDL_RenderPresent(this->game_renderer); }
+
+void SDLContext::draw(const api::Sprite & sprite,
+					  const api::Transform & transform) {
+
+	static SDL_RendererFlip render_flip
+		= (SDL_RendererFlip) ((SDL_FLIP_HORIZONTAL * sprite.flip.flip_x)
+							  | (SDL_FLIP_VERTICAL * sprite.flip.flip_y));
+
+	int 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),
+		.y = static_cast<int>(transform.position.y),
+		.w = static_cast<int>(w * transform.scale),
+		.h = static_cast<int>(h * transform.scale),
+	};
+
+	double degrees = transform.rotation * 180 / M_PI;
+	SDL_RenderCopyEx(this->game_renderer, sprite.sprite_image->texture, NULL,
+					 &dstrect, degrees, NULL, render_flip);
+}
+
+/*
+SDL_Texture * SDLContext::setTextureFromPath(const char * path, SDL_Rect & clip,
+											 const int row, const int col) {
+	dbg_trace();
+
+	SDL_Surface * tmp = IMG_Load(path);
+	if (!tmp) {
+		std::cerr << "Error surface " << IMG_GetError << std::endl;
+	}
+
+	clip.
+		w = tmp->w / col;
+	clip.h = tmp->h / row;
+
+	SDL_Texture * CreatedTexture
+		= SDL_CreateTextureFromSurface(this->game_renderer, tmp);
+
+	if (!CreatedTexture) {
+		std::cerr << "Error could not create texture " << IMG_GetError
+				  << std::endl;
+	}
+	SDL_FreeSurface(tmp);
+
+	return CreatedTexture;
+}
+*/
+
+SDL_Texture * SDLContext::texture_from_path(const char * path) {
+	dbg_trace();
+
+	SDL_Surface * tmp = IMG_Load(path);
+	if (!tmp) {
+		std::cerr << "Error surface " << IMG_GetError << std::endl;
+	}
+	SDL_Texture * created_texture
+		= SDL_CreateTextureFromSurface(this->game_renderer, tmp);
+
+	if (!created_texture) {
+		std::cerr << "Error could not create texture " << IMG_GetError
+				  << std::endl;
+	}
+	SDL_FreeSurface(tmp);
+
+	return created_texture;
+}
diff --git a/src/crepe/SDLContext.h b/src/crepe/SDLContext.h
new file mode 100644
index 0000000..4d9c1bc
--- /dev/null
+++ b/src/crepe/SDLContext.h
@@ -0,0 +1,52 @@
+#pragma once
+
+#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;
+}
+
+namespace crepe {
+
+class SDLContext {
+
+public:
+	// singleton
+	static SDLContext & get_instance();
+	SDLContext(const SDLContext &) = delete;
+	SDLContext(SDLContext &&) = delete;
+	SDLContext & operator=(const SDLContext &) = delete;
+	SDLContext & operator=(SDLContext &&) = delete;
+
+	//TODO decide events wouter?
+
+private:
+	void handle_events(bool & running);
+
+private:
+	SDLContext();
+	virtual ~SDLContext();
+
+private:
+	friend class api::Texture;
+	SDL_Texture * texture_from_path(const char *);
+	//SDL_Texture* setTextureFromPath(const char*, SDL_Rect& clip, const int row, const int col);
+
+private:
+	friend class RenderSystem;
+	void draw(const api::Sprite &, const api::Transform &);
+	void clear_screen();
+	void present_screen();
+
+private:
+	SDL_Window * game_window = nullptr;
+	SDL_Renderer * game_renderer = nullptr;
+};
+
+} // namespace crepe
diff --git a/src/crepe/Script.cpp b/src/crepe/Script.cpp
deleted file mode 100644
index 42e3666..0000000
--- a/src/crepe/Script.cpp
+++ /dev/null
@@ -1,7 +0,0 @@
-#include "Script.h"
-
-using namespace crepe;
-
-void Script::init() { }
-void Script::update() { }
-
diff --git a/src/crepe/Script.h b/src/crepe/Script.h
deleted file mode 100644
index ba4073a..0000000
--- a/src/crepe/Script.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-namespace crepe {
-
-class Script {
-protected:
-	virtual void init();
-	virtual void update();
-	// NOTE: additional *events* (like unity's OnDisable and OnEnable) should be
-	// implemented as member methods in derivative user script classes and
-	// registered in init(), otherwise this class will balloon in size with each
-	// added event.
-};
-
-}
-
diff --git a/src/crepe/ScriptSystem.cpp b/src/crepe/ScriptSystem.cpp
index e301c71..171b490 100644
--- a/src/crepe/ScriptSystem.cpp
+++ b/src/crepe/ScriptSystem.cpp
@@ -1,15 +1,20 @@
+#include <forward_list>
+#include <functional>
+#include <vector>
+
+#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;
 
-ScriptSystem::ScriptSystem() {
-	dbg_trace();
-}
-ScriptSystem::~ScriptSystem() {
-	dbg_trace();
-}
+ScriptSystem::ScriptSystem() { dbg_trace(); }
+ScriptSystem::~ScriptSystem() { dbg_trace(); }
 
 ScriptSystem & ScriptSystem::get_instance() {
 	static ScriptSystem instance;
@@ -17,6 +22,26 @@ ScriptSystem & ScriptSystem::get_instance() {
 }
 
 void ScriptSystem::update() {
+	using namespace std;
 	dbg_trace();
+
+	forward_list<Script *> scripts = this->get_scripts();
+	for (Script * script : scripts) script->update();
 }
 
+forward_list<Script *> ScriptSystem::get_scripts() {
+	forward_list<Script *> scripts = {};
+	ComponentManager & mgr = ComponentManager::get_instance();
+	vector<reference_wrapper<BehaviorScript>> behavior_scripts
+		= mgr.get_components_by_type<BehaviorScript>();
+
+	for (auto behavior_script_ref : behavior_scripts) {
+		BehaviorScript & behavior_script = behavior_script_ref.get();
+		if (!behavior_script.active) continue;
+		Script * script = behavior_script.script.get();
+		if (script == nullptr) continue;
+		scripts.push_front(script);
+	}
+
+	return scripts;
+}
diff --git a/src/crepe/ScriptSystem.h b/src/crepe/ScriptSystem.h
index e1ed290..1f472a0 100644
--- a/src/crepe/ScriptSystem.h
+++ b/src/crepe/ScriptSystem.h
@@ -1,18 +1,26 @@
 #pragma once
 
+#include <forward_list>
+
 #include "System.h"
 
+namespace crepe::api {
+class Script;
+}
+
 namespace crepe {
 
 class ScriptSystem : public System {
 public:
 	static ScriptSystem & get_instance();
-	virtual void update();
+	void update();
 
 private:
 	ScriptSystem();
 	~ScriptSystem();
-};
 
-}
+private:
+	std::forward_list<api::Script *> get_scripts();
+};
 
+} // 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/Sprite.cpp b/src/crepe/Sprite.cpp
deleted file mode 100644
index a5a5e68..0000000
--- a/src/crepe/Sprite.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <string>
-
-#include "Sprite.h"
-
-using namespace crepe;
-using namespace std;
-
-Sprite::Sprite(string path) : path(path) {}
diff --git a/src/crepe/Sprite.h b/src/crepe/Sprite.h
deleted file mode 100644
index 143e702..0000000
--- a/src/crepe/Sprite.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "Component.h"
-
-namespace crepe {
-
-class Sprite : public Component {
-public:
-	Sprite(std::string path);
-
-	std::string path;
-};
-
-} // namespace crepe
diff --git a/src/crepe/System.h b/src/crepe/System.h
index 3fe3d66..ecbb7f5 100644
--- a/src/crepe/System.h
+++ b/src/crepe/System.h
@@ -8,8 +8,8 @@ public:
 	virtual void update() = 0;
 
 protected:
-	System() { };
-	virtual ~System() { };
+	System() {};
+	virtual ~System() {};
 
 private:
 	// singleton
@@ -19,5 +19,4 @@ private:
 	System & operator=(System &&) = delete;
 };
 
-}
-
+} // namespace crepe
diff --git a/src/crepe/api/AssetManager.cpp b/src/crepe/api/AssetManager.cpp
new file mode 100644
index 0000000..560df6c
--- /dev/null
+++ b/src/crepe/api/AssetManager.cpp
@@ -0,0 +1,17 @@
+#include "util/log.h"
+
+#include "AssetManager.h"
+
+using namespace crepe::api;
+
+AssetManager & AssetManager::get_instance() {
+	static AssetManager instance;
+	return instance;
+}
+
+AssetManager::~AssetManager() {
+	dbg_trace();
+	this->asset_cache.clear();
+}
+
+AssetManager::AssetManager() { dbg_trace(); }
diff --git a/src/crepe/api/AssetManager.h b/src/crepe/api/AssetManager.h
new file mode 100644
index 0000000..3e72a49
--- /dev/null
+++ b/src/crepe/api/AssetManager.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <any>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace crepe::api {
+
+class AssetManager {
+
+private:
+	std::unordered_map<std::string, std::any> asset_cache;
+
+private:
+	AssetManager();
+	virtual ~AssetManager();
+
+public:
+	AssetManager(const AssetManager &) = delete;
+	AssetManager(AssetManager &&) = delete;
+	AssetManager & operator=(const AssetManager &) = delete;
+	AssetManager & operator=(AssetManager &&) = delete;
+
+	static AssetManager & get_instance();
+
+public:
+	template <typename asset>
+	std::shared_ptr<asset> cache(const std::string & file_path,
+								 bool reload = false);
+};
+
+} // namespace crepe::api
+
+#include "AssetManager.hpp"
diff --git a/src/crepe/api/AssetManager.hpp b/src/crepe/api/AssetManager.hpp
new file mode 100644
index 0000000..468724c
--- /dev/null
+++ b/src/crepe/api/AssetManager.hpp
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "AssetManager.h"
+
+namespace crepe::api {
+
+template <typename asset>
+std::shared_ptr<asset> AssetManager::cache(const std::string & file_path,
+										   bool reload) {
+	auto it = asset_cache.find(file_path);
+
+	if (!reload && it != asset_cache.end()) {
+		return std::any_cast<std::shared_ptr<asset>>(it->second);
+	}
+
+	std::shared_ptr<asset> new_asset
+		= std::make_shared<asset>(file_path.c_str());
+
+	asset_cache[file_path] = new_asset;
+
+	return new_asset;
+}
+
+} // namespace crepe::api
diff --git a/src/crepe/api/AudioSource.cpp b/src/crepe/api/AudioSource.cpp
index b512d27..35b8d83 100644
--- a/src/crepe/api/AudioSource.cpp
+++ b/src/crepe/api/AudioSource.cpp
@@ -1,7 +1,8 @@
-#include "AudioSource.h"
+#include <memory>
 
 #include "../Sound.h"
-#include <memory>
+
+#include "AudioSource.h"
 
 using namespace crepe::api;
 
diff --git a/src/crepe/api/AudioSource.h b/src/crepe/api/AudioSource.h
index 2d26cda..7980212 100644
--- a/src/crepe/api/AudioSource.h
+++ b/src/crepe/api/AudioSource.h
@@ -2,8 +2,8 @@
 
 #include <memory>
 
-#include "Asset.h"
-#include "Component.h"
+#include "../Asset.h"
+#include "../Component.h"
 
 namespace crepe {
 class Sound;
diff --git a/src/crepe/api/BehaviorScript.cpp b/src/crepe/api/BehaviorScript.cpp
index 2dd933e..e69de29 100644
--- a/src/crepe/api/BehaviorScript.cpp
+++ b/src/crepe/api/BehaviorScript.cpp
@@ -1,10 +0,0 @@
-#include "../util/log.h"
-
-#include "BehaviorScript.h"
-
-using namespace crepe::api;
-
-BehaviorScript::BehaviorScript() {
-	dbg_trace();
-}
-
diff --git a/src/crepe/api/BehaviorScript.h b/src/crepe/api/BehaviorScript.h
index e9542c1..6133cc8 100644
--- a/src/crepe/api/BehaviorScript.h
+++ b/src/crepe/api/BehaviorScript.h
@@ -1,17 +1,35 @@
 #pragma once
 
-#include "../Script.h"
+#include <memory>
+
 #include "../Component.h"
 
+namespace crepe {
+class ScriptSystem;
+class ComponentManager;
+} // namespace crepe
+
 namespace crepe::api {
 
-class BehaviorScript : public Script, public Component {
-	// only allow ComponentManager to instantiate scripts
-	friend class ComponentManager;
+class Script;
+
+class BehaviorScript : public Component {
+protected:
+	friend class crepe::ComponentManager;
+	using Component::Component;
+
+public:
+	virtual ~BehaviorScript() = default;
+
+public:
+	template <class T>
+	BehaviorScript & set_script();
 
 protected:
-	BehaviorScript();
+	friend class crepe::ScriptSystem;
+	std::unique_ptr<Script> script = nullptr;
 };
 
-}
+} // namespace crepe::api
 
+#include "BehaviorScript.hpp"
diff --git a/src/crepe/api/BehaviorScript.hpp b/src/crepe/api/BehaviorScript.hpp
new file mode 100644
index 0000000..2a3502f
--- /dev/null
+++ b/src/crepe/api/BehaviorScript.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <type_traits>
+
+#include "../util/log.h"
+
+#include "BehaviorScript.h"
+#include "Script.h"
+
+namespace crepe::api {
+
+template <class T>
+BehaviorScript & BehaviorScript::set_script() {
+	static_assert(std::is_base_of<Script, T>::value);
+	dbg_trace();
+	Script * s = new T();
+	s->parent = this;
+	this->script = std::unique_ptr<Script>(s);
+	return *this;
+}
+
+} // namespace crepe::api
diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt
index 86623de..0bb1263 100644
--- a/src/crepe/api/CMakeLists.txt
+++ b/src/crepe/api/CMakeLists.txt
@@ -1,10 +1,31 @@
 target_sources(crepe PUBLIC
 	# AudioSource.cpp
 	BehaviorScript.cpp
+	Script.cpp
+	GameObject.cpp
+	Rigidbody.cpp
+	Force.cpp
+	ParticleEmitter.cpp
+	Transform.cpp
+	Color.cpp
+	Texture.cpp
+	AssetManager.cpp
+	Sprite.cpp
 )
 
 target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	# AudioSource.h
 	BehaviorScript.h
+	Config.h
+	Script.h
+	Script.hpp
+	GameObject.h
+	GameObject.hpp
+	Rigidbody.h
+	Sprite.h
+	Point.h
+	Color.h
+	Texture.h 
+	AssetManager.h 
+	AssetManager.hpp
 )
-
diff --git a/src/crepe/api/CircleCollider.h b/src/crepe/api/CircleCollider.h
new file mode 100644
index 0000000..762574b
--- /dev/null
+++ b/src/crepe/api/CircleCollider.h
@@ -0,0 +1,13 @@
+#pragma once
+#include "../Collider.h"
+
+namespace crepe::api {
+
+class CircleCollider : public Collider {
+public:
+	CircleCollider(uint32_t game_object_id, int radius)
+		: Collider(game_object_id), radius(radius) {}
+	int radius;
+};
+
+} // namespace crepe::api
diff --git a/src/crepe/api/Color.cpp b/src/crepe/api/Color.cpp
new file mode 100644
index 0000000..fb5bd1a
--- /dev/null
+++ b/src/crepe/api/Color.cpp
@@ -0,0 +1,34 @@
+#include "Color.h"
+
+using namespace crepe::api;
+
+Color Color::white = Color(255, 255, 255, 0);
+Color Color::red = Color(255, 0, 0, 0);
+Color Color::green = Color(0, 255, 0, 0);
+Color Color::blue = Color(0, 0, 255, 0);
+Color Color::black = Color(0, 0, 0, 0);
+Color Color::cyan = Color(0, 255, 255, 0);
+Color Color::yellow = Color(255, 255, 0, 0);
+Color Color::magenta = Color(255, 0, 255, 0);
+
+// 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;
+	this->g = green;
+	this->b = blue;
+};
+
+const Color & Color::get_white() { return Color::white; };
+
+const Color & Color::get_red() { return Color::red; };
+const Color & Color::get_green() { return Color::green; };
+const Color & Color::get_blue() { return Color::blue; };
+
+const Color & Color::get_black() { return Color::black; };
+
+const Color & Color::get_cyan() { return Color::cyan; };
+
+const Color & Color::get_yellow() { return Color::yellow; };
+
+const Color & Color::get_magenta() { return Color::magenta; };
diff --git a/src/crepe/api/Color.h b/src/crepe/api/Color.h
new file mode 100644
index 0000000..e818de4
--- /dev/null
+++ b/src/crepe/api/Color.h
@@ -0,0 +1,37 @@
+#pragma once
+
+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();
+	static const Color & get_red();
+	static const Color & get_green();
+	static const Color & get_blue();
+	static const Color & get_cyan();
+	static const Color & get_magenta();
+	static const Color & get_yellow();
+	static const Color & get_black();
+
+private:
+	double r;
+	double g;
+	double b;
+	double a;
+
+	static Color white;
+	static Color red;
+	static Color green;
+	static Color blue;
+	static Color cyan;
+	static Color magenta;
+	static Color yellow;
+	static Color black;
+};
+
+} // namespace crepe::api
diff --git a/src/crepe/api/Config.h b/src/crepe/api/Config.h
new file mode 100644
index 0000000..8a7f268
--- /dev/null
+++ b/src/crepe/api/Config.h
@@ -0,0 +1,40 @@
+#pragma once
+
+#include "../util/log.h"
+
+namespace crepe::api {
+
+class Config {
+private:
+	Config() = default;
+
+public:
+	~Config() = default;
+
+public:
+	//! Retrieve handle to global Config instance
+	static Config & get_instance() {
+		static Config instance;
+		return instance;
+	}
+
+public:
+	//! Logging-related settings
+	struct {
+		/**
+		 * \brief Log level
+		 *
+		 * Only messages with equal or higher priority than this value will be
+		 * logged.
+		 */
+		util::LogLevel level = util::LogLevel::INFO;
+		/**
+		 * \brief Colored log output
+		 *
+		 * Enables log coloring using ANSI escape codes.
+		 */
+		bool color = true;
+	} log;
+};
+
+} // namespace crepe::api
diff --git a/src/crepe/api/Force.cpp b/src/crepe/api/Force.cpp
new file mode 100644
index 0000000..e359adc
--- /dev/null
+++ b/src/crepe/api/Force.cpp
@@ -0,0 +1,21 @@
+#include <cmath>
+
+#include "Force.h"
+
+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>(
+		std::round(magnitude * std::cos(radian_direction)));
+	force_y = static_cast<int32_t>(
+		std::round(magnitude * std::sin(radian_direction)));
+}
+
+} // namespace crepe::api
diff --git a/src/crepe/api/Force.h b/src/crepe/api/Force.h
new file mode 100644
index 0000000..8da9a00
--- /dev/null
+++ b/src/crepe/api/Force.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <cstdint>
+
+#include "../Component.h"
+
+namespace crepe::api {
+
+class Force : public Component {
+public:
+	Force(uint32_t game_object_id, uint32_t magnitude, uint32_t direction);
+
+	int32_t force_x;
+	int32_t force_y;
+};
+
+} // namespace crepe::api
diff --git a/src/crepe/api/GameObject.cpp b/src/crepe/api/GameObject.cpp
new file mode 100644
index 0000000..b167187
--- /dev/null
+++ b/src/crepe/api/GameObject.cpp
@@ -0,0 +1,7 @@
+#include "GameObject.h"
+
+using namespace crepe::api;
+using namespace std;
+
+GameObject::GameObject(uint32_t id, string name, string tag, int layer)
+	: id(id), name(name), tag(tag), active(true), layer(layer) {}
diff --git a/src/crepe/GameObject.h b/src/crepe/api/GameObject.h
index 3588d9a..57508c5 100644
--- a/src/crepe/GameObject.h
+++ b/src/crepe/api/GameObject.h
@@ -3,14 +3,14 @@
 #include <cstdint>
 #include <string>
 
-namespace crepe {
+namespace crepe::api {
 
 class GameObject {
 public:
 	GameObject(uint32_t id, std::string name, std::string tag, int layer);
 
 	template <typename T, typename... Args>
-	void add_component(Args &&... args);
+	T & add_component(Args &&... args);
 
 	uint32_t id;
 	std::string name;
@@ -19,6 +19,6 @@ public:
 	int layer;
 };
 
-} // namespace crepe
+} // namespace crepe::api
 
 #include "GameObject.hpp"
diff --git a/src/crepe/api/GameObject.hpp b/src/crepe/api/GameObject.hpp
new file mode 100644
index 0000000..3c7e867
--- /dev/null
+++ b/src/crepe/api/GameObject.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "../ComponentManager.h"
+
+#include "GameObject.h"
+
+namespace crepe::api {
+
+template <typename T, typename... Args>
+T & GameObject::add_component(Args &&... args) {
+	auto & mgr = ComponentManager::get_instance();
+	return mgr.add_component<T>(this->id, std::forward<Args>(args)...);
+}
+
+} // namespace crepe::api
diff --git a/src/crepe/api/ParticleEmitter.cpp b/src/crepe/api/ParticleEmitter.cpp
new file mode 100644
index 0000000..0b3a9ee
--- /dev/null
+++ b/src/crepe/api/ParticleEmitter.cpp
@@ -0,0 +1,37 @@
+#include <ctime>
+#include <iostream>
+
+#include "Particle.h"
+#include "ParticleEmitter.h"
+
+using namespace crepe;
+
+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;
+	// 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();
+	}
+}
+
+ParticleEmitter::~ParticleEmitter() {
+	std::vector<Particle>::iterator it = this->particles.begin();
+	while (it != this->particles.end()) {
+		it = this->particles.erase(it);
+	}
+}
diff --git a/src/crepe/api/ParticleEmitter.h b/src/crepe/api/ParticleEmitter.h
new file mode 100644
index 0000000..2e2e95b
--- /dev/null
+++ b/src/crepe/api/ParticleEmitter.h
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include "Component.h"
+#include "Particle.h"
+
+namespace crepe {
+
+class ParticleEmitter : public Component {
+public:
+	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 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;
+
+	//! collection of particles
+	std::vector<Particle> particles;
+};
+
+} // namespace crepe
diff --git a/src/crepe/api/Point.h b/src/crepe/api/Point.h
new file mode 100644
index 0000000..b47b7e6
--- /dev/null
+++ b/src/crepe/api/Point.h
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace crepe::api {
+
+class Point {
+public:
+	double x;
+	double y;
+};
+
+} // namespace crepe::api
diff --git a/src/crepe/api/Rigidbody.cpp b/src/crepe/api/Rigidbody.cpp
new file mode 100644
index 0000000..ebf9fb9
--- /dev/null
+++ b/src/crepe/api/Rigidbody.cpp
@@ -0,0 +1,8 @@
+#include "Rigidbody.h"
+
+using namespace crepe::api;
+
+Rigidbody::Rigidbody(uint32_t game_object_id, int mass, int gravity_scale,
+					 BodyType bodyType)
+	: 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
new file mode 100644
index 0000000..6079a76
--- /dev/null
+++ b/src/crepe/api/Rigidbody.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <cstdint>
+
+#include "../Component.h"
+
+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,
+	//! 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 game_object_id, int mass, int gravity_scale,
+			  BodyType body_type);
+	int32_t velocity_x;
+	int32_t velocity_y;
+	int mass;
+	int gravity_scale;
+	BodyType body_type;
+};
+
+} // namespace crepe::api
diff --git a/src/crepe/api/Script.cpp b/src/crepe/api/Script.cpp
new file mode 100644
index 0000000..5016ed0
--- /dev/null
+++ b/src/crepe/api/Script.cpp
@@ -0,0 +1,3 @@
+#include "Script.h"
+
+using namespace crepe::api;
diff --git a/src/crepe/api/Script.h b/src/crepe/api/Script.h
new file mode 100644
index 0000000..59e6ec0
--- /dev/null
+++ b/src/crepe/api/Script.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <vector>
+
+namespace crepe {
+class ScriptSystem;
+}
+
+namespace crepe::api {
+
+class BehaviorScript;
+
+class Script {
+	friend class crepe::ScriptSystem;
+
+protected:
+	virtual void init() {}
+	virtual void update() {}
+	// NOTE: additional *events* (like unity's OnDisable and OnEnable) should be
+	// implemented as member methods in derivative user script classes and
+	// registered in init(), otherwise this class will balloon in size with each
+	// added event.
+
+protected:
+	template <typename T>
+	T & get_component();
+
+	template <typename T>
+	std::vector<std::reference_wrapper<T>> get_components();
+
+private:
+	friend class crepe::api::BehaviorScript;
+	BehaviorScript * parent = nullptr;
+};
+
+} // namespace crepe::api
+
+#include "Script.hpp"
diff --git a/src/crepe/api/Script.hpp b/src/crepe/api/Script.hpp
new file mode 100644
index 0000000..8004fe3
--- /dev/null
+++ b/src/crepe/api/Script.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "../ComponentManager.h"
+
+#include "BehaviorScript.h"
+#include "Script.h"
+
+namespace crepe::api {
+
+template <typename T>
+T & Script::get_component() {
+	std::vector<std::reference_wrapper<T>> all_components
+		= this->get_components<T>();
+	if (all_components.size() < 1) throw nullptr; // TODO
+
+	return all_components.back().get();
+}
+
+template <typename T>
+std::vector<std::reference_wrapper<T>> Script::get_components() {
+	ComponentManager & mgr = ComponentManager::get_instance();
+	return mgr.get_components_by_id<T>(this->parent->game_object_id);
+}
+
+} // namespace crepe::api
diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp
new file mode 100644
index 0000000..806f147
--- /dev/null
+++ b/src/crepe/api/Sprite.cpp
@@ -0,0 +1,20 @@
+#include <cstdint>
+#include <memory>
+
+#include "api/Texture.h"
+#include "util/log.h"
+
+#include "Component.h"
+#include "Sprite.h"
+
+using namespace std;
+using namespace crepe;
+using namespace crepe::api;
+
+Sprite::Sprite(uint32_t id, shared_ptr<Texture> image, const Color & color,
+			   const FlipSettings & flip)
+	: Component(id), color(color), flip(flip), sprite_image(image) {
+	dbg_trace();
+}
+
+Sprite::~Sprite() { dbg_trace(); }
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
new file mode 100644
index 0000000..b06125e
--- /dev/null
+++ b/src/crepe/api/Sprite.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#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:
+	Sprite(uint32_t game_id, std::shared_ptr<Texture> image,
+		   const Color & color, const FlipSettings & flip);
+	~Sprite();
+	std::shared_ptr<Texture> sprite_image;
+	Color color;
+	FlipSettings flip;
+	uint8_t sorting_in_layer;
+	uint8_t order_in_layer;
+};
+
+} // namespace crepe::api
diff --git a/src/crepe/api/Texture.cpp b/src/crepe/api/Texture.cpp
new file mode 100644
index 0000000..481ef7c
--- /dev/null
+++ b/src/crepe/api/Texture.cpp
@@ -0,0 +1,32 @@
+#include <SDL2/SDL_render.h>
+
+#include "util/log.h"
+
+#include "Asset.h"
+#include "SDLContext.h"
+#include "Texture.h"
+
+using namespace crepe::api;
+using namespace std;
+
+Texture::Texture(unique_ptr<Asset> res) {
+	dbg_trace();
+	this->load(std::move(res));
+}
+
+Texture::Texture(const char * src) {
+	dbg_trace();
+	this->load(make_unique<Asset>(src));
+}
+
+Texture::~Texture() {
+	dbg_trace();
+	if (this->texture != nullptr) {
+		SDL_DestroyTexture(this->texture);
+	}
+}
+
+void Texture::load(unique_ptr<Asset> res) {
+	SDLContext & ctx = SDLContext::get_instance();
+	this->texture = ctx.texture_from_path(res->canonical());
+}
diff --git a/src/crepe/api/Texture.h b/src/crepe/api/Texture.h
new file mode 100644
index 0000000..f8481e3
--- /dev/null
+++ b/src/crepe/api/Texture.h
@@ -0,0 +1,33 @@
+#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>
+
+#include "Asset.h"
+
+namespace crepe {
+class SDLContext;
+}
+
+namespace crepe::api {
+
+class Texture {
+
+public:
+	Texture(const char * src);
+	Texture(std::unique_ptr<Asset> res);
+	~Texture();
+
+private:
+	void load(std::unique_ptr<Asset> res);
+
+private:
+	SDL_Texture * texture = nullptr;
+
+	friend class crepe::SDLContext;
+};
+
+} // namespace crepe::api
diff --git a/src/crepe/api/Transform.cpp b/src/crepe/api/Transform.cpp
new file mode 100644
index 0000000..3b218bc
--- /dev/null
+++ b/src/crepe/api/Transform.cpp
@@ -0,0 +1,15 @@
+#include <cstdint>
+
+#include "api/Point.h"
+#include "util/log.h"
+
+#include "Component.h"
+#include "Transform.h"
+
+using namespace crepe::api;
+
+Transform::Transform(uint32_t game_id, const Point & point, double rot, double scale)
+	: Component(game_id), position(point), rotation(rot), scale(scale) {
+	dbg_trace();
+}
+Transform::~Transform() { dbg_trace(); }
diff --git a/src/crepe/api/Transform.h b/src/crepe/api/Transform.h
new file mode 100644
index 0000000..c451c16
--- /dev/null
+++ b/src/crepe/api/Transform.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <cstdint>
+
+#include "api/Point.h"
+
+#include "Component.h"
+
+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, const Point &, double, double);
+	~Transform();
+	//! Translation (shift)
+	Point position;
+	//! Rotation, in radians
+	double rotation;
+	//! Multiplication factor
+	double scale;
+};
+
+} // namespace crepe::api
diff --git a/src/crepe/util/CMakeLists.txt b/src/crepe/util/CMakeLists.txt
index 100f028..bbeaad9 100644
--- a/src/crepe/util/CMakeLists.txt
+++ b/src/crepe/util/CMakeLists.txt
@@ -1,9 +1,12 @@
 target_sources(crepe PUBLIC
+	color.cpp
 	log.cpp
+	fmt.cpp
 )
 
 target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	color.h
 	log.h
+	fmt.h
 )
 
diff --git a/src/crepe/util/color.cpp b/src/crepe/util/color.cpp
new file mode 100644
index 0000000..a7bbc81
--- /dev/null
+++ b/src/crepe/util/color.cpp
@@ -0,0 +1,91 @@
+#include <cstdarg>
+
+#include "../api/Config.h"
+#include "color.h"
+#include "fmt.h"
+
+using namespace crepe::util;
+using namespace std;
+
+static constexpr const char * RESET_CODE = "\e[0m";
+
+const string LogColor::str(const string & content) {
+	auto & cfg = api::Config::get_instance();
+	string out = content;
+	if (cfg.log.color) out = this->code + out;
+	if (content.size() == 0) return out;
+	if (cfg.log.color) out = out + RESET_CODE;
+	return out;
+}
+
+const char * LogColor::c_str(const char * content) {
+	this->final = this->str(content == NULL ? "" : content);
+	return this->final.c_str();
+}
+
+const char * LogColor::fmt(const char * fmt, ...) {
+	va_list args;
+	va_start(args, fmt);
+	string content = va_stringf(args, fmt);
+	va_end(args);
+	return this->c_str(content.c_str());
+}
+
+LogColor & LogColor::add_code(unsigned int code) {
+	this->code += stringf("\e[%dm", code);
+	return *this;
+}
+
+LogColor & LogColor::reset() {
+	this->code = RESET_CODE;
+	return *this;
+}
+
+LogColor & LogColor::fg_black(bool bright) {
+	return this->add_code(bright ? 90 : 30);
+}
+LogColor & LogColor::fg_red(bool bright) {
+	return this->add_code(bright ? 91 : 31);
+}
+LogColor & LogColor::fg_green(bool bright) {
+	return this->add_code(bright ? 92 : 32);
+}
+LogColor & LogColor::fg_yellow(bool bright) {
+	return this->add_code(bright ? 93 : 33);
+}
+LogColor & LogColor::fg_blue(bool bright) {
+	return this->add_code(bright ? 94 : 34);
+}
+LogColor & LogColor::fg_magenta(bool bright) {
+	return this->add_code(bright ? 95 : 35);
+}
+LogColor & LogColor::fg_cyan(bool bright) {
+	return this->add_code(bright ? 96 : 36);
+}
+LogColor & LogColor::fg_white(bool bright) {
+	return this->add_code(bright ? 97 : 37);
+}
+LogColor & LogColor::bg_black(bool bright) {
+	return this->add_code(bright ? 100 : 40);
+}
+LogColor & LogColor::bg_red(bool bright) {
+	return this->add_code(bright ? 101 : 41);
+}
+LogColor & LogColor::bg_green(bool bright) {
+	return this->add_code(bright ? 102 : 42);
+}
+LogColor & LogColor::bg_yellow(bool bright) {
+	return this->add_code(bright ? 103 : 43);
+}
+LogColor & LogColor::bg_blue(bool bright) {
+	return this->add_code(bright ? 104 : 44);
+}
+LogColor & LogColor::bg_magenta(bool bright) {
+	return this->add_code(bright ? 105 : 45);
+}
+LogColor & LogColor::bg_cyan(bool bright) {
+	return this->add_code(bright ? 106 : 46);
+}
+LogColor & LogColor::bg_white(bool bright) {
+	return this->add_code(bright ? 107 : 47);
+}
diff --git a/src/crepe/util/color.h b/src/crepe/util/color.h
index 066c9d3..91e1abe 100644
--- a/src/crepe/util/color.h
+++ b/src/crepe/util/color.h
@@ -1,41 +1,51 @@
 #pragma once
 
-namespace crepe::util::color {
-
-constexpr const char * RESET = "\e[0m";
-
-constexpr const char * FG_BLACK = "\e[30m";
-constexpr const char * FG_RED = "\e[31m";
-constexpr const char * FG_GREEN = "\e[32m";
-constexpr const char * FG_YELLOW = "\e[33m";
-constexpr const char * FG_BLUE = "\e[34m";
-constexpr const char * FG_MAGENTA = "\e[35m";
-constexpr const char * FG_CYAN = "\e[36m";
-constexpr const char * FG_WHITE = "\e[37m";
-constexpr const char * BG_BLACK = "\e[40m";
-constexpr const char * BG_RED = "\e[41m";
-constexpr const char * BG_GREEN = "\e[42m";
-constexpr const char * BG_YELLOW = "\e[43m";
-constexpr const char * BG_BLUE = "\e[44m";
-constexpr const char * BG_MAGENTA = "\e[45m";
-constexpr const char * BG_CYAN = "\e[46m";
-constexpr const char * BG_WHITE = "\e[47m";
-
-constexpr const char * FG_BLACK_BRIGHT = "\e[90m";
-constexpr const char * FG_RED_BRIGHT = "\e[91m";
-constexpr const char * FG_GREEN_BRIGHT = "\e[92m";
-constexpr const char * FG_YELLOW_BRIGHT = "\e[93m";
-constexpr const char * FG_BLUE_BRIGHT = "\e[94m";
-constexpr const char * FG_MAGENTA_BRIGHT = "\e[95m";
-constexpr const char * FG_CYAN_BRIGHT = "\e[96m";
-constexpr const char * FG_WHITE_BRIGHT = "\e[97m";
-constexpr const char * BG_BLACK_BRIGHT = "\e[100m";
-constexpr const char * BG_RED_BRIGHT = "\e[101m";
-constexpr const char * BG_GREEN_BRIGHT = "\e[102m";
-constexpr const char * BG_YELLOW_BRIGHT = "\e[103m";
-constexpr const char * BG_BLUE_BRIGHT = "\e[104m";
-constexpr const char * BG_MAGENTA_BRIGHT = "\e[105m";
-constexpr const char * BG_CYAN_BRIGHT = "\e[106m";
-constexpr const char * BG_WHITE_BRIGHT = "\e[107m";
-
-} // namespace crepe::util::color
+#include <string>
+
+namespace crepe::util {
+
+class LogColor {
+public:
+	LogColor() = default;
+
+public:
+	//! get color code as c-style string (or color content string)
+	const char * c_str(const char * content = NULL);
+	//! color printf-style format string
+	const char * fmt(const char * fmt, ...);
+	//! get color code as stl string (or color content string)
+	const std::string str(const std::string & content = "");
+
+public:
+	//! reset color to default foreground and background color
+	LogColor & reset();
+
+public:
+	LogColor & fg_black(bool bright = false);
+	LogColor & fg_red(bool bright = false);
+	LogColor & fg_green(bool bright = false);
+	LogColor & fg_yellow(bool bright = false);
+	LogColor & fg_blue(bool bright = false);
+	LogColor & fg_magenta(bool bright = false);
+	LogColor & fg_cyan(bool bright = false);
+	LogColor & fg_white(bool bright = false);
+
+public:
+	LogColor & bg_black(bool bright = false);
+	LogColor & bg_red(bool bright = false);
+	LogColor & bg_green(bool bright = false);
+	LogColor & bg_yellow(bool bright = false);
+	LogColor & bg_blue(bool bright = false);
+	LogColor & bg_magenta(bool bright = false);
+	LogColor & bg_cyan(bool bright = false);
+	LogColor & bg_white(bool bright = false);
+
+private:
+	LogColor & add_code(unsigned int code);
+
+private:
+	std::string code = "";
+	std::string final = "";
+};
+
+} // namespace crepe::util
diff --git a/src/crepe/util/fmt.cpp b/src/crepe/util/fmt.cpp
new file mode 100644
index 0000000..8ef1164
--- /dev/null
+++ b/src/crepe/util/fmt.cpp
@@ -0,0 +1,33 @@
+#include <cstdarg>
+#include <cstdio>
+#include <string>
+
+#include "fmt.h"
+
+using namespace std;
+
+string crepe::util::va_stringf(va_list args, const char * fmt) {
+	va_list args_copy;
+	va_copy(args_copy, args);
+
+	size_t sz = vsnprintf(NULL, 0, fmt, args_copy) + 1;
+	char * msg = (char *) malloc(sz);
+	va_end(args_copy);
+
+	vsnprintf(msg, sz, fmt, args);
+
+	string out = msg;
+	free(msg);
+
+	va_end(args);
+
+	return out;
+}
+
+string crepe::util::stringf(const char * fmt, ...) {
+	va_list args;
+	va_start(args, fmt);
+	string out = va_stringf(args, fmt);
+	va_end(args);
+	return out;
+}
diff --git a/src/crepe/util/fmt.h b/src/crepe/util/fmt.h
new file mode 100644
index 0000000..44c426f
--- /dev/null
+++ b/src/crepe/util/fmt.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <string>
+
+namespace crepe::util {
+
+std::string va_stringf(va_list args, const char * fmt);
+std::string stringf(const char * fmt, ...);
+
+} // namespace crepe::util
diff --git a/src/crepe/util/log.cpp b/src/crepe/util/log.cpp
index f91d52c..6bcc4ae 100644
--- a/src/crepe/util/log.cpp
+++ b/src/crepe/util/log.cpp
@@ -3,48 +3,51 @@
 #include <cstdlib>
 #include <string>
 
+#include "../api/Config.h"
+#include "fmt.h"
 #include "log.h"
 
 using namespace crepe::util;
+using namespace std;
+
+string log_prefix(LogLevel level) {
+	switch (level) {
+		case LogLevel::TRACE:
+			return LogColor().fg_white().str("[TRACE]") + " ";
+		case LogLevel::DEBUG:
+			return LogColor().fg_magenta().str("[DEBUG]") + " ";
+		case LogLevel::INFO:
+			return LogColor().fg_blue().str("[INFO]") + " ";
+		case LogLevel::WARNING:
+			return LogColor().fg_yellow().str("[WARN]") + " ";
+		case LogLevel::ERROR:
+			return LogColor().fg_red().str("[ERROR]") + " ";
+	}
+	return "";
+}
 
-static const char * const LOG_PREFIX[] = {
-	[log_level::DEBUG] = "[DBG] ",
-	[log_level::INFO] = "[INFO] ",
-	[log_level::WARNING] = "[WARN] ",
-	[log_level::ERROR] = "[ERR] ",
-};
-
-static void va_logf(enum log_level level, va_list args, const std::string fmt) {
-	va_list args_copy;
-	va_copy(args_copy, args);
-
-	// prepend log level and ensure newline
-	std::string format_fixed = LOG_PREFIX[level] + fmt;
-	if (!format_fixed.ends_with("\n")) format_fixed += "\n";
-
-	size_t sz = vsnprintf(NULL, 0, format_fixed.c_str(), args_copy) + 1;
-	char * msg = (char *) malloc(sz);
-	va_end(args_copy);
+static void log(LogLevel level, const string msg) {
+	auto & cfg = crepe::api::Config::get_instance();
+	if (level < cfg.log.level) return;
 
-	vsnprintf(msg, sz, format_fixed.c_str(), args);
+	string out = log_prefix(level) + msg;
+	if (!out.ends_with("\n")) out += "\n";
 
 	// TODO: also log to file or smth
-	printf("%s", msg);
+	printf("%s", out.c_str());
 	fflush(stdout);
-
-	free(msg);
 }
 
 void crepe::util::logf(const char * fmt, ...) {
 	va_list args;
 	va_start(args, fmt);
-	va_logf(crepe::util::log_level::DEBUG, args, fmt);
+	log(LogLevel::DEBUG, va_stringf(args, fmt));
 	va_end(args);
 }
 
-void crepe::util::logf(log_level level, const char * fmt, ...) {
+void crepe::util::logf(LogLevel level, const char * fmt, ...) {
 	va_list args;
 	va_start(args, fmt);
-	va_logf(level, args, fmt);
+	log(level, va_stringf(args, fmt));
 	va_end(args);
 }
diff --git a/src/crepe/util/log.h b/src/crepe/util/log.h
index 2b0fbe1..308ba96 100644
--- a/src/crepe/util/log.h
+++ b/src/crepe/util/log.h
@@ -6,24 +6,28 @@
 #include "color.h"
 
 // utility macros
-#define _crepe_logf_here(fmt, ...) \
-	crepe::util::logf(util::log_level::DEBUG, "%s%s (%s:%d)" fmt "\n", \
-					  crepe::util::color::FG_WHITE, __PRETTY_FUNCTION__, \
-					  __FILE_NAME__, __LINE__, crepe::util::color::RESET, \
-					  __VA_ARGS__)
+#define _crepe_logf_here(level, format, ...) \
+	crepe::util::logf( \
+		level, "%s" format, \
+		crepe::util::LogColor().fg_white(false).fmt( \
+			"%s (%s:%d)", __PRETTY_FUNCTION__, __FILE_NAME__, __LINE__), \
+		__VA_ARGS__)
 
 // very illegal global function-style macros
 // NOLINTBEGIN
-#define dbg_logf(fmt, ...) _crepe_logf_here(": " fmt, __VA_ARGS__)
-#define dbg_log(str) _crepe_logf_here(": %s", str)
-#define dbg_trace() _crepe_logf_here("%s", "")
+#define dbg_logf(fmt, ...) \
+	_crepe_logf_here(crepe::util::LogLevel::DEBUG, ": " fmt, __VA_ARGS__)
+#define dbg_log(str) \
+	_crepe_logf_here(crepe::util::LogLevel::DEBUG, "%s: " str, "")
+#define dbg_trace() _crepe_logf_here(crepe::util::LogLevel::TRACE, "%s", "")
 // NOLINTEND
 
 #endif
 
 namespace crepe::util {
 
-enum log_level {
+enum LogLevel {
+	TRACE,
 	DEBUG,
 	INFO,
 	WARNING,
@@ -31,6 +35,6 @@ enum log_level {
 };
 
 void logf(const char * fmt, ...);
-void logf(enum log_level level, const char * fmt, ...);
+void logf(enum LogLevel level, const char * fmt, ...);
 
 } // namespace crepe::util