asset_manager.h

Go to the documentation of this file.

 
 
#ifndef ASW_ASSET_MANAGER_H
#define ASW_ASSET_MANAGER_H
 
#include <string>
#include <unordered_map>
 
#include "./assets.h"
#include "./types.h"
 
namespace asw {
 
  class AssetManager {
   public:
    // --- Textures ---
 
    Texture getTexture(const std::string& path) {
      auto it = textures.find(path);
      if (it != textures.end()) {
        return it->second;
      }
      auto tex = asw::assets::loadTexture(path);
      textures[path] = tex;
      return tex;
    }
 
    bool hasTexture(const std::string& path) const {
      return textures.find(path) != textures.end();
    }
 
    // --- Fonts ---
 
    Font getFont(const std::string& path, float size) {
      std::string key = path + ":" + std::to_string(size);
      auto it = fonts.find(key);
      if (it != fonts.end()) {
        return it->second;
      }
      auto font = asw::assets::loadFont(path, size);
      fonts[key] = font;
      return font;
    }
 
    bool hasFont(const std::string& path, float size) const {
      std::string key = path + ":" + std::to_string(size);
      return fonts.find(key) != fonts.end();
    }
 
    // --- Samples ---
 
    Sample getSample(const std::string& path) {
      auto it = samples.find(path);
      if (it != samples.end()) {
        return it->second;
      }
      auto sample = asw::assets::loadSample(path);
      samples[path] = sample;
      return sample;
    }
 
    bool hasSample(const std::string& path) const {
      return samples.find(path) != samples.end();
    }
 
    // --- Music ---
 
    Music getMusic(const std::string& path) {
      auto it = music.find(path);
      if (it != music.end()) {
        return it->second;
      }
      auto m = asw::assets::loadMusic(path);
      music[path] = m;
      return m;
    }
 
    bool hasMusic(const std::string& path) const {
      return music.find(path) != music.end();
    }
 
    // --- Management ---
 
    void unloadTexture(const std::string& path) { textures.erase(path); }
 
    void unloadFont(const std::string& path, float size) {
      fonts.erase(path + ":" + std::to_string(size));
    }
 
    void unloadSample(const std::string& path) { samples.erase(path); }
 
    void unloadMusic(const std::string& path) { music.erase(path); }
 
    void clear() {
      textures.clear();
      fonts.clear();
      samples.clear();
      music.clear();
    }
 
    size_t getTextureCount() const { return textures.size(); }
 
    size_t getFontCount() const { return fonts.size(); }
 
    size_t getSampleCount() const { return samples.size(); }
 
    size_t getMusicCount() const { return music.size(); }
 
    size_t getTotalCount() const {
      return textures.size() + fonts.size() + samples.size() + music.size();
    }
 
   private:
    std::unordered_map<std::string, Texture> textures;
    std::unordered_map<std::string, Font> fonts;
    std::unordered_map<std::string, Sample> samples;
    std::unordered_map<std::string, Music> music;
  };
 
}  // namespace asw
 
#endif  // ASW_ASSET_MANAGER_H