HighlightRegionSystem.cpp

#include "Foundation/Logging/Logger.h"
 
#include "Systems/Core/TransformSystem.h"
 
#include "Resources/MaterialManager.h"
 
#include "Context.h"
 
#include "HighlightRegionSystem.h"
#include "HighlightRegionBounds.h"
#include "HighlightRegionPicker.h"
#include "HighlightRegionRenderer.h"
 
namespace {
  using namespace Cogs::Core;
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("HighlightRegion");
 
}
 
void Cogs::Core::HighlightRegionSystem::update(Context* context)
{
  if (!material || !material->isActive()) return;
 
 
  for (HighlightRegionComponent& regionComp : pool) {
    HighlightRegionData& data = getData(&regionComp);
    bool update = regionComp.hasChanged();
 
    if (!data.materialInstance) {
      data.materialInstance = context->materialInstanceManager->createMaterialInstance(material);
      if (VariableKey key = material->getTextureKey("offscreenDepth"); key != NoProperty) {
        data.materialInstance->setTextureFilterMode(key, SamplerState::FilterMode::MinMagMipPoint);
      }
      update = true;
    }
 
    if (TransformComponent* trComp = regionComp.getComponent<TransformComponent>(); trComp) {
      data.worldMatrix = context->transformSystem->getLocalToWorld(trComp);
    }
 
    if (update) {
      data.materialInstance->setVariant("DebugForceVisible", regionComp.debugForceVisible);
      data.materialInstance->setVariant("DebugShowTriangles", regionComp.debugShowTriangles);
      data.materialInstance->setVariant("DebugDiscardBehindNearNotEye", regionComp.debugDiscardBehindNearNotEye);
 
      data.debugForceNoSplit = regionComp.debugForceNoSplit;
      data.materialInstance->setVariant("SplitCube", !data.debugForceNoSplit);
 
      size_t instanceCount = std::min(regionComp.id.size(),
                                      std::min(std::min(regionComp.position.size(),
                                               regionComp.rotation.size()),
                                      std::min(regionComp.scale.size(),
                                               regionComp.color.size())));
      const float alpha = regionComp.alpha;
      constexpr float sqrt3 = 1.74f;
      data.instanceData.resize(instanceCount);
      glm::vec3 boundsMin = glm::vec3(std::numeric_limits<float>::max());
      glm::vec3 boundsMax = glm::vec3(-std::numeric_limits<float>::max());
      for (size_t i = 0; i < instanceCount; i++) {
        const glm::quat& r = regionComp.rotation[i];
        const glm::vec3& p = regionComp.position[i];
        const glm::vec3& s = regionComp.scale[i];
        const glm::vec4& c = regionComp.color[i];
 
        float radius = sqrt3 * std::max(s.x, std::max(s.y, s.z));
        boundsMin = glm::min(boundsMin, p - glm::vec3(radius));
        boundsMax = glm::max(boundsMax, p + glm::vec3(radius));
 
        // R[row][col]
        const glm::mat3 R = glm::mat3_cast(r);
 
        data.instanceData[i].data0 = glm::mat4(R[0][0], R[1][0], R[2][0], p.x,
                                               R[0][1], R[1][1], R[2][1], p.y,
                                               R[0][2], R[1][2], R[2][2], p.z,
                                               c.r, c.g, c.b, c.a * alpha);
 
        data.instanceData[i].data1 = glm::mat4(s.x, s.y, s.z, 0.f,
                                               0.f, 0.f, 0.f, 0.f,
                                               0.f, 0.f, 0.f, 0.f,
                                               0.f, 0.f, 0.f, 0.f);
      }
      data.boundsMin = boundsMin;
      data.boundsMax = boundsMax;
      data.instanceDataUpdated = true;
    }
 
  }
}
 
ComponentHandle Cogs::Core::HighlightRegionSystem::createComponent()
{
  if (pool.size() == 0) {
    if (!material) {
      material = context->materialManager->loadMaterial("HighlightRegionMaterial.material");
    }
 
    assert(bounds == nullptr);
    bounds = new HighlightRegionBounds(this);
    context->bounds->addBoundsExtension(bounds);
 
    assert(picker == nullptr);
    picker = new HighlightRegionPicker(this);
    context->rayPicking->addPickable(picker);
 
    renderer = new HighlightRegionRenderer(this);
    context->renderer->registerExtension(renderer);
 
    LOG_DEBUG(logger, "Registered bounds, picker, and renderer extensions");
  }
  ComponentHandle handle = ComponentSystemWithDataPool::createComponent();
  return handle;
}
 
void Cogs::Core::HighlightRegionSystem::destroyComponent(ComponentHandle handle)
{
  ComponentSystemWithDataPool::destroyComponent(handle);
  if (pool.size() == 0) {
    assert(bounds);
    context->bounds->removeBoundsExtension(bounds);
    delete bounds;
    bounds = nullptr;
 
    assert(picker);
    context->rayPicking->removePickable(picker);
    delete picker;
    picker = nullptr;
 
    assert(renderer);
    context->renderer->unregisterExtension(renderer);
    delete renderer;
    renderer = nullptr;
 
    LOG_DEBUG(logger, "Unregistered bounds, picker, and renderer extensions");
  }
}