FontManager.h

#pragma once
 
#include "ResourceManager.h"
 
#include <unordered_map>
 
#include "Font.h"
 
#include "IFontLoader.h"
 
 
namespace std
{
  template<>
  struct hash<Cogs::Core::FontDefinition>
  {
    size_t operator()(const Cogs::Core::FontDefinition & definition) const
    {
      size_t val = std::hash<std::string>()(definition.fontFamily);
      val *= std::hash<float>()(definition.fontSize);
 
      return val;
    }
  };
}
 
 
namespace Cogs
{
  class IGraphicsDevice;
 
  namespace Core
  {
    class FontManager : public ResourceManager<Font, FontLoadInfo>
    {
    public:
      explicit FontManager(Context * context) : ResourceManager(context) {}
      
      ~FontManager() override;
 
      void initialize() override;
 
      void clear() override;
 
      COGSCORE_DLL_API FontHandle loadFont(const std::string & name, float size, ResourceId resourceId, ResourceLoadFlags flags = ResourceLoadFlags::None);
 
      FontHandle loadFont(const FontDefinition & definition, const ResourceId id, ResourceLoadFlags flags = ResourceLoadFlags::None);
 
      void getBakedCharacter(const Font * font, int characterIndex, float & x, float & y, Font::BakedCharacter & bakedCharacter) const;
 
      void handleLoad(FontLoadInfo * loadInfo) override;
 
      ActivationResult handleActivation(FontHandle handle, Font * font) override;
 
      void handleDeletion(Font* font) override;
 
      void handleFailedLoad(const FontLoadInfo * loadInfo) override;
 
      virtual bool shouldMergeBySource() const override { return false; }
 
    public:
      ResourceId DefaultMonospaceFont = NoResourceId;
 
      ResourceId DefaultRegularFont = NoResourceId;
 
      ResourceId DefaultBoldFont = NoResourceId;
 
      FontHandle regularFont = FontHandle::NoHandle;
 
      FontHandle boldFont = FontHandle::NoHandle;
 
      std::unordered_map<FontDefinition, FontHandle> sharedFonts;
    };
  }
}