FontManager.cpp

#include "FontManager.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "ResourceStore.h"
 
#include "Context.h"
 
#include "TextureManager.h"
 
#include "Services/TaskManager.h"
 
#include <cmath>
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("FontManager");
}
 
Cogs::Core::FontManager::~FontManager()
{
  reportLeaks("Font");
}
 
void Cogs::Core::FontManager::initialize()
{
  ResourceManager::initialize();
 
  DefaultMonospaceFont = getNextResourceId();
  DefaultRegularFont = getNextResourceId();
  DefaultBoldFont = getNextResourceId();
 
  defaultResource = loadFont("Fonts/Inconsolata-Regular.ttf", 16, DefaultMonospaceFont);
  regularFont = loadFont("Fonts/SourceSansPro-Regular.ttf", 20, DefaultRegularFont);
  boldFont = loadFont("Fonts/SourceCodePro-Bold.ttf", 36, DefaultBoldFont);
 
#ifdef _WIN32
  context->resourceStore->addSearchPath("C:/Windows/Fonts/");
#endif
 
  LOG_DEBUG(logger, "Initialized font manager.");
}
 
void Cogs::Core::FontManager::clear()
{
  defaultResource = FontHandle::NoHandle;
  boldFont = FontHandle::NoHandle;
  regularFont = FontHandle::NoHandle;
 
  sharedFonts.clear();
  swapQueue.clear();
 
  ResourceManager::clear();
}
 
Cogs::Core::FontHandle Cogs::Core::FontManager::loadFont(const std::string & name, float size, const ResourceId id, ResourceLoadFlags flags)
{
  return loadFont(FontDefinition{ .fontFamily = name, .fontSize = size }, id, flags);
}
 
Cogs::Core::FontHandle Cogs::Core::FontManager::loadFont(const FontDefinition & definition, ResourceId resourceId, ResourceLoadFlags flags)
{
  auto sharedFont = sharedFonts.find(definition);
 
  // Reuse existing if handle is accessible by client, e.g. not released.
  if (sharedFont != sharedFonts.end() && isValidResource(sharedFont->second->getId())) {
    return sharedFont->second;
  }
 
  if (resourceId == NoResourceId) {
    resourceId = getNextResourceId();
  }
 
  // Font not matching any existing fonts. Avoid reusing resource with same path, but different size.
  FontLoadInfo & loadInfo = *createLoadInfo();
  loadInfo.resourceId = resourceId;
  loadInfo.loadFlags = flags;
 
  //FIXME: Make font path lookup platform independent.
  loadInfo.definition = definition;
  loadInfo.resourceName = definition.fontFamily + " " + std::to_string(definition.fontSize) + "px";
#ifdef _WIN32
  if (definition.fontFamily.find("System:") != std::string::npos) {
    loadInfo.resourcePath = "C:/Windows/Fonts/" + definition.fontFamily.substr(7) + ".ttf";
  } else {
    loadInfo.resourcePath = definition.fontFamily;
  }
#else
  loadInfo.resourcePath = definition.fontFamily;
#endif
 
  auto handle = loadResource(&loadInfo);
 
  // Default fonts (and corresponding texture, see handleActivation()) as dependency resources to
  // ensure the scene is redrawn when ready.
  handle->setFlag(ResourceFlags::Dependency);
 
  sharedFonts[definition] = handle;
 
  return handle;
}
 
void Cogs::Core::FontManager::handleLoad(FontLoadInfo * loadInfo)
{
  if (!checkPreloaded(loadInfo)) return;
 
  auto loadResource = [loadInfo, this]()
  {
    auto loader = findLoader(loadInfo);
 
    if (loader) {
      if (!loader->load(context, *loadInfo)) {
        loadInfo->handle->setFailedLoad();
      }
    } else {
      LOG_WARNING(logger, "No suitable font loader found for %s.", loadInfo->resourceName.c_str());
 
      loadInfo->handle->setFailedLoad();
    }
 
    setProcessed(loadInfo, !loadInfo->loadSync());
  };
 
  if (loadInfo->loadSync()) {
    loadResource();
  } else {
    context->taskManager->enqueue(TaskManager::ResourceQueue, loadResource);
  }
}
 
namespace Cogs
{
  namespace Core
  {
    inline void getCharacterQuad(const Font::Character * chardata, int pw, int ph, int charIndex, float * xPos, float * yPos, Font::BakedCharacter * q, int openGLFill, int alignToInteger = 0)
    {
      const float d3dBias = openGLFill ? 0 : -0.5f;
      float ipw = 1.0f / pw, iph = 1.0f / ph;
      const Font::Character * b = chardata + charIndex;
 
      if (alignToInteger) {
        float x = floorf((*xPos + b->xOffset) + 0.5f);
        float y = floorf((*yPos + b->yOffset) + 0.5f);
        q->x0 = x + d3dBias;
        q->y0 = y + d3dBias;
        q->x1 = x + b->xOffset2 - b->xOffset + d3dBias;
        q->y1 = y + b->yOffset2 - b->yOffset + d3dBias;
      } else {
        q->x0 = *xPos + b->xOffset + d3dBias;
        q->y0 = *yPos + b->yOffset + d3dBias;
        q->x1 = *xPos + b->xOffset2 + d3dBias;
        q->y1 = *yPos + b->yOffset2 + d3dBias;
      }
 
      q->s0 = b->x0 * ipw;
      q->t0 = b->y0 * iph;
      q->s1 = b->x1 * ipw;
      q->t1 = b->y1 * iph;
 
      *xPos += b->xAdvance;
    }
  }
}
 
void Cogs::Core::FontManager::getBakedCharacter(const Font * font, int characterIndex, float & x, float & y, Font::BakedCharacter & bakedCharacter) const
{
  if (characterIndex < 0) {
    characterIndex += 256;
  } else if (characterIndex > 255) {
    characterIndex = 0;
  }
 
  getCharacterQuad(font->characters.data(), font->bitmapSize, font->bitmapSize, characterIndex, &x, &y, &bakedCharacter, true, true);
}
 
void Cogs::Core::FontManager::handleFailedLoad(const FontLoadInfo * loadInfo)
{
  LOG_WARNING(logger, "Loading font from path %s failed.", loadInfo->resourcePath.c_str());
}
 
Cogs::Core::ActivationResult Cogs::Core::FontManager::handleActivation(FontHandle, Font * font)
{
  auto textureManager = context->textureManager;
 
  if (font->bitmap.empty()) {
    LOG_ERROR(logger, "Font contents empty.");
    return ActivationResult::Failure;
  }
 
  auto texture = textureManager->loadTexture2D(font->bitmap.data(),
                                               font->bitmapSize,
                                               font->bitmapSize,
                                               TextureFormat::R8G8B8A8_UNORM_SRGB,
                                               0,
                                               NoResourceId,
                                               TextureLoadFlags::None);
 
  if (HandleIsValid(texture)) {
    font->texture = texture;
 
    texture->setName("Texture:" + font->getName().to_string());
    texture->setFlag(ResourceFlags::Dependency);
 
    return ActivationResult::Success;
  } else {
    return ActivationResult::Failure;
  }
}
 
void Cogs::Core::FontManager::handleDeletion(Font * font)
{
  font->unsetFlag(ResourceFlags::Resident);
}