FontSelectorComponent.cpp

#include "FontSelectorComponent.h"
 
#include "Context.h"
#include "Types.h"
#include "EntityStore.h"
 
#include "Components/Core/TextComponent.h"
 
#include "Resources/FontManager.h"
 
#include "Scene/SceneTraversal.h"
 
using namespace Cogs::Reflection;
 
void Cogs::Core::FontSelectorComponent::registerType()
{
  static constexpr EnumeratorDef enums [] = {
    { "ApplyToChildren", FontSelectorFlags::ApplyToChildren },
    { "SelfOnly", FontSelectorFlags::SelfOnly },
  };
 
  TypeDatabase::createType<FontSelectorFlags>().setEnumerators(enums);
 
  Field fields [] = {
    Field(Name("fontName"), &FontSelectorComponent::fontName),
    Field(Name("fontSize"), &FontSelectorComponent::fontSize),
    Field(Name("flags"), &FontSelectorComponent::flags),
  };
 
  Method methods [] = {
    Method(Name("initialize"), &FontSelectorComponent::initialize),
    Method(Name("update"), &FontSelectorComponent::update),
  };
 
  DynamicComponent::registerDerivedType<FontSelectorComponent>().setFields(fields).setMethods(methods);
}
 
void Cogs::Core::FontSelectorComponent::initialize(Context * context)
{
  this->context = context;
}
 
void Cogs::Core::FontSelectorComponent::update()
{
  if (!hasChanged()) return;
 
  // We just load a new font here. The font manager will take care of sharing font resources for us.
  fontHandle = context->fontManager->loadFont(fontName, fontSize, NoResourceId);
 
  switch (flags) {
  case Cogs::Core::FontSelectorFlags::ApplyToChildren:
    {
      recurseFontSelection(this, getContainer());
      applyRecursiveFieldChange(getContainer(), &TextComponent::fontHandle, fontHandle, [](const Entity* entity) {
        const FontSelectorComponent* fontSelectorComponent = entity->getComponent<FontSelectorComponent>();
        return fontSelectorComponent == nullptr || fontSelectorComponent->flags == FontSelectorFlags::ApplyToChildren;
        });
    }
    break;
 
  case Cogs::Core::FontSelectorFlags::SelfOnly:
    {
      auto textComponent = getComponent<TextComponent>();
 
      if (textComponent) {
        textComponent->fontHandle = fontHandle;
        textComponent->setChanged();
      }
 
      break;
    }
  }
}
 
void Cogs::Core::FontSelectorComponent::recurseFontSelection(const FontSelectorComponent* source, const Entity* parent)
{
  const SceneComponent* sceneComponent = parent->getComponent<SceneComponent>();
  if (sceneComponent) {
    for (auto& child : sceneComponent->children) {
      FontSelectorComponent* fontSelectorComponent = child->getComponent<FontSelectorComponent>();
      if (fontSelectorComponent) {
        if (fontSelectorComponent->fontName != source->fontName) {
          fontSelectorComponent->fontName = source->fontName;
          fontSelectorComponent->setChanged();
        }
        if (fontSelectorComponent->fontSize != source->fontSize) {
          fontSelectorComponent->fontSize = source->fontSize;
          fontSelectorComponent->setChanged();
        }
 
        if (fontSelectorComponent->flags == FontSelectorFlags::ApplyToChildren) {
          recurseFontSelection(source, child.get());
        }
      }
    }
  }
}