GeometryProcessing.h

#pragma once
#include <atomic>
#include <vector>
#include <glm/glm.hpp>
#include "Base.h"
 
namespace Cogs::Core
{
  class Context;
}
 
namespace Cogs::Core::GeometryProcessing
{
  void COGSCORE_DLL_API uniqueVertexSubset(Context* context,
                                           std::vector<uint32_t>& unique,
                                           std::vector<uint32_t>& map,
                                           const float * P,
                                           const size_t P_stride,
                                           const float* N,
                                           const size_t N_stride,
                                           const float * T,
                                           const size_t T_stride,
                                           const uint32_t Vn,
                                           const float epsilon = std::numeric_limits<float>::epsilon());
 
 
  void COGSCORE_DLL_API normalsFromIndexedTriangles(Context* context,
                                                    std::vector<glm::vec3>& N,
                                                    std::vector<uint32_t>& remap,
                                                    std::vector<uint32_t>& newIndices,
                                                    const float* P,
                                                    size_t P_stride, // byte-stride
                                                    const uint32_t Nv,
                                                    const uint32_t* indices,
                                                    const uint32_t Ni,
                                                    const float featureAngle = 0.7f,
                                                    const float protrusionAngle = 0.7f,
                                                    const bool flip = false);
 
 
  void COGSCORE_DLL_API normalsFromIndexedTriangles(Context* context,
                                                    float* normals,
                                                    uint32_t normalStride,
                                                    const float* vertices,
                                                    uint32_t vertexStride,
                                                    const uint32_t numVertices,
                                                    const uint32_t* indices,
                                                    const uint32_t numIndices,
                                                    const uint32_t taskSize = 10000,
                                                    std::atomic<uint64_t>* elapsed_us = nullptr);
 
}