vertex_container.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_CONTAINERS_VERTEX_CONTAINER_H
#define VCL_MESH_CONTAINERS_VERTEX_CONTAINER_H
 
#include "base/element_container.h"
 
#include <vclib/mesh/elements/vertex.h>
#include <vclib/mesh/elements/vertex_components.h>
 
#include <typeindex>
 
namespace vcl {
namespace mesh {
 
template<VertexConcept T>
class VertexContainer : public ElementContainer<T>
{
    template<VertexConcept U>
    friend class VertexContainer;
 
    using VertexContainerType = VertexContainer<T>;
    using Base                = ElementContainer<T>;
 
public:
    using Vertex              = T;
    using VertexType          = T;
    using VertexIterator      = Base::ElementIterator;
    using ConstVertexIterator = Base::ConstElementIterator;
 
    VertexContainer() = default;
 
    const VertexType& vertex(uint i) const { return Base::element(i); }
 
    VertexType& vertex(uint i) { return Base::element(i); }
 
    uint vertexNumber() const { return Base::elementNumber(); }
 
    uint vertexContainerSize() const { return Base::elementContainerSize(); }
 
    uint deletedVertexNumber() const { return Base::deletedElementNumber(); }
 
    uint addVertex() { return Base::addElement(); }
 
    uint addVertex(const typename T::PositionType& p)
    {
        uint vid               = addVertex();
        vertex(vid).position() = p; // set the position to the vertex
        return vid;
    }
 
    uint addVertices(uint n) { return Base::addElements(n); }
 
    template<typename... VC>
    uint addVertices(const typename T::PositionType& p, const VC&... v)
    {
        uint vid = vertexContainerSize();
        // reserve the new number of vertices
        reserveVertices(vid + sizeof...(VC) + 1);
        addVertex(p);
        // pack expansion: will be translated at compile time as an addVertex()
        // call for each argument of the addVertices member function
        (addVertex(v), ...);
        return vid;
    }
 
    template<vcl::Range R>
    uint addVertices(R&& range) requires RangeOf<R, typename T::PositionType>
    {
        uint vid = vertexContainerSize();
        reserveVertices(vid + std::ranges::size(range));
        for (const auto& v : range) {
            addVertex(v);
        }
        return vid;
    }
 
    void clearVertices() { Base::clearElements(); }
 
    void resizeVertices(uint n) { Base::resizeElements(n); }
 
    void reserveVertices(uint n) { Base::reserveElements(n); }
 
    void compactVertices() { Base::compactElements(); }
 
    void deleteVertex(uint i) { Base::deleteElement(i); }
 
    void deleteVertex(const VertexType* v) { Base::deleteElement(v); }
 
    uint vertexIndexIfCompact(uint i) const
    {
        return Base::elementIndexIfCompact(i);
    }
 
    std::vector<uint> vertexCompactIndices() const
    {
        return Base::elementCompactIndices();
    }
 
    void updateVertexReferences(const std::vector<uint>& newIndices)
    {
        Base::updateElementReferences(newIndices);
    }
 
    VertexIterator vertexBegin(bool jumpDeleted = true)
    {
        return Base::elementBegin(jumpDeleted);
    }
 
    VertexIterator vertexEnd() { return Base::elementEnd(); }
 
    ConstVertexIterator vertexBegin(bool jumpDeleted = true) const
    {
        return Base::elementBegin(jumpDeleted);
    }
 
    ConstVertexIterator vertexEnd() const { return Base::elementEnd(); }
 
    auto vertices(bool jumpDeleted = true)
    {
        return Base::elements(jumpDeleted);
    }
 
    auto vertices(uint begin, uint end = UINT_NULL)
    {
        return Base::elements(begin, end);
    }
 
    auto vertices(bool jumpDeleted = true) const
    {
        return Base::elements(jumpDeleted);
    }
 
    auto vertices(uint begin, uint end = UINT_NULL) const
    {
        return Base::elements(begin, end);
    }
 
    void enableAllPerVertexOptionalComponents()
    {
        Base::enableAllOptionalComponents();
    }
 
    void disableAllPerVertexOptionalComponents()
    {
        Base::disableAllOptionalComponents();
    }
 
    // Adjacent Edges
 
    bool isPerVertexAdjacentEdgesEnabled() const
        requires vert::HasOptionalAdjacentEdges<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::AdjacentEdges>();
    }
 
    void enablePerVertexAdjacentEdges()
        requires vert::HasOptionalAdjacentEdges<T>
    {
        Base::template enableOptionalComponent<typename T::AdjacentEdges>();
    }
 
    void disablePerVertexAdjacentEdges()
        requires vert::HasOptionalAdjacentEdges<T>
    {
        Base::template disableOptionalComponent<typename T::AdjacentEdges>();
    }
 
    // Adjacent Faces
 
    bool isPerVertexAdjacentFacesEnabled() const
        requires vert::HasOptionalAdjacentFaces<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::AdjacentFaces>();
    }
 
    void enablePerVertexAdjacentFaces()
        requires vert::HasOptionalAdjacentFaces<T>
    {
        Base::template enableOptionalComponent<typename T::AdjacentFaces>();
    }
 
    void disablePerVertexAdjacentFaces()
        requires vert::HasOptionalAdjacentFaces<T>
    {
        Base::template disableOptionalComponent<typename T::AdjacentFaces>();
    }
 
    // Adjacent Vertices
 
    bool isPerVertexAdjacentVerticesEnabled() const
        requires vert::HasOptionalAdjacentVertices<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::AdjacentVertices>();
    }
 
    void enablePerVertexAdjacentVertices()
        requires vert::HasOptionalAdjacentVertices<T>
    {
        Base::template enableOptionalComponent<typename T::AdjacentVertices>();
    }
 
    void disablePerVertexAdjacentVertices()
        requires vert::HasOptionalAdjacentVertices<T>
    {
        Base::template disableOptionalComponent<typename T::AdjacentVertices>();
    }
 
    // Color
 
    bool isPerVertexColorEnabled() const requires vert::HasOptionalColor<T>
    {
        return Base::template isOptionalComponentEnabled<typename T::Color>();
    }
 
    void enablePerVertexColor() requires vert::HasOptionalColor<T>
    {
        return Base::template enableOptionalComponent<typename T::Color>();
    }
 
    void disablePerVertexColor() requires vert::HasOptionalColor<T>
    {
        Base::template disableOptionalComponent<typename T::Color>();
    }
 
    // Mark
 
    bool isPerVertexMarkEnabled() const requires vert::HasOptionalMark<T>
    {
        return Base::template isOptionalComponentEnabled<typename T::Mark>();
    }
 
    void enablePerVertexMark() requires vert::HasOptionalMark<T>
    {
        Base::template enableOptionalComponent<typename T::Mark>();
    }
 
    void disablePerVertexMark() requires vert::HasOptionalMark<T>
    {
        Base::template disableOptionalComponent<typename T::Mark>();
    }
 
    // MaterialIndex
 
    bool isPerVertexMaterialIndexEnabled() const
        requires vert::HasOptionalMaterialIndex<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::MaterialIndex>();
    }
 
    void enablePerVertexMaterialIndex()
        requires vert::HasOptionalMaterialIndex<T>
    {
        Base::template enableOptionalComponent<typename T::MaterialIndex>();
    }
 
    void disablePerVertexMaterialIndex()
        requires vert::HasOptionalMaterialIndex<T>
    {
        Base::template disableOptionalComponent<typename T::MaterialIndex>();
    }
 
    // Normal
 
    bool isPerVertexNormalEnabled() const requires vert::HasOptionalNormal<T>
    {
        return Base::template isOptionalComponentEnabled<typename T::Normal>();
    }
 
    void enablePerVertexNormal() requires vert::HasOptionalNormal<T>
    {
        Base::template enableOptionalComponent<typename T::Normal>();
    }
 
    void disablePerVertexNormal() requires vert::HasOptionalNormal<T>
    {
        Base::template disableOptionalComponent<typename T::Normal>();
    }
 
    // PrincipalCurvature
 
    bool isPerVertexPrincipalCurvatureEnabled() const
        requires vert::HasOptionalPrincipalCurvature<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::PrincipalCurvature>();
    }
 
    void enablePerVertexPrincipalCurvature()
        requires vert::HasOptionalPrincipalCurvature<T>
    {
        Base::template enableOptionalComponent<
            typename T::PrincipalCurvature>();
    }
 
    void disablePerVertexPrincipalCurvature()
        requires vert::HasOptionalPrincipalCurvature<T>
    {
        Base::template disableOptionalComponent<
            typename T::PrincipalCurvature>();
    }
 
    // Quality
 
    bool isPerVertexQualityEnabled() const requires vert::HasOptionalQuality<T>
    {
        return Base::template isOptionalComponentEnabled<typename T::Quality>();
    }
 
    void enablePerVertexQuality() requires vert::HasOptionalQuality<T>
    {
        Base::template enableOptionalComponent<typename T::Quality>();
    }
 
    void disablePerVertexQuality() requires vert::HasOptionalQuality<T>
    {
        Base::template disableOptionalComponente<typename T::Quality>();
    }
 
    // Tangent
 
    bool isPerVertexTangentEnabled() const requires vert::HasOptionalTangent<T>
    {
        return Base::template isOptionalComponentEnabled<typename T::Tangent>();
    }
 
    void enablePerVertexTangent() requires vert::HasOptionalTangent<T>
    {
        Base::template enableOptionalComponent<typename T::Tangent>();
    }
 
    void disablePerVertexTangent() requires vert::HasOptionalTangent<T>
    {
        Base::template disableOptionalComponent<typename T::Tangent>();
    }
 
    // TexCoord
 
    bool isPerVertexTexCoordEnabled() const
        requires vert::HasOptionalTexCoord<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::TexCoord>();
    }
 
    void enablePerVertexTexCoord() requires vert::HasOptionalTexCoord<T>
    {
        Base::template enableOptionalComponent<typename T::TexCoord>();
    }
 
    void disablePerVertexTexCoord() requires vert::HasOptionalTexCoord<T>
    {
        Base::template disableOptionalComponent<typename T::TexCoord>();
    }
 
    // Custom Components
 
    bool hasPerVertexCustomComponent(const std::string& name) const
        requires vert::HasCustomComponents<T>
    {
        return Base::hasElemCustomComponent(name);
    }
 
    std::vector<std::string> perVertexCustomComponentNames() const
        requires vert::HasCustomComponents<T>
    {
        return Base::elemCustomComponentNames();
    }
 
    template<typename K>
    bool isPerVertexCustomComponentOfType(const std::string& name) const
        requires vert::HasCustomComponents<T>
    {
        return Base::template isElemCustomComponentOfType<K>(name);
    }
 
    std::type_index perVertexCustomComponentType(const std::string& name) const
        requires vert::HasCustomComponents<T>
    {
        return Base::elemComponentType(name);
    }
 
    template<typename K>
    std::vector<std::string> perVertexCustomComponentNamesOfType() const
        requires vert::HasCustomComponents<T>
    {
        return Base::template elemCustomComponentNamesOfType<K>();
    }
 
    template<typename K>
    void addPerVertexCustomComponent(const std::string& name)
        requires vert::HasCustomComponents<T>
    {
        Base::template addElemCustomComponent<K>(name);
    }
 
    void deletePerVertexCustomComponent(const std::string& name)
        requires vert::HasCustomComponents<T>
    {
        Base::deleteElemCustomComponent(name);
    }
 
    template<typename K>
    CustomComponentVectorHandle<K> perVertexCustomComponentVectorHandle(
        const std::string& name) requires vert::HasCustomComponents<T>
    {
        return Base::template customComponentVectorHandle<K>(name);
    }
 
    template<typename K>
    ConstCustomComponentVectorHandle<K> perVertexCustomComponentVectorHandle(
        const std::string& name) const requires vert::HasCustomComponents<T>
    {
        return Base::template customComponentVectorHandle<K>(name);
    }
 
    template<typename K>
    void serializePerVertexCustomComponentsOfType(std::ostream& os) const
        requires vert::HasCustomComponents<T>
    {
        Base::template serializePerElementCustomComponentsOfType<K>(os);
    }
 
    template<typename K>
    void deserializePerVertexCustomComponentsOfType(std::istream& is)
        requires vert::HasCustomComponents<T>
    {
        Base::template deserializePerElementCustomComponentsOfType<K>(is);
    }
};
 
/* Concepts */
 
template<typename T>
concept HasVertexContainer = std::derived_from< // same type or derived type
    std::remove_cvref_t<T>,
    VertexContainer<typename RemoveRef<T>::VertexType>>;
 
} // namespace mesh
 
template<typename... Args>
concept HasVertices = (mesh::HasVertexContainer<Args> || ...);
 
} // namespace vcl
 
#endif // VCL_MESH_CONTAINERS_VERTEX_CONTAINER_H