BadgeSetSystem.cpp

#include "BadgeSetSystem.h"
#include "Context.h"
 
#include "Systems/Core/CameraSystem.h"
#include "ViewContext.h"
#include "Services/DPIService.h"
 
#include "Components/Core/MeshComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Components/Core/TransformComponent.h"
#include "Components/Core/InstancedMeshRenderComponent.h"
#include "Resources/MaterialManager.h"
#include "Resources/MeshManager.h"
#include "Resources/VertexFormats.h"
#include "Systems/Core/TransformSystem.h"
#include "Resources/TextureManager.h"
 
#include "Foundation/Logging/Logger.h"
 
using namespace Cogs::Geometry;
 
namespace {
  Cogs::Logging::Log  gLogger = Cogs::Logging::getLogger("BadgeSetSystem");
}
 
Cogs::Core::BadgeSetSystem::~BadgeSetSystem()
{
}
 
void Cogs::Core::BadgeSetSystem::initialize(Context* context) {
  ComponentSystemWithDataPool::initialize(context);
  generateMesh(context);
}
 
void Cogs::Core::BadgeSetSystem::generateMesh(Context* context)
{
  quadMesh = context->meshManager->create();
 
  std::vector<glm::vec3> points = {
    { 0, 0, 0 },
    { 1, 0, 0 },
    { 1, 1, 0 },
    { 0, 1, 0 },
  };
 
  std::vector<glm::vec2> texCoords = {
    { 0, 0 },
    { 1, 0 },
    { 1, 1 },
    { 0, 1 }
  };
 
  std::vector<uint32_t> indices = { 0,1,2,2,3,0 };
 
  quadMesh->primitiveType = Cogs::PrimitiveType::TriangleList;
  quadMesh->setPositions(points);
  quadMesh->setIndexes(indices);
  quadMesh->setTexCoords(texCoords);
 
  instMaterial = context->materialManager->loadMaterial("BadgeMaterial.material");
  context->materialManager->processLoading();
 
  Material* mat = instMaterial.resolve();
  viewPlaneLocalKey = mat->getFloatKey("viewPlaneLocal");
  viewXLocalKey = mat->getFloatKey("viewXLocal");
  viewYLocalKey = mat->getFloatKey("viewYLocal");
  pointSizeKey = mat->getVec2Key("pointSize");
  anchorPointOffsetKey = mat->getVec2Key("anchorPointOffset");
  nearCutoffKey = mat->getVec2Key("nearCutoff");
  farCutoffKey = mat->getVec2Key("farCutoff");
  nearVisibilityLimitKey = mat->getFloatKey("nearVisibilityLimit");
  farVisibilityLimitKey = mat->getFloatKey("farVisibilityLimit");
  outputAlphaValueKey = mat->getFloatKey("outputAlphaValue");
 
  iconTextureKey = mat->getTextureKey("iconMap");
  styleTextureKey = mat->getTextureKey("styleMap");
  digitTextureKey = mat->getTextureKey("digitMap");
 
  if (!picker) {
    picker = std::make_unique<BadgeSetPicker>(this);
    if (picker) {
      LOG_DEBUG(gLogger, "Registered badge set picker extension");
      context->rayPicking->addPickable(picker.get());
    }
    else {
      LOG_ERROR(gLogger, "Badge set picker extension could not be initialized!");
    }
  }
}
 
void Cogs::Core::BadgeSetSystem::update(Context* /*context*/)
{
  //Get refs here as it will be the same for all comps in the system pool
  const CameraData& mainCamData = context->cameraSystem->getMainCameraData();
  
  for (BadgeSetComponent& badgeSetComp : pool) {
    if (!badgeSetComp.isActive()) {
      continue;
    }
 
    InstancedMeshRenderComponent* instancedMeshRenderComponent = badgeSetComp.getComponent<InstancedMeshRenderComponent>();
    if (!instancedMeshRenderComponent) {
      LOG_WARNING_ONCE(gLogger, "Missing InstancedMeshRendererComponent, skipping Entity update on this system");
      continue;
    }
 
    BadgeSetData& data = getData(&badgeSetComp);
 
    if (!data.texturesLoaded) {
      if ((badgeSetComp.styleTexture && badgeSetComp.iconTexture && badgeSetComp.digitTexture)) {
        SceneComponent* sceneComponent = badgeSetComp.getComponent<SceneComponent>();
        if (!badgeSetComp.styleTexture->isActive() ||
            !badgeSetComp.iconTexture->isActive() ||
            !badgeSetComp.digitTexture->isActive()) {
          sceneComponent->visible = false;
          instancedMeshRenderComponent->unsetRenderFlag(Cogs::Core::RenderFlags::SelfVisibility);
        }
        else {
          data.texturesLoaded = true;
          sceneComponent->visible = true;
          instancedMeshRenderComponent->setRenderFlag(Cogs::Core::RenderFlags::SelfVisibility);
        }
      }
    }
 
    if (!data.initialized) {
 
      MeshComponent* meshComponent = badgeSetComp.getComponent<MeshComponent>();
      if (!meshComponent) {
        LOG_WARNING_ONCE(gLogger, "Missing MeshComponent, skipping Entity update on this system");
        continue;
      }
      
      meshComponent->meshHandle = quadMesh;
      meshComponent->setChanged();
 
      instancedMeshRenderComponent->unsetRenderFlag(RenderFlags::SelfPickable | RenderFlags::ParentPickable);
 
      if (!HandleIsValid(badgeSetComp.iconTexture)) {
        LOG_WARNING_ONCE(gLogger, "icon texture provided is not a valid texture handle");
        continue;
      }
      if (!HandleIsValid(badgeSetComp.digitTexture)) {
        LOG_WARNING_ONCE(gLogger, "digit texture provided is not a valid texture handle");
        continue;
      }
 
      if (badgeSetComp.positions.size() != badgeSetComp.icons.size() || badgeSetComp.positions.size() != badgeSetComp.styles.size())
      {
        LOG_WARNING_ONCE(gLogger, "Positions, icons and styles must contain the same number of elements");
        continue;
      }
 
      std::vector<glm::vec4> interleavedData;
      interleavedData.resize(badgeSetComp.positions.size());
      for (size_t i = 0; i < badgeSetComp.positions.size(); i++) {
        interleavedData[i] = glm::vec4(badgeSetComp.numbers[i], badgeSetComp.styles[i], 0, badgeSetComp.icons[i]);
      }
 
      instancedMeshRenderComponent->instanceMesh = context->meshManager->create();
      instancedMeshRenderComponent->instanceMesh->setInstancePositions(badgeSetComp.positions);
 
      instancedMeshRenderComponent->instanceMesh->setInstanceColors(interleavedData);
 
      instancedMeshRenderComponent->startInstance = 0;
      instancedMeshRenderComponent->instanceCount = static_cast<uint32_t>(-1);
      instancedMeshRenderComponent->startIndex = 0;
 
      data.materialInstance = instancedMeshRenderComponent->material ? instancedMeshRenderComponent->material : context->materialInstanceManager->createMaterialInstance(instMaterial);
      data.materialInstance->setOption("CullMode", "None");
      data.materialInstance->setVariant("AlphaTest", "None");
 
      instancedMeshRenderComponent->material = data.materialInstance;
      instancedMeshRenderComponent->setChanged();
      data.initialized = true;
    }
 
    TransformComponent* trComp = badgeSetComp.getComponent<TransformComponent>();
 
    // We use the main cam to determine view-dependent orientation etc. This is usually the camera that is used
    // for rendering. In VR applications, we have a camera per eye, and what they see have to agree, so by using
    // the main camera to define orientation (and not the the camera used for rendering) they agree.
    // NOTE: The vec/matrix multiplications here simplify the expansion 
    // ( ([0,1,0,0] M^-1) )^t = (M^-1)^t [0,1,0,0]^t of a more traditional space transformation
    glm::mat4 viewFromLocal = mainCamData.viewMatrix * context->transformSystem->getLocalToWorld(trComp);
    data.viewPlaneLocal = glm::vec4(0.f, 0.f, -1.f, 0.f) * viewFromLocal;
    data.viewXLocal = glm::vec3(1.f, 0.f, 0.f) * glm::mat3(viewFromLocal);
    data.viewYLocal = glm::vec3(0.f, 1.f, 0.f) * glm::mat3(viewFromLocal);
    //Equivalent to doing, we just grab the key representing the literal string value.
    //data.materialInstance->setVec4Property("viewPlaneLocal", data.viewPlaneLocal);
    data.materialInstance->setVec4Property(viewPlaneLocalKey, data.viewPlaneLocal);
 
    data.materialInstance->setVec4Property(viewXLocalKey, glm::vec4(data.viewXLocal, 1.f));
    data.materialInstance->setVec4Property(viewYLocalKey, glm::vec4(data.viewYLocal, 1.f));
    // Near and far distances are relative to the main camera (distance from viewPLaneLocal)
    data.materialInstance->setFloatProperty(nearVisibilityLimitKey, badgeSetComp.nearVisibilityLimit);
    data.materialInstance->setFloatProperty(farVisibilityLimitKey, badgeSetComp.farVisibilityLimit);
    data.materialInstance->setFloatProperty(outputAlphaValueKey, badgeSetComp.outputAlphaValue);
 
    // Near and far cutoff points are relative to the main camera (distance from viewPlaneLocal)
    data.materialInstance->setFloatProperty(nearCutoffKey, badgeSetComp.nearScalingCutoff);
    data.materialInstance->setFloatProperty(farCutoffKey, badgeSetComp.farScalingCutoff);
    // Point size is in object space units.
    data.materialInstance->setVec2Property(pointSizeKey, glm::vec2(badgeSetComp.badgeSize));
 
    data.materialInstance->setVec2Property(anchorPointOffsetKey, glm::vec2(-badgeSetComp.anchorPoint.x, -badgeSetComp.anchorPoint.y));
 
    data.materialInstance->setVariant("Textured", true);
 
    data.materialInstance->setTextureAddressMode(iconTextureKey, SamplerState::Clamp);
    data.materialInstance->setTextureProperty(iconTextureKey, badgeSetComp.iconTexture);
 
    data.materialInstance->setTextureAddressMode(styleTextureKey, SamplerState::Clamp);
    data.materialInstance->setTextureProperty(styleTextureKey, badgeSetComp.styleTexture);
 
    data.materialInstance->setTextureAddressMode(digitTextureKey, SamplerState::Clamp);
    data.materialInstance->setTextureProperty(digitTextureKey, badgeSetComp.digitTexture);
 
    if (badgeSetComp.hasFieldChanged(&BadgeSetComponent::positions) || badgeSetComp.hasFieldChanged(&BadgeSetComponent::icons) || badgeSetComp.hasFieldChanged(&BadgeSetComponent::styles)) {
      if (badgeSetComp.positions.size() != badgeSetComp.icons.size() || badgeSetComp.positions.size() != badgeSetComp.styles.size())
      {
        LOG_WARNING_ONCE(gLogger, "Positions, icons and styles must contain the same number of elements");
        continue;
      }
      
      if (!instancedMeshRenderComponent->instanceMesh) {
        instancedMeshRenderComponent->instanceMesh = context->meshManager->create();
      }
      instancedMeshRenderComponent->instanceMesh->clear();
      instancedMeshRenderComponent->instanceMesh->setInstancePositions(badgeSetComp.positions);
 
      std::vector<glm::vec4> interleavedData;
      interleavedData.resize(badgeSetComp.positions.size());
      for (size_t i = 0; i < badgeSetComp.positions.size(); i++) {
        interleavedData[i] = glm::vec4(badgeSetComp.numbers[i], badgeSetComp.styles[i], 0, badgeSetComp.icons[i]);
      }
 
      instancedMeshRenderComponent->instanceMesh->setInstanceColors(interleavedData);
    }
  }
}
 
void Cogs::Core::BadgeSetSystem::cleanup(Context* /*context*/)
{
 
}