initial import, >900commits predate this

framework/simple_sdl_renderer/CMakeLists.txt

@@ -0,0 +1,28 @@
+cmake_minimum_required(VERSION 3.2)
+project(simple_sdl_renderer_service CXX)
+
+add_library(simple_sdl_renderer_service
+	src/mm/simple_sdl_renderer/target.hpp
+
+	src/mm/services/simple_sdl_renderer.hpp
+	src/mm/services/simple_sdl_renderer.cpp
+)
+
+target_include_directories(simple_sdl_renderer_service PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/src")
+target_include_directories(simple_sdl_renderer_service PUBLIC "${SDL2_INCLUDE_DIR}")
+
+target_link_libraries(simple_sdl_renderer_service
+	engine
+	glm
+	sdl_service
+)
+
+if(EMSCRIPTEN)
+	set_target_properties(simple_sdl_renderer_service PROPERTIES COMPILE_FLAGS "-s USE_SDL=2")
+	set_target_properties(simple_sdl_renderer_service PROPERTIES LINK_FLAGS "-s USE_SDL=2")
+endif()
+
+if (BUILD_TESTING)
+	add_subdirectory(test)
+endif()
+

framework/simple_sdl_renderer/src/mm/services/simple_sdl_renderer.cpp

@@ -0,0 +1,77 @@
+#include "simple_sdl_renderer.hpp"
+
+#include <mm/logger.hpp>
+#define LOG_CRIT(...)		__LOG_CRIT(	"SimpleSDLRenderer", __VA_ARGS__)
+#define LOG_ERROR(...)		__LOG_ERROR("SimpleSDLRenderer", __VA_ARGS__)
+#define LOG_WARN(...)		__LOG_WARN(	"SimpleSDLRenderer", __VA_ARGS__)
+#define LOG_INFO(...)		__LOG_INFO(	"SimpleSDLRenderer", __VA_ARGS__)
+#define LOG_DEBUG(...)		__LOG_DEBUG("SimpleSDLRenderer", __VA_ARGS__)
+#define LOG_TRACE(...)		__LOG_TRACE("SimpleSDLRenderer", __VA_ARGS__)
+
+
+namespace MM::Services {
+
+SimpleSDLRendererService::SimpleSDLRendererService(void) {
+	MM::Logger::initSectionLogger("SimpleSDLRenderer");
+}
+
+SimpleSDLRendererService::~SimpleSDLRendererService(void) {
+}
+
+bool SimpleSDLRendererService::enable(Engine& engine) {
+	auto* sdl_ss = engine.tryService<SDLService>();
+	if (!sdl_ss) {
+		LOG_ERROR("SimpleSDLRendererService requires SDLService in engine!");
+		return false;
+	}
+
+	if (!sdl_ss->win) {
+		sdl_ss->createWindow("SimpleSDLRendererService Window", 800, 600);
+	}
+
+	renderer = SDL_CreateRenderer(
+			sdl_ss->win,
+			-1,
+			SDL_RENDERER_ACCELERATED |
+			SDL_RENDERER_PRESENTVSYNC |
+			SDL_RENDERER_TARGETTEXTURE
+		);
+
+	if (!renderer) {
+		LOG_ERROR("could not create sdl_renderer");
+		return false;
+	}
+
+	_render_handle = engine.addUpdate([this](Engine& e){ this->render(e); });
+
+	targets["display"].reset(renderer, 800, 600);
+
+	return true;
+}
+
+void SimpleSDLRendererService::disable(Engine& engine) {
+	if (!_render_handle.expired()) {
+		engine.removeUpdate(_render_handle);
+	}
+
+	processors.clear();
+
+	targets.clear();
+
+	SDL_DestroyRenderer(renderer);
+}
+
+void SimpleSDLRendererService::render(Engine& engine) {
+	targets["display"].clear(renderer, {40, 40, 40, 255});
+
+	for (auto& p : processors) {
+		p(*this, engine);
+	}
+
+	SDL_SetRenderTarget(renderer, NULL);
+	SDL_RenderCopy(renderer, targets["display"].texture, NULL, NULL);
+	SDL_RenderPresent(renderer);
+}
+
+} // namespace MM::Services
+

framework/simple_sdl_renderer/src/mm/services/simple_sdl_renderer.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <SDL.h>
+
+#include <mm/engine.hpp>
+
+#include <mm/services/sdl_service.hpp>
+
+#include <mm/simple_sdl_renderer/target.hpp>
+
+namespace MM::Services {
+
+	class SimpleSDLRendererService : public Service {
+		public:
+			SimpleSDLRendererService(void);
+			~SimpleSDLRendererService(void);
+
+			SDL_Renderer* renderer = nullptr;
+
+			std::unordered_map<std::string, SimpleSDLRenderer::Target> targets;
+
+			std::vector<std::function<void(SimpleSDLRendererService&, Engine&)>> processors;
+
+		private:
+			Engine::FunctionDataHandle _render_handle;
+
+		public:
+			bool enable(Engine& engine) override;
+			void disable(Engine& engine) override;
+
+			const char* name(void) override { return "SimpleSDLServiceSystem"; };
+
+		private:
+			void render(Engine& engine);
+	};
+
+} // namespace MM::Services
+

framework/simple_sdl_renderer/src/mm/simple_sdl_renderer/target.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <SDL.h>
+
+namespace MM::SimpleSDLRenderer {
+
+	struct Target {
+		SDL_Texture* texture = nullptr;
+
+		~Target(void) {
+			SDL_DestroyTexture(texture);
+		}
+
+		void reset(SDL_Renderer* ren, int width, int height) {
+			if (texture)
+				SDL_DestroyTexture(texture);
+
+			texture = SDL_CreateTexture(ren, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, width, height);
+		}
+
+		void clear(SDL_Renderer* ren, SDL_Color col = {0,0,0,255}) {
+			set(ren);
+			SDL_SetRenderDrawColor(ren, col.r, col.g, col.b, col.a);
+			SDL_RenderClear(ren);
+		}
+
+		void set(SDL_Renderer* ren) {
+			SDL_SetRenderTarget(ren, texture);
+		}
+	};
+
+} // MM::SimpleSDLRenderer
+

framework/simple_sdl_renderer/test/CMakeLists.txt

@@ -0,0 +1,14 @@
+add_executable(simple_sdl_renderer_service_test
+	start_test.cpp
+)
+
+target_include_directories(simple_sdl_renderer_service_test PRIVATE ".")
+
+target_link_libraries(simple_sdl_renderer_service_test
+	simple_sdl_renderer_service
+	sdl_service
+	gtest_main
+)
+
+add_test(NAME simple_sdl_renderer_service_test COMMAND simple_sdl_renderer_service_test)
+

framework/simple_sdl_renderer/test/start_test.cpp

@@ -0,0 +1,38 @@
+#include <gtest/gtest.h>
+
+#include <mm/engine.hpp>
+
+#include <mm/services/sdl_service.hpp>
+#include <mm/services/simple_sdl_renderer.hpp>
+
+TEST(simple_sdl_renderer, basic) {
+	srand(1);
+	MM::Engine engine;
+
+	// sdl dep
+	{
+		engine.addService<MM::Services::SDLService>();
+		ASSERT_TRUE(engine.enableService<MM::Services::SDLService>());
+	}
+
+	auto& ren = engine.addService<MM::Services::SimpleSDLRendererService>();
+	ASSERT_TRUE(engine.enableService<MM::Services::SimpleSDLRendererService>());
+
+	ren.processors.emplace_back([](auto& r, auto&) {
+			r.targets["display"].set(r.renderer);
+
+			SDL_Rect rect {
+				rand() % 700,
+				rand() % 500,
+				100,
+				100
+			};
+
+			SDL_SetRenderDrawColor(r.renderer, 255, 0, 0, 255);
+			SDL_RenderFillRect(r.renderer, &rect);
+		}
+	);
+
+	engine.run();
+}
+