BoundingBox.cpp

#include "Services/TaskManager.h"
#include "Services/Features.h"
#include "Platform/Instrumentation.h"
#include "Context.h"
 
#include "BoundingBox.h"
 
#include "Foundation/Memory/MemoryBuffer.h"
 
using namespace Cogs::Core;
 
void Cogs::Core::EchoSounder::includeInBBox(Context* context,
                                            Geometry::BoundingBox& bbox,
                                            const float* vertices,
                                            size_t vertexStride,
                                            const size_t numVertices,
                                            const size_t taskSize)
{
  auto & tm = context->taskManager;
  auto N = (numVertices + taskSize - 1) / taskSize;
 
#ifndef EMSCRIPTEN
  if (context->features->supported(CPUFeature::SSE2)) {
    Memory::TypedBuffer<float> minmaxes(8*N);
 
    auto group = tm->createGroup();
    for (size_t i = 0; i < N; i++) {
      auto * minmax = minmaxes.data() + 8 * i;
      auto ia = i*taskSize;
      auto ib = std::min(numVertices, ia + taskSize);
      tm->enqueueChild(group, [vertices, vertexStride, minmax, ia, ib]
      {
        CpuInstrumentationScope(SCOPE_GEOMETRY, "BBoxFindSSE2");
        __m128 min = _mm_set1_ps(std::numeric_limits<float>::max());
        __m128 max = _mm_sub_ps(_mm_setzero_ps(), min);
        for (size_t i = ia; i < ib; i++) {
          __m128 p = _mm_loadu_ps(vertices + i*vertexStride);
          min = _mm_min_ps(min, p);
          max = _mm_max_ps(max, p);
        }
        _mm_storeu_ps(minmax + 0, min);
        _mm_storeu_ps(minmax + 4, max);
      });
    }
    tm->wait(group);
    tm->destroy(group);
 
    {
      CpuInstrumentationScope(SCOPE_GEOMETRY, "BBoxMergeSSE2");
 
      __m128 min = _mm_set1_ps(std::numeric_limits<float>::max());
      __m128 max = _mm_sub_ps(_mm_setzero_ps(), min);
      for (size_t i = 0; i < N; i++) {
        min = _mm_min_ps(min, _mm_loadu_ps(minmaxes.data() + 8 * i + 0));
        max = _mm_max_ps(max, _mm_loadu_ps(minmaxes.data() + 8 * i + 4));
      }
      for (uint32_t k = 0; k < 3; k++) {
        bbox.min[k] = std::min(bbox.min[k], min.m128_f32[k]);
        bbox.max[k] = std::max(bbox.max[k], max.m128_f32[k]);
      }
    }
 
  }
  else {
#else
 
    {
#endif
    std::vector<Cogs::Geometry::BoundingBox> bboxes(N);
 
    auto group = tm->createGroup();
    for (int i = 0; i < N; i++) {
      auto * sub_bbox = bboxes.data() + i;
      auto ia = i*taskSize;
      auto ib = std::min(numVertices, ia + taskSize);
      tm->enqueueChild(group, [vertices, vertexStride, sub_bbox, ia, ib]
      {
        CpuInstrumentationScope(SCOPE_GEOMETRY, "BBoxFind");
        (*sub_bbox) = Cogs::Geometry::makeEmptyBoundingBox<Cogs::Geometry::BoundingBox>();
        for (size_t i = ia; i < ib; i++) {
          (*sub_bbox) += *reinterpret_cast<const glm::vec3*>(vertices + i*vertexStride);
        }
      });
    }
    tm->wait(group);
    tm->destroy(group);
 
    {
      CpuInstrumentationScope(SCOPE_GEOMETRY, "BBoxMerge");
      for (int i = 0; i < N; i++) {
        bbox += bboxes[i];
      }
    }
  }
}