RayPickExtension.cpp

 
#include "Foundation/Logging/Logger.h"
 
#include "Utilities/Math.h"
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/TransformSystem.h"
 
#include "Image360System.h"
 
namespace {
  using namespace Cogs::Core;
  using namespace Cogs::Core::Image360;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Image360");
 
  void cubemapDecode(int& f, glm::vec2& uv, const glm::vec3& d)
  {
    glm::vec3 m = abs(d);
    if (m.x > m.y && m.x > m.z) {
      f = 0.f <= d.x ? 0 : 1;   // 0 for +X face, 1 for -X face.
      uv.x = -d.z / d.x;        // -Z for +X face, Z for -X face.
      uv.y = d.y / m.x;         // Y for both +X and -X faces.
    }
    else if (m.y > m.z) {
      f = 0.f <= d.y ? 2 : 3;   // 2 for +Y face, 3 for -Y face.
      uv.x = d.x / m.y;         // X for both +Y and -Y faces.
      uv.y = -d.z / d.y;        // -Z for +Y face, Z for -Y face.
    }
    else {
      f = 0.f <= d.z ? 4 : 5;   // 4 for +Z face, 5 for -Z face.
      uv.x = d.x / d.z;         // X for +Z face, -X for -Z face.
      uv.y = d.y / m.z;         // Y for both +Z and -Z faces.
    }
    uv = 0.5f * (uv + glm::vec2(1.0));
  }
 
  bool lookupDistance(float& dist, const RendererExtensionData& rendererData, const DynamicLodTree& lodTree, const Config& conf, const glm::vec3 dir)
  {
    int f;
    glm::vec2 uv_;
    cubemapDecode(f, uv_, dir);
 
    glm::vec2 uv = uv_;
    int ix = lodTree.data[f];
    for (size_t l = 0; ix < -1 && l <= conf.treeMaxSize; l++) {
      uv = 2.f * uv;
      glm::vec2 o = glm::floor(uv);
      uv = uv - o;
      ix = -ix + 2 * int(o.y) + int(o.x);
      ix = lodTree.data[ix];
    }
 
    if (ix < 0) {  // base level should always have data
      ix = f;
      uv = uv_;
    }
    else {
      if ((ix & 4) != 0) {
        uv = 0.5f * (uv + glm::vec2(ix & 1, (ix >> 1) & 1));
      }
      ix = ix >> 3;
    }
 
    assert(0 <= ix);
    if (size_t(ix) < rendererData.depth.tilesData.size()) {
      const Cogs::Memory::MemoryBuffer* buffer = rendererData.depth.tilesData[ix].get();
      if (buffer) {
        assert(buffer->size() == sizeof(uint16_t) * conf.baseSize * conf.baseSize);
        glm::ivec2 loc = glm::clamp(glm::ivec2(glm::vec2(float(conf.baseSize)) * uv), glm::ivec2(0), glm::ivec2(conf.baseSize-1));
 
        uint16_t value = ((const uint16_t*)buffer->data())[loc.y * conf.baseSize + loc.x];
        if (value == rendererData.noDataDepth) {
          return false;
        }
        dist = rendererData.depth.scale * float(value) + rendererData.depth.bias;
        return true;
      }
    }
    return false;
  }
 
}
 
 
Cogs::Core::Image360::RayPickExtension::RayPickExtension(Image360System* im360System) : im360System(im360System) {}
 
bool Cogs::Core::Image360::RayPickExtension::pickCamera(Context* context,
                                                        const CameraComponent& camera,
                                                        const glm::vec2& normPosition,
                                                        float /*rayLength*/,
                                                        float /*radius*/,
                                                        PickingFlags pickingFlags,
                                                        PicksReturned returnFlag,
                                                        const RayPicking::RayPickFilter& filter,
                                                        std::vector<RayPicking::RayPickHit>& hits)
{
  const CameraData& cameraData = context->cameraSystem->getData(&camera);
  const float clipSpaceNearPlane = context->variables->get("renderer.reverseDepth", false) ? 1.f : -1.f;
 
  const bool returnChildEntity = (pickingFlags & PickingFlags::ReturnChildEntity) == PickingFlags::ReturnChildEntity;
 
  bool hitSomething = false;
  for (Image360Component& comp : im360System->pool) {
    if (!comp.isPickable() || filter.isUnwantedType(comp)) { continue; }
 
    const RenderComponent* renderComp = comp.getComponent<RenderComponent>();
    if (renderComp && !renderComp->isVisibleInLayer(filter.layerMask)) { continue; }
 
    const Image360Data& data = im360System->getData(&comp);
    if (data.state != Image360Data::State::Running) { continue; }
    if (!data.config.hasDepth) { continue; }
    if (data.rendererData.depth.tilesData.empty()) { continue; }
 
    const glm::mat3 localFromView = data.rendererData.localFromWorld * glm::mat3(cameraData.inverseViewMatrix);
    const glm::mat3 viewFromLocal = glm::mat3(cameraData.viewMatrix) * data.rendererData.worldFromLocal;
 
    const glm::mat4 localFromClip = glm::mat4(localFromView) * cameraData.inverseProjectionMatrix;
    const glm::vec3 dir = glm::normalize(euclidean(localFromClip * glm::vec4(normPosition, clipSpaceNearPlane, 1)));
 
    float dist = 0.0;
    if (lookupDistance(dist, data.rendererData, data.lodTree, data.config, dir)) {
 
      // Transform from 360 image frame to view frame. These frame must have the same
      // origin so there is no translation.
      glm::vec3 posView = viewFromLocal * (dist * dir);
      glm::vec4 posClip = cameraData.rawProjectionMatrix * glm::vec4(posView, 1.f);
 
      glm::vec4 posWorld_h = cameraData.inverseViewMatrix * glm::vec4(posView, 1.f);
      float depth = -posView.z;
      if (0 <= depth) {
        if (returnFlag == PicksReturned::Closest && !hits.empty()) {
          if (depth < hits[0].distance) {
            hits[0] = {comp, returnChildEntity, euclidean(posWorld_h), depth};
            hitSomething = true;
          }
          // else, the intersection we found is further, so don't do anything
        }
        else {
          hits.emplace_back(comp, returnChildEntity, euclidean(posWorld_h), depth);
          hitSomething = true;
        }
      }
    }
  }
 
  // Sort hits based on distance
  if (returnFlag == PicksReturned::AllSorted) {
    std::sort(hits.begin(), hits.end());
  }
 
  return hitSomething;
}