merge conficts fixed

70 files changed, 1666 insertions, 126 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 09c60bd..b60a0cd 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -8,6 +8,7 @@ set(CMAKE_BUILD_TYPE Debug)
 project(crepe C CXX)
 
 find_package(SDL2 REQUIRED)
+find_package(SDL2_image REQUIRED)
 find_package(SoLoud REQUIRED)
 find_package(GTest REQUIRED)
 
@@ -20,7 +21,8 @@ target_include_directories(crepe
 
 target_link_libraries(crepe
 	PRIVATE soloud
-	PRIVATE SDL2
+	PUBLIC SDL2
+	PUBLIC SDL2_image
 )
 
 add_subdirectory(crepe)
@@ -36,4 +38,3 @@ target_link_libraries(test_main
 	PRIVATE gtest_main
 	PUBLIC crepe
 )
-
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 cfa51fb..d938eb8 100644
--- a/src/crepe/CMakeLists.txt
+++ b/src/crepe/CMakeLists.txt
@@ -2,20 +2,35 @@ target_sources(crepe PUBLIC
 	Asset.cpp
 	Sound.cpp
 	SoundContext.cpp
+	Particle.cpp
+	ParticleSystem.cpp
+	SDLApp.cpp
 	ComponentManager.cpp
 	Component.cpp
 	ScriptSystem.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
 	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
new file mode 100644
index 0000000..13a3f33
--- /dev/null
+++ b/src/crepe/Collider.cpp
@@ -0,0 +1,5 @@
+#include "Collider.h"
+
+using namespace crepe;
+
+Collider::Collider(uint32_t gameObjectId) : Component(gameObjectId) {}
diff --git a/src/crepe/Collider.h b/src/crepe/Collider.h
new file mode 100644
index 0000000..68a7d1d
--- /dev/null
+++ b/src/crepe/Collider.h
@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Component.h"
+
+namespace crepe {
+
+class Collider : public Component {
+public:
+	Collider(uint32_t game_object_id);
+
+	int size;
+};
+
+} // namespace crepe
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 bce90f1..358ce31 100644
--- a/src/crepe/Component.cpp
+++ b/src/crepe/Component.cpp
@@ -1,3 +1,5 @@
 #include "Component.h"
 
 using namespace crepe;
+
+Component::Component(uint32_t id) : game_object_id(id), active(true) {}
diff --git a/src/crepe/Component.h b/src/crepe/Component.h
index 9cda177..bc44865 100644
--- a/src/crepe/Component.h
+++ b/src/crepe/Component.h
@@ -1,16 +1,22 @@
 #pragma once
 
+#include <cstdint>
+
 namespace crepe {
 
+class ComponentManager;
+
 class Component {
 protected:
-	Component() = default;
+	friend class crepe::ComponentManager;
+	Component(uint32_t id);
 
 public:
 	virtual ~Component() = default;
 
 public:
-	bool active = true;
+	uint32_t game_object_id;
+	bool active;
 };
 
 } // 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/ComponentManager.hpp b/src/crepe/ComponentManager.hpp
index 2377a94..9b07f13 100644
--- a/src/crepe/ComponentManager.hpp
+++ b/src/crepe/ComponentManager.hpp
@@ -30,7 +30,7 @@ T & 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));
 
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/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/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/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
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 bb067dc..35b8d83 100644
--- a/src/crepe/api/AudioSource.cpp
+++ b/src/crepe/api/AudioSource.cpp
@@ -1,9 +1,9 @@
 #include <memory>
 
-#include "AudioSource.h"
-
 #include "../Sound.h"
 
+#include "AudioSource.h"
+
 using namespace crepe::api;
 
 AudioSource::AudioSource(std::unique_ptr<Asset> audio_clip) {
diff --git a/src/crepe/api/BehaviorScript.cpp b/src/crepe/api/BehaviorScript.cpp
index 84bfd4c..e69de29 100644
--- a/src/crepe/api/BehaviorScript.cpp
+++ b/src/crepe/api/BehaviorScript.cpp
@@ -1,7 +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 25d3cc5..6133cc8 100644
--- a/src/crepe/api/BehaviorScript.h
+++ b/src/crepe/api/BehaviorScript.h
@@ -3,7 +3,6 @@
 #include <memory>
 
 #include "../Component.h"
-#include "Script.h"
 
 namespace crepe {
 class ScriptSystem;
@@ -17,7 +16,7 @@ class Script;
 class BehaviorScript : public Component {
 protected:
 	friend class crepe::ComponentManager;
-	BehaviorScript();
+	using Component::Component;
 
 public:
 	virtual ~BehaviorScript() = default;
diff --git a/src/crepe/api/BehaviorScript.hpp b/src/crepe/api/BehaviorScript.hpp
index a6bd81c..2a3502f 100644
--- a/src/crepe/api/BehaviorScript.hpp
+++ b/src/crepe/api/BehaviorScript.hpp
@@ -3,7 +3,9 @@
 #include <type_traits>
 
 #include "../util/log.h"
+
 #include "BehaviorScript.h"
+#include "Script.h"
 
 namespace crepe::api {
 
@@ -12,6 +14,7 @@ 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;
 }
diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt
index ae92f3d..0bb1263 100644
--- a/src/crepe/api/CMakeLists.txt
+++ b/src/crepe/api/CMakeLists.txt
@@ -3,19 +3,29 @@ target_sources(crepe PUBLIC
 	BehaviorScript.cpp
 	Script.cpp
 	GameObject.cpp
-	Collider.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
-	Collider.h
 	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/Collider.cpp b/src/crepe/api/Collider.cpp
deleted file mode 100644
index 6370a42..0000000
--- a/src/crepe/api/Collider.cpp
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "Collider.h"
-
-using namespace crepe::api;
-
-Collider::Collider(int size) : size(size) {}
diff --git a/src/crepe/api/Collider.h b/src/crepe/api/Collider.h
deleted file mode 100644
index 72d8e77..0000000
--- a/src/crepe/api/Collider.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-
-#include "../Component.h"
-
-namespace crepe::api {
-
-class Collider : public Component {
-public:
-	Collider(int size);
-
-	int size;
-};
-
-} // 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.hpp b/src/crepe/api/GameObject.hpp
index 8295ea3..3c7e867 100644
--- a/src/crepe/api/GameObject.hpp
+++ b/src/crepe/api/GameObject.hpp
@@ -9,7 +9,7 @@ namespace crepe::api {
 template <typename T, typename... Args>
 T & GameObject::add_component(Args &&... args) {
 	auto & mgr = ComponentManager::get_instance();
-	return mgr.add_component<T>(id, std::forward<Args>(args)...);
+	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
index 98d1d60..ebf9fb9 100644
--- a/src/crepe/api/Rigidbody.cpp
+++ b/src/crepe/api/Rigidbody.cpp
@@ -2,5 +2,7 @@
 
 using namespace crepe::api;
 
-Rigidbody::Rigidbody(int mass, int gravityScale, int bodyType)
-	: mass(mass), gravity_scale(gravityScale), body_type(bodyType) {}
+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
index 6cae579..6079a76 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -1,16 +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(int mass, int gravityScale, int 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;
 	int gravity_scale;
-	int body_type;
+	BodyType body_type;
 };
 
 } // namespace crepe::api
diff --git a/src/crepe/api/Script.h b/src/crepe/api/Script.h
index 0036d1f..59e6ec0 100644
--- a/src/crepe/api/Script.h
+++ b/src/crepe/api/Script.h
@@ -1,11 +1,15 @@
 #pragma once
 
+#include <vector>
+
 namespace crepe {
 class ScriptSystem;
 }
 
 namespace crepe::api {
 
+class BehaviorScript;
+
 class Script {
 	friend class crepe::ScriptSystem;
 
@@ -16,6 +20,19 @@ protected:
 	// 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
index aa7dbb0..806f147 100644
--- a/src/crepe/api/Sprite.cpp
+++ b/src/crepe/api/Sprite.cpp
@@ -1,8 +1,20 @@
-#include <string>
+#include <cstdint>
+#include <memory>
 
+#include "api/Texture.h"
+#include "util/log.h"
+
+#include "Component.h"
 #include "Sprite.h"
 
-using namespace crepe::api;
 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(string path) : path(path) {}
+Sprite::~Sprite() { dbg_trace(); }
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index 580f825..b06125e 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -1,16 +1,32 @@
 #pragma once
 
-#include <string>
+#include <SDL2/SDL_rect.h>
+#include <cstdint>
+#include <memory>
 
-#include "../Component.h"
+#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(std::string path);
 
-	std::string path;
+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..626cd67
--- /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, 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..c69ec61
--- /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, 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 e2cffaf..bbeaad9 100644
--- a/src/crepe/util/CMakeLists.txt
+++ b/src/crepe/util/CMakeLists.txt
@@ -1,4 +1,5 @@
 target_sources(crepe PUBLIC
+	color.cpp
 	log.cpp
 	fmt.cpp
 )
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/log.cpp b/src/crepe/util/log.cpp
index 0c2ce1e..6bcc4ae 100644
--- a/src/crepe/util/log.cpp
+++ b/src/crepe/util/log.cpp
@@ -3,21 +3,34 @@
 #include <cstdlib>
 #include <string>
 
+#include "../api/Config.h"
 #include "fmt.h"
 #include "log.h"
 
 using namespace crepe::util;
+using namespace std;
 
-static const char * const LOG_PREFIX[] = {
-	[log_level::DEBUG] = "[DBG] ",
-	[log_level::INFO] = "[INFO] ",
-	[log_level::WARNING] = "[WARN] ",
-	[log_level::ERROR] = "[ERR] ",
-};
+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 void log(LogLevel level, const string msg) {
+	auto & cfg = crepe::api::Config::get_instance();
+	if (level < cfg.log.level) return;
 
-static void log(enum log_level level, const std::string & msg) {
-	using namespace std;
-	string out = string(LOG_PREFIX[level]) + msg;
+	string out = log_prefix(level) + msg;
 	if (!out.ends_with("\n")) out += "\n";
 
 	// TODO: also log to file or smth
@@ -28,11 +41,11 @@ static void log(enum log_level level, const std::string & msg) {
 void crepe::util::logf(const char * fmt, ...) {
 	va_list args;
 	va_start(args, fmt);
-	log(log_level::DEBUG, va_stringf(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);
 	log(level, va_stringf(args, fmt));
diff --git a/src/crepe/util/log.h b/src/crepe/util/log.h
index 3e36f0a..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)%s" 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
diff --git a/src/example/CMakeLists.txt b/src/example/CMakeLists.txt
index 53f584f..fea6f60 100644
--- a/src/example/CMakeLists.txt
+++ b/src/example/CMakeLists.txt
@@ -17,6 +17,10 @@ function(add_example target_name)
 endfunction()
 
 add_example(audio_internal)
-add_example(components_internal)
+# add_example(components_internal)
 add_example(script)
-
+add_example(log)
+add_example(rendering)
+add_example(asset_manager)
+add_example(particle)
+add_example(physics)
diff --git a/src/example/asset_manager.cpp b/src/example/asset_manager.cpp
new file mode 100644
index 0000000..7e15d1f
--- /dev/null
+++ b/src/example/asset_manager.cpp
@@ -0,0 +1,39 @@
+
+
+#include <crepe/Sound.h>
+#include <crepe/api/AssetManager.h>
+#include <crepe/api/Texture.h>
+
+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
+	{ 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");
+
+		auto img = mgr.cache<Texture>("../asset/texture/img.png");
+		auto img1 = mgr.cache<Texture>("../asset/texture/second.png");
+	}
+
+	{
+		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");
+
+		auto img = mgr.cache<Texture>("../asset/texture/img.png");
+		auto img1 = mgr.cache<Texture>("../asset/texture/second.png");
+	}
+}
diff --git a/src/example/components_internal.cpp b/src/example/components_internal.cpp
index e2169e1..3c68974 100644
--- a/src/example/components_internal.cpp
+++ b/src/example/components_internal.cpp
@@ -9,7 +9,6 @@
 #include <crepe/Component.h>
 #include <crepe/ComponentManager.h>
 
-#include <crepe/api/Collider.h>
 #include <crepe/api/GameObject.h>
 #include <crepe/api/Rigidbody.h>
 #include <crepe/api/Sprite.h>
@@ -36,14 +35,13 @@ int main() {
 
 		game_object[i]->add_component<Sprite>("test");
 		game_object[i]->add_component<Rigidbody>(0, 0, i);
-		game_object[i]->add_component<Collider>(i);
 	}
 
 	auto stop_adding = chrono::high_resolution_clock::now();
 
 	auto sprites = mgr.get_components_by_type<Sprite>();
 	for (auto sprite : sprites) {
-		assert(sprite.get().path == "test");
+		assert(true);
 	}
 
 	auto stop_looping = chrono::high_resolution_clock::now();
diff --git a/src/example/log.cpp b/src/example/log.cpp
new file mode 100644
index 0000000..3bc6d80
--- /dev/null
+++ b/src/example/log.cpp
@@ -0,0 +1,24 @@
+/** \file
+ * 
+ * Standalone example for usage of the logging functions
+ */
+
+#include <crepe/api/Config.h>
+#include <crepe/util/log.h>
+
+using namespace crepe;
+using namespace crepe::util;
+
+int main() {
+	auto & cfg = api::Config::get_instance();
+	// make sure all log messages get printed
+	cfg.log.level = util::LogLevel::TRACE;
+
+	dbg_trace();
+	dbg_logf("cfg.log.color is equal to %d", cfg.log.color);
+	logf(LogLevel::INFO, "info message!");
+	logf(LogLevel::WARNING, "very scary warning");
+	logf(LogLevel::ERROR, "fatal error!!!");
+
+	return 0;
+}
diff --git a/src/example/particle.cpp b/src/example/particle.cpp
new file mode 100644
index 0000000..53fa213
--- /dev/null
+++ b/src/example/particle.cpp
@@ -0,0 +1,102 @@
+#include "Particle.h"
+#include "ParticleSystem.h"
+#include "SDLApp.h"
+#include "api/ParticleEmitter.h"
+#include <chrono>
+#include <crepe/Component.h>
+#include <crepe/ComponentManager.h>
+#include <crepe/api/GameObject.h>
+#include <iostream>
+#include <thread>
+
+using namespace crepe::api;
+using namespace crepe;
+using namespace std;
+
+const int WINDOW_WIDTH = 800;
+const int WINDOW_HEIGHT = 600;
+
+int main(int argc, char * argv[]) {
+	SDLApp app(WINDOW_WIDTH, WINDOW_HEIGHT);
+
+	if (!app.initialize()) {
+		cerr << "Failed to initialize SDLApp." << endl;
+		return 1;
+	}
+
+	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
+	unsigned int emission_rate = 10; // particles created per second
+	unsigned int speed = 50; // base speed of particles
+	unsigned int speed_offset = 10; // random offset for particle speed
+	unsigned int angle = 270; // base angle of particle emission
+	unsigned int angle_offset = 30; // random offset for particle angle
+	float begin_lifespan = 0.0f; // beginning lifespan of particles
+	float end_lifespan = 6.0f; // ending lifespan of particles
+
+	// Vector to hold all the emitters
+	// vector<ParticleEmitter> emitters;
+	game_object[0]->add_component<ParticleEmitter>(
+		max_particles, emission_rate, speed, speed_offset, angle, angle_offset,
+		begin_lifespan, end_lifespan);
+
+	// Loop to create 1000 emitters
+	// for (unsigned int i = 0; i < 1000; ++i) {
+	//     ParticleEmitter emitter(maxParticles, emissionRate, speed, speedOffset, angle, angleOffset, beginLifespan, endLifespan);
+
+	//     // Set a position for each emitter, modifying the position for demonstration
+	//     emitter.m_position = {static_cast<float>(200 + (i % 100)), static_cast<float>(200 + (i / 100) * 10)}; // Adjust position for each emitter
+
+	//     emitters.push_back(emitter); // Add the emitter to the vector
+	// }
+	float delta_time = 0.1f;
+	bool running = true;
+	cout << "start loop " << endl;
+	while (running) {
+		app.handle_events(running);
+
+		// Start timing
+		auto start = chrono::high_resolution_clock::now();
+
+		// POC CODE
+		particle_system.update();
+		// POC CODE
+
+		// End timing
+		auto end = chrono::high_resolution_clock::now();
+		chrono::duration<float, milli> duration
+			= end - start; // get duration in milliseconds
+
+		cout << "Update took " << duration.count() << " ms" << endl;
+		app.clear_screen();
+
+		start = chrono::high_resolution_clock::now();
+		// render particles using the draw_square method from SDLApp
+		ComponentManager & mgr = ComponentManager::get_instance();
+		std::vector<std::reference_wrapper<ParticleEmitter>> emitters
+			= mgr.get_components_by_type<ParticleEmitter>();
+		for (const ParticleEmitter & emitter : emitters) {
+			for (const Particle & particle : emitter.particles) {
+				if (particle.active)
+					app.draw_square(particle.position.x, particle.position.y,
+									5); // draw each particle
+			}
+		}
+
+		app.present_screen();
+		end = chrono::high_resolution_clock::now();
+		duration = end - start; // get duration in milliseconds
+
+		cout << "screen took " << duration.count() << " ms" << endl;
+
+		this_thread::sleep_for(chrono::milliseconds(20)); // simulate ~50 FPS
+	}
+
+	app.clean_up();
+	return 0;
+}
diff --git a/src/example/physics.cpp b/src/example/physics.cpp
new file mode 100644
index 0000000..db69b9b
--- /dev/null
+++ b/src/example/physics.cpp
@@ -0,0 +1,30 @@
+#include "PhysicsSystem.h"
+#include <chrono>
+#include <crepe/Component.h>
+#include <crepe/ComponentManager.h>
+#include <crepe/api/Force.h>
+#include <crepe/api/GameObject.h>
+#include <crepe/api/Rigidbody.h>
+#include <crepe/api/Transform.h>
+#include <iostream>
+#include <thread>
+
+using namespace crepe::api;
+using namespace crepe;
+using namespace std;
+
+int main(int argc, char * argv[]) {
+	PhysicsSystem physics_system;
+	GameObject * game_object[2];
+	game_object[1] = new GameObject(2, "Name", "Tag", 0); // not found not used
+	game_object[0] = new GameObject(5, "Name", "Tag", 0);
+	Point point = {
+		.x = 0,
+		.y = 0,
+	};
+	game_object[0]->add_component<Transform>(point, 0, 0);
+	game_object[0]->add_component<Rigidbody>(1, 1, BodyType::DYNAMIC);
+	game_object[0]->add_component<Force>(1, 0);
+	physics_system.update();
+	return 0;
+}
diff --git a/src/example/rendering.cpp b/src/example/rendering.cpp
new file mode 100644
index 0000000..1bf448c
--- /dev/null
+++ b/src/example/rendering.cpp
@@ -0,0 +1,71 @@
+
+
+#include <crepe/ComponentManager.h>
+#include <crepe/RenderSystem.h>
+#include <crepe/api/GameObject.h>
+#include <crepe/util/log.h>
+
+#include <crepe/api/AssetManager.h>
+#include <crepe/api/Color.h>
+#include <crepe/api/Point.h>
+#include <crepe/api/Sprite.h>
+#include <crepe/api/Texture.h>
+#include <crepe/api/Transform.h>
+
+#include <chrono>
+#include <memory>
+
+using namespace std;
+using namespace crepe;
+using namespace crepe::api;
+
+int main() {
+
+	dbg_trace();
+
+	auto obj = GameObject(0, "name", "tag", 0);
+	auto obj1 = GameObject(1, "name", "tag", 0);
+	auto obj2 = GameObject(2, "name", "tag", 0);
+
+	auto & mgr = AssetManager::get_instance();
+	// Normal adding components
+	{
+		Color color(0, 0, 0, 0);
+		Point point = {
+			.x = 0,
+			.y = 0,
+		};
+		obj.add_component<Transform>(point, 1, 1);
+		obj.add_component<Sprite>(
+			make_shared<Texture>("../asset/texture/img.png"), color,
+			FlipSettings{true, true});
+	}
+
+	{
+		Color color(0, 0, 0, 0);
+		Point point = {
+			.x = 500,
+			.y = 0,
+		};
+		obj1.add_component<Transform>(point, 0, 0.1);
+		auto img = mgr.cache<Texture>("../asset/texture/second.png");
+		obj1.add_component<Sprite>(img, color, FlipSettings{true, true});
+	}
+
+	{
+		Color color(0, 0, 0, 0);
+		Point point = {
+			.x = 800,
+			.y = 0,
+		};
+		//obj.add_component<Transform>(point, 0, 0.1);
+		auto img = mgr.cache<Texture>("../asset/texture/second.png");
+		obj2.add_component<Sprite>(img, color, FlipSettings{true, true});
+	}
+
+	auto & sys = crepe::RenderSystem::get_instance();
+	auto start = std::chrono::steady_clock::now();
+	while (std::chrono::steady_clock::now() - start < std::chrono::seconds(5)) {
+		sys.update();
+	}
+}
diff --git a/src/example/script.cpp b/src/example/script.cpp
index 6e5563c..43f1c22 100644
--- a/src/example/script.cpp
+++ b/src/example/script.cpp
@@ -8,21 +8,32 @@
 #include <crepe/util/log.h>
 
 #include <crepe/api/BehaviorScript.h>
+#include <crepe/api/Config.h>
 #include <crepe/api/GameObject.h>
 #include <crepe/api/Script.h>
+#include <crepe/api/Transform.h>
 
 using namespace crepe;
 using namespace crepe::api;
 using namespace std;
 
 class MyScript : public Script {
-	void update() { dbg_log("MY SCRIPT UPDATE"); }
+	void update() {
+		Transform & test = get_component<Transform>();
+		dbg_logf("Transform(%.2f, %.2f)", test.position.x, test.position.y);
+	}
 };
 
 int main() {
-	dbg_trace();
+	auto & cfg = api::Config::get_instance();
+	cfg.log.level = util::LogLevel::TRACE;
 
 	auto obj = GameObject(0, "name", "tag", 0);
+	Point point = {
+		.x = 1.2,
+		.y = 3.4,
+	};
+	obj.add_component<Transform>(point, 0, 0);
 	obj.add_component<BehaviorScript>().set_script<MyScript>();
 
 	auto & sys = ScriptSystem::get_instance();
diff --git a/src/makefile b/src/makefile
index c1ef601..3f74a2a 100644
--- a/src/makefile
+++ b/src/makefile
@@ -2,5 +2,7 @@
 
 FMT += $(shell git ls-files '*.c' '*.cpp' '*.h' '*.hpp')
 format: FORCE
-	clang-tidy -p build/compile_commands.json --fix-errors $(FMT)
+	# clang-tidy -p build/compile_commands.json --fix-errors $(FMT)
+
+# TODO: re-enable linter after 2024-11-10