RenderSystem.cpp

#include "RenderSystem.h"
 
#include "Components/Core/MeshRenderComponent.h"
#include "Context.h"
 
#include "Components/Core/TransformComponent.h"
#include "Components/Core/MeshComponent.h"
#include "Components/Core/NearLimitComponent.h"
#include "Components/Core/ClipShapeComponent.h"
 
#include "Scene/RayPick.h"
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/ClipShapeSystem.h"
 
#include "Resources/Mesh.h"
#include "Resources/MeshManager.h"
 
#include "Services/Variables.h"
#include "Services/TaskManager.h"
 
#include "Utilities/Parallel.h"
#include "Math/RayIntersection.h"
 
#include "Scene/GetBounds.h"
 
 
#include "Foundation/Logging/Logger.h"
 
using namespace Cogs::Core;
using namespace Cogs::Geometry;
 
 
using namespace Cogs::Core;
 
Cogs::Logging::Log logger = Cogs::Logging::getLogger("RenderSystem");
 
void Cogs::Core::RenderSystem::initialize(Context * context)
{
  ComponentSystem::initialize(context);
 
  geometryGroup = context->taskManager->createGroup();
}
 
void Cogs::Core::RenderSystem::update(Context * context)
{
  const bool workParallel = context->engine->workParallel();
 
  context->taskManager->wait(geometryGroup);
 
  needsPost = false;
 
  auto updateComponent = [this](MeshRenderComponent & renderComponent, size_t)
  {
    needsPost |= renderComponent.hasChanged();
 
    auto & data = this->getData<MeshRenderData>(&renderComponent);
    auto & localBounds = getLocalBounds(&renderComponent);
 
    if (!data.transformComponent) {
      data.transformComponent = renderComponent.getComponentHandle<TransformComponent>();
      data.meshComponent = renderComponent.getComponentHandle<MeshComponent>();
    }
 
    // Update local bounds if necessary.
    {
      if ((data.flags & MeshRenderDataFlags::LocalBoundsOverride) == 0) {
        auto meshComponent = data.meshComponent.resolveComponent<MeshComponent>();
 
        if (!meshComponent->meshHandle) return;
 
        auto mesh = meshComponent->meshHandle.resolve();
 
        if (meshComponent->hasChanged() || data.meshBoundsGeneration != mesh->getGeneration() || mesh->boundsDirty()) {
          if (mesh->boundsDirty() || (isEmpty(mesh->boundingBox) && mesh->getCount())) {
            mesh->boundingBox = calculateBounds(mesh);
 
            if (!isEmpty(mesh->boundingBox) && !mesh->isInitialized()) {
              mesh->setChanged();
            }
          }
 
          if (mesh->boundingBox.min.x <= mesh->boundingBox.max.x) {
            localBounds = mesh->boundingBox;
          } else {
            localBounds = calculateBounds(mesh, renderComponent.startIndex, renderComponent.vertexCount);
          }
 
          data.meshBoundsGeneration = (uint8_t)mesh->getGeneration();
          ++data.localBoundsGeneration;
        }
      }
    }
 
    // Check world bounds
    {
      auto transform = data.transformComponent.resolveComponent<TransformComponent>();
 
      if (data.worldBoundsGeneration != data.localBoundsGeneration || transformSystem->hasChanged(transform)) {
        data.localToWorld = transformSystem->getLocalToWorld(transform);
 
        if (!isEmpty(localBounds)) {
          getWorldBounds(&renderComponent) = Bounds::getTransformedBounds(localBounds, data.localToWorld);
        } else {
          getWorldBounds(&renderComponent) = localBounds;
        }
 
        if (data.worldBoundsGeneration != data.localBoundsGeneration) {
          data.worldBoundsGeneration = data.localBoundsGeneration;
          //FIXME: If the local bounding box has changed the current frame, the world bounds used for culling will lag
          // a frame behind, potentially being empty or invalid. To ensure the object is not culled we reset the
          // culling index, disable culling. The culling index will be set to a valid slot the next frame.
          // This behavior will result in sub-optimal performance for e.g dynamic geometry out of frame.
          data.cullingIndex = NoCullingIndex;
        }
      }
    }
  };
 
  if (workParallel) {
    CpuInstrumentationScope(SCOPE_SYSTEMS, "RenderSystem::update");
 
    Parallel::processComponents(context, pool, "RenderSystem::updateComponent", updateComponent, geometryGroup);
 
    context->taskManager->wait(geometryGroup);
  } else {
    Serial::processComponents(pool, updateComponent);
  }
 
  ++generation;
}
 
void Cogs::Core::RenderSystem::postUpdate(Context * context)
{
  if (needsPost) {
    ComponentSystem::postUpdate(context);
  }
}
 
void Cogs::Core::RenderSystem::cleanup(Context * context)
{
  if (geometryGroup.isValid()) {
    context->taskManager->destroy(geometryGroup);
  }
}
 
ComponentHandle Cogs::Core::RenderSystem::createComponent()
{
  ComponentHandle handle = base_type::createComponent();
 
  // Ensure consistent Bounds.
  if (pool.size() == 1u) {
    assert(picker == nullptr);
    picker = std::make_unique<MeshRenderPicker>(this);
    context->rayPicking->addPickable(picker.get());
  }
 
  return handle;
}
void Cogs::Core::RenderSystem::destroyComponent(ComponentHandle component)
{
  base_type::destroyComponent(component);
 
  if (pool.size() == 0u) {
    context->rayPicking->removePickable(picker.get());
    picker.reset();
  }
}
 
void Cogs::Core::RenderSystem::initializeCulling(CullingSource* cullSource)
{
  const auto offset = cullSource->count;
  const auto count = pool.size();
  const auto total = offset + count;
  if (!count) return;
 
  cullSource->count = total;
  cullSource->bbMinWorld.resize(total);
  cullSource->bbMaxWorld.resize(total);
 
  if (count < 2048) {
    for (SizeType i = 0; i < count; ++i) {
      auto & meshData = this->getData<MeshRenderData>(&pool[i]);
      SizeType j = (SizeType)offset + i;
      meshData.cullingIndex = j;
      cullSource->bbMinWorld[j] = getWorldBounds(&pool[i]).min;
      cullSource->bbMaxWorld[j] = getWorldBounds(&pool[i]).max;
    }
  }
  else {
    auto scope = Parallel::forEach(context, count, [this, offset, cullSource](size_t i) {
      auto & meshData = this->getData<MeshRenderData>(&pool[(SizeType)i]);
      SizeType j = (SizeType)offset + (SizeType)i;
      meshData.cullingIndex = j;
      cullSource->bbMinWorld[j] = getWorldBounds(&pool[(SizeType)i]).min;
      cullSource->bbMaxWorld[j] = getWorldBounds(&pool[(SizeType)i]).max;
    }, "MeshRenderSystem::initializeCulling");
    scope.Wait();
  }
}
 
bool Cogs::Core::MeshRenderPicker::pickImpl(Context* context,
                                            const glm::mat4& worldPickMatrix,
                                            const glm::mat4& rawViewProjection,
                                            const glm::mat4& viewMatrix,
                                            const RayPicking::RayPickFilter& filter,
                                            PickingFlags pickingFlags,
                                            PicksReturned returnFlag,
                                            std::vector<RayPicking::RayPickHit>& hits)
{
  const bool returnChildEntity = (pickingFlags & PickingFlags::ReturnChildEntity) == PickingFlags::ReturnChildEntity;
 
  const size_t hitsBefore = hits.size();
 
  const Cogs::SizeType itemCount = system->pool.size();
  const Cogs::SizeType batchSize = 1024;
 
  TaskId group = context->taskManager->createGroup();
  Mutex batchLock;
 
  for (Cogs::SizeType start = 0; start < itemCount; start += batchSize) {
    const Cogs::SizeType end = std::min(start + batchSize, itemCount);
 
    context->taskManager->enqueueChild(group,
      [&, start, end]() {
        CpuInstrumentationScope(SCOPE_RAYPICK, "executePickingQueryTask");
 
        std::vector<RayPicking::RayPickHit> batchPickResults;
        if (returnFlag != PicksReturned::Closest) {
          batchPickResults.reserve(10); // Reserve space for 10 hits in the current batch based purely on guessing.
        }
 
        for (Cogs::SizeType i = start; i < end; i++) {
          const MeshRenderComponent& comp = system->pool[i];
 
          // If set, rayPicking handled by elsewhere by some dedicated system
          if (comp.customRayPickHandling) { continue; }
 
          // Filter out unwanted, invisible or disabled entities early to speed up queries.
          if (filter.isUnwantedType(comp) || comp.lod.currentLod != comp.lod.selectedLod) { continue; }
 
          // ForcePickable flag overrides visibility and flags.
          if (!comp.isRenderFlagSet(RenderFlags::ForcePickable)) {
            if (!comp.isVisible() || !comp.isVisibleInLayer(filter.layerMask) || !comp.isPickable()) {
              continue;
            }
          }
 
          const RayPicking::Ordinal ordinal = filter.getOrdinal(comp);
 
          const MeshRenderData& renderData = system->getData<MeshRenderData>(&comp);
          if (!renderData.meshComponent) {
            continue;
          }
 
          const Geometry::BoundingBox& bboxWorld = system->getWorldBounds(&comp);
          const Mesh* mesh = renderData.meshComponent.resolveComponent<MeshComponent>()->meshHandle.resolve();
          if (!mesh) {
            continue;
          }
          TextureCoordinateInfo texcoordInfo = getTextureCoordinateInfo(*mesh);
 
          // Note that the bbox test must be 'fuzzy' (including tolerance) for
          // line picking not to prematurely fail in bbox test (bbox of single
          // line is a single line).
          if (isEmpty(bboxWorld)) {
            continue;
          }
 
          if (frustumClassifyBoundingBox(worldPickMatrix, bboxWorld.min, bboxWorld.max) != FrustumPlanes::InsideAll) {
            continue;
          }
 
          // Create transform from local frame to pick frustum, where pick ray
          // is negative Z and ray fuzziness is +/- w.
          glm::mat4 localPickMatrix = worldPickMatrix * renderData.localToWorld;
 
          std::vector<RayIntersectionHit> meshHits;
          std::vector<FrustumPlanes> scratch;
          if (!intersectMesh(meshHits,
                            scratch,
                            localPickMatrix,
                            *mesh,
                            comp.startIndex,
                            comp.vertexCount,
                            static_cast<uint32_t>(-1))) {
            continue;
          }
 
          if (meshHits.empty()) {
            continue;
          }
 
          for (const RayIntersectionHit& meshHit : meshHits) {
            const glm::vec4 position = renderData.localToWorld * glm::vec4(meshHit.pos_, 1.f);
 
            if (const ClipShapeComponent* clipComp = comp.clipShapeComponent.resolveComponent<ClipShapeComponent>(); clipComp) {
              const ClipShapeData& clipData = context->clipShapeSystem->getData(clipComp);
              if (clippedByClipComp(clipData, position)) {
                continue;
              }
            }
 
            const glm::vec4 clipPos = rawViewProjection * glm::vec4(position.x, position.y, position.z, 1.f);
            // use clip space to see if the point falls within the view frustum
            if ((-clipPos.w < clipPos.z) && (clipPos.z < clipPos.w)) {
 
              glm::vec4 viewPos = viewMatrix * position;
              float viewDist = -viewPos.z;
 
              if (returnFlag == PicksReturned::Closest && !batchPickResults.empty()) {
                if (batchPickResults[0].isBehind(ordinal, viewDist)) {
                  glm::vec2 textureCoords = getTextureCoords(texcoordInfo, meshHit, pickingFlags);
                  batchPickResults[0] = {comp, returnChildEntity, position, ordinal, viewDist, textureCoords};
                }
                // else, the intersection we found is further, so don't do anything
              }
              else {
                glm::vec2 textureCoords = getTextureCoords(texcoordInfo, meshHit, pickingFlags);
                batchPickResults.emplace_back(comp, returnChildEntity, position, ordinal, viewDist, textureCoords);
              }
            }
          }
        }
 
        if (!batchPickResults.empty()) {
          LockGuard guard(batchLock);
          if (returnFlag == PicksReturned::Closest) {
            if (hits.empty()) {
              hits = std::move(batchPickResults);
            }
            else if (batchPickResults[0] < hits[0]) {
              hits[0] = batchPickResults[0];
            }
            //else don't insert anything because we found a hit further away than what we already had
          }
          else {
            hits.insert(hits.end(),
                        std::make_move_iterator(batchPickResults.begin()),
                        std::make_move_iterator(batchPickResults.end()));
          }
        }
      }
    );
  }
  context->taskManager->destroy(group);
 
  return hitsBefore != hits.size();
}