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 "Resources/Texture.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;
      }
    }
 
  };
 
  constexpr int styleMaskOpaque = 1;
  constexpr int styleMaskTransparent = 0;
  constexpr int styleMaskUnknown = -1;
 
  int sampleStyleMask(const BadgeSetComponent& comp, size_t badgeIndex, const glm::vec2& quadUV)
  {
    const std::vector<int>& mask = comp.masks;
    if (mask.size() < 3) {
      return styleMaskUnknown;
    }
 
    const int width = mask[0];
    const int height = mask[1];
    const int layers = mask[2];
    if (width <= 0 || height <= 0 || layers <= 0) {
      return styleMaskUnknown;
    }
 
    // The style array layer for this badge is its style index (see BadgeSetSystem).
    int layer = 0;
    if (badgeIndex < comp.styles.size()) {
      const int styleIndex = comp.styles[badgeIndex];
      if (styleIndex < 0 || styleIndex >= layers) {
        return styleMaskUnknown;
      }
      layer = styleIndex;
    }
 
    const size_t wordsPerLayer = (static_cast<size_t>(width) * static_cast<size_t>(height) + 31u) / 32u;
    const size_t expectedSize = 3u + wordsPerLayer * static_cast<size_t>(layers);
    if (mask.size() < expectedSize) {
      return styleMaskUnknown;
    }
 
    const float u = glm::clamp(quadUV.x, 0.f, 1.f);
    const float v = glm::clamp(quadUV.y, 0.f, 1.f);
    const int px = std::min(static_cast<int>(u * static_cast<float>(width)), width - 1);
    // The quad's v coordinate increases upwards while mask rows are stored top-down, so flip.
    const int py = std::min(static_cast<int>((1.f - v) * static_cast<float>(height)), height - 1);
    const size_t p = static_cast<size_t>(py) * static_cast<size_t>(width) + static_cast<size_t>(px);
    const size_t layerBase = 3u + wordsPerLayer * static_cast<size_t>(layer);
    const uint32_t word = static_cast<uint32_t>(mask[layerBase + (p >> 5)]);
    const bool opaque = (word & (1u << (p & 31u))) != 0u;
    return opaque ? styleMaskOpaque : styleMaskTransparent;
  }
 
  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 - comp.anchorPoint.y},
          { comp.boundingBoxUpper.x - comp.anchorPoint.x, comp.boundingBoxUpper.y - 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)) {
            // Only count the hit if it lands on a non-transparent part of the badge's
            // style texture. Recover the pick position as a fraction of the projected
            // bounding box, then remap it into the quad/texture coordinate the shader
            // samples 'styleMap' with: the bounding box is only a sub-region of the
            // [0,1] quad, so a non-default boundingBoxLower/Upper must be folded back in
            // (otherwise the box fraction would be stretched across the whole mask).
            // When no mask is available sampleStyleMask returns "unknown" and we keep the
            // geometric hit. anchorPoint cancels out here (it shifts both corners equally).
            const glm::vec2 boxSpan = cornerTopRightView - cornerBottomLeftView;
            const glm::vec2 boxFraction = {
              boxSpan.x != 0.f ? (pickPosView.x - cornerBottomLeftView.x) / boxSpan.x : 0.f,
              boxSpan.y != 0.f ? (pickPosView.y - cornerBottomLeftView.y) / boxSpan.y : 0.f,
            };
            const glm::vec2 texCoord = comp.boundingBoxLower + boxFraction * (comp.boundingBoxUpper - comp.boundingBoxLower);
            const int maskState = sampleStyleMask(comp, i, texCoord);
            if (maskState != styleMaskTransparent) {
              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;
}