meshutils.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "mesh.h"
#include "box.h"
#include "triangleiterator.h"
#include "renderglobals.h"
 
// External Includes
#include <box.h>
 
namespace nap
{
    namespace utility
    {
        // Binds all the points to a set of triangular faces
        using MeshConnectivityMap = std::vector<std::vector<Triangle>>;
 
        bool NAPAPI isTriangleMesh(const nap::MeshInstance& meshInstance);
 
        int NAPAPI getTriangleCount(const MeshInstance& meshInstance);
 
        glm::vec3 NAPAPI computeTriangleNormal(const TriangleData<glm::vec3>& vertices);
 
        void NAPAPI setTriangleIndices(nap::MeshShape& mesh, EDrawMode drawMode, int number, const std::array<int, 3>& indices);
 
        template<typename T>
        void computeBoundingBox(const MeshInstance& mesh, math::Box& outBox);
 
        template<typename T>
        math::Box computeBoundingBox(const MeshInstance& mesh);
         
        template<typename T>
        void computeBoundingBox(const nap::MeshInstance& mesh, const nap::MeshShape& shape, math::Box& outBox);
 
        template<typename T>
        math::Box computeBoundingBox(const nap::MeshInstance& mesh, const nap::MeshShape& shape);
 
        float NAPAPI computeBoundingSphere(const math::Box& box);
 
        void NAPAPI computeNormals(const nap::MeshInstance& mesh, const nap::VertexAttribute<glm::vec3>& vertices, nap::VertexAttribute<glm::vec3>& outNormals);
 
        void NAPAPI reverseWindingOrder(nap::MeshInstance& mesh);
 
        void NAPAPI generateIndices(nap::MeshShape& shape, int vertexCount, bool loop = false, int offset = 0);
 
        void NAPAPI computeConnectivity(const nap::MeshInstance& mesh, MeshConnectivityMap& outConnectivityMap);
 
        float NAPAPI computeTriangleArea(const TriangleData<glm::vec3>& vertices);
 
        float NAPAPI computeArea(nap::MeshInstance& mesh, const nap::VertexAttribute<glm::vec3>& vertices, std::vector<float>& outList);
 
        bool NAPAPI intersect(const glm::vec3& rayOrigin, const glm::vec3& rayDirection, const TriangleData<glm::vec3>& vertices, glm::vec3& outCoordinates);
 
        glm::vec3 NAPAPI computeBarycentric(const glm::vec3& point, const TriangleData<glm::vec3>& triangle);
 
        float NAPAPI computeCameraDistance(const glm::vec2& planeDimensions, float cameraFOV);
 
        float NAPAPI computeCameraDistance(float radius, float cameraFOV);
 
        template<typename T>
        T interpolateVertexAttr(const TriangleData<T>& vertexValues, const glm::vec3& barycentricCoordinates);
 
 
        // Template Definitions
 
        template<typename T>
        T interpolateVertexAttr(const TriangleData<T>& vertexValues, const glm::vec3& coords)
        {
            return (vertexValues.first() * (1.0f - coords.x - coords.y)) + (vertexValues.second() * coords.x) + (vertexValues.third() * coords.y);
        }
 
        template<typename T>
        void computeBoundingBox(const MeshInstance& mesh, math::Box& outBox)
        {
            glm::vec3 min(math::max<float>());
            glm::vec3 max(math::min<float>());
 
            const nap::VertexAttribute<T>& positions = mesh.getAttribute<T>(vertexid::position);
            for (const auto& point : positions.getData())
            {
                if (point.x < min.x) { min.x = point.x; }
                if (point.x > max.x) { max.x = point.x; }
                if (point.y < min.y) { min.y = point.y; }
                if (point.y > max.y) { max.y = point.y; }
                if (point.z < min.z) { min.z = point.z; }
                if (point.z > max.z) { max.z = point.z; }
            }
            outBox.mMinCoordinates = min;
            outBox.mMaxCoordinates = max;
        }
 
        template<typename T>
        nap::math::Box computeBoundingBox(const MeshInstance& mesh)
        {
            math::Box mesh_bounds;
            computeBoundingBox<T>(mesh, mesh_bounds);
            return mesh_bounds;
        }
 
        template<typename T>
        void computeBoundingBox(const nap::MeshInstance& mesh, const nap::MeshShape& shape, math::Box& outBox)
        {
            glm::vec3 min(math::max<float>());
            glm::vec3 max(math::min<float>());
 
            const nap::VertexAttribute<T>& positions = mesh.getAttribute<T>(vertexid::position);
            for (unsigned int i : shape.getIndices())
            {
                const auto& point = positions[i];
                if (point.x < min.x) { min.x = point.x; }
                if (point.x > max.x) { max.x = point.x; }
                if (point.y < min.y) { min.y = point.y; }
                if (point.y > max.y) { max.y = point.y; }
                if (point.z < min.z) { min.z = point.z; }
                if (point.z > max.z) { max.z = point.z; }
            }
            outBox.mMinCoordinates = min;
            outBox.mMaxCoordinates = max;
        }
 
        template<typename T>
        math::Box computeBoundingBox(const nap::MeshInstance& mesh, const nap::MeshShape& shape)
        {
            math::Box box;
            computeBoundingBox<T>(mesh, shape);
            return box;
        }
    }
}