DynamicLodTree.cpp

#include "Context.h"
#include "Utilities/Math.h"
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/CameraSystem.h"
 
#include "Image360System.h"
 
namespace {
  using namespace Cogs::Core;
  using namespace Cogs::Core::Image360;
 
  bool isQuadVisible(const glm::vec3(&planes)[5],
                     const glm::vec3& o,
                     const glm::vec3& u,
                     const glm::vec3& v)
  {
    const glm::vec3 corners[4] = {
      o - u - v,
      o + u - v,
      o + u + v,
      o - u + v,
    };
    for (const glm::vec3& plane : planes) {
      bool anyIn = false;
      for (size_t i = 0; i < 4; i++) {
        anyIn = anyIn || (0.f <= glm::dot(plane, corners[i]));
      }
      if (!anyIn) {
        return false;
      }
    }
    return true;
  }
 
  bool initializeQuads(Context* context,
                       DynamicLodTree& tree,
                       Cache& cache,
                       Fetcher& fetcher,
                       const Image360Component& im360Comp,
                       const Config& config,
                       const uint32_t currentFrame,
                       std::vector<DynamicLodTree::Quad>& quads)
  {
    static const struct Face {
      glm::vec3 o;
      glm::vec3 u;
      glm::vec3 v;
    } faces[6] = {
      {.o = {+1 ,0, 0}, .u = {0, 0, -1}, .v = {0, +1, 0}},
      {.o = {-1, 0, 0}, .u = {0, 0, +1}, .v = {0, +1, 0}},
      {.o = {0, +1, 0}, .u = {+1, 0, 0}, .v = {0, 0, -1}},
      {.o = {0, -1, 0}, .u = {+1, 0, 0}, .v = {0, 0, +1}},
      {.o = {0, 0, +1}, .u = {+1, 0, 0}, .v = {0, +1, 0}},
      {.o = {0, 0, -1}, .u = {-1, 0, 0}, .v = {0, +1, 0}}
    };
 
    bool allBaseLevelsPresent = true;
    quads.resize(6);
    tree.data.resize(6);
    for (size_t i = 0; i < 6; i++) {
      quads[i].o = faces[i].o;
      quads[i].u = faces[i].u;
      quads[i].v = faces[i].v;
      quads[i].slot = cache.isQuadInCache(context, fetcher, im360Comp, config, currentFrame, 0, i);
      quads[i].cacheLevelIndex = i;
      quads[i].encodedTreeIndex = i;
      quads[i].level = 0;
      if (0 <= quads[i].slot) {
        tree.data[i] = quads[i].slot << 3;
      }
      else {
        tree.data[i] = -1;
        allBaseLevelsPresent = false;
      }
    }
    return allBaseLevelsPresent;
  }
 
  bool quadRefineIteration(Context* context,
                           DynamicLodTree& tree,
                           Cache& cache,
                           Fetcher& fetcher,
                           const Image360Component& im360Comp,
                           const Config& config,
                           const glm::vec3(&planes)[5],
                           const uint32_t currentFrame,
                           const float cosinePerTile,
                           std::vector<DynamicLodTree::Quad>& quads,
                           std::vector<DynamicLodTree::Quad>& quadsNext)
  {
    quadsNext.clear();
 
    for (const DynamicLodTree::Quad& quad : quads) {
 
      // Cannot descend beyond treedepth
      if (config.treeDepth <= quad.level + 1) continue;
 
      // Do not descend if FOV covered by quad is sufficently small.
      // Do both U and V on both sides since the tiles are not necessarily symmetric
      glm::vec3 m00 = glm::normalize(quad.o - quad.u - quad.v);
      glm::vec3 m10 = glm::normalize(quad.o + quad.u - quad.v);
      glm::vec3 m01 = glm::normalize(quad.o - quad.u + quad.v);
      glm::vec3 m11 = glm::normalize(quad.o + quad.u + quad.v);
 
      // We want to make sure the largest angle is less than the limit. Since cosine
      // decreases with increasing angle in [0, pi], ordering is switched (we find the
      // min cosine and see if this is larger than the limit.
      float angleMinCosine = glm::min(glm::min(glm::dot(m00, m10),
                                               glm::dot(m01, m11)),
                                      glm::min(glm::dot(m00, m01),
                                               glm::dot(m10, m11)));
 
      if (cosinePerTile <= angleMinCosine) {
        continue;
      }
 
      size_t leavesBase = tree.data.size();
      if (config.treeMaxSize < leavesBase + 4) {
        break;  // no more space in tree, cannot refine any more
      }
 
      DynamicLodTree::Quad childQuads[4];
      size_t childQuadCount = 0;
      EncodedSlotIx leaves[4] = { -1, -1, -1, -1 };
 
      for (size_t k = 0; k < 4; k++) {
 
        // Check if child quad is inside frustum
        glm::vec3 u = 0.5f * quad.u;
        glm::vec3 v = 0.5f * quad.v;
        glm::vec3 o = quad.o + ((k & 1) == 0 ? -u : u) + ((k & 2) == 0 ? -v : v);
 
 
        EncodedSlotIx encodedCacheSlot = (quad.slot << 3) + 4 + (EncodedSlotIx)k;
        if (isQuadVisible(planes, o, u, v)) {
 
          // Check if quad data is present in cache (and if not, a fetch might get triggered)
          size_t childLevel = quad.level + 1;
          size_t childCacheLevelIndex = 4 * quad.cacheLevelIndex + k;
          SlotIx cacheSlot = cache.isQuadInCache(context, fetcher, im360Comp, config, currentFrame, childLevel, childCacheLevelIndex);
          if (0 <= cacheSlot) {
            childQuads[childQuadCount++] = DynamicLodTree::Quad{
              .o = o,
              .u = u,
              .v = v,
              .slot = cacheSlot,
              .cacheLevelIndex = childCacheLevelIndex,
              .encodedTreeIndex = leavesBase + k,
              .level = childLevel
            };
            encodedCacheSlot = cacheSlot << 3;
          }
        }
 
        leaves[k] = encodedCacheSlot;
      }
 
      // If we have any children and they are all ready, commit refinement
      if (childQuadCount) {
 
        // Push visible children onto queue for further refinement
        for (size_t k = 0; k < childQuadCount; k++) {
          quadsNext.emplace_back(childQuads[k]);
        }
 
        // Let all children be represented in the tree
        for (size_t k = 0; k < 4; k++) {
          tree.data.push_back(leaves[k]);
        }
 
        // Convert parent leaf into a branch with these leaves
        tree.data[quad.encodedTreeIndex] = -Image360::SlotIx(leavesBase);
      }
    }
    quads.swap(quadsNext);
 
    return !quads.empty();
  }
 
 
}
 
 
void Cogs::Core::Image360::DynamicLodTree::update(Context* context,
                                                  RendererExtensionData& rendererData,
                                                  Fetcher& fetcher,
                                                  Cache& cache,
                                                  const Image360Component& im360Comp,
                                                  const Config& config,
                                                  const uint32_t currentFrame,
                                                  const Image360Component& comp)
{
  TransformComponent* trComp = comp.getComponent<TransformComponent>();
  if (trComp == nullptr) return;
 
  quads.clear();
  bool allBaseLevelsPresent = initializeQuads(context, *this, cache, fetcher, im360Comp, config, currentFrame, quads);
 
  rendererData.worldFromLocal = context->transformSystem->getLocalToWorld(trComp);
  rendererData.localFromWorld = glm::inverse(rendererData.worldFromLocal);
 
  const CameraData& camData = context->cameraSystem->getMainCameraData();
  const float clipSpaceNearPlane = context->variables->get("renderer.reverseDepth", false) ? 1.f : -1.f;
 
  // Discard translation, eye should be at origin when combined with localFromWorld
  const glm::mat3 localFromView = rendererData.localFromWorld * glm::mat3(camData.inverseViewMatrix);
  const glm::vec3 fwd = localFromView * glm::vec3(0, 0, -1);
 
  const glm::mat4 localFromClip = glm::mat4(localFromView) * camData.inverseProjectionMatrix;
  const glm::vec3 c00 = euclidean(localFromClip * glm::vec4(-1.0, -1.0, clipSpaceNearPlane, 1));
  const glm::vec3 c10 = euclidean(localFromClip * glm::vec4(+1.0, -1.0, clipSpaceNearPlane, 1));
  const glm::vec3 c01 = euclidean(localFromClip * glm::vec4(-1.0, +1.0, clipSpaceNearPlane, 1));
  const glm::vec3 c11 = euclidean(localFromClip * glm::vec4(+1.0, +1.0, clipSpaceNearPlane, 1));
  glm::vec3 planes[5] = {
     glm::normalize(glm::cross(c01, c11)),
    -glm::normalize(glm::cross(c00, c10)),
     glm::normalize(glm::cross(c00, c01)),
    -glm::normalize(glm::cross(c10, c11)),
    glm::normalize(fwd)
  };
 
  // Find largest fov-angle a tile can cover without needing to be refined. This is found by
  // calculating the angle-per-pixel for width or height (use the largest).
  float hAngle = glm::acos(glm::dot(glm::normalize(c00), glm::normalize(c10)));
  float vAngle = glm::acos(glm::dot(glm::normalize(c00), glm::normalize(c01)));
  float anglePerPixel;
  if (vAngle <= hAngle) {
    anglePerPixel = hAngle / camData.viewportSize.x;
  }
  else {
    anglePerPixel = vAngle / camData.viewportSize.y;
  }
 
  // The angle per pixel is then scaled by the subsampling factor and then multiplied by the
  // number of pixels in in the tile.
  // 
  // It might be more correct to use steradians to avoid the min/max of horizontal/vert etc,
  // but this simpler approach seems to work OK
  float anglePerTile = std::min(glm::pi<float>(), anglePerPixel * comp.subsampling * config.baseSize);
 
  // We clamp this angle to [0, pi] where cos is monotonically decreasing, so we can just
  // use the cosine in the test without finding the actual angle with acos.
  float cosinePerTile = std::cos(std::min(glm::pi<float>(), anglePerTile));
 
 
  // Just give up if something degenerate.
  if (!std::isfinite(cosinePerTile)) return;
 
  if (allBaseLevelsPresent) {
    while (quadRefineIteration(context, *this, cache, fetcher, im360Comp, config, planes, currentFrame, cosinePerTile, quads, quadsNext)) {}
  }
}