ResourceManager.hpp

#pragma once
 
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <unordered_map>
#include <string>
#include <memory>
 
//Functor
struct TextureFunctorDeleter {
    void operator()(SDL_Texture* texture) const {
        SDL_DestroyTexture(texture);
    }
};
 
std::shared_ptr<SDL_Texture> make_shared_texture(SDL_Renderer* renderer, SDL_Surface* pixels);
 
struct ResourceManager {
 
    static ResourceManager& Instance() {
        if (nullptr == mInstance) {
            mInstance = new ResourceManager;
        }
 
        return *mInstance;
    }
 
    std::shared_ptr<SDL_Texture> LoadTexture(SDL_Renderer* renderer, std::string filepath) {
        if (!mTextureResources.contains(filepath)) {
            // Load the image
            auto extension = filepath.substr(filepath.find_last_of(".") + 1);
            int imgFlags;
            SDL_Surface* pixels;
 
            if (extension == "bmp") {
                pixels = SDL_LoadBMP(filepath.c_str());
            } else {
                if (extension == "png") {
                    imgFlags = IMG_INIT_PNG;
                } else if (extension == "jpg" || extension == "jpeg") {
                    imgFlags = IMG_INIT_JPG;
                } else if (extension == "avif") {
                    imgFlags = IMG_INIT_AVIF;
                } else if (extension == "jxl") {
                    imgFlags = IMG_INIT_JXL;
                } else if (extension == "tif") {
                    imgFlags = IMG_INIT_TIF;
                } else if (extension == "webp") {
                    imgFlags = IMG_INIT_WEBP;
                } else {
                    SDL_Log("Unsupported image format %s", extension.c_str());
                    return nullptr;
                }
                if( !(IMG_Init(imgFlags) & imgFlags)) {
                    SDL_Log( "SDL_image could not initialize! SDL_image Error: %s\n", IMG_GetError() );
                    return nullptr;
                }
                pixels = IMG_Load(filepath.c_str());
            }
 
            if (!pixels) {
                SDL_Log("Failed to load image %s", filepath.c_str());
                return nullptr;
            }
            SDL_SetColorKey(pixels, SDL_TRUE, SDL_MapRGB(pixels->format,0xFF,0,0xFF));
            std::shared_ptr<SDL_Texture> texture = make_shared_texture(renderer, pixels);
            mTextureResources.insert({filepath, texture});
            SDL_FreeSurface(pixels);
            SDL_Log("Created new resource %s", filepath.c_str());
        } else {
            SDL_Log("Reused resource %s", filepath.c_str());
        }
 
        return mTextureResources[filepath];
    }
 
    private:
        ResourceManager() {
        }
 
        inline static ResourceManager* mInstance {nullptr};
        std::unordered_map<std::string, std::shared_ptr<SDL_Texture>> mTextureResources;
};