SubMeshRenderSystem.cpp

#include "SubMeshRenderSystem.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 "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"
 
using namespace Cogs::Core;
using namespace Cogs::Geometry;
 
void Cogs::Core::SubMeshRenderSystem::initialize(Context * context)
{
  ComponentSystem::initialize(context);
 
  geometryGroup = context->taskManager->createGroup();
}
 
void Cogs::Core::SubMeshRenderSystem::update(Context * context)
{
  const bool workParallel = context->engine->workParallel();
 
  context->taskManager->wait(geometryGroup);
 
  needsPost = false;
 
  auto updateComponent = [this, context](SubMeshRenderComponent & renderComponent, size_t)
  {
    needsPost |= renderComponent.hasChanged();
 
    auto & data = this->getData<SubMeshRenderData>(&renderComponent);
    auto & localBounds = getLocalBounds(&renderComponent);
 
    if (!data.transformComponent) {
      data.transformComponent = renderComponent.getComponentHandle<TransformComponent>();
      data.meshComponent = renderComponent.getComponentHandle<MeshComponent>();
    }
 
    if (data.flags) return;
 
    // Update local bounds if necessary.
    {
      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()) {
          mesh->boundingBox = calculateBounds(mesh);
 
          if (!isEmpty(mesh->boundingBox) && !mesh->isInitialized()) {
            mesh->setChanged();
          }
        }
 
        localBounds = mesh->boundingBox;
        data.meshBoundsGeneration = (uint8_t)mesh->getGeneration();
        ++data.localBoundsGeneration;
      }
    }
 
    // Check world bounds
    {
      auto transform = data.transformComponent.resolveComponent<TransformComponent>();
 
      if (data.localBoundsGeneration != data.worldBoundsGeneration || context->transformSystem->hasChanged(transform)) {
        data.localToWorld = context->transformSystem->getLocalToWorld(transform);
 
        if (!isEmpty(localBounds)) {
          getWorldBounds(&renderComponent) = Bounds::getTransformedBounds(localBounds, data.localToWorld);
        } else {
          getWorldBounds(&renderComponent) = localBounds;
        }
 
        data.worldBoundsGeneration = data.localBoundsGeneration;
      }
    }
  };
 
  if (workParallel) {
    CpuInstrumentationScope(SCOPE_SYSTEMS, "SubMeshRenderSystem::update");
 
    Parallel::processComponents(context, pool, "SubMeshRenderSystem::updateComponent", updateComponent, geometryGroup);
 
    context->taskManager->wait(geometryGroup);
  } else {
    Serial::processComponents(pool, updateComponent);
  }
}
 
void Cogs::Core::SubMeshRenderSystem::postUpdate(Context * context)
{
  if (needsPost) {
    ComponentSystem::postUpdate(context);
  }
}
 
void Cogs::Core::SubMeshRenderSystem::cleanup(Context * context)
{
  if (geometryGroup.isValid()) {
    context->taskManager->destroy(geometryGroup);
  }
}
 
ComponentHandle Cogs::Core::SubMeshRenderSystem::createComponent()
{
  ComponentHandle handle = base_type::createComponent();
 
  // Ensure consistent Bounds.
  if (pool.size() == 1u) {
    assert(picker == nullptr);
    picker = std::make_unique<SubMeshPicker>(this);
    context->rayPicking->addPickable(picker.get());
  }
 
  return handle;
}
void Cogs::Core::SubMeshRenderSystem::destroyComponent(ComponentHandle component)
{
  base_type::destroyComponent(component);
 
  if (pool.size() == 0u) {
    context->rayPicking->removePickable(picker.get());
    picker.reset();
  }
}
 
void  Cogs::Core::SubMeshRenderSystem::initializeCulling(CullingSource * cullSource)
{
  const size_t offset = cullSource->count;
  const size_t count = pool.size();
  const size_t 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<SubMeshRenderData>(&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<SubMeshRenderData>(&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;
    }, "SubMeshRenderSystem::initializeCulling");
    scope.Wait();
  }
}
 
 
bool Cogs::Core::SubMeshPicker::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;
 
  bool hitSomething = false;
 
  for (const SubMeshRenderComponent& comp : system->pool) {
    // 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 SubMeshRenderData& renderData = system->getData<SubMeshRenderData>(&comp);
    if (!renderData.meshComponent) {
      continue;
    }
 
    const Geometry::BoundingBox& bboxWorld = system->getWorldBounds(&comp);
    const Mesh* mesh = renderData.meshComponent.resolveComponent<MeshComponent>()->meshHandle.resolve();
 
    if (mesh == nullptr)
        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,
                      0,
                      static_cast<uint32_t>(-1),
                      comp.subMesh)) {
      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);
      if ((-clipPos.w < clipPos.z) && (clipPos.z < clipPos.w)) {
        
        glm::vec4 viewPos = viewMatrix * position;
        float viewDist = -viewPos.z;
 
        if (returnFlag == PicksReturned::Closest && !hits.empty()) {
          if (viewDist < hits[0].distance) {
              glm::vec2 textureCoords = getTextureCoords(texcoordInfo, meshHit, pickingFlags);
              hits[0] = {comp, returnChildEntity, position, viewDist, textureCoords};
              hitSomething = true;
            }
            // else, the intersection we found is further, so don't do anything
        }
        else {
          glm::vec2 textureCoords = getTextureCoords(texcoordInfo, meshHit, pickingFlags);
          hits.emplace_back(comp, returnChildEntity, position, viewDist, textureCoords);
          hitSomething = true;
        }
      }
    }
  }
 
  if (returnFlag == PicksReturned::AllSorted) {
    std::sort(hits.begin(), hits.end());
  }
  return hitSomething;
}