Text3DSystem.cpp

#include "Text3DSystem.h"
#include "TransformSystem.h"
 
#include "../../Context.h"
#include "../../Components/Appearance/MaterialComponent.h"
#include "../../Components/Core/MeshComponent.h"
#include "../../Components/Core/MeshRenderComponent.h"
#include "../../Resources/MaterialManager.h"
#include "../../Resources/MeshManager.h"
#include "../../Resources/FontManager.h"
#include "../../Resources/Texture.h"
 
#include "Rendering/ICapabilities.h"
#include "Foundation/Geometry/IndicesGenerator.h"
 
void Cogs::Core::Text3DSystem::update(Context* context) {
  Cogs::Core::FontManager*  fontManager = context->fontManager;
 
  for (const Text3DComponent& textComponent : pool) {
    if (textComponent.isValid()) {
      Font*                 font = textComponent.fontHandle.resolve();
      MaterialComponent*    material = textComponent.getComponent<MaterialComponent>();
      MeshRenderComponent*  meshRenderComp = textComponent.getComponent<MeshRenderComponent>();
      MaterialInstance*     materialInstance = nullptr;
      bool                  materialChanged = false;
 
      if (!font) {
        font = fontManager->getHandle(fontManager->DefaultRegularFont).resolve();
      }
      if (material) {
        if (material->diffuseMap != font->texture) {
          materialChanged = true;
        }
      }
      else {
        materialInstance = meshRenderComp->material.resolve();
 
        if (materialInstance && (materialInstance->getTextureProperty(materialInstance->material->getTextureKey("diffuseMap")).texture.handle != font->texture)) {
          materialChanged = true;
        }
      }
 
      if (font &&
          font->isActive() &&
          font->texture &&
          font->texture->isActive() &&
          (textComponent.hasChanged() || materialChanged)) {
        MeshHandle              meshHandle = context->meshManager->create();
        Mesh*                   mesh = meshHandle.resolve();
        std::vector<glm::vec3>  vertices;
        std::vector<glm::vec2>  uvs;
        std::vector<glm::vec4>  colours;
        size_t                  glyphCount = 0;
 
        for (const std::string& t : textComponent.texts) {
          glyphCount += t.size();
        }
        vertices.reserve(glyphCount * 4);
        uvs.reserve(glyphCount * 4);
        colours.reserve(glyphCount * 4);
 
        for (size_t textIdx = 0, textCount = textComponent.texts.size(); textIdx < textCount; ++textIdx) {
          const std::string&  text = textComponent.texts[textIdx];
          const glm::vec3&    position = textComponent.positions[textIdx];
          const glm::vec3&    hAxis = textComponent.hAxes[textIdx];
          const glm::vec3&    vAxis = textComponent.vAxes[textIdx];
          const glm::vec4&    colour = textComponent.colors.empty() ? textComponent.defaultColor : textComponent.colors[textIdx];
          const Alignment&    alignment = textComponent.alignments.empty() ? textComponent.defaultAlignment : textComponent.alignments[textIdx];
 
          generateText(vertices, uvs, fontManager, *font, text, position, hAxis, vAxis, alignment);
          colours.insert(colours.end(), text.size() << 2, colour);
        }
 
        std::vector<uint32_t> indices;
        constexpr float       maxfloat = std::numeric_limits<float>::max();
        glm::vec3             minbounds(maxfloat, maxfloat, maxfloat);
        glm::vec3             maxbounds(-maxfloat, -maxfloat, -maxfloat);
 
        for (glm::vec3& vert : vertices) {
          minbounds = glm::min(minbounds, vert);
          maxbounds = glm::max(maxbounds, vert);
        }
 
        Geometry::generateQuadIndices(indices, vertices.size() >> 2, 0, false);
 
        mesh->setName(textComponent.getContainer()->getName());
        mesh->setPositions(vertices);
        mesh->setTexCoords(uvs);
        mesh->setColors(colours);
        mesh->setIndexData(std::move(indices));
        mesh->setBounds({minbounds, maxbounds});
 
        textComponent.getComponent<MeshComponent>()->meshHandle = meshHandle;
        textComponent.getComponent<MeshComponent>()->setChanged();
 
        if (material) {
          material->diffuseMap = font->texture;
          material->setChanged();
        }
        else if (materialInstance) {
          materialInstance->setTextureProperty("diffuseMap", font->texture);
          materialInstance->setTransparent();
          materialInstance->options.blendMode = Cogs::Core::BlendMode::Blend;
          materialInstance->setVariant("Textured", true);
        }
      }
    }
  }
}
 
float Cogs::Core::Text3DSystem::calcTextWidth(const FontManager* fontManager, const Font& font, const std::string& text) {
  Font::BakedCharacter  bc;
  float                 width = 0.0f;
 
  for (auto c : text) {
    float x = 0.0f;
    float y = 0.0f;
 
    fontManager->getBakedCharacter(&font, c, x, y, bc);
    width += bc.x1;
  }
  return width;
}
 
void Cogs::Core::Text3DSystem::generateText(std::vector<glm::vec3>& vertices,
                                            std::vector<glm::vec2>& uvs,
                                            const FontManager*      fontManager, 
                                            const Font&             font,
                                            const std::string&      text,
                                            glm::vec3               position,
                                            glm::vec3               hAxis,
                                            glm::vec3               vAxis,
                                            Alignment               alignment) {
  float height = glm::length(vAxis);
  float verticalScale = height / font.size;
  float horizontalScale = verticalScale * glm::length(hAxis);
  float textwidth = calcTextWidth(fontManager, font, text) * horizontalScale;
 
  hAxis /= glm::length(hAxis);
  vAxis /= height;
 
  switch (alignment & Alignment::Horizontal) {
    case Alignment::Center:   position -= hAxis * (textwidth * 0.5f);   break;
    case Alignment::Right:    position -= hAxis * textwidth;            break;
    default: break;
  }
  switch (alignment & Alignment::Vertical) {
    case Alignment::Middle:   position += vAxis * (font.size * verticalScale * 0.5f);   break;
    case Alignment::Bottom:   position += vAxis * (font.size * verticalScale);          break;
    default: break;
  }
 
  position -= vAxis * (font.ascent * verticalScale);
 
  for (size_t ii = 0; ii < text.size(); ++ii) {
    Font::BakedCharacter  bc;
    float                 x = 0.0f;
    float                 y = 0.0f;
 
    fontManager->getBakedCharacter(&font, text[ii], x, y, bc);
 
    glm::vec3 left = hAxis * (bc.x0 * horizontalScale);
    glm::vec3 right = hAxis * (bc.x1 * horizontalScale);
    glm::vec3 up = vAxis * (bc.y0 * verticalScale);
    glm::vec3 down = vAxis * (bc.y1 * verticalScale);
 
    vertices.push_back(position - up + left);
    vertices.push_back(position - down + left);
    vertices.push_back(position - up + right);
    vertices.push_back(position - down + right);
 
    uvs.push_back({bc.s0, bc.t0});
    uvs.push_back({bc.s0, bc.t1});
    uvs.push_back({bc.s1, bc.t0});
    uvs.push_back({bc.s1, bc.t1});
 
    position += right;
  }
}