base.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_COMPONENTS_BASE_BASE_H
#define VCL_MESH_COMPONENTS_BASE_BASE_H
 
#include <vclib/base.h>
 
namespace vcl {
 
struct CompId
{
    enum Enum {
        BIT_FLAGS = 0,
        POSITION,
        NORMAL,
        COLOR,
        QUALITY,
        MARK,
        MATERIAL_INDEX,
        PRINCIPAL_CURVATURE,
        TANGENT,
        TEX_COORD,
        VERTEX_REFERENCES,
        ADJACENT_EDGES,
        ADJACENT_FACES,
        ADJACENT_VERTICES,
        WEDGE_COLORS,
        WEDGE_TEX_COORDS,
        BOUNDING_BOX,
        NAME,
        MATERIALS,
        TRANSFORM_MATRIX,
        CUSTOM_COMPONENTS,
        // Additional components here
 
        COMPONENTS_NUMBER,
    };
};
 
constexpr const char* COMPONENT_ENUM_STRINGS[CompId::COMPONENTS_NUMBER] = {
    "BitFlags",         "Position",
    "Normal",           "Color",
    "Quality",          "Mark",
    "MaterialIndex",    "PrincipalCurvature",
    "Tangent",          "TexCoord",
    "VertexPointers",   "AdjacentEdges",
    "AdjacentFaces",    "AdjacentVertices",
    "WedgeColors",      "WedgeTexCoords",
    "BoundingBox",      "Name",
    "Materials",        "TransformMatrix",
    "CustomComponents",
};
 
template<uint COMP_ID>
struct ComponentString
{
    const char* str = COMP_ID < CompId::COMPONENTS_NUMBER ?
                          COMPONENT_ENUM_STRINGS[COMP_ID] :
                          nullptr;
};
 
template<uint COMP_ID>
constexpr const char* componentEnumString()
{
    static_assert(
        ComponentString<COMP_ID>().str != nullptr,
        "Invalid ComponentIDEnum. You should specialize the 'ComponentString' "
        "struct with your COMP_ID value.");
 
    return ComponentString<COMP_ID>().str;
}
 
namespace comp {
 
namespace detail {
 
template<uint COMP_ID, typename... Components>
struct ComponentOfTypePred
{
private:
    template<typename Comp>
    struct SameCompPred
    {
        static constexpr bool value = Comp::COMPONENT_ID == COMP_ID;
    };
 
public:
    // TypeWrapper of the found container, if any
    using type =
        typename FilterTypesByCondition<SameCompPred, Components...>::type;
    static constexpr bool value = NumberOfTypes<type>::value == 1;
};
 
// TypeWrapper specialization
template<uint COMP_ID, typename... Components>
struct ComponentOfTypePred<COMP_ID, TypeWrapper<Components...>> :
        public ComponentOfTypePred<COMP_ID, Components...>
{
};
 
} // namespace detail
 
template<uint COMP_ID, typename... Components>
using ComponentOfType = FirstTypeT<
    typename detail::ComponentOfTypePred<COMP_ID, Components...>::type>;
 
template<typename T>
class ReferencesComponentTriggerer
{
};
 
} // namespace comp
 
} // namespace vcl
 
#endif // VCL_MESH_COMPONENTS_BASE_BASE_H