GetBounds.cpp

#include "GetBounds.h"
 
#include "Context.h"
#include "EntityStore.h"
 
#include "Components/Core/MeshRenderComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Components/Core/NearLimitComponent.h"
 
#include "Foundation/ComponentModel/Component.h"
#include "Systems/Core/MeshSystem.h"
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/RenderSystem.h"
#include "Systems/Core/SubMeshRenderSystem.h"
#include "Systems/Core/StaticModelSystem.h"
#include "Systems/Core/SpriteRenderSystem.h"
 
#include "Platform/Instrumentation.h"
 
#include "Rendering/DataFormat.h"
 
#include "Resources/MeshManager.h"
#include "Resources/Buffer.h"
 
#include "Utilities/Parallel.h"
#include "Utilities/Simplex.h"
 
#include "Foundation/Geometry/BoundingBox.hpp"
#include "Foundation/Geometry/Glm.hpp"
#include "Foundation/Logging/Logger.h"
 
#include <glm/gtc/packing.hpp>
 
#include <array>
 
using glm::mat4;
using glm::vec4;
using namespace Cogs::Geometry;
using namespace Cogs::Core;
 
namespace
{
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("GetBounds");
 
  void entityError(const EntityId entityId)
  {
    LOG_ERROR(logger, "Invalid entity id %zd.", size_t(entityId));
  }
 
  template<typename T, glm::precision P>
  glm::tvec3<T, P> transformWithDivision(glm::tvec3<T, P> v, glm::tmat4x4<T, P> m)
  {
    auto hV = glm::tvec4<T, P>(v.x, v.y, v.z, 1);
    auto r = m * hV;
 
    return glm::tvec3<T, P>(r.x / r.w, r.y / r.w, r.z / r.w);
  }
 
  const BoundingBox & getMeshBounds(RenderSystem * renderSystem, const MeshRenderComponent * meshComponent)
  {
    return renderSystem->getWorldBounds(meshComponent);
  }
 
  const BoundingBox & getMeshBounds(SubMeshRenderSystem * subMeshRenderSystem, const SubMeshRenderComponent * meshComponent)
  {
    return subMeshRenderSystem->getWorldBounds(meshComponent);
  }
 
  const BoundingBox & getSpriteBounds(Context * context, const SpriteRenderComponent * sprite)
  {
    return context->spriteRenderSystem->getData(sprite).boundingBox;
  }
 
  [[nodiscard]] BoundingBox getBounds(Context * context, const Entity * entity, bool ignoreVisibility)
  {
    const EntityData* entityData = static_cast<const EntityData *>(entity->getUserData());
 
    if (entityData && entityData->entityContext) {
      const MeshRenderComponent* meshRenderComponent = entity->getComponent<MeshRenderComponent>();
      const MeshComponent* meshComp = entity->getComponent<MeshComponent>();
 
      if (meshRenderComponent && (ignoreVisibility || meshRenderComponent->isVisible()) && meshComp && meshComp->meshHandle) {
        return getMeshBounds(entityData->entityContext->renderSystem, meshRenderComponent);
      }
    } else {
      const MeshRenderComponent* meshRenderComponent = entity->getComponent<MeshRenderComponent>();
      const MeshComponent* meshComp = entity->getComponent<MeshComponent>();
 
      if (meshRenderComponent && (ignoreVisibility || meshRenderComponent->isVisible()) && meshComp && meshComp->meshHandle) {
        return getMeshBounds(context->renderSystem, meshRenderComponent);
      }
 
      const SpriteRenderComponent* spriteRenderComponent = entity->getComponent<SpriteRenderComponent>();
 
      if (spriteRenderComponent && spriteRenderComponent->isVisible()) {
        return getSpriteBounds(context, spriteRenderComponent);
      }
 
      BoundingBox extensionBounds;
      for (auto & bounds : context->bounds->getExtensions()) {
        if (bounds->getBounds(context, entity, extensionBounds, ignoreVisibility))
          return extensionBounds;
            }
    }
 
    return BoundingBox();
  }
 
  BoundingBox getBoundsWithChildren(Context * context, const Entity * entity, bool ignoreVisibility)
  {
    StaticModelComponent* staticModelComponent = entity->getComponent<StaticModelComponent>();
 
    if (staticModelComponent) {
      auto renderSystem = context->staticModelSystem->getRenderSystem(staticModelComponent);
 
      BoundingBox bbox;
 
      if (renderSystem) {
        for (auto& rc : renderSystem->pool) {
          bbox += renderSystem->getWorldBounds(&rc);
        }
      }
 
      return bbox;
    }
 
    auto box = getBounds(context, entity, ignoreVisibility);
    const SceneComponent* sceneComponent = entity->getComponent<SceneComponent>();
 
    if (!sceneComponent) return box;
 
    for (auto & child : sceneComponent->children) {
      box += getBoundsWithChildren(context, child.get(), ignoreVisibility);
    }
 
    return box;
  }
 
 
  bool isInside(const glm::vec3& point, const BoundingBox& bbox)
  {
    return point.x >= bbox.min.x && point.x <= bbox.max.x &&
           point.y >= bbox.min.y && point.y <= bbox.max.y &&
           point.z >= bbox.min.z && point.z <= bbox.max.z;
  }
 
  void findNearFarFromMeshVerts(const Mesh& mesh, const glm::mat4& worldViewProj, const glm::mat4& inverseProj, float& viewNear, float& viewFar)
  {
    const uint8_t* posData = nullptr;
    Cogs::DataFormat posFormat = Cogs::DataFormat::Unknown;
    uint32_t posStride = 0;
    uint32_t posCount = 0;
 
 
    for (size_t i = 0; i < VertexDataType::LastVertexType; ++i) {
      VertexDataType::EVertexDataType vertexType = VertexDataType::EVertexDataType(i);
      if (mesh.hasStream(vertexType)) {
        const DataStream& stream = mesh.streams[mesh.streamIndexes[vertexType]];
        const Cogs::VertexFormat* vertexFormat = Cogs::VertexFormats::getVertexFormat(stream.format);
        for (const Cogs::VertexElement& element : vertexFormat->elements) {
          if (element.semantic == Cogs::ElementSemantic::Position && element.semanticIndex == 0) {
            posData = static_cast<const uint8_t*>(stream.buffer->data()) + stream.offset + element.offset;
            posFormat = element.format;
            posStride = stream.stride;
            posCount = stream.numElements;
            break;
          }
        }
      }
    }
 
    if (posData == nullptr || posCount == 0) {
      return;
    }
 
    glm::vec3 nearLocal{std::numeric_limits<float>::max()};
    glm::vec3 farLocal{std::numeric_limits<float>::min()};
 
    // Looping over vertices will likely be on the hot path, so duplicating the loops to avoid more branching inside.
    switch(posFormat) {
      case Cogs::DataFormat::R10G10B10A2_UINT: {
        for (uint32_t i = 0; i < posCount; i++) {
          glm::vec3 pos = glm::unpackU3x10_1x2(*reinterpret_cast<const uint32_t*>(posData + posStride * i));
          const glm::vec4 posInClip = worldViewProj * glm::vec4{ pos, 1.f };
 
          if (-posInClip.w <= posInClip.x && posInClip.x <= posInClip.w &&
              -posInClip.w <= posInClip.y && posInClip.y <= posInClip.w) {
            const float z = posInClip.z / posInClip.w;
 
            if (z < nearLocal.z) {
              nearLocal = {posInClip.x / posInClip.w, posInClip.y / posInClip.w, z};
            }
            if (z > farLocal.z) {
              farLocal = {posInClip.x / posInClip.w, posInClip.y / posInClip.w, z};
            }
          }
          // else position outside camera frustum, don't take it into account
        }
        break;
      }
      case Cogs::DataFormat::R10G10B10A2_UNORM: {
        const float scaleFactor = (1.f / 1023.f);
        for (uint32_t i = 0; i < posCount; i++) {
          glm::vec3 pos = glm::vec3(glm::unpackU3x10_1x2(*reinterpret_cast<const uint32_t*>(posData + posStride * i))) * scaleFactor;
          const glm::vec4 posInClip = worldViewProj * glm::vec4{ pos, 1.f };
 
          if (-posInClip.w <= posInClip.x && posInClip.x <= posInClip.w &&
              -posInClip.w <= posInClip.y && posInClip.y <= posInClip.w) {
            const float z = posInClip.z / posInClip.w;
 
            if (z < nearLocal.z) {
              nearLocal = {posInClip.x / posInClip.w, posInClip.y / posInClip.w, z};
            }
            if (z > farLocal.z) {
              farLocal = {posInClip.x / posInClip.w, posInClip.y / posInClip.w, z};
            }
          }
          // else position outside camera frustum, don't take it into account
        }
        break;
      }
      case Cogs::DataFormat::R16G16B16_UINT: {
        const glm::u16vec3* verts = reinterpret_cast<const glm::u16vec3*>(posData);
        for (uint32_t i = 0; i < posCount; i++) {
          const glm::vec4 posInClip = worldViewProj * glm::vec4{ verts[i], 1.f };
 
          if (-posInClip.w <= posInClip.x && posInClip.x <= posInClip.w &&
              -posInClip.w <= posInClip.y && posInClip.y <= posInClip.w) {
            const float z = posInClip.z / posInClip.w;
 
            if (z < nearLocal.z) {
              nearLocal = {posInClip.x / posInClip.w, posInClip.y / posInClip.w, z};
            }
            if (z > farLocal.z) {
              farLocal = {posInClip.x / posInClip.w, posInClip.y / posInClip.w, z};
            }
          }
          // else position outside camera frustum, don't take it into account
        }
        break;
      }
      case Cogs::DataFormat::R16G16B16_UNORM: {
        const glm::u16vec3* verts = reinterpret_cast<const glm::u16vec3*>(posData);
        const float scaleFactor = (1.f / 0xFFFF);
        for (uint32_t i = 0; i < posCount; i++) {
          const glm::vec3 posInLocalSpace = glm::vec3(verts[i]) * scaleFactor;
          const glm::vec4 posInClip = worldViewProj * glm::vec4{posInLocalSpace , 1.f };
 
          if (-posInClip.w <= posInClip.x && posInClip.x <= posInClip.w &&
              -posInClip.w <= posInClip.y && posInClip.y <= posInClip.w) {
            const float z = posInClip.z / posInClip.w;
 
            if (z < nearLocal.z) {
              nearLocal = {posInClip.x / posInClip.w, posInClip.y / posInClip.w, z};
            }
            if (z > farLocal.z) {
              farLocal = {posInClip.x / posInClip.w, posInClip.y / posInClip.w, z};
            }
          }
          // else position outside camera frustum, don't take it into account
        }
        break;
      }
      case Cogs::DataFormat::R16G16B16_FLOAT: {
        for (uint32_t i = 0; i < posCount; i++) {
          glm::vec3 pos = glm::unpackHalf4x16(*reinterpret_cast<const uint64_t*>(posData + posStride * i));
          const glm::vec4 posInClip = worldViewProj * glm::vec4{ pos, 1.f };
 
          if (-posInClip.w <= posInClip.x && posInClip.x <= posInClip.w &&
              -posInClip.w <= posInClip.y && posInClip.y <= posInClip.w) {
            const float z = posInClip.z / posInClip.w;
 
            if (z < nearLocal.z) {
              nearLocal = {posInClip.x / posInClip.w, posInClip.y / posInClip.w, z};
            }
            if (z > farLocal.z) {
              farLocal = {posInClip.x / posInClip.w, posInClip.y / posInClip.w, z};
            }
          }
          // else position outside camera frustum, don't take it into account
        }
        break;
      }
      case Cogs::DataFormat::R32G32B32_FLOAT: {
        const glm::vec3* verts = reinterpret_cast<const glm::vec3*>(posData);
        for (uint32_t i = 0; i < posCount; i++) {
          const glm::vec4 posInClip = worldViewProj * glm::vec4{ verts[i], 1.f };
 
          if (-posInClip.w <= posInClip.x && posInClip.x <= posInClip.w &&
              -posInClip.w <= posInClip.y && posInClip.y <= posInClip.w) {
            const float z = posInClip.z / posInClip.w;
 
            if (z < nearLocal.z) {
              nearLocal = {posInClip.x / posInClip.w, posInClip.y / posInClip.w, z};
            }
            if (z > farLocal.z) {
              farLocal = {posInClip.x / posInClip.w, posInClip.y / posInClip.w, z};
            }
          }
          // else position outside camera frustum, don't take it into account
        }
        break;
      }
      // Format usually used by points rendering (eg. MarkerPointSet). For simplicity,take into account just the point position.
      case Cogs::DataFormat::R32G32B32A32_FLOAT: {
        const glm::vec4* verts = reinterpret_cast<const glm::vec4*>(posData);
        for (uint32_t i = 0; i < posCount; i++) {
          const glm::vec4 posInClip = worldViewProj * glm::vec4{ glm::vec3(verts[i]), 1.f };
 
          if (-posInClip.w <= posInClip.x && posInClip.x <= posInClip.w &&
              -posInClip.w <= posInClip.y && posInClip.y <= posInClip.w) {
            const float z = posInClip.z / posInClip.w;
 
            if (z < nearLocal.z) {
              nearLocal = {posInClip.x / posInClip.w, posInClip.y / posInClip.w, z};
            }
            if (z > farLocal.z) {
              farLocal = {posInClip.x / posInClip.w, posInClip.y / posInClip.w, z};
            }
          }
          // else position outside camera frustum, don't take it into account
        }
        break;
      }
      default: {
        const Cogs::FormatInfo* formatInfo = Cogs::getFormatInfo(posFormat);
        LOG_ERROR(logger, "Unsupported position format: %s", formatInfo->name);
        return;
      }
    }
 
    if (nearLocal.z < std::numeric_limits<float>::max()) {
      const glm::vec4 closest = inverseProj * glm::vec4(nearLocal, 1.f);
      viewNear = -closest.z / closest.w;
    }
    if (farLocal.z > std::numeric_limits<float>::min()) {
      const glm::vec4 farthest = inverseProj * glm::vec4(farLocal, 1.f);
      viewFar = -farthest.z / farthest.w;
    }
  }
 
  void updateCameraDepthBounds(Cogs::Core::Context* context,
                               uint8_t* simplexScratch,
                               float& viewNear,
                               float& viewFar,
                               const BoundingBox& bbox,
                               const mat4& bboxViewMatrix,
                               const mat4& bboxViewMatrixInverse,
                               const mat4& bboxViewProjectionMatrix)
  {
    if(!(bbox.min.x <= bbox.max.x &&
         bbox.min.y <= bbox.max.y &&
         bbox.min.z <= bbox.max.z )){ // Handle empty and NaN Bounding boxes
         return;
    }
    // Classify bounding box w.r.t. frustum
    float localNear = std::numeric_limits<float>::max();
    float localFar = -std::numeric_limits<float>::max();
 
    int insideMask = 0;
    int outsideMask = 0;
    for (int i = 0; i < 8; i++) {
      vec4 t(i & 1 ? bbox.min.x : bbox.max.x,
             i & 2 ? bbox.min.y : bbox.max.y,
             i & 4 ? bbox.min.z : bbox.max.z,
             1.f);
 
      vec4 c = bboxViewProjectionMatrix * t;
      int pointMask = 0;
      if (-c.w <= c.x) pointMask |= 0x1;
      if (c.x <= c.w) pointMask |= 0x2;
      if (-c.w <= c.y) pointMask |= 0x4;
      if (c.y <= c.w) pointMask |= 0x8;
      if (pointMask == 0xf) {
        vec4 v = bboxViewMatrix*t;
        float z = v.z / v.w;
        assert(std::isfinite(z));
        localNear = std::min(localNear, -z);
        localFar = std::max(localFar, -z);
      }
      insideMask |= pointMask;
      outsideMask |= ~pointMask & 0xf;
    }
 
    if(localNear >= viewNear && localFar <= viewFar){
      return;
    }
 
    if (insideMask != 0xf) {
      // All points was completely outside at least one clip-plane.
    } else if (outsideMask == 0x0) {
      // If insideMask == 0xf and outsideMask == 0x0, all points we're completely inside.
 
      viewNear = std::min(viewNear, localNear);
      viewFar = std::max(viewFar, localFar);
    } else {
      // If insideMask == 0xf and outsideMask != 0x0, at least one clip plane was pierced, resort to simplex algorithm
 
      glm::mat4 bboxMinAlignedViewProjectionMatrix = glm::translate(bboxViewProjectionMatrix, bbox.min);
      glm::mat4 bboxMinAlignedViewMatrix = glm::translate(bboxViewMatrix, bbox.min);
 
      //glm::vec4 q = bboxMinAlignedViewProjectionMatrix * glm::vec4(0, 0, 0, 1);
      //glm::vec4 p = bboxViewProjectionMatrix * glm::vec4(bbox.min, 1);
 
      glm::vec3 e = bbox.max - bbox.min;
      float scale = std::max(std::max(e.x, e.y), e.z);
      if (scale <= 0.f) {
        // Handle single point
        viewNear = std::min(viewNear, localNear);
        viewFar = std::max(viewFar, localNear);
        return;
      }
 
      float epsilon = std::numeric_limits<float>::epsilon()*scale;
 
      mat4 rows = glm::transpose(bboxMinAlignedViewProjectionMatrix);
      glm::vec4 l = rows[3] + rows[0];
      glm::vec4 r = rows[3] - rows[0];
      glm::vec4 b = rows[3] + rows[1];
      glm::vec4 t = rows[3] - rows[1];
 
      // Implicit conditions
      //   * Min box size: x>=0 y>=0 z>=0
      // Explicit conditions
      //   * Max box size: x<=ex y<=ey z<=ez
      //   * Frustrum conditions:
      double restrictions[7 * 4] =
      {
        // Box conditions
        1.0, 0.0, 0.0, std::max(epsilon, e.x), // x <= xmax-xmin
        0.0, 1.0, 0.0, std::max(epsilon, e.y), // y <= ymax-ymin
        0.0, 0.0, 1.0, std::max(epsilon, e.z), // z <= zmax-zmin
        // Frustrum conditions
        -l.x, -l.y, -l.z, l.w,
        -r.x, -r.y, -r.z, r.w,
        -b.x, -b.y, -b.z, b.w,
        -t.x, -t.y, -t.z, t.w,
      };
 
      double objectives[2 * 3];
      double solutions[2 * 3];
 
      bool find_far = localFar > viewFar;
      bool find_near = localNear < viewNear;
      int objective_count = find_near && find_far ? 2 : 1;
      int max_idx = 0;
      int min_idx = find_far ? 1 : 0;
      if(find_far){
        // Minimize in the view -z direction
        objectives[max_idx*3+0] = -bboxViewMatrixInverse[2].x;
        objectives[max_idx*3+1] = -bboxViewMatrixInverse[2].y;
        objectives[max_idx*3+2] = -bboxViewMatrixInverse[2].z;
      }
      if(find_near){
        // Minimize in the view +z direction
        objectives[min_idx*3+0] = bboxViewMatrixInverse[2].x;
        objectives[min_idx*3+1] = bboxViewMatrixInverse[2].y;
        objectives[min_idx*3+2] = bboxViewMatrixInverse[2].z;
      }
 
      auto rv = simplexMaximize(context,
                                (uintptr_t)simplexScratch,
                                solutions, 3,
                                objectives, objective_count,
                                restrictions, 7,
                                150);
      if (rv == SimplexResult::NoFeasibleSolutions) {
        // No intersection
      } else if (rv == SimplexResult::OptimalSolutionFound) {
        if(find_near){
          vec4 v = bboxMinAlignedViewMatrix*glm::vec4(solutions[3 * min_idx + 0],
                                                      solutions[3 * min_idx + 1],
                                                      solutions[3 * min_idx + 2],
                                                      1.f);
          float z = v.z / v.w;
          assert(std::isfinite(z));
          viewNear = std::min(viewNear, -z);
          // viewFar = std::max(viewFar, -z);
        }
        if(find_far){
          vec4 v = bboxMinAlignedViewMatrix*glm::vec4(solutions[3 * max_idx + 0],
                                                      solutions[3 * max_idx + 1],
                                                      solutions[3 * max_idx + 2],
                                                      1.f);
          float z = v.z / v.w;
          assert(std::isfinite(z));
          // viewNear = std::min(viewNear, -z);
          viewFar = std::max(viewFar, -z);
        }
      } else {
        LOG_DEBUG(logger, "Simplex optimization failed (=%d), reverting to standard approach.", (int)rv);
        for (int i = 0; i < 8; i++) {
          vec4 t_(i & 1 ? bbox.min.x : bbox.max.x,
                  i & 2 ? bbox.min.y : bbox.max.y,
                  i & 4 ? bbox.min.z : bbox.max.z,
                  1.f);
          vec4 v = bboxViewMatrix*t_;
          float z = v.z / v.w;
          assert(std::isfinite(z));
          viewNear = std::min(viewNear, -z);
          viewFar = std::max(viewFar, -z);
        }
 
      }
    }
  }
}
 
Cogs::Geometry::BoundingBox Cogs::Core::Bounds::getBounds(Context * context, const ComponentModel::Entity * entity, bool ignoreVisibility)
{
  return ::getBoundsWithChildren(context, entity, ignoreVisibility);
}
 
Cogs::Geometry::BoundingBox Cogs::Core::Bounds::getTransformedBounds(const Cogs::Geometry::BoundingBox& bbox, const glm::mat4 & m)
{
  std::array<glm::vec3, 8> points;
  Cogs::Geometry::corners(bbox, points);
 
  for (auto & p : points) {
    p = transform(p, m);
  }
 
  return Cogs::Geometry::computeBoundingBox(points.begin(), points.end());
}
 
Cogs::Geometry::BoundingBox Cogs::Core::Bounds::getTransformedBoundsWithDivision(const Cogs::Geometry::BoundingBox& bbox, const glm::mat4 & m)
{
  std::array<glm::vec3, 8> points;
  Cogs::Geometry::corners(bbox, points);
 
  for (auto & p : points) {
    p = transformWithDivision(p, m);
  }
 
  return Cogs::Geometry::computeBoundingBox(points.begin(), points.end());
}
 
Cogs::Geometry::BoundingBox Cogs::Core::Bounds::getBounds(Context* context, const EntityId id, bool ignoreVisibility)
{
  auto entity = context->store->getEntityPtr(id);
 
  if (entity)
    return ::getBoundsWithChildren(context, entity, ignoreVisibility);
  else {
    entityError(id);
    return BoundingBox();
  }
}
Cogs::Geometry::BoundingBox Cogs::Core::Bounds::getBounds(Context* context, std::span<const EntityId> ids, bool ignoreVisibility)
{
  Cogs::Geometry::BoundingBox box;
 
  for (auto& id : ids) {
    auto entity = context->store->getEntityPtr(id);
 
    if (entity) {
      Cogs::Geometry::BoundingBox bb = ::getBoundsWithChildren(context, entity, ignoreVisibility);
      if (!bb.empty()) {
        box += bb;
      }
    }
    else {
      entityError(id);
    }
  }
 
  return box;
}
 
Cogs::Geometry::BoundingBox Cogs::Core::Bounds::getSceneBounds(Context* context, RenderLayers layerMask)
{
  Cogs::Geometry::BoundingBox box;
 
  for (auto & renderComponent : context->renderSystem->pool) {
    if (!renderComponent.isVisibleInLayer(layerMask)) continue;
 
    const auto& bb = ::getMeshBounds(context->renderSystem, &renderComponent);
 
    box += bb;
  }
 
  for (auto & renderComponent : context->subMeshRenderSystem->pool) {
    if (!renderComponent.isVisibleInLayer(layerMask)) continue;
 
    const auto& bb = ::getMeshBounds(context->subMeshRenderSystem, &renderComponent);
 
    box += bb;
  }
 
  // Only include Bounds for sprites rendered in World type coords.
  for (const SpriteRenderComponent& sprite : context->spriteRenderSystem->pool) {
    if (!sprite.isVisibleInLayer(layerMask)) continue;
    const auto& data = context->spriteRenderSystem->getData(&sprite);
    auto batch = context->spriteRenderSystem->getSpriteBatch(data.batchIndex);
    if (!batch) {
      continue;
    }
 
    if (batch->positionMode == PositionMode::Pixels || batch->positionMode == PositionMode::Relative) {
      continue;
    }
 
    const auto& bb = ::getSpriteBounds(context, &sprite);
 
    box += bb;
  }
 
  for (auto & bounds : getExtensions()) {
    BoundingBox extensionBounds;
 
    float nearPlaneLimit = 0.f;
    bounds->getBounds(context, extensionBounds, nearPlaneLimit);
 
    box += extensionBounds;
  }
 
  return box;
}
 
void Cogs::Core::Bounds::getSceneBounds(Context* context, float* values, RenderLayers layerMask)
{
  Cogs::Geometry::BoundingBox box = getSceneBounds(context, layerMask);
  box.toSpan(std::span<float, 6>(values, 6));
}
 
void Cogs::Core::Bounds::getClipPlanes(Context* context, float& nearDist, float& farDist, const CameraComponent & cameraComponent, const glm::mat4 & viewMatrix)
{
  BoundingBox sceneBounds;
 
  {
    RenderLayers layerMask = cameraComponent.layerMask & ~RenderLayers::Sky;
 
    for (auto & renderComponent : context->renderSystem->pool) {
      if (!renderComponent.isVisibleInLayer(layerMask)) continue;
 
      const BoundingBox& bb = ::getMeshBounds(context->renderSystem, &renderComponent);
 
      sceneBounds += bb;
    }
 
    for (auto & renderComponent : context->subMeshRenderSystem->pool) {
      if (!renderComponent.isVisibleInLayer(layerMask)) continue;
 
      const BoundingBox& bb = ::getMeshBounds(context->subMeshRenderSystem, &renderComponent);
 
      sceneBounds += bb;
    }
 
    for (auto & sprite : context->spriteRenderSystem->pool) {
      if (!sprite.isVisibleInLayer(layerMask)) continue;
 
      const BoundingBox& bb = ::getSpriteBounds(context, &sprite);
 
      sceneBounds += bb;
    }
 
    for (auto & bounds : getExtensions()) {
      BoundingBox extensionBounds;
 
      float nearPlaneLimit = 0.f;
      bounds->getBounds(context, extensionBounds, nearPlaneLimit);
 
      if (!extensionBounds.empty()) {
        if (!std::isnan(nearPlaneLimit) && !std::isinf(nearPlaneLimit) && nearPlaneLimit > 0.0f) {
          extensionBounds = getTransformedBounds(extensionBounds, viewMatrix);
 
          nearDist = std::max(std::min(nearDist, -extensionBounds.max.z), nearPlaneLimit);
          farDist = std::max(farDist, -extensionBounds.min.z);
        }
        else {
          sceneBounds += extensionBounds;
        }
      }
    }
  }
 
  if (!sceneBounds.empty()) {
    sceneBounds = getTransformedBounds(sceneBounds, viewMatrix);
 
    nearDist = std::min(nearDist, -sceneBounds.max.z);
    farDist = std::max(farDist, -sceneBounds.min.z);
  }
}
 
void Cogs::Core::Bounds::getCameraDepthBounds(Context* context,
                                              float& depthBoundNear,
                                              float& depthBoundFar,
                                              const CameraComponent & cameraComponent)
{
  CpuInstrumentationScope(SCOPE_BOUNDS, "updateClippingPlanes");
  RenderLayers layerMask = cameraComponent.layerMask & ~RenderLayers::Sky;
 
  auto & cameraData = context->cameraSystem->getData(&cameraComponent);
  {
    CpuInstrumentationScope(SCOPE_BOUNDS, "updateClippingPlanes::meshes");
 
    std::vector<float> nearBounds(context->meshSystem->pool.size(), depthBoundNear);
    std::vector<float> farBounds(context->meshSystem->pool.size(), depthBoundFar);
 
    bool tightBoundsInBBox = context->variables->get("camera.tightBoundsInBBox", false);
    auto gr1 = Parallel::processComponents(context, context->renderSystem->pool, "Bounds::process",
                                          [&](MeshRenderComponent & meshRenderComp, size_t i)
    {
      if (!meshRenderComp.isVisibleInLayer(layerMask)) {
        return;
      }
      if (meshRenderComp.lod.currentLod != meshRenderComp.lod.selectedLod) {
        return;
      }
 
 
      const Cogs::Geometry::BoundingBox& bbox = context->renderSystem->getWorldBounds(&meshRenderComp);
 
      if (!bbox.empty()) {
        float nearPlaneLimit = cameraComponent.nearPlaneLimit;
        // if (meshData.nearLimitComponent) {
        //   auto nearComp = meshData.nearLimitComponent.resolveComponent<NearLimitComponent>();
        //   if (nearComp != nullptr && std::isfinite(nearComp->nearPlaneLimit))
        //     nearPlaneLimit = nearComp->nearPlaneLimit;
        // }
 
        float nb = nearBounds[i];
 
        bool cameraInsideBbox = isInside(cameraData.inverseViewMatrix[3], bbox);
        if (tightBoundsInBBox && cameraInsideBbox) {
          const MeshRenderData& renderData = context->renderSystem->getData<MeshRenderData>(&meshRenderComp);
          assert(renderData.meshComponent != ComponentHandle::Empty());
          const Mesh* mesh = renderData.meshComponent.resolveComponent<MeshComponent>()->meshHandle.resolve();
          assert(mesh != nullptr);
          const TransformComponent* transformComp = meshRenderComp.getComponent<TransformComponent>();
          assert(transformComp != nullptr);
          const glm::mat4& localToWorld = context->transformSystem->getLocalToWorld(transformComp);
 
          findNearFarFromMeshVerts(*mesh, cameraData.viewProjection * localToWorld, cameraData.inverseProjectionMatrix, nb, farBounds[i]);
        }
        else {
          std::vector<uint8_t> simplexScratch(simplexScratchSize(3, 2, 7));
          ::updateCameraDepthBounds(context,
                                    simplexScratch.data(),
                                    nb, farBounds[i],
                                    bbox, cameraData.viewMatrix, cameraData.inverseViewMatrix, cameraData.viewProjection);
        }
 
 
 
        nearBounds[i] = std::min(nearBounds[i], std::max(nearPlaneLimit, nb));
      }
    });
 
    context->taskManager->destroy(gr1);
 
    auto gr2 = Parallel::processComponents(context, context->subMeshRenderSystem->pool, "Bounds::processSubMesh",
                                          [&](SubMeshRenderComponent & subMeshRenderComp, size_t i)
    {
      if (!subMeshRenderComp.isVisibleInLayer(layerMask)) return;
      if (subMeshRenderComp.lod.currentLod != subMeshRenderComp.lod.selectedLod) return;
 
      const Cogs::Geometry::BoundingBox& bbox = context->subMeshRenderSystem->getWorldBounds(&subMeshRenderComp);
      if (!bbox.empty()) {
        float nearPlaneLimit = cameraComponent.nearPlaneLimit;
        // if (meshData.nearLimitComponent) {
        //   auto nearComp = meshData.nearLimitComponent.resolveComponent<NearLimitComponent>();
        //   if (nearComp != nullptr && std::isfinite(nearComp->nearPlaneLimit))
        //     nearPlaneLimit = nearComp->nearPlaneLimit;
        // }
 
        float nb = nearBounds[i];
 
        bool cameraInsideBbox = isInside(cameraData.inverseViewMatrix[3], bbox);
        if (tightBoundsInBBox && cameraInsideBbox) {
          const SubMeshRenderData& renderData = context->subMeshRenderSystem->getData<SubMeshRenderData>(&subMeshRenderComp);
          assert(renderData.meshComponent != ComponentHandle::Empty());
          const Mesh* mesh = renderData.meshComponent.resolveComponent<MeshComponent>()->meshHandle.resolve();
          assert(mesh != nullptr);
          const TransformComponent* transformComp = subMeshRenderComp.getComponent<TransformComponent>();
          assert(transformComp != nullptr);
          const glm::mat4& localToWorld = context->transformSystem->getLocalToWorld(transformComp);
 
          findNearFarFromMeshVerts(*mesh, cameraData.viewProjection * localToWorld, cameraData.inverseProjectionMatrix, nb, farBounds[i]);
        }
        else {
          std::vector<uint8_t> simplexScratch(simplexScratchSize(3, 2, 7));
          ::updateCameraDepthBounds(context,
                                    simplexScratch.data(),
                                    nb, farBounds[i],
                                    bbox, cameraData.viewMatrix, cameraData.inverseViewMatrix, cameraData.viewProjection);
        }
 
        nearBounds[i] = std::min(nearBounds[i], std::max(nearPlaneLimit, nb));
      }
    });
 
    context->taskManager->destroy(gr2);
 
    for (size_t i = 0; i < nearBounds.size(); ++i) {
      depthBoundNear = std::min(depthBoundNear, nearBounds[i]);
      depthBoundFar = std::max(depthBoundFar, farBounds[i]);
    }
  }
 
 
  for (auto & sprite : context->spriteRenderSystem->pool) {
    if (!sprite.isVisibleInLayer(layerMask)) continue;
    auto & data = context->spriteRenderSystem->getData(&sprite);
    if (data.batchIndex == NoBatchIndex) continue;
    const auto & batch = context->spriteRenderSystem->getSpriteBatch(data.batchIndex);
 
    glm::vec4 p;
    if (batch->positionMode == PositionMode::World) {
      p = cameraData.viewMatrix * glm::vec4(data.position, 1);
    } else if(batch->positionMode == PositionMode::Local){
      p = cameraData.viewMatrix * batch->transform * glm::vec4(data.position, 1);
    } else {
      continue;
    }
 
    glm::vec4 c = cameraData.projectionMatrix * p;
    int pointMask = 0;
    if (-c.w <= c.x) pointMask |= 0x1;
    if (c.x <= c.w) pointMask |= 0x2;
    if (-c.w <= c.y) pointMask |= 0x4;
    if (c.y <= c.w) pointMask |= 0x8;
    int outsideMask = ~pointMask & 0xf;
    if(outsideMask)
      continue;
 
    depthBoundNear = std::min(depthBoundNear, (-p.z) * (1.f - std::numeric_limits<float>::epsilon()));
    depthBoundFar = std::max(depthBoundFar, (-p.z) * (1.f + std::numeric_limits<float>::epsilon()));
  }
 
  {
    CpuInstrumentationScope(SCOPE_BOUNDS, "updateClippingPlanes::extensions");
    for (auto & bounds : context->bounds->getExtensions()) {
 
      float nearPlaneLimit = std::numeric_limits<float>::quiet_NaN();
      BoundingBox extensionBounds;
 
      bounds->getBounds(context, extensionBounds, nearPlaneLimit);
      if (!extensionBounds.empty()) {
 
        float nb = depthBoundNear;
        std::vector<uint8_t> simplexScratch(simplexScratchSize(3, 2, 7));
        ::updateCameraDepthBounds(context,
                                  simplexScratch.data(),
                                  nb, depthBoundFar,
                                  extensionBounds, cameraData.viewMatrix, cameraData.inverseViewMatrix, cameraData.viewProjection);
        if (!std::isfinite(nearPlaneLimit)) nearPlaneLimit = cameraComponent.nearPlaneLimit;
 
        depthBoundNear = std::min(depthBoundNear, std::max(nearPlaneLimit, nb));
      }
    }
  }
 
}
 
Cogs::Geometry::BoundingBox Cogs::Core::Bounds::getShadowBounds(Context* context)
{
  RenderLayers layerMask = RenderLayers::Default;
  BoundingBox box;
 
  for (auto & renderComponent : context->renderSystem->pool) {
    if (!renderComponent.isVisible() || !renderComponent.castShadows()) continue;
    if (!renderComponent.isVisibleInLayer(layerMask)) continue;
    BoundingBox bb = ::getMeshBounds(context->renderSystem, &renderComponent);
    box += bb;
  }
 
  for (auto & renderComponent : context->subMeshRenderSystem->pool) {
    if (!renderComponent.isVisible() || !renderComponent.castShadows()) continue;
    if (!renderComponent.isVisibleInLayer(layerMask)) continue;
    BoundingBox bb = ::getMeshBounds(context->subMeshRenderSystem, &renderComponent);
    box += bb;
  }
 
  for (auto & sprite : context->spriteRenderSystem->pool) {
    if (!sprite.isVisible()) continue;
    if (!sprite.isVisibleInLayer(layerMask)) continue;
    if ((sprite.renderFlags & RenderFlags::CastShadows) == 0) continue;
    BoundingBox bb = ::getSpriteBounds(context, &sprite);
    box += bb;
  }
 
  // TODO
  // for (auto & bounds : getExtensions()) {
  //   BoundingBox bb;
  //   float nearPlaneLimit = 0.f;
  //   bounds->getBounds(context, bb, nearPlaneLimit);
  //   if (!bb.empty()) box += bb;
  // }
 
  return box;
}
 
void Cogs::Core::Bounds::addBoundsExtension(IGetBounds * bounds)
{
  extensions.push_back(bounds);
}
 
void Cogs::Core::Bounds::removeBoundsExtension(IGetBounds * bounds)
{
  extensions.erase(std::remove(extensions.begin(), extensions.end(), bounds), extensions.end());
}