CullingManager.cpp

#include "CullingManager.h"
 
#include "Context.h"
 
#include "Services/TaskManager.h"
 
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/RenderSystem.h"
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/SubMeshRenderSystem.h"
#include "Systems/Core/StaticModelSystem.h"
#include "Systems/Core/InstancedMeshRenderSystem.h"
 
void Cogs::Core::CullingManager::initializeCulling()
{
  source.count = 0;
  context->renderSystem->initializeCulling(&source);
  context->subMeshRenderSystem->initializeCulling(&source);
  context->staticModelSystem->initializeCulling(&source);
  context->instancedMeshRenderSystem->initializeCulling(&source);
}
 
 
void Cogs::Core::CullingManager::dispatchCulling(CameraData * viewportData)
{
  if (!viewportData->cullingData) {
    viewportData->cullingData = std::shared_ptr<CullingData>(context->cameraSystem->cullingData.create(), [this](CullingData * cd)
    {
      if (cd->task.isValid()) {
        context->taskManager->destroy(cd->task);
        cd->task = NoTask;
      }
      context->cameraSystem->cullingData.destroy(cd);
    });
  }
 
  const size_t count = source.count;
 
  auto cullData = viewportData->cullingData.get();
  cullData->viewMatrix = viewportData->viewMatrix;
  cullData->viewProjection = viewportData->rawProjectionMatrix * viewportData->viewMatrix;
  cullData->context = context;
  cullData->source = &source;
  cullData->results.resize(count);
  cullData->depths.resize(count);
  if (!cullData->task.isValid()) {
    cullData->task = context->taskManager->createGroup();
  }
 
  if (!count) return;
 
  const size_t batchSize = 1024;
  const size_t batches = (count / batchSize) + 1;
 
  for (size_t i = 0; i < batches; ++i) {
    const size_t start = i * batchSize;
    const size_t end = std::min((i + 1) * batchSize, count);
 
    if (0.f < viewportData->discardThreshold) {
      context->taskManager->enqueueChild(cullData->task,
                                        [cullData,
                                         start,
                                         end,
                                         discardThresholdSqr = viewportData->discardThreshold,
                                         keepThreshold = viewportData->keepThreshold]()
      {
        CpuInstrumentationScope(SCOPE_SYSTEMS, "MeshRenderSystem::culling");
 
        const auto * source = cullData->source;
        for (size_t i = start; i < end; ++i) {
          glm::vec3 bbMinWorld = source->bbMinWorld[i];
          glm::vec3 bbMaxWorld = source->bbMaxWorld[i];
 
          cullData->results[i] = frustumClassifyBoundingBox(cullData->viewProjection,
                                                            bbMinWorld,
                                                            bbMaxWorld,
                                                            discardThresholdSqr,
                                                            keepThreshold);
 
          glm::vec4 p = cullData->viewProjection * glm::vec4(0.5f * (bbMinWorld + bbMaxWorld), 1.f);
          cullData->depths[i] = p.z / p.w;
        }
      });
    } else {
      context->taskManager->enqueueChild(cullData->task, [cullData, start, end]() {
        CpuInstrumentationScope(SCOPE_SYSTEMS, "MeshRenderSystem::culling");
 
        const auto * source = cullData->source;
        for (size_t i = start; i < end; ++i) {
          glm::vec3 bbMinWorld = source->bbMinWorld[i];
          glm::vec3 bbMaxWorld = source->bbMaxWorld[i];
 
          cullData->results[i] = frustumClassifyBoundingBox(cullData->viewProjection,
                                                            bbMinWorld, bbMaxWorld);
 
          glm::vec4 p = cullData->viewProjection * glm::vec4(0.5f * (bbMinWorld + bbMaxWorld), 1.f);
          cullData->depths[i] = p.z / p.w;
        }
      });
    }
  }
}