mesh.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2025                                                    *
 * Visual Computing Lab                                                      *
 * ISTI - Italian National Research Council                                  *
 *                                                                           *
 * All rights reserved.                                                      *
 *                                                                           *
 * This program is free software; you can redistribute it and/or modify      *
 * it under the terms of the Mozilla Public License Version 2.0 as published *
 * by the Mozilla Foundation; either version 2 of the License, or            *
 * (at your option) any later version.                                       *
 *                                                                           *
 * This program is distributed in the hope that it will be useful,           *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the              *
 * Mozilla Public License Version 2.0                                        *
 * (https://www.mozilla.org/en-US/MPL/2.0/) for more details.                *
 ****************************************************************************/
 
#ifndef VCL_MESH_MESH_H
#define VCL_MESH_MESH_H
 
#include "mesh_components.h"
#include "mesh_containers.h"
 
#include <vclib/algorithms/core.h>
 
namespace vcl {
 
template<typename... Args>
class Mesh : public Args...
{
    static_assert(HasVertices<Args...>, "A Mesh must have a VertexContainer.");
 
    template<typename El, bool b>
    friend struct comp::detail::CustomComponentsData;
 
    template<typename El, bool b>
    friend struct comp::detail::ComponentData;
 
    template<ElementConcept T>
    friend class mesh::ElementContainer;
 
    template<uint ELEM_ID, typename MeshType, comp::ComponentConcept... Comps>
    friend class Element;
 
    // Predicate structures
 
    template<uint ELEM_ID>
    struct ContainerOfElement :
            public mesh::ContainerOfElement<ELEM_ID, Mesh<Args...>>
    {
    };
 
    template<ElementConcept El>
    struct ContainerOf : public ContainerOfElement<El::ELEMENT_ID>
    {
    };
 
public:
    using Containers = FilterTypesByCondition<
        mesh::IsElementContainerPred,
        TypeWrapper<Args...>>::type;
 
    using Components =
        FilterTypesByCondition<comp::IsComponentPred, TypeWrapper<Args...>>::
            type;
 
    template<uint ELEM_ID>
    using ContainerType = ContainerOfElement<ELEM_ID>::type;
 
    template<uint ELEM_ID>
    using ElementType = ContainerType<ELEM_ID>::ElementType;
 
    /* Constexpr static member functions */
 
    template<ElementConcept El>
    static constexpr bool hasContainerOf()
    {
        return mesh::HasContainerOfPred<El, Mesh<Args...>>::value;
    }
 
    template<uint ELEM_ID>
    static constexpr bool hasContainerOf()
    {
        return mesh::HasContainerOfElementPred<ELEM_ID, Mesh<Args...>>::value;
    }
 
    template<uint ELEM_ID, uint COMP_ID>
    static constexpr bool hasPerElementComponent()
    {
        return mesh::HasPerElementComponent<Mesh<Args...>, ELEM_ID, COMP_ID>;
    }
 
    template<uint ELEM_ID, uint COMP_ID>
    static constexpr bool hasPerElementOptionalComponent()
    {
        return mesh::
            HasPerElementOptionalComponent<Mesh<Args...>, ELEM_ID, COMP_ID>;
    }
 
    /* Constructors */
 
    Mesh()
    {
        // Set to all element containers their parent mesh (this)
        updateAllParentMeshPointers();
    }
 
    Mesh(const Mesh& oth) :
            Args(oth)... // call auto copy constructors for all the container
                         // elements and components
    {
        // Set to all element containers their parent mesh (this)
        updateAllParentMeshPointers();
 
        // for each container of oth, save its base pointer
        // will need it to update all the pointers of this mesh
        constexpr uint N_CONTAINERS =
            NumberOfTypes<typename Mesh<Args...>::Containers>::value;
        std::array<const void*, N_CONTAINERS> othBases =
            Mesh<Args...>::getContainerBases(oth);
 
        // update all the pointers contained on each container
        // use the base pointer of each container of oth to update all the
        // pointers in this mesh. Each pointer of oth that was copied in this
        // mesh, will be updated computing its offset wrt the base of oth, and
        // then adding that offset to the new base pointer of this mesh
        (updateReferencesOfContainerType<Args>(*this, othBases), ...);
    }
 
    Mesh(Mesh&& oth)
    {
        swap(oth); // use copy and swap idiom: this (empty) mesh is swapped with
                   // the input one
    }
 
    /* Member functions */
 
    bool isCompact() const
    {
        bool isCompact = true;
        ((isCompact &= isContainerCompact<Args>()), ...);
        return isCompact;
    }
 
    void clear() { (clearContainer<Args>(), ...); }
 
    void compact() { (compactContainer<Args>(), ...); }
 
    void enableAllOptionalComponents()
    {
        (enableAllOptionalComponentsInContainer<Args>(), ...);
    }
 
    void disableAllOptionalComponents()
    {
        (disableAllOptionalComponentsInContainer<Args>(), ...);
    }
 
    template<typename OtherMeshType>
    void enableSameOptionalComponentsOf(const OtherMeshType& m)
    {
        // enable all optional components of this Mesh depending on what's
        // available in the OtherMeshType
 
        (enableSameOptionalComponentsOf<Args>(m), ...);
    }
 
    void append(const Mesh& m)
    {
        // for each container of this mesh, save its size
        // will need it to update all the pointers/indices of this mesh
        constexpr uint N_CONTAINERS =
            NumberOfTypes<typename Mesh<Args...>::Containers>::value;
        std::array<std::size_t, N_CONTAINERS> sizes =
            Mesh<Args...>::getContainerSizes(*this);
 
        // for each container of the other mesh m, save its bases
        // will need it to update all the pointers of this mesh
        std::array<const void*, N_CONTAINERS> bases =
            Mesh<Args...>::getContainerBases(m);
 
        // call the append function for each container
        (appendContainer<Args>(m), ...);
 
        // update all the pointers/indices contained on each container
        (updateReferencesOfContainerTypeAfterAppend<Args>(*this, bases, sizes),
         ...);
 
        // manage transform matrix
        if constexpr (mesh::HasTransformMatrix<Mesh<Args...>>) {
            using Matrixtype = typename Mesh<Args...>::TransformMatrixType;
 
            Matrixtype matrix = this->transformMatrix();
            matrix            = matrix.inverse().eval();
            matrix *= m.transformMatrix();
 
            if (matrix != Matrixtype::Identity()) {
                (updatePosAndNormalsOfContainerTypeAfterAppend<Args>(
                     *this, sizes, matrix),
                 ...);
            }
        }
 
        if constexpr (mesh::HasTexturePaths<Mesh<Args...>>) {
            uint nTextures = this->textureNumber();
 
            std::vector<uint> mapping(m.textureNumber());
 
            for (uint i = 0; i < m.textureNumber(); ++i) {
                uint tpi = this->indexOfTexturePath(m.texturePath(i));
 
                if (tpi == UINT_NULL) {
                    if constexpr (mesh::HasTextureImages<Mesh<Args...>>) {
                        this->pushTexture(m.texture(i));
                    }
                    else {
                        this->pushTexturePath(m.texturePath(i));
                    }
                    mapping[i] = nTextures++;
                }
                else {
                    mapping[i] = tpi;
                }
            }
 
            if (nTextures > 0 || mapping.size() > 0) {
                (updateTextureIndicesOfContainerTypeAfterAppend<Args>(
                     *this, sizes, mapping),
                 ...);
            }
        }
    }
 
    template<typename OtherMeshType>
    void importFrom(const OtherMeshType& m)
    {
        // This function will first:
        // Call, for each Container and Component of the mesh, its importFrom
        // function. In case of containers, it first creates the same number of
        // elements in the container, and then calls the importFrom function for
        // each new element.
 
        (Args::importFrom(m), ...);
 
        // Set to all element containers their parent mesh (this)
        updateAllParentMeshPointers();
 
        if constexpr (mesh::HasFaceContainer<Mesh<Args...>>) {
            // Now I need to manage imports between different types of meshes
            // (same type of meshes are already managed from importFrom member
            // function).
            //
            // Generally speaking, Polygon meshes can import from any other type
            // of mesh. We need to take care when this mesh has static vertex
            // references number in the face container (VERTEX_NUMBER >= 3).
            //
            // The follwing case don't need to be managed:
            // - import polygon mesh from triangle mesh
            //
            // I can manage the following cases:
            // - import triangle mesh from polygon mesh: need triangulation
            //
            // I cannot manage the follwing cases:
            // - import static non-triangle mesh from polygon mesh or from a
            //   mesh with different VERTEX_NUMBER
 
            // in case of import from poly to triangle mesh, I need to manage
            // triangulation of polygons and create additional triangle faces
            // for each of the imported polygons. This function statically
            // asserts that the import can be done.
            if constexpr (mesh::HasFaceContainer<OtherMeshType>) {
                using FaceContainer = typename Mesh<Args...>::FaceContainer;
                FaceContainer::manageImportTriFromPoly(m);
            }
        }
    }
 
    void swap(Mesh& m2)
    {
        Mesh<Args...>& m1 = *this;
 
        constexpr uint N_CONTAINERS =
            NumberOfTypes<typename Mesh<Args...>::Containers>::value;
        static_assert(N_CONTAINERS != 0);
 
        // container bases of each container for m1 and m2
        // we save the bases of the containers before swap
        std::array<const void*, N_CONTAINERS> m1Bases =
            Mesh<Args...>::getContainerBases(m1);
        std::array<const void*, N_CONTAINERS> m2Bases =
            Mesh<Args...>::getContainerBases(m2);
 
        // actual swap of all the containers and the components of the mesh
        // using pack expansion: swap will be called for each of the containers
        // (or components!) that compose the Mesh
        using std::swap;
        (swap((Args&) m1, (Args&) m2), ...);
 
        // Set to all elements their parent mesh
        m1.updateAllParentMeshPointers();
        m2.updateAllParentMeshPointers();
 
        // update all the refs to m1 and m2: old base of m1 is now "old
        // base" of m2, and viceversa
        (updateReferencesOfContainerType<Args>(m1, m2Bases), ...);
        (updateReferencesOfContainerType<Args>(m2, m1Bases), ...);
    }
 
    friend void swap(Mesh& a, Mesh& b) { a.swap(b); }
 
    Mesh& operator=(Mesh oth)
    {
        swap(oth);
        return *this;
    }
 
    /*** Generic Element functions ***/
 
    template<ElementConcept El>
    uint index(const El& e) const requires (hasContainerOf<El>())
    {
        using Container = ContainerOf<El>::type;
        return Container::index(&e);
    }
 
    template<ElementConcept El>
    uint index(const El* e) const requires (hasContainerOf<El>())
    {
        using Container = ContainerOf<El>::type;
        return Container::index(e);
    }
 
    template<uint ELEM_ID>
    const auto& element(uint i) const requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::element(i);
    }
 
    template<uint ELEM_ID>
    auto& element(uint i) requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::element(i);
    }
 
    template<uint ELEM_ID>
    uint number() const requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::elementNumber();
    }
 
    template<uint ELEM_ID>
    uint containerSize() const requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::elementContainerSize();
    }
 
    template<uint ELEM_ID>
    uint deletedNumber() const requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::deletedElementNumber();
    }
 
    template<uint ELEM_ID>
    uint add() requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::addElement();
    }
 
    template<uint ELEM_ID>
    uint add(uint n) requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::addElements(n); // add the number elements
    }
 
    template<uint ELEM_ID>
    void clearElements() requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        Cont::clearElements();
    }
 
    template<uint ELEM_ID>
    void resize(uint n) requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        Cont::resizeElements(n);
    }
 
    template<uint ELEM_ID>
    void reserve(uint n) requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        Cont::reserveElements(n);
    }
 
    template<uint ELEM_ID>
    void compactElements() requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        Cont::compactElements();
    }
 
    template<uint ELEM_ID>
    void deleteElement(uint i) requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        Cont::deleteElement(i);
    }
 
    template<ElementConcept El>
    void deleteElement(const El* e) const requires (hasContainerOf<El>())
    {
        using Cont = ContainerOf<El>::type;
        return Cont::deleteElement(e);
    }
 
    template<ElementConcept El>
    void deleteElement(const El& e) const requires (hasContainerOf<El>())
    {
        using Cont = ContainerOf<El>::type;
        return Cont::deleteElement(&e);
    }
 
    template<uint ELEM_ID>
    std::vector<uint> compactIndices() const
        requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::elementConpactIndices();
    }
 
    template<uint ELEM_ID>
    void updateIndices(const std::vector<uint>& newIndices)
        requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::updateElementIndices(newIndices);
    }
 
    void serialize(std::ostream& os) const
    {
        (preSerialization<Args>(os), ...);
 
        (postSerialization<Args>(os), ...);
    }
 
    void deserialize(std::istream& is)
    {
        (preDeserialization<Args>(is), ...);
 
        (postDeserialization<Args>(is), ...);
    }
 
    template<uint ELEM_ID>
    auto begin(bool jumpDeleted = true) requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::elementBegin(jumpDeleted);
    }
 
    template<uint ELEM_ID>
    auto end() requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::elementEnd();
    }
 
    template<uint ELEM_ID>
    auto begin(bool jumpDeleted = true) const
        requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::elementBegin(jumpDeleted);
    }
 
    template<uint ELEM_ID>
    auto end() const requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::elementEnd();
    }
 
    template<uint ELEM_ID>
    auto elements(bool jumpDeleted = true) requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::elements(jumpDeleted);
    }
 
    template<uint ELEM_ID>
    auto elements(uint begin, uint end = UINT_NULL)
        requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::elements(begin, end);
    }
 
    template<uint ELEM_ID>
    auto elements(bool jumpDeleted = true) const
        requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::elements(jumpDeleted);
    }
 
    template<uint ELEM_ID>
    auto elements(uint begin, uint end = UINT_NULL) const
        requires (hasContainerOf<ELEM_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::elements(begin, end);
    }
 
    template<uint ELEM_ID, uint COMP_ID>
    bool isPerElementComponentEnabled() const
        requires (hasPerElementOptionalComponent<ELEM_ID, COMP_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::template isOptionalComponentEnabled<COMP_ID>();
    }
 
    template<uint ELEM_ID, uint COMP_ID>
    void enablePerElementComponent()
        requires (hasPerElementOptionalComponent<ELEM_ID, COMP_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        Cont::template enableOptionalComponent<COMP_ID>();
    }
 
    template<uint ELEM_ID, uint COMP_ID>
    void disablePerElementComponent()
        requires (hasPerElementOptionalComponent<ELEM_ID, COMP_ID>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        Cont::template disableOptionalComponent<COMP_ID>();
    }
 
    template<uint ELEM_ID>
    bool hasPerElementCustomComponent(const std::string& name) const
        requires (hasPerElementComponent<ELEM_ID, CompId::CUSTOM_COMPONENTS>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::hasElemCustomComponent(name);
    }
 
    template<uint ELEM_ID>
    std::vector<std::string> perElementCustomComponentNames() const
        requires (hasPerElementComponent<ELEM_ID, CompId::CUSTOM_COMPONENTS>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::elemCustomComponentNames();
    }
 
    template<uint ELEM_ID, typename K>
    bool isPerElementCustomComponentOfType(const std::string& name) const
        requires (hasPerElementComponent<ELEM_ID, CompId::CUSTOM_COMPONENTS>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::template isElemCustomComponentOfType<K>(name);
    }
 
    template<uint ELEM_ID>
    std::type_index perElementCustomComponentType(const std::string& name) const
        requires (hasPerElementComponent<ELEM_ID, CompId::CUSTOM_COMPONENTS>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::elemCustomComponentType(name);
    }
 
    template<uint ELEM_ID, typename K>
    std::vector<std::string> perElementCustomComponentNamesOfType() const
        requires (hasPerElementComponent<ELEM_ID, CompId::CUSTOM_COMPONENTS>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::template elemCustomComponentNamesOfType<K>();
    }
 
    template<uint ELEM_ID, typename K>
    void addPerElementCustomComponent(const std::string& name)
        requires (hasPerElementComponent<ELEM_ID, CompId::CUSTOM_COMPONENTS>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        Cont::template addElemCustomComponent<K>(name);
    }
 
    template<uint ELEM_ID>
    void deletePerElementCustomComponent(const std::string& name)
        requires (hasPerElementComponent<ELEM_ID, CompId::CUSTOM_COMPONENTS>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        Cont::deleteElemCustomComponent(name);
    }
 
    template<uint ELEM_ID, typename K>
    CustomComponentVectorHandle<K> perElementCustomComponentVectorHandle(
        const std::string& name)
        requires (hasPerElementComponent<ELEM_ID, CompId::CUSTOM_COMPONENTS>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::template customComponentVectorHandle<K>(name);
    }
 
    template<uint ELEM_ID, typename K>
    ConstCustomComponentVectorHandle<K> perElementCustomComponentVectorHandle(
        const std::string& name) const
        requires (hasPerElementComponent<ELEM_ID, CompId::CUSTOM_COMPONENTS>())
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        return Cont::template customComponentVectorHandle<K>(name);
    }
 
    template<uint ELEM_ID, typename K>
    void serializePerElementCustomComponentsOfType(std::ostream& os) const
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        Cont::template serializePerElementCustomComponentsOfType<K>(os);
    }
 
    template<uint ELEM_ID, typename K>
    void deserializePerElementCustomComponentsOfType(std::istream& is)
    {
        using Cont = ContainerOfElement<ELEM_ID>::type;
 
        Cont::template deserializePerElementCustomComponentsOfType<K>(is);
    }
 
protected:
    template<typename Cont>
    bool isContainerCompact() const
    {
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            return Cont::elementNumber() == Cont::elementContainerSize();
        }
        else {
            return true; // does not count as a container
        }
    }
 
    template<typename Cont>
    void compactContainer()
    {
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            if (Cont::elementNumber() != Cont::elementContainerSize()) {
                Cont::compactElements();
            }
        }
    }
 
    template<typename Cont>
    void enableAllOptionalComponentsInContainer()
    {
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            Cont::enableAllOptionalComponents();
        }
    }
 
    template<typename Cont>
    void disableAllOptionalComponentsInContainer()
    {
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            Cont::disableAllOptionalComponents();
        }
    }
 
    template<typename Cont>
    void clearContainer()
    {
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            Cont::clearElements();
        }
    }
 
    template<ElementConcept Element>
    void updateAllReferences(const Element* oldBase)
    {
        if (oldBase != nullptr)
            (updateReferences<Args>(oldBase), ...);
    }
 
    // this function is required in order to get msvc compile
    template<typename Element, typename... A>
    void updateReferences(const Element* oldBase, TypeWrapper<A...>)
    {
        updateReferences(
            oldBase, TypeWrapper<A...>(), std::array<std::size_t, 0>(), 0);
    }
 
    // this function is required in order to get msvc compile
    template<typename Cont, typename Element>
    void updateReferences(const Element* oldBase)
    {
        updateReferences<Cont>(oldBase, std::array<std::size_t, 0>(), 0);
    }
 
    // this additional function is necessary because otherwise msvc jumps
    // totally the pack expansion if called directly in the function
    // updateReferencesOfContainerTypeAfterAppend
    template<typename Element, std::size_t N, typename... A>
    void updateReferences(
        const Element* oldBase,
        TypeWrapper<A...>,
        const std::array<std::size_t, N>& sizes  = std::array<std::size_t, 0>(),
        uint                              offset = 0)
    {
        (updateReferences<A>(oldBase, sizes, offset), ...);
    }
 
    template<typename Cont, typename Element, std::size_t N>
    void updateReferences(
        const Element*                    oldBase,
        const std::array<std::size_t, N>& sizes  = std::array<std::size_t, 0>(),
        uint                              offset = 0)
    {
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            if constexpr (N > 0) {
                using Containers = Mesh<Args...>::Containers;
                constexpr uint I = IndexInTypes<Cont, Containers>::value;
                static_assert(I >= 0 && I != UINT_NULL);
                Cont::updateReferences(oldBase, sizes[I], offset);
            }
            else {
                Cont::updateReferences(oldBase);
            }
        }
    }
 
    template<ElementConcept Element>
    void updateAllReferences(const std::vector<uint>& newIndices)
    {
        (updateReferences<Args, Element>(newIndices), ...);
    }
 
    template<typename Cont, typename Element>
    void updateReferences(const std::vector<uint>& newIndices)
    {
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            Cont::template updateReferences<Element>(newIndices);
        }
    }
 
private:
    // hide init and isAvailable members
    void init() {};
 
    bool isAvailable() const { return true; }
 
    // enable optional components
 
    template<typename Cont, typename OtherMeshType>
    void enableSameOptionalComponentsOf(const OtherMeshType& m)
    {
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            Cont::enableOptionalComponentsOf(m);
        }
    }
 
    // private parent mesh pointers functions
 
    void updateAllParentMeshPointers() { (setParentMeshPointers<Args>(), ...); }
 
    template<typename Cont>
    void setParentMeshPointers()
    {
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            Cont::setParentMeshPointers(this);
        }
    }
 
    template<typename Cont>
    void appendContainer(const Mesh& m)
    {
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            Cont::append((const Cont&) m);
        }
    }
 
    // private copy and swap member functions
 
    template<uint I, typename Cont, typename Array, typename... A>
    static void setContainerBase(const Mesh<A...>& m, Array& bases)
    {
        // since this function is called using pack expansion, it means that
        // Cont could be a mesh component and not a cointainer. We check if Cont
        // is a container
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            static_assert(I >= 0 && I != UINT_NULL);
            bases[I] = m.Cont::mElemVec.data();
        }
    }
 
    template<typename... A>
    static auto getContainerBases(const Mesh<A...>& m)
    {
        using Containers = Mesh<A...>::Containers;
 
        // the number of containers in Mesh<A...>
        constexpr uint N_CONTAINERS = NumberOfTypes<Containers>::value;
        // each element of this array will contain the base pointer of the
        // vector of elements contained in each container of Mesh<A...>
        std::array<const void*, N_CONTAINERS> bases;
 
        // for each container/component of Mesh<A...>, we call the function
        // that sets the base of the container in its index
        (setContainerBase<IndexInTypes<A, Containers>::value, A>(m, bases),
         ...);
 
        return bases;
    }
 
    template<uint I, typename Cont, typename Array, typename... A>
    static void setContainerSize(const Mesh<A...>& m, Array& sizes)
    {
        // since this function is called using pack expansion, it means that
        // Cont could be a mesh component and not a cointainer. We check if Cont
        // is a container
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            static_assert(I >= 0 && I != UINT_NULL);
            sizes[I] = m.Cont::mElemVec.size();
        }
    }
 
    template<typename... A>
    static auto getContainerSizes(const Mesh<A...>& m)
    {
        using Containers = Mesh<A...>::Containers;
 
        // the number of containers in Mesh<A...>
        constexpr uint N_CONTAINERS = NumberOfTypes<Containers>::value;
        // each element of this array will contain the size of the
        // vector of elements contained in each container of Mesh<A...>
        std::array<std::size_t, N_CONTAINERS> sizes;
 
        // for each container/component of Mesh<A...>, we set call the function
        // that sets the size of the container in its index
        (setContainerSize<IndexInTypes<A, Containers>::value, A>(m, sizes),
         ...);
 
        return sizes;
    }
 
    template<typename Cont, typename Array, typename... A>
    static void updateReferencesOfContainerType(
        Mesh<A...>&  m,
        const Array& bases)
    {
        // since this function is called using pack expansion, it means that
        // Cont could be a mesh component and not a cointainer. We check if Cont
        // is a container
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            // The element type contained in the container
            // We need it to get back the actual type of the element from the
            // old bases
            using ElType = Cont::ElementType;
 
            using Containers = Mesh<A...>::Containers;
            constexpr uint I = IndexInTypes<Cont, Containers>::value;
            static_assert(I >= 0 && I != UINT_NULL);
 
            using ContainerWrapper = TypeWrapper<A...>;
 
            // for each Container A in m, we update the references of ElType.
            // old base is contained in the array bases, the new base is the
            // base of the container
            m.updateReferences(
                reinterpret_cast<const ElType*>(bases[I]), ContainerWrapper());
        }
    }
 
    template<typename Cont, typename ArrayB, typename ArrayS, typename... A>
    static void updateReferencesOfContainerTypeAfterAppend(
        Mesh<A...>&   m,
        const ArrayB& bases,
        const ArrayS& sizes)
    {
        // since this function is called using pack expansion, it means that
        // Cont could be a mesh component and not a cointainer. We check if Cont
        // is a container
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            // The element type contained in the container
            // We need it to get back the actual type of the element from the
            // old bases
            using ElType = Cont::ElementType;
 
            using Containers = Mesh<A...>::Containers;
            constexpr uint I = IndexInTypes<Cont, Containers>::value;
            static_assert(I >= 0 && I != UINT_NULL);
 
            using ContainerWrapper = TypeWrapper<A...>;
 
            // for each Container A in m, we update the references of ElType.
            // old base is contained in the array bases
            m.updateReferences(
                reinterpret_cast<const ElType*>(bases[I]),
                ContainerWrapper(),
                sizes,
                sizes[I]);
        }
    }
 
    template<
        typename Cont,
        typename ArrayS,
        Matrix44Concept MatrixType,
        typename... A>
    static void updatePosAndNormalsOfContainerTypeAfterAppend(
        Mesh<A...>&       m,
        const ArrayS&     sizes,
        const MatrixType& matrix)
    {
        // since this function is called using pack expansion, it means that
        // Cont could be a mesh component and not a cointainer. We check if Cont
        // is a container
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            // The element type contained in the container
            // We need it to get back the actual type of the element from the
            // old bases
            using ElType                  = Cont::ElementType;
            static constexpr uint ELEM_ID = ElType::ELEMENT_ID;
 
            using Containers = Mesh<A...>::Containers;
            constexpr uint I = IndexInTypes<Cont, Containers>::value;
            static_assert(I >= 0 && I != UINT_NULL);
 
            if constexpr (hasPerElementComponent<ELEM_ID, CompId::POSITION>()) {
                auto posview = m.template elements<ELEM_ID>((uint) sizes[I]) |
                               vcl::views::positions;
 
                multiplyPointsByMatrix(posview, matrix);
            }
 
            if constexpr (hasPerElementComponent<ELEM_ID, CompId::NORMAL>()) {
                if (m.Cont::template isComponentAvailable<CompId::NORMAL>()) {
                    auto norview =
                        m.template elements<ELEM_ID>((uint) sizes[I]) |
                        vcl::views::normals;
 
                    multiplyNormalsByMatrix(norview, matrix);
                }
            }
        }
    }
 
    template<typename Cont, typename ArrayS, typename... A>
    static void updateTextureIndicesOfContainerTypeAfterAppend(
        Mesh<A...>&              m,
        const ArrayS&            sizes,
        const std::vector<uint>& mapping)
    {
        // since this function is called using pack expansion, it means that
        // Cont could be a mesh component and not a cointainer. We check if Cont
        // is a container
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            // The element type contained in the container
            // We need it to get back the actual type of the element from the
            // old bases
            using ElType                  = Cont::ElementType;
            static constexpr uint ELEM_ID = ElType::ELEMENT_ID;
 
            using Containers = Mesh<A...>::Containers;
            constexpr uint I = IndexInTypes<Cont, Containers>::value;
            static_assert(I >= 0 && I != UINT_NULL);
 
            if constexpr (hasPerElementComponent<
                              ELEM_ID,
                              CompId::TEX_COORD>()) {
                if (m.Cont::template isComponentAvailable<
                        CompId::TEX_COORD>()) {
                    auto tcview =
                        m.template elements<ELEM_ID>((uint) sizes[I]) |
                        vcl::views::texCoords;
                    for (auto& tc : tcview) {
                        tc.index() = mapping[tc.index()];
                    }
                }
            }
 
            if constexpr (hasPerElementComponent<
                              ELEM_ID,
                              CompId::WEDGE_TEX_COORDS>()) {
                if (m.Cont::template isComponentAvailable<
                        CompId::WEDGE_TEX_COORDS>()) {
                    auto elview = m.template elements<ELEM_ID>((uint) sizes[I]);
                    for (auto& e : elview) {
                        e.textureIndex() = mapping[e.textureIndex()];
                    }
                }
            }
        }
    }
 
    // serialization/deserialization
 
    template<typename Cont>
    void preSerialization(std::ostream& os) const
    {
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            Cont::serializeOptionalComponentsAndElementsNumber(os);
        }
    }
 
    template<typename Cont>
    void postSerialization(std::ostream& os) const
    {
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            Cont::serializeElements(os);
        }
        else {
            // cont is a component...
            Cont::serialize(os);
        }
    }
 
    template<typename Cont>
    void preDeserialization(std::istream& is)
    {
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            Cont::deserializeOptionalComponentsAndElementsNumber(is);
        }
    }
 
    template<typename Cont>
    void postDeserialization(std::istream& is)
    {
        if constexpr (mesh::ElementContainerConcept<Cont>) {
            Cont::deserializeElements(is);
        }
        else {
            // cont is a component...
            Cont::deserialize(is);
        }
    }
 
    // member functions used by friends
 
    template<uint ELEM_ID, typename T>
    uint elementIndex(const T* el) const
    {
        using Cont   = ContainerOfElement<ELEM_ID>::type;
        using ElType = Cont::ElementType;
        return index(static_cast<const ElType*>(el));
    }
 
    template<typename El>
    auto& customComponents()
    {
        using ElCont = ContainerOf<El>::type;
 
        return ElCont::mCustomCompVecMap;
    }
 
    template<typename El>
    const auto& customComponents() const
    {
        using ElCont = ContainerOf<El>::type;
 
        return ElCont::mCustomCompVecMap;
    }
 
    template<typename El>
    auto& verticalComponents()
    {
        using ElCont = ContainerOf<El>::type;
 
        return ElCont::mVerticalCompVecTuple;
    }
 
    template<typename El>
    const auto& verticalComponents() const
    {
        using ElCont = ContainerOf<El>::type;
 
        return ElCont::mVerticalCompVecTuple;
    }
};
 
/* Concepts */
 
template<typename T>
concept MeshConcept =
    IsDerivedFromSpecializationOfV<T, Mesh> && mesh::HasVertexContainer<T>;
 
template<typename T>
concept ElementOrMeshConcept = MeshConcept<T> || ElementConcept<T>;
 
} // namespace vcl
 
#endif // VCL_MESH_MESH_H