DensityFieldSystem.cpp

#include "ExtensionRegistry.h"
#include "Resources/MeshManager.h"
#include "Resources/MaterialManager.h"
#include "Components/Core/MeshComponent.h"
#include "Components/Core/SubMeshRenderComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Context.h"
 
#include "Components/PointDataComponent.h"
 
#include "../Tasks/DensityFieldTask.h"
#include "DensityFieldSystem.h"
 
#include "Foundation/ComponentModel/Entity.h"
 
void Cogs::Core::Volumetric::DensityFieldSystem::update(Context * context)
{
  for (auto & fieldComp : pool) {
    if(!fieldComp.pointData) continue;
 
    auto & fieldData = getData(&fieldComp);
 
    if (!fieldData.persistentData) fieldData.persistentData = std::make_shared<DensityFieldTaskData>();
 
    auto pointComp = fieldComp.pointData->getComponent<PointDataComponent>();
    if (!pointComp) continue;
 
    auto sceneComp = fieldComp.getComponent<SceneComponent>();
    auto meshComp = fieldComp.getComponent<MeshComponent>();
 
    if (pointComp->hasChanged()
        || (fieldData.pointPositionGeneration != pointComp->positions.getGeneration())
        || (fieldData.pointDataGeneration != pointComp->data.getGeneration())
        || sceneComp->hasFieldChanged(&SceneComponent::visible))
    {
      fieldData.needsUpdate = true;
    }
 
    if (fieldComp.hasChanged()) {
      if (glm::any(glm::notEqual(fieldData.resolution, fieldComp.resolution))) {
        fieldData.resolution = fieldComp.resolution;
        fieldData.needsUpdate = true;
      }
    }
 
    if (!pointComp->positions) {
      meshComp->meshHandle = {};
      meshComp->setChanged();
      continue;
    }
 
    // If we have the singular reference, no tasks are working.
    if (fieldData.persistentData.use_count() == 1) {
 
      // If context is set, a task has been triggered.
      if (fieldData.persistentData->context != nullptr) {
        fieldData.persistentData->context = nullptr;
 
        meshComp->meshHandle = fieldData.persistentData->mesh;
        meshComp->setChanged();
 
        auto meshRenderComp = fieldComp.getComponent<SubMeshRenderComponent>();
        meshRenderComp->materials.resize(fieldData.persistentData->thresholds.size());
 
        for (size_t i = 0; i < fieldData.persistentData->thresholds.size(); i++) {
          if (!meshRenderComp->materials[i]) {
            meshRenderComp->materials[i] = context->materialInstanceManager->createMaterialInstance(context->materialManager->getDefaultMaterial());
          }
 
          if (fieldComp.innerLayerOpaque && i == 0) {
            meshRenderComp->materials[i]->setOpaque();
          } else {
            meshRenderComp->materials[i]->setTransparent();
          }
          meshRenderComp->materials[i]->clone(fieldComp.material.resolve());
 
          if (meshRenderComp->materials[i]->isDefaultMaterial()) {
            meshRenderComp->materials[i]->setPermutation("Default");
            meshRenderComp->materials[i]->setVariant("Textured", true);
            meshRenderComp->materials[i]->setVariant("EnableLighting", true);
          }
 
          meshRenderComp->materials[i]->setTransparent();
          meshRenderComp->materials[i]->options.depthBiasEnabled = true;
          meshRenderComp->materials[i]->options.depthBias.slope = 0.f;
          meshRenderComp->materials[i]->options.depthBias.constant = i*fieldComp.layerDepthBiasStep;
          meshRenderComp->materials[i]->options.depthBias.clamp = 100000.f;
        }
        meshRenderComp->setChanged();
      }
 
      // Check if it is time to regenerate mesh.
      if (fieldData.needsUpdate) {
        auto r = fieldData.resolution;
 
        fieldData.pointPositionGeneration = pointComp->positions.getGeneration();
        if (pointComp->data) {
          fieldData.pointDataGeneration = pointComp->data.getGeneration();
        }
 
        if (fieldComp.thresholds.empty()
            || pointComp->positions.empty()
            || (std::min(std::min(r.x, r.y), r.z) == 0)
            || !sceneComp->visible)
        {
          // Invalid setup, just set an empty mesh.
          meshComp->meshHandle = MeshHandle::NoHandle;
          meshComp->setChanged();
          continue;
        } else {
          // Set up for a new task
          fieldData.persistentData->update(context,
                                           fieldComp,
                                           fieldData,
                                           pointComp->positions,
                                           pointComp->data);
          // and fire and forget.
          DensityFieldTask task{ fieldData.persistentData };
          context->taskManager->enqueue(context->taskManager->create(context->taskManager->ResourceQueue, task));
        }
      }
    }
  }
}