SDL Breakout Engine: D:/Ryan_Temp/GithubProjects/monorepo-RyanRio/Assignment1_Breakout/Game/include/ResourceManager.hpp Source File

Go to the documentation of this file.
 #ifndef RESOURCE_MANAGER_HPP
 #define RESOURCE_MANAGER_HPP
  
 #include <SDL2/SDL_ttf.h>
 #include <SDL2/SDL_image.h>
 #include <map>
 #include <string>
 #include <memory>
 #include <iterator>
 #include <iostream>
  
 struct Sprite
 {
     std::shared_ptr<SDL_Surface> spriteSheet; 
     std::shared_ptr<SDL_Texture> texture; 
  
     ~Sprite()
     {
         SDL_Log("Sprite being freed");
     }
 };
  
 struct TextureWrapper
 {
     TextureWrapper(const std::shared_ptr<SDL_Texture> &texture)
     {
         mTexture = texture;
     }
  
     SDL_Texture* get() const
     {
         return mTexture.get();
     }
  
 private:
     std::shared_ptr<SDL_Texture> mTexture;
 };
  
 template <typename Derived, class T>
  
 class ResourceManager
 {
 public:
  
     int shutDown()
     {
         while (resourceMap.begin() != resourceMap.end())
         {
             resourceMap.erase(resourceMap.begin());
         }
  
         while (fileMap.begin() != fileMap.end())
         {
             fileMap.erase(fileMap.begin());
         }
  
         return 1;
     }
  
     std::shared_ptr<T> GetResource(const std::string &resourceName)
     {
         auto res = Find(resourceName);
  
         if (res)
             return res->first;
         else
             return NULL;
     }
  
     std::shared_ptr<T> Load(const std::string &path)
     {
         return static_cast<Derived *>(this)->Load(path);
     }
  
     bool AddResource(const std::string &resourceName)
     {
         auto res = Find(resourceName);
  
         if (res)
         {
             ++res->second;
             return true;
         }
  
         auto filePath = fileMap.find(resourceName);
         if (filePath == fileMap.end())
             return false;
  
         std::shared_ptr<T> resource = Load(filePath->second);
  
         if (!resource)
             return false;
  
         resourceMap.emplace(resourceName, std::make_pair(resource, 1));
  
         return true;
     }
  
     bool AddAllResource()
     {
         for (auto const &[key, val] : fileMap)
         {
             printf("loading resource: %s, %s\n", key.c_str(), val.c_str());
             if (!AddResource(key))
                 return false;
         }
         return true;
     }
  
 protected:
  
     std::map<std::string, std::pair<std::shared_ptr<T>, int>> resourceMap; 
     std::map<std::string, std::string> fileMap; 
  
     ResourceManager(){}; 
     ResourceManager(ResourceManager const &); 
     void operator=(ResourceManager const &); 
  
 private:
     std::pair<std::shared_ptr<T>, int> *Find(const std::string &resourceName)
     {
         auto itr = resourceMap.find(resourceName);
  
         if (itr != resourceMap.end())
         {
             return &itr->second;
         }
         else
         {
             return NULL;
         }
     }
 };
  
 #endif