bezier.h

#ifndef OE_SCENE_LOADER_BEZIER_H
#define OE_SCENE_LOADER_BEZIER_H
 
#include "../mesh.h"
#include "../../util/bezier_curve.h"
#include <span>
#include <stdexcept>
 
namespace oe::scene::loader
{
    enum class BezierPatchType
    {
        Biquadratic = 3, //< Each patch contains 9 (3x3) control points
        Bicubic = 4, //< Each patch contains 16 (4x4) control points
    };
 
    template <typename VertexType = Vertex>
    class Bezier : public Mesh<VertexType>
    {
        public:
            using BezierMeshType = oe::scene::Mesh<VertexType>;
 
            Bezier(const BezierPatchType type):
                _patch_type(type),
                _patch_size(type == BezierPatchType::Biquadratic ? 9 : 16)
            {}
 
            void addControlPoint(const Vertex& point);
 
            void setControlPoints(const std::vector<Vertex>& points)
            {
                if (points.size() < _patch_size)
                {
                    throw std::runtime_error("Missing control points!");
                }
 
                _control_points = points;
            }
 
            const std::vector<Vertex>& getControlPoints() const
            {
                return _control_points;
            }
 
            struct BuildMeshInfo
            {
                const uint16_t lod; 
 
                const bool merge_patches = true; 
                const bool generate_texcoords = true; 
                const bool generate_normals = true; 
            };
 
            void buildMesh(const BuildMeshInfo& params, BezierMeshType& result)
            {
                int32_t divisions = params.lod > 1
                    ? params.lod
                    : 1
                ;
 
                auto& vertices = result.vertices;
                auto& indices = result.indices;
                auto& primitives = result.primitives;
 
                const int32_t total_patches = _control_points.size() / _patch_size;
 
                // Generate all points vertices
                for (int32_t id_patch = 0; id_patch < total_patches; ++id_patch)
                {
                    const auto first = _control_points.cbegin() + _patch_size * id_patch;
                    const auto last = _control_points.cbegin() + _patch_size * (id_patch+1);
                    const std::vector<Vertex> patches_points(first, last);
 
                    std::vector<glm::vec3> patches_positions;
 
                    if (params.generate_normals)
                    {
                        patches_positions.reserve(_patch_size);
 
                        for (auto& it : patches_points)
                        {
                            patches_positions.push_back(it.position);
                        }
                    }
 
                    for (int32_t i = 0; i <= divisions; ++i)
                    {
                        float u = i / (float)divisions;
 
                        for (int32_t j = 0; j <= divisions; ++j)
                        {
                            float v = j / (float)divisions;
 
                            Vertex vertex = calculatePatch(patches_points, u, v);
 
                            if constexpr (IsVertexWithTangents<VertexType>)
                            {
                                if (params.generate_normals)
                                {
                                    glm::vec3 tangent = calculateDerivateU<glm::vec3>(patches_positions, u, v);
                                    glm::vec3 bitangent = calculateDerivateV<glm::vec3>(patches_positions, u, v);
 
                                    if (length(tangent) > 0 && length(bitangent) > 0) [[likely]]
                                    {
                                        vertex.normal = glm::normalize(glm::cross(tangent, bitangent));
                                        vertex.tangent = tangent;
                                        vertex.bitangent = bitangent;
                                    }
                                    else
                                    {
                                        // Temp fix
                                        // Sometimes, the same control point is used multiple times in the same patch
                                        // So it is not possible to compute tangent space. As a failsafe measure we use normalized position instead
                                        // (gives wrong normal but its better than nothing)
                                        //
                                        // TODO better
                                        vertex.normal = glm::normalize(vertex.position);
 
                                        if (length(tangent) == 0 && length(bitangent) != 0)
                                        {
                                            vertex.tangent = glm::normalize(glm::cross(vertex.normal, bitangent));
                                            vertex.bitangent = bitangent;
                                        }
                                        else if (length(bitangent) == 0 && length(tangent) != 0)
                                        {
                                            vertex.tangent = tangent;
                                            vertex.bitangent = glm::normalize(glm::cross(vertex.normal, tangent));
                                        }
                                        else
                                        {
                                            assert(false && "Tangent space failed !");
                                        }
                                    }
                                }
                            }
 
                            if constexpr (IsVertexWithTexcoords<VertexType>)
                            {
                                if (params.generate_texcoords)
                                {
                                    vertex.tex_coords_0 = glm::vec2(u, v);
                                }
                            }
 
                            vertices.push_back(vertex);
                        }
                    }
                }
 
                /*
                    Fill triangles indices:
 
                    Example surface:
                    6 3 0
                    7 4 1
                    8 5 2
 
                    If we isolate face points like this...
                    a b
                    x y
 
                    ...We should make 2 triangles like this
                    {x, b, a}
                    {y, b, x}
                */
 
                // Helper values
                const size_t vertices_per_edge = (divisions + 1);
                const size_t vertices_per_edge_pow_2 = vertices_per_edge * vertices_per_edge;
 
                const size_t indices_per_patch = divisions * divisions * 6;
 
                indices.reserve(total_patches * indices_per_patch);
 
                for (int32_t k = 0; k < total_patches; ++k)
                {
                    for (int32_t j = 0; j < divisions; ++j)
                    {
                        for (int32_t i = 0; i < divisions; ++i)
                        {
                            size_t a = k * vertices_per_edge_pow_2 + j * vertices_per_edge + i;
                            size_t b = a + vertices_per_edge;
                            size_t x = a + 1;
                            size_t y = b + 1;
 
                            indices.push_back(x);
                            indices.push_back(b);
                            indices.push_back(a);
 
                            indices.push_back(y);
                            indices.push_back(b);
                            indices.push_back(x);
                        }
                    }
                }
 
                if (params.merge_patches)
                {
                    primitives = {{0, indices.size()}};
                }
                else
                {
                    primitives.reserve(total_patches);
 
                    for (int32_t id_patch = 0; id_patch < total_patches; ++id_patch)
                    {
                        primitives.push_back({id_patch * indices_per_patch, indices_per_patch});
                    }
                }
            }
 
            template <util::CurveValueConcept T>
            T calculateDerivateU(std::span<const T> control_points, const float u, const float v)
            {
                using util::Bezier;
 
                if (_patch_type == BezierPatchType::Biquadratic)
                {
                    assert(control_points.size() == 9);
 
                    std::vector<T> v_curve;
                    v_curve.reserve(3);
 
                    for (int32_t i = 0; i < 3; ++i)
                    {
                        auto points = {
                            control_points[i],
                            control_points[3 + i],
                            control_points[6 + i],
                        };
 
                        v_curve.push_back(Bezier::evaluateCurve<util::BezierCurveType::Quadratic, T>(points, v));
                    }
 
                    return Bezier::evaluateDerivativeCurve<util::BezierCurveType::Quadratic, T>(v_curve, u);
                }
                else //if (_patch_type == BezierPatchType::Bicubic)
                {
                    assert(control_points.size() == 16);
 
                    std::vector<T> v_curve;
                    v_curve.reserve(4);
 
                    for (int32_t i = 0; i < 4; ++i)
                    {
                        auto points = {
                            control_points[i],
                            control_points[4 + i],
                            control_points[8 + i],
                            control_points[12 + i]
                        };
 
                        v_curve.push_back(Bezier::evaluateCurve<util::BezierCurveType::Cubic, T>(points, v));
                    }
 
                    return Bezier::evaluateDerivativeCurve<util::BezierCurveType::Cubic, T>(v_curve, u);
                }
            }
 
            template <util::CurveValueConcept T>
            T calculateDerivateV(std::span<const T> control_points, const float u, const float v)
            {
                using util::Bezier;
 
                if (_patch_type == BezierPatchType::Biquadratic)
                {
                    assert(control_points.size() == 9);
 
                    std::vector<T> u_curve;
                    u_curve.reserve(3);
 
                    for (int32_t i = 0; i < 3; ++i)
                    {
                        u_curve.push_back(Bezier::evaluateCurve<util::BezierCurveType::Quadratic, T>({control_points.data() + 3 * i, 3u}, u));
                    }
 
                    return Bezier::evaluateDerivativeCurve<util::BezierCurveType::Quadratic, T>(u_curve, v);
                }
                else //if (_patch_type == BezierPatchType::Bicubic)
                {
                    assert(control_points.size() == 16);
 
                    std::vector<T> u_curve;
                    u_curve.reserve(4);
 
                    for (int32_t i = 0; i < 4; ++i)
                    {
                        u_curve.push_back(Bezier::evaluateCurve<util::BezierCurveType::Cubic, T>({control_points.data() + 4 * i, 4u}, u));
                    }
 
                    return Bezier::evaluateDerivativeCurve<util::BezierCurveType::Cubic, T>(u_curve, v);
                }
            }
 
            template <typename T>
            T calculatePatch(const std::vector<T>& control_points, const float u, const float v)
            {
                using util::Bezier;
 
                int32_t patch_edge_size = (int32_t)_patch_type;
 
                std::vector<T> curve;
                curve.reserve(patch_edge_size);
 
                for (int32_t i = 0; i < patch_edge_size; ++i)
                {
                    const auto first = control_points.cbegin() + patch_edge_size*i;
                    const auto last = control_points.cbegin() + patch_edge_size*(i+1);
                    const std::vector<T> patches_points(first, last);
 
                    if (_patch_type == BezierPatchType::Biquadratic)
                    {
                        curve.push_back(Bezier::evaluateCurve<util::BezierCurveType::Quadratic, T>(patches_points, u));
                    }
                    else
                    {
                        curve.push_back(Bezier::evaluateCurve<util::BezierCurveType::Cubic, T>(patches_points, u));
                    }
                }
 
                if (_patch_type == BezierPatchType::Biquadratic)
                {
                    return Bezier::evaluateCurve<util::BezierCurveType::Quadratic, T>(curve, v);
                }
                else
                {
                    return Bezier::evaluateCurve<util::BezierCurveType::Cubic, T>(curve, v);
                }
            }
 
        private:
            BezierPatchType _patch_type;
            uint8_t _patch_size;
 
            std::vector<Vertex> _control_points;
    };
}
 
#endif