initial import, >900commits predate this

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
+