rutile-game/src/rutile/core/render_server.cppm

module;

#include <string>
#include <utility>

export module rutile.core.render_server;

import rutile.core.resource_manager;
import rutile.core.texture_loader;
import wrappers.sdl;

export namespace rutile
{
    using TextureID = unsigned int;
    using TextureManager = ResourceManager<TextureID, sdl::Texture, TextureLoader>;

    class RenderServer
    {
        sdl::Renderer renderer_;
        TextureLoader texture_loader_;
        TextureManager texture_manager_;

        public:
            RenderServer() = delete;

            explicit RenderServer(sdl::Renderer&& renderer)
                : renderer_{std::move(renderer)},
                  texture_loader_{renderer_},
                  texture_manager_{texture_loader_}
            {
                renderer_.set_vsync(1);
            }

            // No copy or move operations
            RenderServer(const RenderServer&) = delete;
            RenderServer& operator=(const RenderServer&) = delete;
            RenderServer(RenderServer&&) = delete;
            RenderServer& operator=(RenderServer&&) = delete;

            ~RenderServer() = default;

            constexpr sdl::Renderer& get_renderer()
            {
                return renderer_;
            }

            /**
             * Load a texture from a file (if not loaded yet) and return its texture ID.
             */
            constexpr TextureID load_texture(const std::string& filename)
            {
                return texture_manager_.load_resource_by_name(filename);
            }

            /**
             * Get a reference to a texture by its texture ID.
             */
            constexpr const sdl::Texture& get_texture(const TextureID texture_id) const
            {
                return texture_manager_.get_resource(texture_id);
            }

            void start_frame() const
            {
                renderer_.clear();
            }

            void finish_frame() const
            {
                renderer_.present();
            }

            void render_texture(
                const TextureID texture_id,
                const sdl::FRect* src_rect,
                const sdl::FRect* dest_rect
            ) const
            {
                render_texture(get_texture(texture_id), src_rect, dest_rect);
            }

            constexpr void render_texture(
                const sdl::Texture& texture,
                const sdl::FRect* src_rect,
                const sdl::FRect* dest_rect
            ) const
            {
                renderer_.render_texture(texture, src_rect, dest_rect);
            }
    };
}