SurfaceMesh.h

/*
 * Copyright 2022 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
#pragma once
 
#include <lagrange/AttributeFwd.h>
#include <lagrange/utils/SharedSpan.h>
#include <lagrange/utils/function_ref.h>
#include <lagrange/utils/span.h>
#include <lagrange/utils/value_ptr.h>
 
#include <initializer_list>
#include <string_view>
#include <type_traits>
 
namespace lagrange {

template <typename Scalar_, typename Index_>
class SurfaceMesh;
namespace internal {
template <typename T>
class weak_ptr;
struct SurfaceMeshInfo;
template <typename Scalar, typename Index>
SurfaceMeshInfo from_surface_mesh(const SurfaceMesh<Scalar, Index>&);
template <typename Scalar, typename Index>
SurfaceMesh<Scalar, Index> to_surface_mesh(const SurfaceMeshInfo&);
} // namespace internal


template <typename Scalar_, typename Index_>
class SurfaceMesh
{
public:
    using Scalar = Scalar_;

    using Index = Index_;

    using SignedIndex = std::make_signed_t<Index>;
 
    // Static assertions to prevent users from instantiating unsupported types.
    static_assert(
        std::is_same_v<Scalar, float> || std::is_same_v<Scalar, double>,
        "SurfaceMesh's Scalar template parameter can only be float or double.");
    static_assert(
        std::is_same_v<Index, uint32_t> || std::is_same_v<Index, uint64_t>,
        "SurfaceMesh's Index template parameter can only be uint32_t or uint64_t.");
 
public:
    using SetVertexCoordinatesFunction = function_ref<void(Index v, span<Scalar> p)>;

    using SetSingleFacetIndicesFunction = function_ref<void(span<Index> t)>;

    using SetMultiFacetsIndicesFunction = function_ref<void(Index f, span<Index> t)>;

    using GetFacetsSizeFunction = function_ref<Index(Index f)>;

    using GetEdgeVertices = function_ref<std::array<Index, 2>(Index e)>;
 
public:

    explicit SurfaceMesh(Index dimension = 3);

    ~SurfaceMesh();

    SurfaceMesh(SurfaceMesh&& other) noexcept;

    SurfaceMesh& operator=(SurfaceMesh&& other) noexcept;

    SurfaceMesh(const SurfaceMesh& other);

    SurfaceMesh& operator=(const SurfaceMesh& other);

    template <typename OtherScalar, typename OtherIndex>
    static SurfaceMesh stripped_copy(const SurfaceMesh<OtherScalar, OtherIndex>& other);

    template <typename OtherScalar, typename OtherIndex>
    static SurfaceMesh stripped_move(SurfaceMesh<OtherScalar, OtherIndex>&& other);

    void add_vertex(span<const Scalar> p);

    void add_vertex(std::initializer_list<const Scalar> p);

    void add_vertices(Index num_vertices, span<const Scalar> coordinates = {});

    void add_vertices(Index num_vertices, std::initializer_list<const Scalar> coordinates);

    void add_vertices(Index num_vertices, SetVertexCoordinatesFunction set_vertex_coordinates);

    void add_triangle(Index v0, Index v1, Index v2);

    void add_triangles(Index num_facets, span<const Index> facet_indices = {});

    void add_triangles(Index num_facets, std::initializer_list<const Index> facet_indices);

    void add_triangles(Index num_facets, SetMultiFacetsIndicesFunction set_facets_indices);

    void add_quad(Index v0, Index v1, Index v2, Index v3);

    void add_quads(Index num_facets, span<const Index> facet_indices = {});

    void add_quads(Index num_facets, std::initializer_list<const Index> facet_indices);

    void add_quads(Index num_facets, SetMultiFacetsIndicesFunction set_facets_indices);

    void add_polygon(Index facet_size);

    void add_polygon(span<const Index> facet_indices);

    void add_polygon(std::initializer_list<const Index> facet_indices);

    void add_polygon(Index facet_size, SetSingleFacetIndicesFunction set_facet_indices);

    void add_polygons(Index num_facets, Index facet_size, span<const Index> facet_indices = {});

    void add_polygons(
        Index num_facets,
        Index facet_size,
        std::initializer_list<const Index> facet_indices);

    void add_polygons(
        Index num_facets,
        Index facet_size,
        SetMultiFacetsIndicesFunction set_facets_indices);

    void add_hybrid(span<const Index> facet_sizes, span<const Index> facet_indices = {});

    void add_hybrid(
        std::initializer_list<const Index> facet_sizes,
        std::initializer_list<const Index> facet_indices);

    void add_hybrid(
        Index num_facets,
        GetFacetsSizeFunction facet_sizes,
        SetMultiFacetsIndicesFunction set_facets_indices);

    void remove_vertices(span<const Index> vertices_to_remove);

    void remove_vertices(std::initializer_list<const Index> vertices_to_remove);

    void remove_vertices(function_ref<bool(Index)> should_remove_func);

    void remove_facets(span<const Index> facets_to_remove);

    void remove_facets(std::initializer_list<const Index> facets_to_remove);

    void remove_facets(function_ref<bool(Index)> should_remove_func);

    void flip_facets(
        span<const Index> facets_to_flip,
        AttributeReorientPolicy reorient_policy = AttributeReorientPolicy::None);

    void flip_facets(
        std::initializer_list<const Index> facets_to_flip,
        AttributeReorientPolicy reorient_policy = AttributeReorientPolicy::None);

    void flip_facets(
        function_ref<bool(Index)> should_flip_func,
        AttributeReorientPolicy reorient_policy = AttributeReorientPolicy::None);

    void clear_vertices();

    void clear_facets();

    void shrink_to_fit();

    void compress_if_regular();
 
public:

    [[nodiscard]] bool is_triangle_mesh() const;

    [[nodiscard]] bool is_quad_mesh() const;

    [[nodiscard]] bool is_regular() const;

    [[nodiscard]] bool is_hybrid() const { return !is_regular(); }

    [[nodiscard]] Index get_dimension() const { return m_dimension; }

    [[nodiscard]] Index get_vertex_per_facet() const;

    [[nodiscard]] Index get_num_vertices() const { return m_num_vertices; }

    [[nodiscard]] Index get_num_facets() const { return m_num_facets; }

    [[nodiscard]] Index get_num_corners() const { return m_num_corners; }

    [[nodiscard]] Index get_num_edges() const { return m_num_edges; }

    [[nodiscard]] span<const Scalar> get_position(Index v) const;

    [[nodiscard]] span<Scalar> ref_position(Index v);

    [[nodiscard]] Index get_facet_size(Index f) const
    {
        return get_facet_corner_end(f) - get_facet_corner_begin(f);
    }

    [[nodiscard]] Index get_facet_vertex(Index f, Index lv) const
    {
        return get_corner_vertex(get_facet_corner_begin(f) + lv);
    }

    [[nodiscard]] Index get_facet_corner_begin(Index f) const;

    [[nodiscard]] Index get_facet_corner_end(Index f) const;

    [[nodiscard]] Index get_corner_vertex(Index c) const;

    [[nodiscard]] Index get_corner_facet(Index c) const;

    [[nodiscard]] span<const Index> get_facet_vertices(Index f) const;

    [[nodiscard]] span<Index> ref_facet_vertices(Index f);
 
public:

    [[nodiscard]] AttributeId get_attribute_id(std::string_view name) const;

    [[nodiscard]] std::string_view get_attribute_name(AttributeId id) const;

    template <typename ValueType>
    AttributeId create_attribute(
        std::string_view name,
        AttributeElement element,
        size_t num_channels = 1,
        AttributeUsage usage = AttributeUsage::Vector,
        span<const ValueType> initial_values = {},
        span<const Index> initial_indices = {},
        AttributeCreatePolicy policy = AttributeCreatePolicy::ErrorIfReserved);

    template <typename ValueType>
    AttributeId create_attribute(
        std::string_view name,
        AttributeElement element,
        AttributeUsage usage,
        size_t num_channels = 1,
        span<const ValueType> initial_values = {},
        span<const Index> initial_indices = {},
        AttributeCreatePolicy policy = AttributeCreatePolicy::ErrorIfReserved);

    template <typename OtherScalar, typename OtherIndex>
    AttributeId create_attribute_from(
        std::string_view name,
        const SurfaceMesh<OtherScalar, OtherIndex>& source_mesh,
        std::string_view source_name = {});

    template <typename ValueType>
    AttributeId wrap_as_attribute(
        std::string_view name,
        AttributeElement element,
        AttributeUsage usage,
        size_t num_channels,
        span<ValueType> values_view);

    template <typename ValueType>
    AttributeId wrap_as_attribute(
        std::string_view name,
        AttributeElement element,
        AttributeUsage usage,
        size_t num_channels,
        SharedSpan<ValueType> shared_values);

    template <typename ValueType>
    AttributeId wrap_as_const_attribute(
        std::string_view name,
        AttributeElement element,
        AttributeUsage usage,
        size_t num_channels,
        span<const ValueType> values_view);

    template <typename ValueType>
    AttributeId wrap_as_const_attribute(
        std::string_view name,
        AttributeElement element,
        AttributeUsage usage,
        size_t num_channels,
        SharedSpan<const ValueType> shared_values);

    template <typename ValueType>
    AttributeId wrap_as_indexed_attribute(
        std::string_view name,
        AttributeUsage usage,
        size_t num_values,
        size_t num_channels,
        span<ValueType> values_view,
        span<Index> indices_view);

    template <typename ValueType>
    AttributeId wrap_as_indexed_attribute(
        std::string_view name,
        AttributeUsage usage,
        size_t num_values,
        size_t num_channels,
        SharedSpan<ValueType> shared_values,
        SharedSpan<Index> shared_indices);

    template <typename ValueType>
    AttributeId wrap_as_indexed_attribute(
        std::string_view name,
        AttributeUsage usage,
        size_t num_values,
        size_t num_channels,
        span<ValueType> values_view,
        SharedSpan<Index> shared_indices);

    template <typename ValueType>
    AttributeId wrap_as_indexed_attribute(
        std::string_view name,
        AttributeUsage usage,
        size_t num_values,
        size_t num_channels,
        SharedSpan<ValueType> shared_values,
        span<Index> indices_view);

    template <typename ValueType>
    AttributeId wrap_as_const_indexed_attribute(
        std::string_view name,
        AttributeUsage usage,
        size_t num_values,
        size_t num_channels,
        span<const ValueType> values_view,
        span<const Index> indices_view);

    template <typename ValueType>
    AttributeId wrap_as_const_indexed_attribute(
        std::string_view name,
        AttributeUsage usage,
        size_t num_values,
        size_t num_channels,
        SharedSpan<const ValueType> shared_values,
        SharedSpan<const Index> shared_indices);

    template <typename ValueType>
    AttributeId wrap_as_const_indexed_attribute(
        std::string_view name,
        AttributeUsage usage,
        size_t num_values,
        size_t num_channels,
        span<const ValueType> values_view,
        SharedSpan<const Index> shared_indices);

    template <typename ValueType>
    AttributeId wrap_as_const_indexed_attribute(
        std::string_view name,
        AttributeUsage usage,
        size_t num_values,
        size_t num_channels,
        SharedSpan<const ValueType> shared_values,
        span<const Index> indices_view);

    AttributeId wrap_as_vertices(span<Scalar> vertices_view, Index num_vertices);

    AttributeId wrap_as_vertices(SharedSpan<Scalar> shared_vertices, Index num_vertices);

    AttributeId wrap_as_const_vertices(span<const Scalar> vertices_view, Index num_vertices);

    AttributeId wrap_as_const_vertices(
        SharedSpan<const Scalar> shared_vertices,
        Index num_vertices);

    AttributeId wrap_as_facets(span<Index> facets_view, Index num_facets, Index vertex_per_facet);

    AttributeId
    wrap_as_facets(SharedSpan<Index> shared_facets, Index num_facets, Index vertex_per_facet);

    AttributeId
    wrap_as_const_facets(span<const Index> facets_view, Index num_facets, Index vertex_per_facet);

    AttributeId wrap_as_const_facets(
        SharedSpan<const Index> shared_facets,
        Index num_facets,
        Index vertex_per_facet);

    AttributeId wrap_as_facets(
        span<Index> offsets_view,
        Index num_facets,
        span<Index> facets_view,
        Index num_corners);

    AttributeId wrap_as_facets(
        SharedSpan<Index> shared_offsets,
        Index num_facets,
        SharedSpan<Index> shared_facets,
        Index num_corners);

    AttributeId wrap_as_facets(
        span<Index> offsets_view,
        Index num_facets,
        SharedSpan<Index> shared_facets,
        Index num_corners);

    AttributeId wrap_as_facets(
        SharedSpan<Index> shared_offsets,
        Index num_facets,
        span<Index> facets_view,
        Index num_corners);

    AttributeId wrap_as_const_facets(
        span<const Index> offsets_view,
        Index num_facets,
        span<const Index> facets_view,
        Index num_corners);

    AttributeId wrap_as_const_facets(
        SharedSpan<const Index> shared_offsets,
        Index num_facets,
        SharedSpan<const Index> shared_facets,
        Index num_corners);

    AttributeId wrap_as_const_facets(
        span<const Index> offsets_view,
        Index num_facets,
        SharedSpan<const Index> shared_facets,
        Index num_corners);

    AttributeId wrap_as_const_facets(
        SharedSpan<const Index> shared_offsets,
        Index num_facets,
        span<const Index> facets_view,
        Index num_corners);

    AttributeId duplicate_attribute(std::string_view old_name, std::string_view new_name);

    void rename_attribute(std::string_view old_name, std::string_view new_name);

    void delete_attribute(
        std::string_view name,
        AttributeDeletePolicy policy = AttributeDeletePolicy::ErrorIfReserved);

    void delete_attribute(
        AttributeId id,
        AttributeDeletePolicy policy = AttributeDeletePolicy::ErrorIfReserved);

    template <typename ValueType>
    std::shared_ptr<Attribute<ValueType>> delete_and_export_attribute(
        std::string_view name,
        AttributeDeletePolicy delete_policy = AttributeDeletePolicy::ErrorIfReserved,
        AttributeExportPolicy export_policy = AttributeExportPolicy::CopyIfExternal);

    template <typename ValueType>
    std::shared_ptr<const Attribute<ValueType>> delete_and_export_const_attribute(
        std::string_view name,
        AttributeDeletePolicy delete_policy = AttributeDeletePolicy::ErrorIfReserved,
        AttributeExportPolicy export_policy = AttributeExportPolicy::CopyIfExternal);

    template <typename ValueType>
    auto delete_and_export_indexed_attribute(
        std::string_view name,
        AttributeExportPolicy policy = AttributeExportPolicy::CopyIfExternal)
        -> std::shared_ptr<IndexedAttribute<ValueType, Index>>;

    template <typename ValueType>
    auto delete_and_export_const_indexed_attribute(
        std::string_view name,
        AttributeExportPolicy policy = AttributeExportPolicy::CopyIfExternal)
        -> std::shared_ptr<const IndexedAttribute<ValueType, Index>>;
 
public:

    AttributeId create_metadata(std::string_view name, std::string_view value);

    void set_metadata(AttributeId id, std::string_view value);

    void set_metadata(std::string_view name, std::string_view value);

    std::string_view get_metadata(AttributeId id) const;

    std::string_view get_metadata(std::string_view name) const;
 
public:

    [[nodiscard]] bool has_attribute(std::string_view name) const;

    template <typename ValueType>
    [[nodiscard]] bool is_attribute_type(std::string_view name) const;

    template <typename ValueType>
    [[nodiscard]] bool is_attribute_type(AttributeId id) const;

    [[nodiscard]] bool is_attribute_indexed(std::string_view name) const;

    [[nodiscard]] bool is_attribute_indexed(AttributeId id) const;

    void seq_foreach_attribute_id(function_ref<void(AttributeId)> func) const;

    void seq_foreach_attribute_id(function_ref<void(std::string_view, AttributeId)> func) const;

    void par_foreach_attribute_id(function_ref<void(AttributeId)> func) const;

    void par_foreach_attribute_id(function_ref<void(std::string_view, AttributeId)> func) const;

    [[nodiscard]] const AttributeBase& get_attribute_base(std::string_view name) const;

    [[nodiscard]] const AttributeBase& get_attribute_base(AttributeId id) const;

    template <typename ValueType>
    [[nodiscard]] const Attribute<ValueType>& get_attribute(std::string_view name) const;

    template <typename ValueType>
    [[nodiscard]] const Attribute<ValueType>& get_attribute(AttributeId id) const;

    [[nodiscard]] ::lagrange::internal::weak_ptr<const AttributeBase> _get_attribute_ptr(
        std::string_view name) const;

    [[nodiscard]] ::lagrange::internal::weak_ptr<const AttributeBase> _get_attribute_ptr(
        AttributeId id) const;

    template <typename ValueType>
    [[nodiscard]] auto get_indexed_attribute(std::string_view name) const
        -> const IndexedAttribute<ValueType, Index>&;

    template <typename ValueType>
    [[nodiscard]] auto get_indexed_attribute(AttributeId id) const
        -> const IndexedAttribute<ValueType, Index>&;

    template <typename ValueType>
    [[nodiscard]] Attribute<ValueType>& ref_attribute(std::string_view name);

    template <typename ValueType>
    [[nodiscard]] Attribute<ValueType>& ref_attribute(AttributeId id);

    [[nodiscard]] ::lagrange::internal::weak_ptr<AttributeBase> _ref_attribute_ptr(
        std::string_view name);

    [[nodiscard]] ::lagrange::internal::weak_ptr<AttributeBase> _ref_attribute_ptr(AttributeId id);

    template <typename ValueType>
    [[nodiscard]] auto ref_indexed_attribute(std::string_view name)
        -> IndexedAttribute<ValueType, Index>&;

    template <typename ValueType>
    [[nodiscard]] auto ref_indexed_attribute(AttributeId id) -> IndexedAttribute<ValueType, Index>&;

    [[nodiscard]] const Attribute<Scalar>& get_vertex_to_position() const;

    [[nodiscard]] Attribute<Scalar>& ref_vertex_to_position();

    [[nodiscard]] const Attribute<Index>& get_corner_to_vertex() const;

    [[nodiscard]] Attribute<Index>& ref_corner_to_vertex(
        AttributeRefPolicy policy = AttributeRefPolicy::Default);
 
public:

    static bool attr_name_is_reserved(std::string_view name);

    static constexpr std::string_view attr_name_vertex_to_position()
    {
        return s_reserved_names.vertex_to_position();
    }

    static constexpr std::string_view attr_name_corner_to_vertex()
    {
        return s_reserved_names.corner_to_vertex();
    }

    static constexpr std::string_view attr_name_facet_to_first_corner()
    {
        return s_reserved_names.facet_to_first_corner();
    }

    static constexpr std::string_view attr_name_corner_to_facet()
    {
        return s_reserved_names.corner_to_facet();
    }

    static constexpr std::string_view attr_name_corner_to_edge()
    {
        return s_reserved_names.corner_to_edge();
    }

    static constexpr std::string_view attr_name_edge_to_first_corner()
    {
        return s_reserved_names.edge_to_first_corner();
    }

    static constexpr std::string_view attr_name_next_corner_around_edge()
    {
        return s_reserved_names.next_corner_around_edge();
    }

    static constexpr std::string_view attr_name_vertex_to_first_corner()
    {
        return s_reserved_names.vertex_to_first_corner();
    }

    static constexpr std::string_view attr_name_next_corner_around_vertex()
    {
        return s_reserved_names.next_corner_around_vertex();
    }

    AttributeId attr_id_vertex_to_position() const { return m_reserved_ids.vertex_to_position(); }

    [[deprecated("Use attr_id_vertex_to_position() instead.")]] AttributeId
    attr_id_vertex_to_positions() const
    {
        return m_reserved_ids.vertex_to_position();
    }

    AttributeId attr_id_corner_to_vertex() const { return m_reserved_ids.corner_to_vertex(); }

    AttributeId attr_id_facet_to_first_corner() const
    {
        return m_reserved_ids.facet_to_first_corner();
    }

    AttributeId attr_id_corner_to_facet() const { return m_reserved_ids.corner_to_facet(); }

    AttributeId attr_id_corner_to_edge() const { return m_reserved_ids.corner_to_edge(); }

    AttributeId attr_id_edge_to_first_corner() const
    {
        return m_reserved_ids.edge_to_first_corner();
    }

    AttributeId attr_id_next_corner_around_edge() const
    {
        return m_reserved_ids.next_corner_around_edge();
    }

    AttributeId attr_id_vertex_to_first_corner() const
    {
        return m_reserved_ids.vertex_to_first_corner();
    }

    AttributeId attr_id_next_corner_around_vertex() const
    {
        return m_reserved_ids.next_corner_around_vertex();
    }
 
public:

    void initialize_edges(span<const Index> edges = {});

    void initialize_edges(Index num_user_edges, GetEdgeVertices get_user_edge);

    void clear_edges();

    bool has_edges() const
    {
        return m_reserved_ids.edge_to_first_corner() != invalid_attribute_id();
    }

    Index get_edge(Index f, Index lv) const;

    Index get_corner_edge(Index c) const;

    [[deprecated("Use get_corner_edge() instead.")]] Index get_edge_from_corner(Index c) const;

    std::array<Index, 2> get_edge_vertices(Index e) const;

    Index find_edge_from_vertices(Index v0, Index v1) const;

    Index get_next_corner_around_facet(Index c) const;

    Index get_first_corner_around_edge(Index e) const;

    Index get_next_corner_around_edge(Index c) const;

    Index get_first_corner_around_vertex(Index v) const;

    Index get_next_corner_around_vertex(Index c) const;

    Index count_num_corners_around_edge(Index e) const;

    Index count_num_corners_around_vertex(Index v) const;

    Index get_counterclockwise_corner_around_vertex(Index c) const;

    Index get_clockwise_corner_around_vertex(Index c) const;

    Index get_one_facet_around_edge(Index e) const;

    Index get_one_corner_around_edge(Index e) const;

    Index get_one_corner_around_vertex(Index v) const;

    bool is_boundary_edge(Index e) const;

    void foreach_facet_around_edge(Index e, function_ref<void(Index)> func) const;

    void foreach_facet_around_facet(Index f, function_ref<void(Index)> func) const;

    void foreach_facet_around_vertex(Index v, function_ref<void(Index)> func) const;

    void foreach_corner_around_edge(Index e, function_ref<void(Index)> func) const;

    void foreach_corner_around_vertex(Index v, function_ref<void(Index)> func) const;

    void foreach_edge_around_vertex_with_duplicates(Index v, function_ref<void(Index)> func) const;

 
protected:
    struct BareMeshTag
    {
    };

    explicit SurfaceMesh(BareMeshTag tag);

    template <typename ValueType>
    AttributeId create_attribute_internal(
        std::string_view name,
        AttributeElement element,
        AttributeUsage usage = AttributeUsage::Vector,
        size_t num_channels = 1,
        span<const ValueType> initial_values = {},
        span<const Index> initial_indices = {});

    template <typename ValueType>
    void set_attribute_default_internal(std::string_view name);

    void reindex_vertices_internal(span<const Index> old_to_new);

    std::pair<Index, Index> reindex_facets_internal(span<const Index> old_to_new);

    enum class CornerMappingType {
        RemovingFacets,

        ReversingFacets,
    };

    void reindex_corners_internal(
        function_ref<Index(Index)> old_to_new_corners,
        CornerMappingType mapping_type);

    template <AttributeElement element>
    void resize_elements_internal(Index num_elements);

    void resize_vertices_internal(Index num_vertices);

    void resize_facets_internal(Index num_facets);

    void resize_corners_internal(Index num_corners);

    void resize_edges_internal(Index num_edges);

    span<Index> reserve_indices_internal(Index num_facets, Index facet_size);

    span<Index> reserve_indices_internal(span<const Index> facet_sizes);

    span<Index> reserve_indices_internal(Index num_facets, GetFacetsSizeFunction get_facets_size);

    void compute_corner_to_facet_internal(Index facet_begin, Index facet_end);

    void initialize_edges_internal(
        Index num_user_edges = 0,
        GetEdgeVertices* get_user_edge_ptr = nullptr);

    void update_edges_range_internal(
        Index facet_begin,
        Index facet_end,
        Index num_user_edges = 0,
        GetEdgeVertices* get_user_edge_ptr = nullptr);

    void update_edges_last_internal(
        Index count,
        Index num_user_edges = 0,
        GetEdgeVertices* get_user_edge_ptr = nullptr);

    [[nodiscard]] size_t get_num_elements_internal(AttributeElement element) const;

    template <typename ValueType>
    void wrap_as_attribute_internal(
        Attribute<std::decay_t<ValueType>>& attr,
        size_t num_values,
        span<ValueType> values_view);

    template <typename ValueType>
    void wrap_as_attribute_internal(
        Attribute<std::decay_t<ValueType>>& attr,
        size_t num_values,
        SharedSpan<ValueType> shared_values);

    template <typename OffsetSpan, typename FacetSpan>
    AttributeId wrap_as_facets_internal(
        OffsetSpan offsets,
        Index num_facets,
        FacetSpan facets,
        Index num_corners);

    template <typename ValueSpan, typename IndexSpan = span<Index>>
    AttributeId wrap_as_attribute_internal(
        std::string_view name,
        AttributeElement element,
        AttributeUsage usage,
        size_t num_values,
        size_t num_channels,
        ValueSpan values,
        IndexSpan indices = {});
 
protected:

    template <typename, typename>
    friend class SurfaceMesh;

    template <typename S, typename I>
    friend internal::SurfaceMeshInfo internal::from_surface_mesh(const SurfaceMesh<S, I>&);
    template <typename S, typename I>
    friend SurfaceMesh<S, I> internal::to_surface_mesh(const internal::SurfaceMeshInfo&);

    struct AttributeManager;

 
protected:
    Index m_num_vertices = Index(0);

    Index m_num_facets = Index(0);

    Index m_num_corners = Index(0);

    Index m_num_edges = Index(0);

    Index m_dimension = Index(3);

    Index m_vertex_per_facet = Index(0);

    value_ptr<AttributeManager> m_attributes;

    struct ReservedAttributeIds
    {
        AttributeId items[9];
 
        ReservedAttributeIds() { std::fill_n(items, 9, invalid_attribute_id()); }
        static constexpr int size() { return 9; }
 
        AttributeId& vertex_to_position() { return items[0]; };
        AttributeId& corner_to_vertex() { return items[1]; };
        AttributeId& facet_to_first_corner() { return items[2]; };
        AttributeId& corner_to_facet() { return items[3]; };
        AttributeId& corner_to_edge() { return items[4]; };
        AttributeId& edge_to_first_corner() { return items[5]; };
        AttributeId& next_corner_around_edge() { return items[6]; };
        AttributeId& vertex_to_first_corner() { return items[7]; };
        AttributeId& next_corner_around_vertex() { return items[8]; };
 
        const AttributeId& vertex_to_position() const { return items[0]; };
        const AttributeId& corner_to_vertex() const { return items[1]; };
        const AttributeId& facet_to_first_corner() const { return items[2]; };
        const AttributeId& corner_to_facet() const { return items[3]; };
        const AttributeId& corner_to_edge() const { return items[4]; };
        const AttributeId& edge_to_first_corner() const { return items[5]; };
        const AttributeId& next_corner_around_edge() const { return items[6]; };
        const AttributeId& vertex_to_first_corner() const { return items[7]; };
        const AttributeId& next_corner_around_vertex() const { return items[8]; };
    } m_reserved_ids;
 
protected:
    static constexpr struct
    {
        std::string_view items[9] = {
            "$vertex_to_position",
            "$corner_to_vertex",
            "$facet_to_first_corner",
            "$corner_to_facet",
            "$corner_to_edge",
            "$edge_to_first_corner",
            "$next_corner_around_edge",
            "$vertex_to_first_corner",
            "$next_corner_around_vertex",
        };
        std::string_view vertex_to_position() const { return items[0]; }
        std::string_view corner_to_vertex() const { return items[1]; }
        std::string_view facet_to_first_corner() const { return items[2]; }
        std::string_view corner_to_facet() const { return items[3]; }
        std::string_view corner_to_edge() const { return items[4]; }
        std::string_view edge_to_first_corner() const { return items[5]; }
        std::string_view next_corner_around_edge() const { return items[6]; }
        std::string_view vertex_to_first_corner() const { return items[7]; }
        std::string_view next_corner_around_vertex() const { return items[8]; }
    } s_reserved_names = {};
};
 
using SurfaceMesh32f = SurfaceMesh<float, uint32_t>;
using SurfaceMesh32d = SurfaceMesh<double, uint32_t>;
using SurfaceMesh64f = SurfaceMesh<float, uint64_t>;
using SurfaceMesh64d = SurfaceMesh<double, uint64_t>;

 
} // namespace lagrange