BadgeSetPicker.cpp

#include "BadgeSetPicker.h"
#include "BadgeSetSystem.h"
 
#include "Context.h"
#include "ViewContext.h"
#include "Components/Core/SceneComponent.h"
#include "Components/Core/TransformComponent.h"
#include "Systems/Core/TransformSystem.h"
#include "Scene/RayPick.h"
#include "Services/DPIService.h"
#include "Resources/Mesh.h"
#include "Systems/Core/CameraSystem.h"
#include "Utilities/Math.h"
#include "Systems/ComponentSystem.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/ICapabilities.h"
 
#include "Foundation/Logging/Logger.h"
 
namespace
{
  using namespace Cogs::Core;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("BadgeSetPicker");
 
  struct BoundingBox
  {
    glm::vec2 min;
    glm::vec2 max;
    BoundingBox (float minX, float minY, float maxX, float maxY) {
      min.x = minX;
      min.y = minY;
      max.x = maxX;
      max.y = maxY;
    }
 
    bool isPointWithin(const glm::vec2 &mouse) const {
      return mouse.x >= min.x && mouse.x <= max.x && mouse.y >= min.y && mouse.y <= max.y;
    }
  };
 
  struct RecordHit
  {
    std::vector<RayPicking::RayPickHit>& hits;
    const BadgeSetComponent& comp;
    RayPicking::Ordinal ordinal;
    const RenderComponent& renderComp;
    const glm::mat4& worldFromLocal;
    const float rayFromLocalScale;
    bool returnClosest;
    bool returnChildEntity;
    bool hitSomething = false;
 
    void operator()(const glm::vec4& posLocal, const float distanceLocal, size_t index) {
      glm::vec4 posWorld = worldFromLocal * posLocal;
      const float distanceWorld = rayFromLocalScale * distanceLocal;
      if (returnClosest && !hits.empty()) {
        if (hits[0].isBehind(ordinal, distanceWorld)) {
          hits[0] = { renderComp, returnChildEntity, glm::vec3(posWorld), ordinal, distanceWorld, glm::vec2(static_cast<float>(index)) };
          hitSomething = true;
        }
        // else, the intersection we found is further, so don't do anything
      }
      else {
        hits.emplace_back(renderComp, returnChildEntity, glm::vec3(posWorld), ordinal, distanceWorld, glm::vec2(static_cast<float>(index)));
        hitSomething = true;
      }
    }
 
  };
 
  void pickScaledFixedScreenSizeBox(RecordHit& recordHit,
                             const BadgeSetComponent& comp,
                             const BadgeSetData& data,
                             const glm::vec3& rayOriginLocal,
                             const glm::vec3& rayUnitDirectionLocal,
                             const glm::mat4& clipFromLocal,
                             const glm::vec2& queryClip,
                             const glm::vec2 viewportSize,
                             const float maxDistanceLocal,
                             const float dpiScale)
  {
    const float nearDistance = comp.nearVisibilityLimit;
    const float farDistance = std::min(comp.farVisibilityLimit, maxDistanceLocal);
    const float size = comp.badgeSize * dpiScale;
    const glm::vec4 viewPlaneLocal = data.viewPlaneLocal;
    const glm::vec3 mainCamViewDirLocal(data.viewPlaneLocal);
    const glm::vec2 pickPosView = queryClip * viewportSize;
    const float rcp = -1.f / glm::dot(mainCamViewDirLocal, rayUnitDirectionLocal);
    const float mp = glm::dot(mainCamViewDirLocal, rayOriginLocal);
    if (std::isfinite(rcp)) {
      for (size_t i = 0; i < comp.positions.size(); i++) {
        const glm::vec4 posLocal(comp.positions[i], 1.f);
        float viewZ = glm::dot(viewPlaneLocal, posLocal);
        float scaleFactor = viewZ / glm::clamp(viewZ, comp.nearScalingCutoff, comp.farScalingCutoff);
        float adjustedPointSize = size * scaleFactor;
 
        // Adjusting the bounding box so that it fits when/if the anchor of the badge changes
        glm::vec2 corners[2] = {
          { comp.boundingBoxLower.x - comp.anchorPoint.x, comp.boundingBoxLower.y - (1 - comp.anchorPoint.y)},
          { comp.boundingBoxUpper.x - comp.anchorPoint.x, comp.boundingBoxUpper.y - (1 - comp.anchorPoint.y)}
        };
 
        glm::vec3 cornerBottomLeft = glm::vec3(posLocal) + ((adjustedPointSize * corners[0].x) * data.viewXLocal + (adjustedPointSize * corners[0].y) * data.viewYLocal);
        glm::vec3 cornerTopRight = glm::vec3(posLocal) + ((adjustedPointSize * corners[1].x) * data.viewXLocal + (adjustedPointSize * corners[1].y) * data.viewYLocal);
 
        if (nearDistance <= viewZ && viewZ <= farDistance) {
 
          glm::vec3 cornerBottomLeftClipSpace = euclidean(clipFromLocal * glm::vec4(cornerBottomLeft, 1));
          glm::vec2 cornerBottomLeftView = glm::vec2(cornerBottomLeftClipSpace) * viewportSize;
 
          glm::vec3 cornerTopRightClipSpace = euclidean(clipFromLocal * glm::vec4(cornerTopRight, 1));
          glm::vec2 cornerTopRightView = glm::vec2(cornerTopRightClipSpace) * viewportSize;
 
          BoundingBox box(cornerBottomLeftView.x, cornerBottomLeftView.y, cornerTopRightView.x, cornerTopRightView.y);
          const float t = rcp * (mp - glm::dot(glm::vec3(data.viewPlaneLocal), glm::vec3(posLocal)));
 
          if (box.isPointWithin(pickPosView)) {
            recordHit(posLocal, t, i);
          }
        }
      }
    }
  }
}
 
 
bool Cogs::Core::BadgeSetPicker::pickCamera(Context* context,
                                                  const CameraComponent& camera,
                                                  const glm::vec2& queryClip,
                                                  float rayLength,
                                                  float rayPixelRadius,
                                                  PickingFlags pickingFlags,
                                                  PicksReturned returnFlag,
                                                  const RayPicking::RayPickFilter& filter,
                                                  std::vector<RayPicking::RayPickHit>& hits)
{
  const CameraData& cameraData = context->cameraSystem->getData(&camera);
  const float dpiScale = context->getDefaultView()->dpiService->getScaleFactor();
 
  bool hitSomething = false;
  for (const BadgeSetComponent& comp : system->pool) {
    if (filter.isUnwantedType(comp)) {
      continue;
    }
 
    const SceneComponent* sceneComp = comp.getComponent<SceneComponent>();
    if (sceneComp && (!sceneComp->visible || !sceneComp->pickable)) {
      continue;
    }
 
    const RenderComponent* renderComp = comp.getComponent<RenderComponent>();
    if (renderComp == nullptr || !renderComp->isVisibleInLayer(filter.layerMask)) {
      continue;
    }
 
    const BadgeSetData& data = system->getData(&comp);
 
    const TransformComponent* transformComp = comp.getComponent<TransformComponent>();
    const glm::mat4 worldFromLocal = context->transformSystem->getLocalToWorld(transformComp);
    const glm::mat4 clipFromLocal = cameraData.rawViewProjection * worldFromLocal;
    const glm::mat4 localFromClip = glm::inverse(clipFromLocal);
    const glm::vec2 sigma = glm::vec2(2.f * rayPixelRadius) / cameraData.viewportSize;
    const glm::vec3 rayOriginLocal = euclidean(localFromClip * glm::vec4(queryClip, -1.f, 1.f));
    const glm::vec3 rayOriginFarLocal = euclidean(localFromClip * glm::vec4(queryClip, 1.f, 1.f));
    const glm::vec3 rayDirLocal = rayOriginFarLocal - rayOriginLocal;
    const glm::vec3 rayOriginSigmaLocal = euclidean(localFromClip * glm::vec4(queryClip + sigma, -1.f, 1.f));
    const glm::vec3 rayOriginSigmaFarLocal = euclidean(localFromClip * glm::vec4(queryClip + sigma, 1.f, 1.f));
    const float rayLengthRcp = 1.f / glm::length(rayDirLocal);
    const glm::vec3 rayUnitDirLocal = rayLengthRcp * rayDirLocal;
    const float worldFromLocalScale = glm::determinant(glm::mat3(worldFromLocal));
 
    // The min below is to work-around local scale becoming infinity if raylength is max_float.
    const float maxDistanceLocal = std::min(std::numeric_limits<float>::max(), 2.f * worldFromLocalScale * rayLength);
 
    RecordHit recordHit{
      .hits = hits,
      .comp = comp,
      .ordinal = filter.getOrdinal(*renderComp),
      .renderComp = *renderComp,
      .worldFromLocal = worldFromLocal,
      .rayFromLocalScale = worldFromLocalScale,
      .returnClosest = returnFlag == PicksReturned::Closest,
      .returnChildEntity = (pickingFlags & PickingFlags::ReturnChildEntity) == PickingFlags::ReturnChildEntity
    };
 
    pickScaledFixedScreenSizeBox(recordHit, comp, data, rayOriginLocal, rayUnitDirLocal, clipFromLocal, queryClip, cameraData.viewportSize, maxDistanceLocal, dpiScale);
 
    hitSomething |= recordHit.hitSomething;
  }
 
  return hitSomething;
}