OctDummyProviderSystem.cpp

#include "Context.h"
#include "ExtensionRegistry.h"
#include "Services/TaskManager.h"
#include "Components/Geometry/MarkerPointSetComponent.h"
 
#include "OctSystem.h"
#include "OctDummyProviderSystem.h"
 
#include "Foundation/Logging/Logger.h"
 
namespace {
  using namespace Cogs::Core;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("OctDummy");
 
 
  struct OctDummySubTask
  {
    std::shared_ptr<Volumetric::OctDummyPersistent> persistent;
    size_t index;
 
    void operator()()
    {
      auto & res = persistent->responses[index];
 
      const auto & min = res->min;
      const auto & max = res->max;
      const auto & N = res->N;
      auto & data = res->data0;
      data.resize(N.x*N.y*N.z);
 
      glm::vec3 s(1.f / N.x,
                  1.f / N.y,
                  1.f / N.z);
 
      Cogs::Memory::TypedBuffer<float> v;
      v.resize(N.x*N.y*N.z);
 
      std::vector<glm::vec3> Q;
      Q.reserve(res->regionKeys.size());
      for (const auto regionKey : res->regionKeys) {
        Q.push_back(persistent->positions[regionKey]);
      }
 
      const auto r2 = persistent->radius * persistent->radius;
      for (unsigned k = 0; k < N.z; k++) {
        for (unsigned j = 0; j < N.y; j++) {
          for (unsigned i = 0; i < N.x; i++) {
 
            auto b1 = s*glm::vec3(i + 0.5f,
                                  j + 0.5f,
                                  k + 0.5f);
            auto b0 = glm::vec3(1.f) - b1;
 
            auto p = b0*min + b1*max;
 
            float value = 0.f;
            for (const auto & q : Q) {
              const auto v_ = q - p;
              if (glm::dot(v_, v_) <= r2) value += 10.f*(r2 - glm::dot(v_, v_));
            }
 
            v[(k*N.y + j)*N.x + i] = value;
          }
        }
      }
 
 
      for (unsigned k = 0; k < N.z; k++) {
        for (unsigned j = 0; j < N.y; j++) {
          for (unsigned i = 0; i < N.x; i++) {
 
            unsigned km = std::max(k, 1u) - 1;
            unsigned kp = std::min(k + 1, N.z - 1);
            unsigned jm = std::max(j, 1u) - 1;
            unsigned jp = std::min(j + 1, N.y - 1);
            unsigned im = std::max(i, 1u) - 1;
            unsigned ip = std::min(i + 1, N.x - 1);
 
            data[(k*N.y + j)*N.x + i] = glm::vec4((1.0 / (ip - im))*(v[(k*N.y + j)*N.x + ip] - v[(k*N.y + j)*N.x + im]),
                                                  (1.0 / (jp - jm))*(v[(k*N.y + jp)*N.x + i] - v[(k*N.y + jm)*N.x + i]),
                                                  (1.0 / (kp - km))*(v[(kp*N.y + j)*N.x + i] - v[(km*N.y + j)*N.x + i]),
                                                  v[(k*N.y + j)*N.x + i]);
 
          }
        }
      }
 
    }
 
  };
 
  struct OctDummyTask
  {
    Context* context;
    std::shared_ptr<Volumetric::OctDummyPersistent> persistent;
 
    void operator()()
    {
      auto group = context->taskManager->createGroup(Cogs::Core::TaskManager::ResourceQueue);
 
      for (size_t i = 0; i < persistent->responses.size(); i++) {
        context->taskManager->enqueueChild(group, OctDummySubTask{ persistent, i });
      }
      context->taskManager->wait(group);
      persistent->tasksRunning = false;
    }
 
  };
 
 
 
}
 
 
 
void Cogs::Core::Volumetric::OctDummyProviderSystem::initialize(Context * context)
{
  ComponentSystemWithDataPool::initialize(context);
 
  octtreeSystem = ExtensionRegistry::getExtensionSystem<OctSystem>(context);
  assert(octtreeSystem && "octtreeSystem must be initialized before octtreeRenderSystem");
}
 
void Cogs::Core::Volumetric::OctDummyProviderSystem::preUpdate(Context * /*context*/)
{
  const unsigned L = 300;
 
  // Update set of tiles before OctSystem:Update(@PostView) runs.
  for (auto & providerComp : pool) {
    const auto * markerPointSetComponent = providerComp.debugSource->getComponent<MarkerPointSetComponent>();
 
    if (providerComp.hasChanged() || markerPointSetComponent->hasChanged()) {
      auto & providerData = getData(&providerComp);
      auto * octComp = providerComp.getComponent<OctComponent>();
 
      // If anything has changed, flush everything and re-populate octComp.
      if (providerComp.hasChanged()) {
        octComp->clearAllRegions = true;
        providerData.pointsSeen = std::max(size_t(L), markerPointSetComponent->positions.size()) - L;
      }
 
      // Fill and pop points.
      const glm::vec3 R(providerComp.radius);
      while (providerData.pointsSeen < markerPointSetComponent->positions.size()) {
        const auto & p = markerPointSetComponent->positions[providerData.pointsSeen];
        octComp->regionsToAdd.push_back(Region{ providerData.pointsSeen, p - R, p + R });
        providerData.pointsSeen++;
        if (L <= providerData.pointsSeen) {
          octComp->regionsToRemove.push_back(providerData.pointsSeen - L);
        }
      }
 
      octComp->setChanged();
    }
  }
}
 
 
void Cogs::Core::Volumetric::OctDummyProviderSystem::update(Context * context)
{
  for (auto & providerComp : pool) {
    const auto * markerPointSetComponent = providerComp.debugSource->getComponent<MarkerPointSetComponent>();
 
    if(!markerPointSetComponent) continue;
 
    auto & providerData = getData(&providerComp);
 
    if (!providerData.persistent) providerData.persistent = std::make_shared<OctDummyPersistent>();
    if(providerData.persistent->tasksRunning) continue;
 
 
    auto * octComp = providerComp.getComponent<OctComponent>();
    while (!providerData.persistent->responses.empty()) {
      octComp->submitTileResponse(std::move(providerData.persistent->responses.back()), true);
      providerData.persistent->responses.pop_back();
    }
 
    // OctSystem:Update(@PostView) has run, pull new requests and populate with data.
    for (const auto reqTileKey : octComp->tileRequests) {
 
      auto res = octComp->initTileResponse(&reqTileKey);
      if (!res) break;
 
      if (res->regionKeys.empty()) {
        LOG_WARNING(logger, "Tile request with no regions.");
      }
 
      providerData.persistent->responses.push_back(std::move(res));
    }
    
    providerData.persistent->radius = providerComp.radius;
    providerData.persistent->positions = markerPointSetComponent->positions;  // Make a copy that is fixed while task is running.
    providerData.persistent->tasksRunning = true;
    context->taskManager->enqueue(Cogs::Core::TaskManager::ResourceQueue, OctDummyTask{ context, providerData.persistent });
 
  }
}