TextSystem.cpp

#include "Rendering/ICapabilities.h"
 
#include "TextSystem.h"
 
#include "Context.h"
 
 
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/SpriteRenderSystem.h"
 
#include "Resources/MaterialManager.h"
#include "Resources/FontManager.h"
#include "Resources/Texture.h"
 
void Cogs::Core::TextSystem::initialize(Context * context)
{
  ComponentSystem::initialize(context);
 
  if (context->device->getCapabilities()->getDeviceCapabilities().GeometryShaders) {
    textMaterial = context->materialManager->loadMaterial("Materials/TextMaterial.material");
  }
  else {
    textMaterial = context->materialManager->loadMaterial("Materials/TextNoGsMaterial.material");
  }
  context->materialManager->processLoading();
 
  textMaterial->options.blendMode = BlendMode::PremultipliedBlend;
  textMaterial->options.depthWriteEnabled = false;
 
  spriteMaterial = context->spriteRenderSystem->registerSpriteMaterial(textMaterial);
}
 
void Cogs::Core::TextSystem::update(Context * context)
{
  for (auto & component : pool) {
    if (!component.transformComponent) {
      component.transformComponent = component.getComponentHandle<TransformComponent>();
      component.spriteRenderComponent = component.getComponentHandle<SpriteRenderComponent>();
    }
  }
 
  auto fontManager = context->fontManager;
  auto sprites = context->spriteRenderSystem;
  for (auto & textComponent : pool) {
    if (!textComponent.texts.size()) continue;
    if (!textComponent.spriteRenderComponent) continue;
 
    auto spriteRenderer = textComponent.spriteRenderComponent.resolveComponent<SpriteRenderComponent>();
 
    if (!spriteRenderer->isVisible()) continue;
 
    auto font = textComponent.fontHandle.resolve();
    if (!font) font = context->fontManager->getHandle(context->fontManager->DefaultRegularFont).resolve();
 
    if (!font || !font->isActive()) continue;
    if (!font->texture) continue;
    if (!font->texture->isActive()) continue;
 
    auto batch = sprites->begin(spriteMaterial,
      font->sdf ? "Sdf" : "",
      textComponent.positionMode,
      SizeMode::Pixels,
      font->texture,
      textComponent.color);
 
#ifdef EMSCRIPTEN
    batch->blendMode = BlendMode::Blend;
#else
    batch->blendMode = BlendMode::PremultipliedBlend;
#endif
 
    const bool useOffsets = textComponent.positions.size() == textComponent.texts.size();
    const auto transformComponent = textComponent.transformComponent.resolveComponent<TransformComponent>();
 
    for (size_t i = 0; i < textComponent.texts.size(); ++i) {
      auto & text = textComponent.texts[i];
 
      if (textComponent.colors.size() == textComponent.texts.size()) {
        batch = sprites->begin(spriteMaterial,
          font->sdf ? "Sdf" : "",
          textComponent.positionMode,
          SizeMode::Pixels,
          font->texture,
          textComponent.colors[i]);
        batch->blendMode = BlendMode::PremultipliedBlend;
      }
 
      const glm::vec3 offset = useOffsets ? textComponent.positions[i] : glm::vec3(0.0f);
      glm::vec3 startPosition = glm::vec3(0.0f);
      float depth = -1;
 
      if (textComponent.positionMode == PositionMode::World) {
        auto & localToWorld = context->transformSystem->getLocalToWorld(transformComponent);
        auto position = glm::vec3(localToWorld * glm::vec4(0, 0, 0, 1));
        startPosition = glm::vec4(position + offset, 1);
      } else if (textComponent.positionMode == PositionMode::Local) {
        startPosition = glm::vec4(offset, 1);
        batch->transform = context->transformSystem->getLocalToWorld(transformComponent);
      } else {
        startPosition += transformComponent->position + offset;
      }
 
      batch->depth = std::max(batch->depth, depth);
 
      const float factor = 0.72f;
      float verticalOffset = 0.0f;
      switch (textComponent.verticalAlignment) {
      case VerticalAlignment::Center:
        verticalOffset = (font->size / 2.0f) * factor;
        break;
      case VerticalAlignment::Bottom:
        verticalOffset = (font->size) * factor;
        break;
      default:
        break;
      }
 
      float x = 0;
      float y = 0;
 
      if (textComponent.horizontalJustification == HorizontalJustification::Left) {
        for (size_t ii = 0; ii < text.size(); ++ii) {
          Font::BakedCharacter q;
          fontManager->getBakedCharacter(font, text[ii], x, y, q);
 
          glm::vec2 offset2 = {
            (q.x0 + q.x1) * 0.5f,
            (q.y0 + q.y1) * -0.5f - verticalOffset,
          };
 
          glm::vec2 size = {
            q.x1 - q.x0,
            q.y1 - q.y0
          };
 
          glm::vec4 uv = {
            q.s0,
            q.t1,
            q.s1,
            q.t0,
          };
 
          sprites->addSprite(spriteRenderer, startPosition, offset2, size, uv);
        }
      } else if(textComponent.horizontalJustification == HorizontalJustification::Right) {
        const float startX = x;
 
        for (size_t ii = 0; ii < text.size(); ++ii) {
          Font::BakedCharacter q;
          fontManager->getBakedCharacter(font, text[text.size() - 1 - ii], x, y, q);
 
          const float width = q.x1 - q.x0;
          const float start = startX - (q.x0 - startX);
 
          glm::vec2 offset2 = {
            start - width * 0.5f,
            (q.y0 + q.y1) * -0.5f - verticalOffset,
          };
 
          glm::vec2 size = {
            q.x1 - q.x0,
            q.y1 - q.y0
          };
 
          glm::vec4 uv = {
            q.s0,
            q.t1,
            q.s1,
            q.t0,
          };
 
          sprites->addSprite(spriteRenderer, startPosition, offset2, size, uv);
        }
      }
      else {
        Font::BakedCharacter q0;
        fontManager->getBakedCharacter(font, text[0], x, y, q0);
        Font::BakedCharacter qn = q0;
 
        for (size_t ii = 1; ii < text.size(); ++ii)
          fontManager->getBakedCharacter(font, text[ii], x, y, qn);
        x = 0;
        y = 0;
        const float horizontalOffset = (qn.x1 - q0.x0) * 0.5f;
 
        for (size_t ii = 0; ii < text.size(); ++ii) {
          Font::BakedCharacter q;
          fontManager->getBakedCharacter(font, text[ii], x, y, q);
 
          glm::vec2 offset_ = {
            (q.x0 + q.x1) * 0.5f - horizontalOffset,
            (q.y0 + q.y1) * -0.5f - verticalOffset,
          };
 
          glm::vec2 size = {
            q.x1 - q.x0,
            q.y1 - q.y0
          };
 
          glm::vec4 uv = {
            q.s0,
            q.t1,
            q.s1,
            q.t0,
          };
 
          sprites->addSprite(spriteRenderer, startPosition, offset_, size, uv);
        }
      }
 
      if (batch->positionMode >= PositionMode::World) {
        batch->flags |= RenderItemFlags::CalculateDepth;
      }
    }
  }
}