face.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2026                                                    *
 * 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_ELEMENTS_FACE_H
#define VCL_MESH_ELEMENTS_FACE_H
 
#include "base/element.h"
#include "face_components.h"
 
#include <vclib/base.h>
 
namespace vcl {
 
template<typename MeshType, comp::ComponentConcept... Comps>
class Face : public Element<ElemId::FACE, MeshType, Comps...>
{
    using Base = Element<ElemId::FACE, MeshType, Comps...>;
 
    // VertexPointers or VertexIndices component of the Face
    using VRefs = typename Face::VertexReferences;
 
    static const int NV = VRefs::VERTEX_COUNT; // If dynamic, NV will be -1
 
public:
    using VertexType = typename VRefs::VertexType;
 
    Face() = default;
 
    friend void swap(Face& a, Face& b) { a.swap(b); }
 
    template<Range Rng>
    void setVertices(Rng&& r)
        requires (InputRange<Rng, VertexType*> || InputRange<Rng, uint>)
    {
        VRefs::setVertices(r);
 
        // if polygonal, I need to resize all the TTVC components
        if constexpr (NV < 0) {
            (resizeTTVCComponent<Comps>(std::ranges::size(r)), ...);
        }
    }
 
    template<typename... V>
    void setVertices(V... args) requires (
        (std::convertible_to<V, VertexType*> || std::convertible_to<V, uint>) &&
        ...)
    {
        setVertices(std::list({args...}));
    }
 
    void resizeVertices(uint n) requires (NV < 0)
    {
        VRefs::resizeVertices(n);
 
        // Now I need to resize all the TTVC components
        (resizeTTVCComponent<Comps>(n), ...);
    }
 
    void pushVertex(VertexType* v) requires (NV < 0)
    {
        VRefs::pushVertex(v);
 
        // Now I need to pushBack in all the TTVC components
        (pushBackTTVCComponent<Comps>(), ...);
    }
 
    void pushVertex(uint vi) requires (NV < 0)
    {
        VRefs::pushVertex(vi);
 
        // Now I need to pushBack in all the TTVC components
        (pushBackTTVCComponent<Comps>(), ...);
    }
 
    void insertVertex(uint i, VertexType* v) requires (NV < 0)
    {
        VRefs::insertVertex(i, v);
 
        // Now I need to insert in all the TTVC components
        (insertTTVCComponent<Comps>(i), ...);
    }
 
    void insertVertex(uint i, uint vi) requires (NV < 0)
    {
        VRefs::insertVertex(i, vi);
 
        // Now I need to insert in all the TTVC components
        (insertTTVCComponent<Comps>(i), ...);
    }
 
    void eraseVertex(uint i) requires (NV < 0)
    {
        VRefs::eraseVertex(i);
 
        // Now I need to erase in all the TTVC components
        (eraseTTVCComponent<Comps>(i), ...);
    }
 
    void clearVertices() requires (NV < 0)
    {
        VRefs::clearVertices();
 
        // Now I need to clear all the TTVC components
        (clearTTVCComponent<Comps>(), ...);
    }
 
    template<typename ElType>
    void importFrom(const ElType& v, bool importRefs = true)
    {
        if constexpr (comp::HasVertexReferences<ElType> && NV < 0) {
            VRefs::resizeVertices(v.vertexCount());
            // Now I need to resize all the TTVC components
            (resizeTTVCComponent<Comps>(v.vertexCount()), ...);
        }
 
        Base::importFrom(v, importRefs);
    }
 
private:
    template<typename Comp>
    void resizeTTVCComponent(uint n)
    {
        if constexpr (comp::IsTiedToVertexCount<Comp>) {
            if (Comp::isAvailable())
                Comp::resize(n);
        }
    }
 
    template<typename Comp>
    void pushBackTTVCComponent()
    {
        if constexpr (comp::IsTiedToVertexCount<Comp>) {
            if (Comp::isAvailable())
                Comp::pushBack();
        }
    }
 
    template<typename Comp>
    void insertTTVCComponent(uint i)
    {
        if constexpr (comp::IsTiedToVertexCount<Comp>) {
            if (Comp::isAvailable())
                Comp::insert(i);
        }
    }
 
    template<typename Comp>
    void eraseTTVCComponent(uint i)
    {
        if constexpr (comp::IsTiedToVertexCount<Comp>) {
            if (Comp::isAvailable())
                Comp::erase(i);
        }
    }
 
    template<typename Comp>
    void clearTTVCComponent()
    {
        if constexpr (comp::IsTiedToVertexCount<Comp>) {
            if (Comp::isAvailable())
                Comp::clear();
        }
    }
};
 
template<typename MeshType, comp::ComponentConcept... Comps>
class Face<MeshType, TypeWrapper<Comps...>> : public Face<MeshType, Comps...>
{
};
 
/* Concepts */
 
template<typename T>
concept FaceConcept =
    IsDerivedFromSpecializationOfV<T, Face> &&
    RemoveRef<T>::ELEMENT_ID == ElemId::FACE && face::HasBitFlags<T> &&
    face::HasVertexReferences<T> &&
    (RemoveRef<T>::VERTEX_COUNT < 0 || RemoveRef<T>::VERTEX_COUNT >= 3) &&
    (!face::HasTriangleBitFlags<T> || RemoveRef<T>::VERTEX_COUNT == 3) &&
    comp::SanityCheckAdjacentEdges<T> && comp::SanityCheckAdjacentFaces<T> &&
    comp::SanityCheckWedgeColors<T> && comp::SanityCheckWedgeTexCoords<T>;
 
template<typename T>
concept TriangleFaceConcept = RemoveRef<T>::VERTEX_COUNT == 3 && FaceConcept<T>;
 
template<typename T>
concept PolygonFaceConcept = RemoveRef<T>::VERTEX_COUNT < 0 && FaceConcept<T>;
 
} // namespace vcl
 
#endif // VCL_MESH_ELEMENTS_FACE_H