InstancedMeshRenderSystem.cpp

#include "InstancedMeshRenderSystem.h"
 
#include "Context.h"
 
#include "Components/Core/TransformComponent.h"
#include "Components/Core/MeshComponent.h"
#include "Components/Core/NearLimitComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Components/Core/ClipShapeComponent.h"
 
#include "Scene/PickingFlags.h"
#include "Scene/RayPick.h"
#include "Systems/Core/RenderSystem.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 "Resources/Buffer.h"
 
#include "Services/Variables.h"
#include "Services/TaskManager.h"
 
#include "Utilities/Parallel.h"
#include "Math/RayIntersection.h"
 
#include "Foundation/Geometry/Glm.hpp"
#include "Foundation/Logging/Logger.h"
 
using namespace Cogs::Core;
using namespace Cogs::Geometry;
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("InstancedMeshRendererLogger");
 
  Cogs::Geometry::BoundingBox getTransformedBounds(const Cogs::Geometry::BoundingBox& bbox, const glm::mat4 & m)
  {
    const glm::vec3 c000 = glm::vec3(m * glm::vec4(bbox.min.x, bbox.min.y, bbox.min.z, 1.f));
    const glm::vec3 c001 = glm::vec3(m * glm::vec4(bbox.min.x, bbox.min.y, bbox.max.z, 1.f));
    const glm::vec3 c010 = glm::vec3(m * glm::vec4(bbox.min.x, bbox.max.y, bbox.min.z, 1.f));
    const glm::vec3 c011 = glm::vec3(m * glm::vec4(bbox.min.x, bbox.max.y, bbox.max.z, 1.f));
    const glm::vec3 c100 = glm::vec3(m * glm::vec4(bbox.max.x, bbox.min.y, bbox.min.z, 1.f));
    const glm::vec3 c101 = glm::vec3(m * glm::vec4(bbox.max.x, bbox.min.y, bbox.max.z, 1.f));
    const glm::vec3 c110 = glm::vec3(m * glm::vec4(bbox.max.x, bbox.max.y, bbox.min.z, 1.f));
    const glm::vec3 c111 = glm::vec3(m * glm::vec4(bbox.max.x, bbox.max.y, bbox.max.z, 1.f));
    return Cogs::Geometry::BoundingBox {
      glm::min(glm::min(glm::min(c000, c001), glm::min(c010, c011)),
               glm::min(glm::min(c100, c101), glm::min(c110, c111))),
      glm::max(glm::max(glm::max(c000, c001), glm::max(c010, c011)),
               glm::max(glm::max(c100, c101), glm::max(c110, c111)))
    };
  }
}
 
void Cogs::Core::InstancedMeshRenderSystem::initialize(Context * context)
{
  ComponentSystem::initialize(context);
 
  geometryGroup = context->taskManager->createGroup();
}
 
void Cogs::Core::InstancedMeshRenderSystem::update(Context * context)
{
  const bool workParallel = context->engine->workParallel();
 
  context->taskManager->wait(geometryGroup);
 
  needsPost = false;
 
  auto updateComponent = [this](InstancedMeshRenderComponent & renderComponent, size_t)
  {
    needsPost |= renderComponent.hasChanged();
 
    InstancedMeshRenderData& data = this->getData<InstancedMeshRenderData>(&renderComponent);
    Cogs::Geometry::BoundingBox& 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) {
        const MeshComponent* meshComponent = data.meshComponent.resolveComponent<MeshComponent>();
 
        if (!meshComponent->meshHandle) return;
        if (!renderComponent.instanceMesh) return;
 
        Mesh* mesh = meshComponent->meshHandle.resolve();
        Mesh* instanceMesh = renderComponent.instanceMesh.resolve();
 
        if (meshComponent->hasChanged() ||
            data.meshBoundsGeneration != mesh->getGeneration() ||
            mesh->boundsDirty() ||
            renderComponent.hasChanged() ||
            data.instanceMeshBoundsGeneration != instanceMesh->getGeneration() ||
            instanceMesh->boundsDirty()) {
          if (mesh->boundsDirty() || (isEmpty(mesh->boundingBox) && mesh->getCount())) {
            mesh->boundingBox = calculateBounds(mesh);
 
            if (!isEmpty(mesh->boundingBox) && !mesh->isInitialized()) {
              mesh->setChanged();
            }
          }
 
          Geometry::BoundingBox instanceBounds;
 
          if (mesh->boundingBox.min.x <= mesh->boundingBox.max.x) {
            instanceBounds = mesh->boundingBox;
          } else {
            instanceBounds = calculateBounds(mesh, renderComponent.startIndex, renderComponent.vertexCount);
          }
 
          localBounds = Cogs::Geometry::BoundingBox();
 
          if (isEmpty(instanceMesh->boundingBox)) {
 
            if (Cogs::Core::Mesh::StreamReference instancedMatrix = instanceMesh->getSemanticStream(ElementSemantic::InstanceMatrix, DataFormat::MAT4X4_FLOAT); instancedMatrix.ptr) {
              uint32_t instanceCount = InstancedMeshRenderComponent::getRenderCount(renderComponent.startInstance, renderComponent.instanceCount, std::min(instancedMatrix.count, instanceMesh->getCount()));
              for (size_t i = 0; i < instanceCount; ++i) {
                Cogs::Geometry::BoundingBox b = getTransformedBounds(instanceBounds, instancedMatrix.getDataAt<const glm::mat4>(renderComponent.startInstance + i));
                localBounds.min = glm::min(localBounds.min, b.min);
                localBounds.max = glm::max(localBounds.max, b.max);
              }
            }
 
            else if (Cogs::Core::Mesh::StreamReference instancedPosition = instanceMesh->getSemanticStream(ElementSemantic::InstanceVector, DataFormat::X32Y32Z32_FLOAT); instancedPosition.ptr) {
              uint32_t instanceCount = InstancedMeshRenderComponent::getRenderCount(renderComponent.startInstance, renderComponent.instanceCount, std::min(instancedPosition.count, instanceMesh->getCount()));
              for (size_t i = 0; i < instanceCount; ++i) {
                const glm::vec3& pos = instancedPosition.getDataAt<const glm::vec3>(renderComponent.startInstance + i);
                localBounds.min = glm::min(localBounds.min, instanceBounds.min + pos);
                localBounds.max = glm::max(localBounds.max, instanceBounds.max + pos);
              }
            }
 
            else {
              return;
            }
 
          } else {
            localBounds.min = glm::min(localBounds.min, instanceBounds.min + instanceMesh->boundingBox.min);
            localBounds.max = glm::max(localBounds.max, instanceBounds.max + instanceMesh->boundingBox.max);
          }
 
          data.meshBoundsGeneration = static_cast<uint8_t>(mesh->getGeneration());
          data.instanceMeshBoundsGeneration = static_cast<uint8_t>(instanceMesh->getGeneration());
          ++data.localBoundsGeneration;
        }
      }
    }
 
    // Check world bounds
    {
      const TransformComponent* transform = data.transformComponent.resolveComponent<TransformComponent>();
 
      if (data.worldBoundsGeneration != data.localBoundsGeneration || transformSystem->hasChanged(transform)) {
        data.localToWorld = transformSystem->getLocalToWorld(transform);
 
        if (!isEmpty(localBounds)) {
          getWorldBounds(&renderComponent) = 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, "InstancedMeshRenderSystem::update");
 
    Parallel::processComponents(context, pool, "InstancedMeshRenderSystem::updateComponent", updateComponent, geometryGroup);
 
    context->taskManager->wait(geometryGroup);
  } else {
    Serial::processComponents(pool, updateComponent);
  }
 
  ++generation;
}
 
void Cogs::Core::InstancedMeshRenderSystem::postUpdate(Context * context)
{
  if (needsPost) {
    ComponentSystem::postUpdate(context);
  }
}
 
void Cogs::Core::InstancedMeshRenderSystem::cleanup(Context * context)
{
  if (geometryGroup.isValid()) {
    context->taskManager->destroy(geometryGroup);
  }
}
 
 
ComponentHandle Cogs::Core::InstancedMeshRenderSystem::createComponent()
{
  ComponentHandle handle = base_type::createComponent();
 
  // Ensure consistent Bounds.
  if (pool.size() == 1u) {
    assert(bounds == nullptr);
    bounds = std::make_unique<InstancedMeshRenderBounds>(this);
    context->bounds->addBoundsExtension(bounds.get());
 
    assert(picker == nullptr);
    picker = std::make_unique<InstancedMeshPicker>(this);
    context->rayPicking->addPickable(picker.get());
  }
 
  return handle;
}
void Cogs::Core::InstancedMeshRenderSystem::destroyComponent(ComponentHandle component)
{
  base_type::destroyComponent(component);
 
  if (pool.size() == 0u) {
    if (bounds) {
      context->bounds->removeBoundsExtension(bounds.get());
      bounds.reset();
    }
 
    if (picker) {
      context->rayPicking->removePickable(picker.get());
      picker.reset();
    }
  }
}
 
void Cogs::Core::InstancedMeshRenderSystem::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) {
      InstancedMeshRenderData& meshData = this->getData<InstancedMeshRenderData>(&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) {
      InstancedMeshRenderData& meshData = this->getData<InstancedMeshRenderData>(&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;
    }, "InstancedMeshRenderSystem::initializeCulling");
    scope.Wait();
  }
}
 
// ----
 
 
void Cogs::Core::InstancedMeshRenderBounds::getBounds(Context* /*context*/, Cogs::Geometry::BoundingBox& bounds)
{
  for (InstancedMeshRenderComponent& component : system->pool) {
    const Cogs::Geometry::BoundingBox bbox = system->getWorldBounds(&component);
    if (!isEmpty(bbox))
      bounds += bbox;
  }
}
 
bool Cogs::Core::InstancedMeshRenderBounds::getBounds(Context* /*context*/, const ComponentModel::Entity* entity, Cogs::Geometry::BoundingBox& bounds, bool ignoreVisibility) const
{
  const InstancedMeshRenderComponent* component = entity->getComponent<InstancedMeshRenderComponent>();
  if (!component) return false;
 
  if (!ignoreVisibility) {
    const SceneComponent* sc = component->getComponent<SceneComponent>();
    if (sc && !sc->visible)
      return false;
  }
 
  const Cogs::Geometry::BoundingBox bbox = system->getWorldBounds(component);
  if (isEmpty(bbox)) {
    return false;
  }
  else {
    bounds = bbox;
    return true;
  }
}
 
 
// ----
bool Cogs::Core::InstancedMeshPicker::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 InstancedMeshRenderComponent& comp : system->pool) {
 
    // 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 InstancedMeshRenderData& renderData = system->getData<InstancedMeshRenderData>(&comp);
    if (!renderData.meshComponent) { continue; }
 
 
    Mesh* instanceMesh = comp.instanceMesh.resolve();
    if (!instanceMesh || !instanceMesh->isActive()) { continue; }
 
    const Geometry::BoundingBox& bboxWorld = system->getWorldBounds(&comp);
 
    // 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 (boundingBoxOutsideFrustum(worldPickMatrix, bboxWorld.min, bboxWorld.max)) {
      continue;
    }
 
 
    uint32_t instanceCount = 0;
    Cogs::Core::Mesh::StreamReference instancedMatrix{};
    Cogs::Core::Mesh::StreamReference instancedPosition{};
    if (instancedMatrix = instanceMesh->getSemanticStream(ElementSemantic::InstanceMatrix, DataFormat::MAT4X4_FLOAT); instancedMatrix.ptr) {
      instanceCount = InstancedMeshRenderComponent::getRenderCount(comp.startInstance, comp.instanceCount, std::min(instancedMatrix.count, instanceMesh->getCount()));
    }
    else if (instancedPosition =  instanceMesh->getSemanticStream(ElementSemantic::InstanceVector, DataFormat::X32Y32Z32_FLOAT); instancedPosition.ptr) {
      instanceCount = InstancedMeshRenderComponent::getRenderCount(comp.startInstance, comp.instanceCount, std::min(instancedPosition.count, instanceMesh->getCount()));
    }
    else { continue; }
 
    const Mesh* mesh = renderData.meshComponent.resolveComponent<MeshComponent>()->meshHandle.resolve();
    TextureCoordinateInfo texcoordInfo = getTextureCoordinateInfo(*mesh);
    const uint32_t instanceIdMultiplier = comp.instanceIdMultiplier;
 
    for (size_t i = 0; i < instanceCount; ++i) {
 
      glm::mat4 instanceTransform;
      if (instancedMatrix.ptr) {
        const glm::mat4& mat = instancedMatrix.getDataAt<const glm::mat4>(comp.startInstance + i);
        instanceTransform = renderData.localToWorld * mat;
      }
      else if (instancedPosition.ptr) {
        const glm::vec3& pos = instancedPosition.getDataAt<const glm::vec3>(comp.startInstance + i);
        instanceTransform = renderData.localToWorld * glm::translate(glm::mat4(1.0f), pos);
      }
      else {
        assert(false);
        continue;
      }
 
      // Create transform from local frame to pick frustum, where pick ray
      // is negative Z and ray fuzziness is +/- w.
      glm::mat4 localPickMatrix = worldPickMatrix * instanceTransform;
 
      // Per-instance bbox reject, avoids running full mesh intersection for instances outside the pick frustum.
      if (!isEmpty(mesh->boundingBox) && boundingBoxOutsideFrustum(localPickMatrix, mesh->boundingBox.min, mesh->boundingBox.max)) {
        continue;
      }
 
      const RayPicking::Ordinal ordinal = filter.getOrdinal(comp);
 
      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 = instanceTransform * 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 (hits[0].isBehind(ordinal, viewDist)) {
              glm::vec2 textureCoords = getTextureCoords(texcoordInfo, meshHit, pickingFlags);
              if (instanceIdMultiplier) {
                textureCoords.x = static_cast<float>(static_cast<uint32_t>(textureCoords.x) + instanceIdMultiplier * i);
              }
              hits[0] = {comp, returnChildEntity, position, ordinal, viewDist, textureCoords};
              hitSomething = true;
            }
            // else, the intersection we found is further, so don't do anything
          }
          else {
            glm::vec2 textureCoords = getTextureCoords(texcoordInfo, meshHit, pickingFlags);
            if (instanceIdMultiplier) {
              textureCoords.x = static_cast<float>(static_cast<uint32_t>(textureCoords.x) + instanceIdMultiplier * i);
            }
            hits.emplace_back(comp, returnChildEntity, position, ordinal, viewDist, textureCoords);
            hitSomething = true;
          }
        }
      }
    }
  }
 
  return hitSomething;
}