ImageRepository.h

Go to the documentation of this file.

#pragma once

#include <chrono>
#include <future>
#include <iterator>
#include <map>
#include <vector>
#include <type_traits>
#include "Renderer.h"
#include "Surface.h"
#include "Texture.h"
#include "Utilities.h"

namespace rose {
    using namespace std;

    class ImageRepository {
    public:

        using ImageStore = map<ImageId, sdl::TextureData>;

        using SurfaceStore = map<ImageId, sdl::Surface>;

        static constexpr ImageId InvalidImageId = 0x0u;     

        static constexpr ImageId FirstApplicationImageId = 0x100u;

    protected:
        static constexpr ImageId FirstUserImageId = 0x200u; 
        ImageId mNextUserImageId;                           

        ImageStore mImageStore{};       
        SurfaceStore mSurfaceStore{};   

        void getSurface(sdl::Renderer &renderer, ImageId imageId) {
            if (!mSurfaceStore.empty()) {
                if (auto surface = mSurfaceStore.find(imageId); surface != mSurfaceStore.end()) {
                    if (!mImageStore.empty() && mImageStore.find(imageId) == mImageStore.end()) {
                        sdl::TextureData textureData{surface->second.toTexture(renderer)};
                        textureData.setLoadedTime(std::chrono::system_clock::now());
                        mImageStore[imageId] = std::move(textureData);
                    } else {
                        mImageStore.at(imageId) = surface->second.toTexture(renderer).release();
                        mImageStore.at(imageId).setLoadedTime(std::chrono::system_clock::now());
                    }
                    mSurfaceStore.erase(imageId);
                }
            }
        }

    public:
        ImageRepository() : mNextUserImageId{FirstUserImageId} {}

        ~ImageRepository() = default;

        ImageId getImageId() {
            return mNextUserImageId++;
        }

        sdl::TextureData &image(ImageId imageId) {
            return mImageStore.at(imageId);
        }

        [[nodiscard]] const sdl::TextureData &image(ImageId imageId) const {
            return (mImageStore.at(imageId));
        }

        [[nodiscard]] string_view imageName(ImageId imageId) const {
            return mImageStore.at(imageId).getName();
        }

        [[nodiscard]] string_view imagePath(ImageId imageId) const {
            return mImageStore.at(imageId).getPath();
        }

        [[nodiscard]] string_view imageURI(ImageId imageId) const {
            return mImageStore.at(imageId).getPath();
        }

        void renderCopy(sdl::Renderer &renderer, ImageId imageId, SDL_Rect &imgSrcRect, SDL_Rect &imgPaintRect) {
            getSurface(renderer, imageId);
            auto tex = mImageStore.at(imageId).get();
            SDL_RenderCopy(renderer.get(), tex, &imgSrcRect, &imgPaintRect);
        }

        void renderCopy(sdl::Renderer &renderer, ImageId imageId, SDL_Rect &imgPaintRect) {
            getSurface(renderer, imageId);
            SDL_RenderCopy(renderer.get(), mImageStore.at(imageId).get(), nullptr, &imgPaintRect);
        }

        void renderCopy(sdl::Renderer &renderer, ImageId imageId, Rectangle &imgSrcRect, Rectangle &imgDstRect) {
            auto src = imgSrcRect.toSdlRect();
            auto dst = imgDstRect.toSdlRect();
            renderCopy(renderer, imageId, src, dst);
        }

        void renderCopy(sdl::Renderer &renderer, ImageId imageId, Rectangle &imgDstRect) {
            auto dst = imgDstRect.toSdlRect();
            sdl::ClipRectangleGuard clipRectangleGuard(renderer);
            Rectangle clip{imgDstRect};
            clipRectangleGuard.intersection(clip);
            renderCopy( renderer, imageId, dst);
        }

        void setImage(ImageId imageId, sdl::TextureData textureData) {
            mImageStore[imageId] = std::move(textureData);
        }

        void setImageSurface(ImageId imageId, sdl::Surface &surface) {
            mSurfaceStore[imageId] = std::move(surface);
        }

        [[nodiscard]] bool empty() const { return mImageStore.empty(); }

        [[nodiscard]] auto size() const { return mImageStore.size(); }

        bool isValidImage(sdl::Renderer &renderer, ImageId imageId) {
            if (!mImageStore.empty() && mImageStore.find(imageId) != mImageStore.end())
                return true;
            if (!mSurfaceStore.empty() && mSurfaceStore.find(imageId) != mSurfaceStore.end()) {
                getSurface(renderer, imageId);
                return true;
            }
            return false;
        }
    };
}