SwathPathMeshManager.cpp

#include "Services/Variables.h"
#include "SwathPathMeshManager.h"
#include "Components/Core/MeshComponent.h"
#include "Resources/Mesh.h"
#include "Context.h"
 
#include "Foundation/ComponentModel/Entity.h"
 
#include <iostream>
#include <algorithm>
 
void Cogs::Core::EchoSounder::SwathPathMeshManager::discardEntity(WeakEntityPtr entity)
{
  if (entity.expired()) return;
 
  auto e = entity.lock();
  auto meshComp = e->getComponent<MeshComponent>();
  meshComp->meshHandle = MeshHandle::NoHandle;
  meshComp->setChanged();
  entityPool.push_back(entity);
}
 
bool Cogs::Core::EchoSounder::SwathPathMeshManager::ready() {
  if(persistent->running != 0)
    return false;
  for(auto &tmp : persistent->toBuild)
    if(tmp.second && !tmp.second->isActive())
      return false;
  return true;
}
 
bool Cogs::Core::EchoSounder::SwathPathMeshManager::update(Context* context,
                                                           SwathPathChunks& chunks,
                                                           CreateBuildFunc& createBuildFunc,
                                                           CreateEntity & createEntity,
                                                           ActivateEntity & activateEntity)
{
  assert(persistent->running == 0);
 
  if (chunkGen != chunks.getGeneration()) {
    chunkGen = chunks.getGeneration();
    handleClear = true;
  }
 
  if (handleClear) {
    handleClear = false;
 
    for (auto & i : current) {
      discardEntity(i.second.entity);
    }
    current.clear();
 
    // toBuild is cleared further down, which releases the meshhandles.
  }
  else {
 
    for (auto & i : toDiscard) {
      discardEntity(i.second.entity);
      current.erase(i.first);
    }
 
    for (auto & i : persistent->toBuild) {
 
      if (i.second) { // We only bother to actually setup an entity if there is any mesh.
 
        EntityPtr entity;
        if (!entityPool.empty()) {
          if (!entityPool.back().expired()) {
            entity = entityPool.back().lock();
          }
          entityPool.pop_back();
        }
 
        if (!entity) entity = createEntity();
 
        auto meshComp = entity->getComponent<MeshComponent>();
        meshComp->meshHandle = i.second;
        meshComp->setChanged();
 
        activateEntity(entity, i.first.index);
 
        i.first.entity = entity;
      }
 
      current.insert(std::make_pair(i.first.index, i.first));
    }
  }
  toDiscard.clear();
  persistent->toBuild.clear();
 
  if (update_current) {
    for (auto & i : current) {
      i.second.dirty = true;
    }
    update_current = false;
  }
 
  // Update discard
  for (auto & i : current) {
    if (!chunks.getChunks().validIndex(i.first)
      || !(chunks.getChunks()[i.first].support == i.second.chunk.support)
      || !(chunks.getChunks()[i.first].extent == i.second.chunk.extent)
      || !(chunks.getChunks()[i.first].flags == i.second.chunk.flags))
    {
      toDiscard.insert(std::make_pair(i.first, i.second));
    }
  }
 
  // Update toBuild
  auto maxNewChunks = static_cast<uint32_t>(std::max(1, context->variables->get("echo.maxNewChunks", 0)));
 
  for (uint32_t i = chunks.getChunks().count(); (0 < i) && ((persistent->toBuild.size() < maxNewChunks)); i--) {
    const auto index = chunks.getChunks().frontIndex() + i - 1;
    const auto & c = chunks.getChunks()[index];
 
    auto it = current.find(index);
    if (it == current.end()
      || update_current
      || !(c.extent == it->second.chunk.extent)
      || !(c.support == it->second.chunk.support)
      || !(c.flags == it->second.chunk.flags)
      || it->second.dirty)
    {
      persistent->toBuild.push_back(std::make_pair(EntityInfo({ c, index, WeakEntityPtr(), false }), MeshHandle::NoHandle));
      if (it != current.end()) { //entity already exists but was added to toBuild because it was dirty. Mark the old version for discarding
        toDiscard.insert(std::make_pair(it->first, it->second));
      }
    }
  }
 
  if (!persistent->toBuild.empty()) {
    persistent->running = 1;
 
    auto group = context->taskManager->createGroup();
    std::vector<TaskId> tasks;
 
    for (auto & i : persistent->toBuild) {
      tasks.push_back(context->taskManager->createChild(group, createBuildFunc(i.second, i.first.index)));
    }
 
    context->taskManager->enqueue(context->taskManager->GlobalQueue, [p=persistent, tasks, context, group]()
    {
      for (auto task : tasks) {
        context->taskManager->enqueue(task);
      }
      context->taskManager->wait(group);
      p->running = 0;
    });
 
  }
 
  return !persistent->toBuild.empty() || !toDiscard.empty();
}