RayIntersection.cpp

 
#include "Foundation/Logging/Logger.h"
 
#include "Utilities/FrustumClassification.h"
 
#include "RayIntersection.h"
 
#include "Math/RayTriangleIntersection.h"
#include "Math/RayBoxIntersection.h"
#include "Resources/Mesh.h"
#include "Resources/Buffer.h"
 
#include <glm/gtc/packing.hpp>
 
namespace {
  using namespace Cogs::Geometry;
  using namespace Cogs::Core;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RayIntersection");
 
  struct PosStreamRef
  {
    const uint8_t* ptr = nullptr;
    Cogs::DataFormat format = Cogs::DataFormat::Unknown;
    uint32_t stride = 0;
    uint32_t count = 0;
  };
 
  struct IxStreamRef
  {
    const uint8_t* ptr = nullptr;
    uint32_t stride = 0;
    uint32_t count = 0;
  };
 
  struct SubMeshStreamRef
  {
    const SubMesh* ptr = nullptr;
    uint32_t stride = 0;
    uint32_t count = 0;
  };
 
  bool intersectThickRayAndPoint(glm::vec3& intersection, const glm::mat4& localPickMatrix, const glm::vec3& l0)
  {
    glm::vec4 h0 = localPickMatrix * glm::vec4(l0.x, l0.y, l0.z, 1.f);
    glm::vec2 p0 = (1.f / h0.w) * glm::vec2(h0.x, h0.y);
    if (glm::dot(p0, p0) <= 1.f) {
      intersection = l0;
      return true;
    }
    return false;
  }
 
  // Intersects thick ray (specified by the frustum in which vertexPickCoords lie) and a line segment.
  bool intersectThickRayAndLineSegment(glm::vec3& intersection, glm::vec2 barycentric, const glm::mat4& localPickMatrix, const glm::vec3& pt0, const glm::vec3& pt1)
  {
    barycentric = glm::vec2(-1.0f);
    glm::vec3 l0 = pt0;
    glm::vec3 l1 = pt1;
 
    glm::vec4 h0 = localPickMatrix * glm::vec4(l0.x, l0.y, l0.z, 1.f);
    glm::vec4 h1 = localPickMatrix * glm::vec4(l1.x, l1.y, l1.z, 1.f);
 
    // clip against the near-plane (to avoid numerical issues wrt projection)
    if (h0.z < -h0.w && h1.z < -h1.w) {
      return false; // completely in front of the near plane
    }
    else if (h0.z < -h0.w) {
      // (1-t)z0 + t z1 = -((1-t)w0 + tw1)
      // z0 - tz0 + tz1 = -w0 + tw0 - tw1
      // z0 + t(z1-z0) = -w0 + t(w0 - w1)
      // t(z1-z0 + w1 - w0) = -(w0 + z0)
      // t = -(w0 + z0)/(z1-z0 + w1 - w0)
      float t = -(h0.w + h0.z) / (h1.z - h0.z + h1.w - h0.w);
      h0 = glm::mix(h0, h1, t);
      l0 = glm::inverse(localPickMatrix) * h0;
    }
    else if (h1.z < -h1.w) {
      float t = -(h0.w + h0.z) / (h1.z - h0.z + h1.w - h0.w);
      h1 = glm::mix(h0, h1, t);
      l1 = glm::inverse(localPickMatrix) * h1;
    }
 
    // project and solve 2D problem
    glm::vec2 p0 = (1.f / h0.w) * glm::vec2(h0.x, h0.y);
    glm::vec2 p1 = (1.f / h1.w) * glm::vec2(h1.x, h1.y);
    glm::vec2 v01 = p1 - p0;
    float t;
    float d2 = glm::dot(v01, v01);
    if (std::numeric_limits<float>::epsilon() < d2) {
      // project origin onto v01 and clamp it onto the line segment
      t = glm::clamp(-glm::dot(p0, v01) / d2, 0.f, 1.f);
    }
    else {
      // otherwise, if v01 is degenerate, we leave t=0.5 and use the midpoint
      t = 0.5f;
    }
 
    // pt is the nearest point on [p0,p1]
    glm::vec2 pt = glm::mix(p0, p1, t);
 
    // and check if it is inside the pixel ellipsiod
    if (glm::dot(pt, pt) <= 1.f) {
      // do perspective correction
      glm::vec2 w((1.f - t) / h0.w, t / h1.w);
      glm::vec2 b = (1.f / (w.x + w.y)) * w;
      intersection = b.x * l0 + b.y * l1;
      barycentric = b;
      return true;
    }
    return false;
  }
 
  // Simplified line intersection code where the intersection line is the z-axis.
  bool intersectTriangleBarycentric(glm::vec3& barycentric, const glm::mat4& localPickMatrix, const glm::vec3& l0, const glm::vec3& l1, const glm::vec3& l2)
  {
    glm::vec4 h0 = localPickMatrix * glm::vec4(l0.x, l0.y, l0.z, 1.f);
    glm::vec4 h1 = localPickMatrix * glm::vec4(l1.x, l1.y, l1.z, 1.f);
    glm::vec4 h2 = localPickMatrix * glm::vec4(l2.x, l2.y, l2.z, 1.f);
 
    if ((h0.z < -h0.w) && (h1.z < -h1.w) && (h2.z < -h2.w)) {
      return false; // completely in front of the near plane, reject
    }
    else if ((h0.z < -h0.w) || (h1.z < -h1.w) || (h2.z < -h2.w)) {
      // intersecting the near plane, solve problem in R3.
      glm::mat4 Q = glm::inverse(localPickMatrix);
      glm::vec4 R0 = Q * glm::vec4(0.f, 0.f, -1.f, 1.f);
      glm::vec3 r0 = (1.f / R0.w) * glm::vec3(R0.x, R0.y, R0.z);
      glm::vec4 R1 = Q * glm::vec4(0.f, 0.f, 1.f, 1.f);
      glm::vec3 r1 = (1.f / R1.w) * glm::vec3(R1.x, R1.y, R1.z);
 
      glm::vec3 intersection;
      bool front;
      return intersect(l0, l1, l2, r0, r1 - r0, intersection, barycentric, front);
    }
 
    glm::vec2 p0 = (1.f / h0.w) * glm::vec2(h0.x, h0.y);
    glm::vec2 p1 = (1.f / h1.w) * glm::vec2(h1.x, h1.y);
    glm::vec2 p2 = (1.f / h2.w) * glm::vec2(h2.x, h2.y);
    glm::vec2 v01 = p1 - p0;
    glm::vec2 v12 = p2 - p1;
    glm::vec2 v20 = p0 - p2;
 
    // signed areas
    glm::vec4 areas(v12.x * p1.y - p1.x * v12.y,    // = 2*area[p1, p2, origin]
      v20.x * p2.y - p2.x * v20.y,    // = 2*area[p2, p0, origin]
      v01.x * p0.y - p0.x * v01.y,    // = 2*area[p0, p1, origin]
      v01.x * v20.y - v20.x * v01.y); // = 2*area[p0, p1, p2]
 
    // Assert that the triangle hasn't degenerated to a line or point from the projection
    if (std::numeric_limits<float>::epsilon() < glm::abs(areas.w)) {
 
      // check sign of all areas
      glm::bvec4 signs = glm::lessThan(areas, glm::vec4(0.f));
 
      // if all signs are equal, the point is inside.
      if (glm::all(glm::equal(glm::bvec4(signs.w), signs))) {
        glm::vec3 w = glm::vec3(areas.x / h0.w, areas.y / h1.w, areas.z / h2.w);
        barycentric = (1.f / (w.x + w.y + w.z)) * w;
//        intersection = b.x * l0 + b.y * l1 + b.z * l2;
        return true;
      }
    }
 
    return false;
  }
 
 
  // Simplified line intersection code where the intersection line is the z-axis.
  bool intersectTriangle(glm::vec3& intersection, glm::vec3 &barycenric, const glm::mat4& localPickMatrix, const glm::vec3& l0, const glm::vec3& l1, const glm::vec3& l2)
  {
    bool result = intersectTriangleBarycentric(barycenric, localPickMatrix, l0, l1, l2);
    if (result) {
      intersection = barycenric.x * l0 + barycenric.y * l1 + barycenric.z * l2;
    }
    return result;
  }
 
  template<typename Fetch>
  void classify(FrustumPlanes* vertexFlags,
                const glm::mat4& localPickMatrix,
                const PosStreamRef& positions)
  {
    for (size_t i = 0; i < positions.count; i++) {
      glm::vec4 h = localPickMatrix * glm::vec4(Fetch::fetch(positions, i), 1.f);
      vertexFlags[i] = (( h.x <= h.w ? FrustumPlanes::InsidePosX : FrustumPlanes::InsideNone) |
                        (-h.w <= h.x ? FrustumPlanes::InsideNegX : FrustumPlanes::InsideNone) |
                        ( h.y <= h.w ? FrustumPlanes::InsidePosY : FrustumPlanes::InsideNone) |
                        (-h.w <= h.y ? FrustumPlanes::InsideNegY : FrustumPlanes::InsideNone) |
                        ( h.z <= h.w ? FrustumPlanes::InsidePosZ : FrustumPlanes::InsideNone) |
                        (-h.w <= h.z ? FrustumPlanes::InsideNegZ : FrustumPlanes::InsideNone));
    }
  }
 
 
  template<size_t IndexStride, typename Fetch>
  void intersectPoints(std::vector<RayIntersectionHit>& hits,
                       const glm::mat4& localPickMatrix,
                       const FrustumPlanes* vertexFlags,
                       const PosStreamRef& positions,
                       const IxStreamRef& indices,
                       const size_t a,
                       const size_t b,
                       const float scale)
  {
    static_assert(IndexStride == 0 || IndexStride == 2 || IndexStride == 4);
    for (size_t i = a; i < b; i++) {
 
      size_t ix0;
      if constexpr (IndexStride == 2) {
        ix0 = reinterpret_cast<const uint16_t*>(indices.ptr)[i];
        if (positions.count <= ix0) continue;
      }
      else if constexpr (IndexStride == 4) {
        ix0 = reinterpret_cast<const uint32_t*>(indices.ptr)[i];
        if (positions.count <= ix0) continue;
      }
      else {
        ix0 = i;
      }
 
      if (vertexFlags[ix0] == FrustumPlanes::InsideAll) { // bbox reject failed
        glm::vec3 intersection;
        glm::vec3 barycentric = glm::vec3(1.0f, 0.0f, 0.0f);
        if (intersectThickRayAndPoint(intersection, localPickMatrix,
                                      Fetch::fetch(positions, ix0))) {
          hits.emplace_back(RayIntersectionHit{ scale * intersection, barycentric, glm::uvec3(ix0, ix0, ix0) });
        }
      }
    }
  }
 
 
  template<size_t IndexStride, typename Fetch>
  void intersectLines(std::vector<RayIntersectionHit>& hits,
                      const glm::mat4& localPickMatrix,
                      const FrustumPlanes* vertexFlags,
                      const PosStreamRef& positions,
                      const IxStreamRef& indices,
                      const size_t a,
                      const size_t b,
                      const size_t indexStep,
                      const float scale)
  {
    static_assert(IndexStride == 0 || IndexStride == 2 || IndexStride == 4);
    for (size_t i = a; i < b; i += indexStep) {
 
      size_t ix0, ix1;
      if constexpr (IndexStride == 2) {
        ix0 = reinterpret_cast<const uint16_t*>(indices.ptr)[i + 0];
        ix1 = reinterpret_cast<const uint16_t*>(indices.ptr)[i + 1];
        if (positions.count <= ix0 || positions.count <= ix1) continue;
      }
      else if constexpr (IndexStride == 4) {
        ix0 = reinterpret_cast<const uint32_t*>(indices.ptr)[i + 0];
        ix1 = reinterpret_cast<const uint32_t*>(indices.ptr)[i + 1];
        if (positions.count <= ix0 || positions.count <= ix1) continue;
      }
      else {
        ix0 = i + 0;
        ix1 = i + 1;
      }
 
      if ((vertexFlags[ix0] | vertexFlags[ix1]) == FrustumPlanes::InsideAll) { // bbox reject failed
 
        glm::vec3 intersection;
        glm::vec2 barycentric;
        if (intersectThickRayAndLineSegment(intersection, barycentric, localPickMatrix,
                                            Fetch::fetch(positions, ix0),
                                            Fetch::fetch(positions, ix1))) {
          hits.emplace_back(RayIntersectionHit{ scale * intersection, glm::vec3(1.f, 0.f, 0.f), glm::uvec3(ix0, ix1, 0) });
        }
      }
    }
  }
 
  template<size_t IndexStride, typename Fetch>
  void intersectTriangles(std::vector<RayIntersectionHit>& hits,
                          const glm::mat4& localPickMatrix,
                          const FrustumPlanes* vertexFlags,
                          const PosStreamRef& positions,
                          const IxStreamRef& indices,
                          const size_t a,
                          const size_t b,
                          const size_t indexStep,
                          const float scale)
  {
    static_assert(IndexStride == 0 || IndexStride == 2 || IndexStride == 4);
    for (size_t i = a; i + 2 < b; i += indexStep) {
 
      size_t ix0, ix1, ix2;
      if constexpr (IndexStride == 2) {
        ix0 = reinterpret_cast<const uint16_t*>(indices.ptr)[i + 0];
        ix1 = reinterpret_cast<const uint16_t*>(indices.ptr)[i + 1];
        ix2 = reinterpret_cast<const uint16_t*>(indices.ptr)[i + 2];
        if (positions.count <= ix0 || positions.count <= ix1 || positions.count <= ix2) continue;
      }
      else if constexpr (IndexStride == 4) {
        ix0 = reinterpret_cast<const uint32_t*>(indices.ptr)[i + 0];
        ix1 = reinterpret_cast<const uint32_t*>(indices.ptr)[i + 1];
        ix2 = reinterpret_cast<const uint32_t*>(indices.ptr)[i + 2];
        if (positions.count <= ix0 || positions.count <= ix1 || positions.count <= ix2) continue;
      }
      else {
        ix0 = i + 0;
        ix1 = i + 1;
        ix2 = i + 2;
      }
 
      if ((vertexFlags[ix0] | vertexFlags[ix1] | vertexFlags[ix2]) == FrustumPlanes::InsideAll) {
 
        glm::vec3 intersection;
        glm::vec3 barycentric;
        if (intersectTriangle(intersection, barycentric, localPickMatrix,
                              Fetch::fetch(positions, ix0),
                              Fetch::fetch(positions, ix1),
                              Fetch::fetch(positions, ix2))) {
          hits.emplace_back(RayIntersectionHit{ scale * intersection, barycentric, glm::uvec3(ix0, ix1, ix2) });
        }
      }
    }
  }
 
  template<size_t IndexStride, typename Fetch>
  void intersectSubMesh(std::vector<RayIntersectionHit>& hits,
                        const glm::mat4& localPickMatrix,
                        const FrustumPlanes* vertexFlags,
                        const SubMeshStreamRef& subMeshes,
                        const IxStreamRef& indices,
                        const PosStreamRef& positions,
                        const Mesh* mesh,
                        const float scale = 1.f)
  {
    for (size_t i = 0; i < subMeshes.count; i++) {
      const SubMesh& subMesh = subMeshes.ptr[i];
 
      size_t a, b;
      if (subMesh.numIndexes == uint32_t(-1)) {
        a = 0;
        b = mesh->getCount();
      }
      else {
        a = subMesh.startIndex;
        b = a + subMesh.numIndexes;
      }
 
      if constexpr (IndexStride == 0) {
        if (positions.count < a || positions.count < b) {
          LOG_ERROR_ONCE(logger, "Draw range is out of bounds");
          continue;
        }
      }
      else {
        if (indices.count < a || indices.count < b) {
          LOG_ERROR_ONCE(logger, "Draw range is out of bounds");
          continue;
        }
      }
 
      switch (subMesh.primitiveType) {
      case Cogs::PrimitiveType::PointList:
        intersectPoints<IndexStride, Fetch>(hits, localPickMatrix, vertexFlags, positions, indices, a, b, scale);
        break;
 
      case Cogs::PrimitiveType::LineList:
        intersectLines<IndexStride, Fetch>(hits, localPickMatrix, vertexFlags, positions, indices, a, b, 2, scale);
        break;
 
      case Cogs::PrimitiveType::LineStrip:
        intersectLines<IndexStride, Fetch>(hits, localPickMatrix, vertexFlags, positions, indices, a, b, 1, scale);
        break;
 
      case Cogs::PrimitiveType::TriangleList:
        intersectTriangles<IndexStride, Fetch>(hits, localPickMatrix, vertexFlags, positions, indices, a, b, 3, scale);
        break;
 
      case Cogs::PrimitiveType::TriangleStrip:
        intersectTriangles<IndexStride, Fetch>(hits, localPickMatrix, vertexFlags, positions, indices, a, b, 1, scale);
        break;
 
      default:
        break;
      }
    }
  }
 
 
  struct Fetch_R10G10B10_UINT { static glm::vec3 fetch(const PosStreamRef& pos, size_t ix) { return  glm::unpackU3x10_1x2(*reinterpret_cast<const uint32_t*>(pos.ptr + pos.stride * ix)); } };
  struct Fetch_R16G16B16_UINT { static glm::vec3 fetch(const PosStreamRef& pos, size_t ix) { return *reinterpret_cast<const glm::u16vec3*>(pos.ptr + pos.stride * ix); } };
  struct Fetch_R16G16B16_FLOAT { static glm::vec3 fetch(const PosStreamRef& pos, size_t ix) { return  glm::unpackHalf4x16(*reinterpret_cast<const uint64_t*>(pos.ptr + pos.stride * ix)); } };
  struct Fetch_R32G32B32_FLOAT { static glm::vec3 fetch(const PosStreamRef& pos, size_t ix) { return *reinterpret_cast<const glm::vec3*>(pos.ptr + pos.stride * ix); } };
 
 
}
 
 
bool Cogs::Core::intersectMesh(std::vector<RayIntersectionHit>& hits,
                               std::vector<FrustumPlanes>& scratch,
                               const glm::mat4& pickMatrix,
                               const Mesh& mesh,
                               uint32_t startIndex,
                               uint32_t vertexCount,
                               uint32_t subMeshIndex)
{
 
  // Transform all coordinates into pick frustum, and do the frustum-
  // bound half-plane tests and store results in a bitmask. Combining
  // these bitmasks allows us to do frustum culling of the convex hull
  // of any subset of the points.
  //
  // Note: This is a likely hotspot (in particular for large meshes), so if
  // there are issues with performance, make sure that the following loop
  // is appropriately optimized and parallelized.
 
 
  // Get position stream
  PosStreamRef positions;
  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 VertexFormat* vertexFormat = Cogs::VertexFormats::getVertexFormat(stream.format);
      for (const VertexElement& element : vertexFormat->elements) {
        if (element.semantic == ElementSemantic::Position && element.semanticIndex == 0) {
          positions.ptr = static_cast<const uint8_t*>(stream.buffer->data()) + stream.offset + element.offset;
          positions.format = element.format;
          positions.stride = stream.stride;
          positions.count = stream.numElements;
          goto found_position;
          break;
        }
      }
    }
  }
  LOG_ERROR_ONCE(logger, "Mesh has no position data");
  return false;
 
found_position:
  assert(positions.ptr);
 
  // Get index stream
  IxStreamRef indices;
  if (mesh.hasStream(VertexDataType::Indexes)) {
    const DataStream& stream = mesh.streams[mesh.streamIndexes[VertexDataType::Indexes]];
    indices.ptr = static_cast<const uint8_t*>(stream.buffer->data());
    indices.stride = stream.stride;
    indices.count = stream.numElements;
  }
 
  // Submesh stream
  SubMesh noSubMesh;
  SubMeshStreamRef submeshes;
  if (mesh.hasStream(VertexDataType::SubMeshes)) {
    const DataStream& stream = mesh.streams[mesh.streamIndexes[VertexDataType::SubMeshes]];
    if (stream.numElements) {
      submeshes.ptr = static_cast<const SubMesh*>(stream.buffer->data());
      submeshes.count = stream.numElements;
      goto found_submeshes;
    }
  }
  noSubMesh.startIndex = startIndex;
  noSubMesh.numIndexes = vertexCount;
  noSubMesh.primitiveType = mesh.primitiveType;
  submeshes.ptr = &noSubMesh;
  submeshes.count = 1;
 
found_submeshes:
  assert(submeshes.ptr && submeshes.count);
 
  if (subMeshIndex != ~0u) {
    if (submeshes.count <= subMeshIndex) {
      LOG_ERROR_ONCE(logger, "Illegal submesh index %u", subMeshIndex);
      return false;
    }
    submeshes.ptr += subMeshIndex;
    submeshes.count = 1;
  }
 
  constexpr float scale10u = 1.f / 0x3FFu;
  constexpr float scale16u = 1.f / 0xFFFFu;
  scratch.resize(positions.count);
  switch (positions.format) {
 
  case DataFormat::R10G10B10A2_UNORM: {
    glm::mat4 M = pickMatrix * glm::mat4(scale10u, 0.f, 0.f, 0.f,
                                         0.f, scale10u, 0.f, 0.f,
                                         0.f, 0.f, scale10u, 0.f,
                                         0.f, 0.f, 0.f, 1.f);
    classify<Fetch_R10G10B10_UINT>(scratch.data(), M, positions);
    switch (indices.stride) {
    case 0: intersectSubMesh<0, Fetch_R10G10B10_UINT>(hits, M, scratch.data(), submeshes, indices, positions, &mesh, scale10u); break;
    case 2: intersectSubMesh<2, Fetch_R10G10B10_UINT>(hits, M, scratch.data(), submeshes, indices, positions, &mesh, scale10u); break;
    case 4: intersectSubMesh<4, Fetch_R10G10B10_UINT>(hits, M, scratch.data(), submeshes, indices, positions, &mesh, scale10u); break;
    default: assert(false); break;
    }
    break;
  }
 
  case DataFormat::R16G16B16_UNORM: {
    glm::mat4 M = pickMatrix * glm::mat4(scale16u, 0.f, 0.f, 0.f,
                                         0.f, scale16u, 0.f, 0.f,
                                         0.f, 0.f, scale16u, 0.f,
                                         0.f, 0.f, 0.f, 1.f);
    classify<Fetch_R16G16B16_UINT>(scratch.data(), M, positions);
    switch (indices.stride) {
    case 0: intersectSubMesh<0, Fetch_R16G16B16_UINT>(hits, M, scratch.data(), submeshes, indices, positions, &mesh, scale16u); break;
    case 2: intersectSubMesh<2, Fetch_R16G16B16_UINT>(hits, M, scratch.data(), submeshes, indices, positions, &mesh, scale16u); break;
    case 4: intersectSubMesh<4, Fetch_R16G16B16_UINT>(hits, M, scratch.data(), submeshes, indices, positions, &mesh, scale16u); break;
    default: assert(false); break;
    }
    break;
  }
 
  case DataFormat::R16G16B16_FLOAT:
    classify<Fetch_R16G16B16_FLOAT>(scratch.data(), pickMatrix, positions);
    switch (indices.stride) {
    case 0: intersectSubMesh<0, Fetch_R16G16B16_FLOAT>(hits, pickMatrix, scratch.data(), submeshes, indices, positions, &mesh); break;
    case 2: intersectSubMesh<2, Fetch_R16G16B16_FLOAT>(hits, pickMatrix, scratch.data(), submeshes, indices, positions, &mesh); break;
    case 4: intersectSubMesh<4, Fetch_R16G16B16_FLOAT>(hits, pickMatrix, scratch.data(), submeshes, indices, positions, &mesh); break;
    default: assert(false); break;
    }
    break;
 
  case DataFormat::R32G32B32_FLOAT:
    classify<Fetch_R32G32B32_FLOAT>(scratch.data(), pickMatrix, positions);
    switch (indices.stride) {
    case 0: intersectSubMesh<0, Fetch_R32G32B32_FLOAT>(hits, pickMatrix, scratch.data(), submeshes, indices, positions, &mesh); break;
    case 2: intersectSubMesh<2, Fetch_R32G32B32_FLOAT>(hits, pickMatrix, scratch.data(), submeshes, indices, positions, &mesh); break;
    case 4: intersectSubMesh<4, Fetch_R32G32B32_FLOAT>(hits, pickMatrix, scratch.data(), submeshes, indices, positions, &mesh); break;
    default: assert(false); break;
    }
    break;
 
  default: {
    const FormatInfo* info = getFormatInfo(positions.format);
    LOG_ERROR_ONCE(logger, "Unsupported vertex format %s ", info ? info->vName : "null");
    return false;
  }
  }
 
  return true;
}
 
 
bool Cogs::Core::frustumClassifyVertex(FrustumPlanes* dstPtr, const glm::mat4& matrix, const glm::vec3* positions, const size_t count)
{
  classify<Fetch_R32G32B32_FLOAT>(dstPtr, matrix, PosStreamRef{ .ptr = (const uint8_t*)positions, .stride = sizeof(glm::vec3), .count = uint32_t(count) });
  return true;
}