PointVisualizationSystem.cpp

#include "PointVisualizationSystem.h"
 
#include "Context.h"
 
#include "ExtensionRegistry.h"
#include "Resources/MeshManager.h"
#include "Resources/MaterialManager.h"
#include "Components/Core/MeshComponent.h"
#include "Components/Core/MeshRenderComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Components/PointDataComponent.h"
 
#include "Foundation/ComponentModel/Entity.h"
#include "Foundation/Memory/MemoryBuffer.h"
 
void Cogs::Core::Volumetric::PointVisualizationSystem::update(Context * context)
{
  Cogs::Memory::TypedBuffer<glm::vec4> tmp;
 
  for (auto & pvizComp : pool) {
    auto & pvizData = getData(&pvizComp);
 
    auto * sceneComp = pvizComp.getComponent<SceneComponent>();
    if (!sceneComp || sceneComp->visible == false) continue;
 
    if (!pvizComp.pointData) continue;
    auto pointComp = pvizComp.pointData->getComponent<PointDataComponent>();
    if (pointComp == nullptr) continue;
 
    if ((pvizData.pointPositionGeneration != pointComp->positions.getGeneration())
        || (pvizData.pointDataGeneration != pointComp->auxData0.getGeneration())
        || sceneComp->hasFieldChanged(&SceneComponent::visible)) {
      pvizData.needsUpdate = true;
    }
 
    if (pointComp->hasChanged()) {
      auto mrndComp = pvizComp.getComponent<MeshRenderComponent>();
      mrndComp->material = pvizComp.material;
      pvizData.needsUpdate = true;
    }
 
    if (pvizData.needsUpdate) {
      if (!HandleIsValid(pvizData.mesh)) {
        pvizData.mesh = context->meshManager->create();
 
        auto meshComp = pvizComp.getComponent<MeshComponent>();
        meshComp->meshHandle = pvizData.mesh;
      }
 
      if (!pointComp->positions || pointComp->positions.empty()) {
        pvizData.mesh->clear();
      } else {
        const auto Nv = pointComp->positions.size();
        auto & mesh = pvizData.mesh;
 
        if (!pointComp->data.empty()) {
          auto bbox = Cogs::Geometry::makeEmptyBoundingBox<Cogs::Geometry::BoundingBox>();
 
          tmp.resize(Nv, false);
          for (size_t i = 0; i < Nv; i++) {
            const auto p = pointComp->positions[i];
            const auto w = pointComp->data[i];
            bbox.min = glm::min(bbox.min, p);
            bbox.max = glm::max(bbox.max, p);
            tmp[i] = glm::vec4(p, w);
          }
 
          mesh->setVertexData(tmp.data(), Nv, VertexFormats::Pos4f);
          mesh->primitiveType = PrimitiveType::PointList;
          if ((pointComp->extentMin.x <= pointComp->extentMax.x) &&
              (pointComp->extentMin.y <= pointComp->extentMax.y) &&
              (pointComp->extentMin.z <= pointComp->extentMax.z)) {
            auto bbox_ = Cogs::Geometry::makeEmptyBoundingBox<Cogs::Geometry::BoundingBox>();
            bbox_.min = pointComp->extentMin;
            bbox_.max = pointComp->extentMax;
            mesh->setBounds(bbox_);
          }
        } else {
          mesh->setVertexData(pointComp->positions.data(), Nv, VertexFormats::Pos3f);
          mesh->primitiveType = PrimitiveType::PointList;
          if ((pointComp->extentMin.x <= pointComp->extentMax.x) &&
              (pointComp->extentMin.y <= pointComp->extentMax.y) &&
              (pointComp->extentMin.z <= pointComp->extentMax.z)) {
            auto bbox = Cogs::Geometry::makeEmptyBoundingBox<Cogs::Geometry::BoundingBox>();
            bbox.min = pointComp->extentMin;
            bbox.max = pointComp->extentMax;
            mesh->setBounds(bbox);
          }
        }
      }
    }
  }
}