initial import, >900commits predate this

framework/opengl_renderer/test/CMakeLists.txt

@@ -0,0 +1,154 @@
+add_executable(opengl_renderer_s_test ./opengl_renderer_s_test.cpp)
+
+target_include_directories(opengl_renderer_s_test PRIVATE ".")
+
+target_link_libraries(opengl_renderer_s_test
+	opengl_renderer_s
+	gtest_main
+)
+
+add_test(NAME opengl_renderer_s_test COMMAND opengl_renderer_s_test)
+
+#################
+
+add_executable(imgui_render_task_test imgui_render_task_test.cpp)
+
+target_include_directories(imgui_render_task_test PRIVATE ".")
+
+target_link_libraries(imgui_render_task_test
+	opengl_renderer_s
+	imgui_service
+	imgui_render_task
+	gtest_main
+)
+
+add_test(NAME imgui_render_task_test COMMAND imgui_render_task_test)
+
+################# simple rect render task
+
+add_executable(simple_rect_render_task_test simple_rect_render_task_test.cpp)
+
+target_include_directories(simple_rect_render_task_test PRIVATE ".")
+
+target_link_libraries(simple_rect_render_task_test
+	opengl_renderer_s
+	simple_scene
+	simple_rect_render_task
+
+	simple_velocity_system
+
+	gtest_main
+)
+
+add_test(NAME simple_rect_render_task_test COMMAND simple_rect_render_task_test)
+
+################# simple sprite render task
+
+add_executable(simple_sprite_render_task_test simple_sprite_render_task_test.cpp)
+
+target_include_directories(simple_sprite_render_task_test PRIVATE ".")
+
+target_link_libraries(simple_sprite_render_task_test
+	opengl_renderer_s
+	simple_scene
+	simple_sprite_render_task
+
+	simple_velocity_system
+
+	gtest_main
+)
+
+add_test(NAME simple_sprite_render_task_test COMMAND simple_sprite_render_task_test)
+
+################# simple spritesheet render task
+
+add_executable(simple_spritesheet_render_task_test simple_spritesheet_render_task_test.cpp)
+
+target_include_directories(simple_spritesheet_render_task_test PRIVATE ".")
+
+target_link_libraries(simple_spritesheet_render_task_test
+	opengl_renderer_s
+	simple_scene
+	simple_spritesheet_render_task
+
+	#simple_velocity_system
+
+	gtest_main
+)
+
+add_test(NAME simple_spritesheet_render_task_test COMMAND simple_spritesheet_render_task_test)
+
+################# batched spritesheet render task
+
+add_executable(batched_spritesheet_render_task_test batched_spritesheet_render_task_test.cpp)
+
+target_include_directories(batched_spritesheet_render_task_test PRIVATE ".")
+
+target_link_libraries(batched_spritesheet_render_task_test
+	opengl_renderer_s
+	simple_scene
+	batched_spritesheet_render_task
+
+	#simple_velocity_system
+
+	gtest_main
+)
+
+add_test(NAME batched_spritesheet_render_task_test COMMAND batched_spritesheet_render_task_test)
+
+#################
+
+add_executable(blur_render_task_test blur_render_task_test.cpp)
+
+target_include_directories(blur_render_task_test PRIVATE ".")
+
+target_link_libraries(blur_render_task_test
+	opengl_renderer_s
+	simple_scene
+	simple_rect_render_task
+	blur_render_task
+	imgui_service
+	imgui_render_task
+
+	simple_velocity_system
+
+	gtest_main
+)
+
+add_test(NAME blur_render_task_test COMMAND blur_render_task_test)
+
+################# tilemap render task
+
+add_executable(tilemap_render_task_test tilemap_render_task_test.cpp)
+
+target_include_directories(tilemap_render_task_test PRIVATE ".")
+
+target_link_libraries(tilemap_render_task_test
+	opengl_renderer_s
+	simple_scene
+	imgui_service
+	tilemap_render_task
+
+	gtest_main
+)
+
+add_test(NAME tilemap_render_task_test COMMAND tilemap_render_task_test)
+
+################# fast sky render task
+
+add_executable(fast_sky_render_task_test fast_sky_render_task_test.cpp)
+
+target_include_directories(fast_sky_render_task_test PRIVATE ".")
+
+target_link_libraries(fast_sky_render_task_test
+	opengl_renderer_s
+	simple_scene
+	#imgui_service
+	fast_sky_render_task
+	fast_sky_sun_system
+
+	gtest_main
+)
+
+add_test(NAME fast_sky_render_task_test COMMAND fast_sky_render_task_test)
+

framework/opengl_renderer/test/batched_spritesheet_render_task_test.cpp

@@ -0,0 +1,111 @@
+#include <gtest/gtest.h>
+
+#include <mm/engine.hpp>
+
+#include <mm/services/filesystem.hpp>
+#include <mm/services/sdl_service.hpp>
+#include <mm/services/simple_scene.hpp>
+#include <mm/services/opengl_renderer.hpp>
+
+#include <entt/entity/registry.hpp>
+
+#include <mm/opengl/texture_loader.hpp>
+
+#include <mm/opengl/render_tasks/batched_spritesheet.hpp>
+
+#include <mm/components/transform2d.hpp>
+#include <mm/components/color.hpp>
+#include <mm/opengl/render_tasks/spritesheet_renderable.hpp>
+
+#include <physfs.h>
+#include "res/textures.zip.h"
+
+const char* argv0;
+
+TEST(batched_spritesheet_render_task, it) {
+	MM::Engine engine;
+
+	auto& sdl_ss = engine.addService<MM::Services::SDLService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::SDLService>());
+
+	sdl_ss.createGLWindow("batched_spritesheet_render_task_test", 1280, 720);
+
+	engine.addService<MM::Services::SimpleSceneService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::SimpleSceneService>());
+
+	bool provide_ret = engine.provide<MM::Services::SceneServiceInterface, MM::Services::SimpleSceneService>();
+	ASSERT_TRUE(provide_ret);
+	auto& scene = engine.tryService<MM::Services::SceneServiceInterface>()->getScene();
+
+	engine.addService<MM::Services::FilesystemService>(argv0, "batched_spritesheet_render_task_test");
+	ASSERT_TRUE(engine.enableService<MM::Services::FilesystemService>());
+
+	ASSERT_TRUE(PHYSFS_mountMemory(textures_zip, textures_zip_len, NULL, "", NULL, 0));
+
+	auto& rs = engine.addService<MM::Services::OpenGLRenderer>();
+	ASSERT_TRUE(engine.enableService<MM::Services::OpenGLRenderer>());
+
+	auto& cam = scene.set<MM::OpenGL::Camera3D>();
+	cam.horizontalViewPortSize = 5;
+	cam.setOrthographic();
+	cam.updateView();
+
+	rs.addRenderTask<MM::OpenGL::RenderTasks::BatchedSpriteSheet>(engine);
+
+	float accu = 0.f;
+	MM::AddSystemToScene(scene, [&accu](auto& scene, float delta) {
+		accu += delta;
+
+		if (accu >= 1.f/10) {
+			accu -= 1.f/10;
+			scene.template view<MM::OpenGL::SpriteSheetRenderable>()
+				.each([](auto, auto& spr) {
+						spr.tile_index = (spr.tile_index+spr.sp.tile_count.x) % (spr.sp.tile_count.x*spr.sp.tile_count.y);
+					}
+				);
+		}
+	});
+
+	auto& rm_t = MM::ResourceManager<MM::OpenGL::Texture>::ref();
+	ASSERT_TRUE(rm_t.load<MM::OpenGL::TextureLoaderFile>("anim_run", engine, "/textures/animation_running-1_ea_0.3.png"));
+	ASSERT_TRUE(rm_t.load<MM::OpenGL::TextureLoaderFile>("anim_idle", engine, "/textures/animation_standing-1_ea_0.1.png"));
+
+	{
+		auto e = scene.create();
+		auto& t = scene.emplace<MM::Components::Transform2D>(e);
+		t.position.x = -1.f;
+		t.scale.x = 1.5f;
+		t.scale.y = 2.f;
+
+		auto& spr = scene.emplace<MM::OpenGL::SpriteSheetRenderable>(e);
+		spr.sp.tex = rm_t.get("anim_run"_hs);
+		spr.sp.tile_count.x = 8;
+		spr.sp.tile_count.y = 8;
+		spr.tile_index = 2;
+	}
+
+	{
+		auto e = scene.create();
+		auto& t = scene.emplace<MM::Components::Transform2D>(e);
+		t.position.x = 1.f;
+		t.scale.x = 1.5f;
+		t.scale.y = 2.f;
+
+		auto& spr = scene.emplace<MM::OpenGL::SpriteSheetRenderable>(e);
+		spr.sp.tex = rm_t.get("anim_idle"_hs);
+		spr.sp.tile_count.x = 8;
+		spr.sp.tile_count.y = 4;
+		spr.tile_index = 0;
+	}
+
+	engine.run();
+}
+
+int main(int argc, char** argv) {
+	argv0 = argv[0];
+
+	::testing::InitGoogleTest(&argc, argv);
+
+	return RUN_ALL_TESTS();
+}
+

framework/opengl_renderer/test/blur_render_task_test.cpp

@@ -0,0 +1,120 @@
+#include <gtest/gtest.h>
+
+#include <mm/engine.hpp>
+
+#include <mm/services/filesystem.hpp>
+#include <mm/services/sdl_service.hpp>
+#include <mm/services/simple_scene.hpp>
+#include <mm/services/opengl_renderer.hpp>
+#include <mm/services/imgui_s.hpp>
+
+#include <entt/entity/registry.hpp>
+
+#include <mm/opengl/render_tasks/simple_rect.hpp>
+#include <mm/opengl/render_tasks/blur.hpp>
+#include <mm/opengl/render_tasks/imgui.hpp>
+
+#include <mm/components/transform2d.hpp>
+#include <mm/components/color.hpp>
+
+#include <mm/systems/simple_velocity_system2d.hpp>
+
+#include <mm/opengl/fbo_builder.hpp>
+
+#include <imgui/imgui.h>
+
+#include <random>
+
+const char* argv0;
+
+TEST(blur_render_task, it) {
+	MM::Engine engine;
+
+	auto& sdl_ss = engine.addService<MM::Services::SDLService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::SDLService>());
+
+	sdl_ss.createGLWindow("blur_render_task_test", 1280, 720);
+
+	engine.addService<MM::Services::SimpleSceneService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::SimpleSceneService>());
+
+	bool provide_ret = engine.provide<MM::Services::SceneServiceInterface, MM::Services::SimpleSceneService>();
+	ASSERT_TRUE(provide_ret);
+	auto& scene = engine.tryService<MM::Services::SceneServiceInterface>()->getScene();
+
+	engine.addService<MM::Services::FilesystemService>(argv0, "blur_render_task_test");
+	ASSERT_TRUE(engine.enableService<MM::Services::FilesystemService>());
+
+	engine.addService<MM::Services::ImGuiService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::ImGuiService>());
+
+	auto& rs = engine.addService<MM::Services::OpenGLRenderer>();
+	ASSERT_TRUE(engine.enableService<MM::Services::OpenGLRenderer>());
+
+	rs.addRenderTask<MM::OpenGL::RenderTasks::SimpleRect>(engine).target_fbo = "game_view";
+
+	MM::OpenGL::RenderTasks::SimpleRect* bsrr_rend_ptr = &rs.addRenderTask<MM::OpenGL::RenderTasks::SimpleRect>(engine);
+	bsrr_rend_ptr->target_fbo = "blur_in";
+
+	MM::OpenGL::RenderTasks::Blur* blur_rend_ptr = &rs.addRenderTask<MM::OpenGL::RenderTasks::Blur>(engine);
+	blur_rend_ptr->target_fbo = "display";
+
+	rs.addRenderTask<MM::OpenGL::RenderTasks::ImGuiRT>(engine);
+
+
+	{
+		auto [w, h] = sdl_ss.getWindowSize();
+
+		rs.targets["game_view"] = MM::OpenGL::FBOBuilder::start()
+			.attachTexture(MM::OpenGL::Texture::createEmpty(GL_RGB, w, h, GL_RGB, GL_UNSIGNED_BYTE))
+			.finish();
+		rs.targets["blur_in"] = MM::OpenGL::FBOBuilder::start()
+			.attachTexture(MM::OpenGL::Texture::createEmpty(GL_RGB, w, h, GL_RGB, GL_UNSIGNED_BYTE))
+			.finish();
+		rs.targets["blur_out"] = MM::OpenGL::FBOBuilder::start()
+			.attachTexture(MM::OpenGL::Texture::createEmpty(GL_RGB, w, h, GL_RGB, GL_UNSIGNED_BYTE))
+			.finish();
+	}
+
+
+	// setup v system
+	MM::AddSystemToScene(scene, MM::Systems::SimpleVelocity);
+
+	std::mt19937 mt(42);
+
+	for (int i = 0; i < 10; i++) {
+		auto e = scene.create();
+		auto& t = scene.emplace<MM::Components::Transform2D>(e);
+		t.position.x = i * 9.f - 40;
+		t.scale = {5,5};
+
+		auto& v = scene.emplace<MM::Components::Velocity2D>(e);
+		v.rotation = i * 0.3f;
+
+		if (mt() % 2) {
+			auto& col = scene.emplace<MM::Components::Color>(e);
+			auto rc = [&mt]() -> float {
+				return (mt() % 1001) / 1000.f ;
+			};
+			col.color = {rc(),rc(),rc(),1};
+		}
+
+	}
+
+	engine.addUpdate(
+		[&](MM::Engine&) {
+			ImGui::ColorEdit4("rect_col", &bsrr_rend_ptr->default_color[0]);
+		}
+	);
+
+	engine.run();
+}
+
+int main(int argc, char** argv) {
+	argv0 = argv[0];
+
+	::testing::InitGoogleTest(&argc, argv);
+
+	return RUN_ALL_TESTS();
+}
+

framework/opengl_renderer/test/fast_sky_render_task_test.cpp

@@ -0,0 +1,59 @@
+#include "mm/opengl/camera_3d.hpp"
+#include <gtest/gtest.h>
+
+#include <mm/engine.hpp>
+
+#include <mm/services/filesystem.hpp>
+#include <mm/services/sdl_service.hpp>
+#include <mm/services/simple_scene.hpp>
+#include <mm/services/opengl_renderer.hpp>
+
+#include <entt/entity/registry.hpp>
+
+#include <mm/opengl/render_tasks/fast_sky_render_task.hpp>
+#include <mm/systems/fast_sky_sun_system.hpp>
+
+const char* argv0;
+
+TEST(fast_sky_render_task, it) {
+	MM::Engine engine;
+
+	auto& sdl_ss = engine.addService<MM::Services::SDLService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::SDLService>());
+
+	sdl_ss.createGLWindow("fast_sky_render_task_test", 1280, 720);
+
+	engine.addService<MM::Services::SimpleSceneService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::SimpleSceneService>());
+
+	bool provide_ret = engine.provide<MM::Services::SceneServiceInterface, MM::Services::SimpleSceneService>();
+	ASSERT_TRUE(provide_ret);
+	auto& scene = engine.tryService<MM::Services::SceneServiceInterface>()->getScene();
+
+	engine.addService<MM::Services::FilesystemService>(argv0, "fast_sky_render_task_test");
+	ASSERT_TRUE(engine.enableService<MM::Services::FilesystemService>());
+
+	auto& rs = engine.addService<MM::Services::OpenGLRenderer>();
+	ASSERT_TRUE(engine.enableService<MM::Services::OpenGLRenderer>());
+
+	rs.addRenderTask<MM::OpenGL::RenderTasks::FastSky>(engine);
+
+	MM::AddSystemToScene(scene, MM::Systems::FastSkySun);
+
+	auto& cam = scene.set<MM::OpenGL::Camera3D>();
+	cam.setPerspective();
+	cam.updateView();
+
+	scene.set<MM::OpenGL::RenderTasks::FastSkyContext>();
+
+	engine.run();
+}
+
+int main(int argc, char** argv) {
+	argv0 = argv[0];
+
+	::testing::InitGoogleTest(&argc, argv);
+
+	return RUN_ALL_TESTS();
+}
+

framework/opengl_renderer/test/imgui_render_task_test.cpp

@@ -0,0 +1,46 @@
+#include <gtest/gtest.h>
+
+#include <mm/engine.hpp>
+
+#include <mm/services/sdl_service.hpp>
+#include <mm/services/opengl_renderer.hpp>
+#include <mm/services/imgui_s.hpp>
+#include <mm/opengl/render_tasks/imgui.hpp>
+
+#include <imgui/imgui.h>
+
+TEST(imgui_render_task, demowindow) {
+	MM::Engine engine;
+
+	engine.addService<MM::Services::SDLService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::SDLService>());
+
+	auto& rs = engine.addService<MM::Services::OpenGLRenderer>();
+	ASSERT_TRUE(engine.enableService<MM::Services::OpenGLRenderer>());
+
+	// needs a open window (and opengl context) which the OpenGLRenderer creates in this case
+	engine.addService<MM::Services::ImGuiService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::ImGuiService>());
+
+	rs.addRenderTask<MM::OpenGL::RenderTasks::ImGuiRT>(engine);
+
+	auto handle = engine.addUpdate([](MM::Engine&) {
+			ImGui::ShowDemoWindow();
+		}
+	);
+
+	{
+		auto tmp_lock = handle.lock();
+		tmp_lock->priority = 0;
+		tmp_lock->name = "imgui demo window";
+	}
+
+	engine.run();
+}
+
+int main(int argc, char** argv) {
+	::testing::InitGoogleTest(&argc, argv);
+
+	return RUN_ALL_TESTS();
+}
+

framework/opengl_renderer/test/opengl_renderer_s_test.cpp

@@ -0,0 +1,26 @@
+#include <gtest/gtest.h>
+
+#include <mm/engine.hpp>
+#include <mm/services/sdl_service.hpp>
+#include <mm/services/opengl_renderer.hpp>
+
+TEST(opengl_renderer_s, basic) {
+	MM::Engine engine;
+
+	engine.addService<MM::Services::SDLService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::SDLService>());
+
+	engine.addService<MM::Services::OpenGLRenderer>();
+	ASSERT_TRUE(engine.enableService<MM::Services::OpenGLRenderer>());
+
+	engine.update();
+}
+
+int main(int argc, char** argv) {
+	//argv0 = argv[0];
+
+	::testing::InitGoogleTest(&argc, argv);
+
+	return RUN_ALL_TESTS();
+}
+

framework/opengl_renderer/test/simple_rect_render_task_test.cpp

@@ -0,0 +1,83 @@
+#include <gtest/gtest.h>
+
+#include <mm/engine.hpp>
+
+#include <mm/services/filesystem.hpp>
+#include <mm/services/sdl_service.hpp>
+#include <mm/services/simple_scene.hpp>
+#include <mm/services/opengl_renderer.hpp>
+
+#include <entt/entity/registry.hpp>
+
+#include <mm/opengl/render_tasks/simple_rect.hpp>
+
+#include <mm/components/transform2d.hpp>
+#include <mm/components/color.hpp>
+
+#include <mm/systems/simple_velocity_system2d.hpp>
+
+#include <random>
+
+const char* argv0;
+
+TEST(simple_rect_render_task, it) {
+	MM::Engine engine;
+
+	auto& sdl_ss = engine.addService<MM::Services::SDLService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::SDLService>());
+
+	sdl_ss.createGLWindow("simple_rect_render_task_test", 1280, 720);
+
+	engine.addService<MM::Services::SimpleSceneService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::SimpleSceneService>());
+
+	bool provide_ret = engine.provide<MM::Services::SceneServiceInterface, MM::Services::SimpleSceneService>();
+	ASSERT_TRUE(provide_ret);
+	auto& scene = engine.tryService<MM::Services::SceneServiceInterface>()->getScene();
+
+	engine.addService<MM::Services::FilesystemService>(argv0, "simple_rect_render_task_test");
+	ASSERT_TRUE(engine.enableService<MM::Services::FilesystemService>());
+
+	auto& rs = engine.addService<MM::Services::OpenGLRenderer>();
+	ASSERT_TRUE(engine.enableService<MM::Services::OpenGLRenderer>());
+
+	rs.addRenderTask<MM::OpenGL::RenderTasks::SimpleRect>(engine);
+
+	// setup v system
+	MM::AddSystemToScene(scene, MM::Systems::SimpleVelocity);
+
+	std::mt19937 mt(42);
+
+	for (int y = 0; y < 10; y++) {
+		for (int i = 0; i < 10; i++) {
+			auto e = scene.create();
+			auto& t = scene.emplace<MM::Components::Transform2D>(e);
+			t.position.x = i * 9.f - 40;
+			t.position.y = -y * 6.f + 25;
+			t.scale = {5,5};
+
+			auto& v = scene.emplace<MM::Components::Velocity2D>(e);
+			v.rotation = i * 0.3f;
+
+			if (mt() % 2) {
+				auto& col = scene.emplace<MM::Components::Color>(e);
+				auto rc = [&mt]() -> float {
+					return (mt() % 1001) / 1000.f ;
+				};
+				col.color = {rc(),rc(),rc(),1};
+			}
+
+		}
+	}
+
+	engine.run();
+}
+
+int main(int argc, char** argv) {
+	argv0 = argv[0];
+
+	::testing::InitGoogleTest(&argc, argv);
+
+	return RUN_ALL_TESTS();
+}
+

framework/opengl_renderer/test/simple_sprite_render_task_test.cpp

@@ -0,0 +1,88 @@
+#include <gtest/gtest.h>
+
+#include <mm/engine.hpp>
+
+#include <mm/services/filesystem.hpp>
+#include <mm/services/sdl_service.hpp>
+#include <mm/services/simple_scene.hpp>
+#include <mm/services/opengl_renderer.hpp>
+
+#include <entt/entity/registry.hpp>
+
+#include <mm/opengl/render_tasks/simple_sprite.hpp>
+
+#include <mm/components/transform2d.hpp>
+#include <mm/opengl/components/texture.hpp>
+#include <mm/components/color.hpp>
+
+#include <mm/systems/simple_velocity_system2d.hpp>
+
+#include <random>
+
+const char* argv0;
+
+TEST(simple_sprite_render_task, it) {
+	MM::Engine engine;
+
+	auto& sdl_ss = engine.addService<MM::Services::SDLService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::SDLService>());
+
+	sdl_ss.createGLWindow("simple_sprite_render_task_test", 1280, 720);
+
+	engine.addService<MM::Services::SimpleSceneService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::SimpleSceneService>());
+
+	bool provide_ret = engine.provide<MM::Services::SceneServiceInterface, MM::Services::SimpleSceneService>();
+	ASSERT_TRUE(provide_ret);
+	auto& scene = engine.tryService<MM::Services::SceneServiceInterface>()->getScene();
+
+	engine.addService<MM::Services::FilesystemService>(argv0, "simple_sprite_render_task_test");
+	ASSERT_TRUE(engine.enableService<MM::Services::FilesystemService>());
+
+	auto& rs = engine.addService<MM::Services::OpenGLRenderer>();
+	ASSERT_TRUE(engine.enableService<MM::Services::OpenGLRenderer>());
+
+	rs.addRenderTask<MM::OpenGL::RenderTasks::SimpleSprite>(engine);
+
+	// setup v system
+	MM::AddSystemToScene(scene, MM::Systems::SimpleVelocity);
+
+	auto& rm_t = MM::ResourceManager<MM::OpenGL::Texture>::ref();
+
+	std::mt19937 mt(42);
+
+	for (int y = 0; y < 10; y++) {
+		for (int i = 0; i < 10; i++) {
+			auto e = scene.create();
+			auto& t = scene.emplace<MM::Components::Transform2D>(e);
+			t.position.x = i * 9.f - 40;
+			t.position.y = -y * 6.f + 25;
+			t.scale = {5,5};
+
+			auto& v = scene.emplace<MM::Components::Velocity2D>(e);
+			v.rotation = i * 0.3f;
+
+			auto& tex = scene.emplace<MM::Components::OpenGL::Texture>(e);
+			tex.tex = rm_t.get("errig"_hs);
+
+			if (mt() % 2) {
+				auto& col = scene.emplace<MM::Components::Color>(e);
+				auto rc = [&mt]() -> float {
+					return (mt() % 1001) / 1000.f ;
+				};
+				col.color = {rc(),rc(),rc(),1};
+			}
+		}
+	}
+
+	engine.run();
+}
+
+int main(int argc, char** argv) {
+	argv0 = argv[0];
+
+	::testing::InitGoogleTest(&argc, argv);
+
+	return RUN_ALL_TESTS();
+}
+

framework/opengl_renderer/test/simple_spritesheet_render_task_test.cpp

@@ -0,0 +1,101 @@
+#include <gtest/gtest.h>
+
+#include <mm/engine.hpp>
+
+#include <mm/services/filesystem.hpp>
+#include <mm/services/sdl_service.hpp>
+#include <mm/services/simple_scene.hpp>
+#include <mm/services/opengl_renderer.hpp>
+
+#include <entt/entity/registry.hpp>
+
+#include <mm/opengl/texture_loader.hpp>
+
+#include <mm/opengl/render_tasks/simple_spritesheet.hpp>
+
+#include <mm/components/transform2d.hpp>
+#include <mm/components/color.hpp>
+#include <mm/opengl/render_tasks/spritesheet_renderable.hpp>
+
+#include <physfs.h>
+#include "res/textures.zip.h"
+
+TEST(simple_spritesheet_render_task, it) {
+	MM::Engine engine;
+
+	auto& sdl_ss = engine.addService<MM::Services::SDLService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::SDLService>());
+
+	sdl_ss.createGLWindow("simple_spritesheet_render_task_test", 1280, 720);
+
+	engine.addService<MM::Services::SimpleSceneService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::SimpleSceneService>());
+
+	bool provide_ret = engine.provide<MM::Services::SceneServiceInterface, MM::Services::SimpleSceneService>();
+	ASSERT_TRUE(provide_ret);
+	auto& scene = engine.tryService<MM::Services::SceneServiceInterface>()->getScene();
+
+	engine.addService<MM::Services::FilesystemService>(nullptr, "simple_spritesheet_render_task_test");
+	ASSERT_TRUE(engine.enableService<MM::Services::FilesystemService>());
+
+	ASSERT_TRUE(PHYSFS_mountMemory(textures_zip, textures_zip_len, NULL, "", NULL, 0));
+
+	auto& rs = engine.addService<MM::Services::OpenGLRenderer>();
+	ASSERT_TRUE(engine.enableService<MM::Services::OpenGLRenderer>());
+
+	auto& cam = scene.set<MM::OpenGL::Camera3D>();
+	cam.horizontalViewPortSize = 5;
+	cam.setOrthographic();
+	cam.updateView();
+
+	rs.addRenderTask<MM::OpenGL::RenderTasks::SimpleSpriteSheet>(engine);
+
+	float accu = 0.f;
+	MM::AddSystemToScene(scene, [&accu](auto& scene, float delta) {
+		accu += delta;
+
+		if (accu >= 1.f/10) {
+			accu -= 1.f/10;
+			scene.template view<MM::OpenGL::SpriteSheetRenderable>()
+				.each([](auto, auto& spr) {
+						spr.tile_index = (spr.tile_index+spr.sp.tile_count.x) % (spr.sp.tile_count.x*spr.sp.tile_count.y);
+					}
+				);
+		}
+	});
+
+	auto& rm_t = MM::ResourceManager<MM::OpenGL::Texture>::ref();
+	ASSERT_TRUE(rm_t.load<MM::OpenGL::TextureLoaderFile>("anim_run", engine, "/textures/animation_running-1_ea_0.3.png"));
+	ASSERT_TRUE(rm_t.load<MM::OpenGL::TextureLoaderFile>("anim_idle", engine, "/textures/animation_standing-1_ea_0.1.png"));
+
+	{
+		auto e = scene.create();
+		auto& t = scene.emplace<MM::Components::Transform2D>(e);
+		t.position.x = -1.f;
+		t.scale.x = 1.5f;
+		t.scale.y = 2.f;
+
+		auto& spr = scene.emplace<MM::OpenGL::SpriteSheetRenderable>(e);
+		spr.sp.tex = rm_t.get("anim_run"_hs);
+		spr.sp.tile_count.x = 8;
+		spr.sp.tile_count.y = 8;
+		spr.tile_index = 2;
+	}
+
+	{
+		auto e = scene.create();
+		auto& t = scene.emplace<MM::Components::Transform2D>(e);
+		t.position.x = 1.f;
+		t.scale.x = 1.5f;
+		t.scale.y = 2.f;
+
+		auto& spr = scene.emplace<MM::OpenGL::SpriteSheetRenderable>(e);
+		spr.sp.tex = rm_t.get("anim_idle"_hs);
+		spr.sp.tile_count.x = 8;
+		spr.sp.tile_count.y = 4;
+		spr.tile_index = 0;
+	}
+
+	engine.run();
+}
+

framework/opengl_renderer/test/tilemap_render_task_test.cpp

@@ -0,0 +1,97 @@
+#include <gtest/gtest.h>
+
+#include <mm/engine.hpp>
+
+#include <mm/services/filesystem.hpp>
+#include <mm/services/sdl_service.hpp>
+#include <mm/services/simple_scene.hpp>
+#include <mm/services/opengl_renderer.hpp>
+
+#include <entt/entity/registry.hpp>
+
+#include <mm/opengl/camera_3d.hpp>
+#include <mm/opengl/render_tasks/tilemap.hpp>
+
+#include <mm/opengl/render_tasks/tilemap_renderable.hpp>
+#include <mm/components/transform2d.hpp>
+
+#include <mm/opengl/texture_loader.hpp>
+
+TEST(tilemap_render_task_test, it) {
+	MM::Engine engine;
+
+	auto& sdl_ss = engine.addService<MM::Services::SDLService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::SDLService>());
+
+	sdl_ss.createGLWindow("tilemap_render_task_test", 1280, 720);
+
+	engine.addService<MM::Services::SimpleSceneService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::SimpleSceneService>());
+
+	bool provide_ret = engine.provide<MM::Services::SceneServiceInterface, MM::Services::SimpleSceneService>();
+	ASSERT_TRUE(provide_ret);
+	auto& scene = engine.tryService<MM::Services::SceneServiceInterface>()->getScene();
+
+	auto& cam = scene.set<MM::OpenGL::Camera3D>();
+	cam.translation = {2.f, -2.f, 0.f};
+	cam.horizontalViewPortSize = 20.f;
+	cam.setOrthographic();
+	cam.updateView();
+
+	engine.addService<MM::Services::FilesystemService>(nullptr, "tilemap_render_task_test");
+	ASSERT_TRUE(engine.enableService<MM::Services::FilesystemService>());
+
+	auto& rs = engine.addService<MM::Services::OpenGLRenderer>();
+	ASSERT_TRUE(engine.enableService<MM::Services::OpenGLRenderer>());
+
+	rs.addRenderTask<MM::OpenGL::RenderTasks::Tilemap>(engine);
+
+	auto& rm_t = MM::ResourceManager<MM::OpenGL::Texture>::ref();
+
+	{
+		auto e = scene.create();
+		scene.emplace<MM::Components::Transform2D>(e);
+
+		auto& tm = scene.emplace<MM::OpenGL::TilemapRenderable>(e);
+
+		auto& slayer = tm.sprite_layer.emplace_back();
+
+		// fill sprite sheet
+		{
+			slayer.sprite_sheet.tile_count.x = 1;
+			slayer.sprite_sheet.tile_count.y = 1;
+			//slayer.sprite_sheet.tex = rm_t.get("default"_hs);
+			slayer.sprite_sheet.tex = rm_t.get("errig"_hs);
+		}
+
+		// fill tiles
+		{
+			std::vector<uint32_t> temp_map {
+				1, 1, 1, 1, 1,
+				1, 0, 0, 0, 1,
+				1, 0, 1, 0, 1,
+				1, 0, 0, 0, 1,
+				1, 1, 1, 1, 1,
+			};
+
+			uint32_t width = 5;
+			uint32_t height = 5;
+
+			for (uint32_t y = 0; y < height; y++) {
+				for (uint32_t x = 0; x < width; x++) {
+					if (temp_map[y*width + x] != 0) {
+						auto& tile = slayer.map.emplace_back();
+						tile.pos[0] = x;
+						tile.pos[1] = y;
+						tile.sprite_sheet_index = temp_map[y*width + x] - 1;
+					}
+				}
+			}
+
+			slayer.syncMapBuffer(); // send to opengl
+		}
+	}
+
+	engine.run();
+}
+