mesh_render_info.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_RENDER_DRAWABLE_MESH_MESH_RENDER_INFO_H
#define VCL_RENDER_DRAWABLE_MESH_MESH_RENDER_INFO_H
 
#include "mesh_render_info_macros.h"
 
#include <vclib/base.h>
#include <vclib/space/core/bit_set.h>
 
#include <array>
 
namespace vcl {
 
namespace detail {
 
template<typename Enum>
auto constexpr makeExclusiveReangesArray(auto... args)
{
    std::array<Enum, sizeof...(args)> array;
 
    std::size_t i = 0;
    ((array[i++] = args), ...);
 
    return array;
};
 
} // namespace detail
 
class MeshRenderInfo
{
public:
    enum class Buffers : uint {
        VERTICES,
        VERT_NORMALS,
        VERT_COLORS,
        VERT_TEXCOORDS,
        VERT_TANGENT,
 
        TRIANGLES,
        TRI_NORMALS,
        TRI_COLORS,
        WEDGE_TEXCOORDS,
 
        WIREFRAME,
 
        EDGES,
        EDGE_COLORS,
        EDGE_NORMALS,
 
        TEXTURES,
 
        MESH_UNIFORMS,
 
        COUNT,
    };
 
    enum class Primitive {
        POINTS = 0,
        SURFACE,
        WIREFRAME,
        EDGES,
 
        COUNT
    };
 
private:
    using BuffersBitSetUnderlyingType = ushort;
 
    static_assert(
        sizeof(BuffersBitSetUnderlyingType) < (uint) Buffers::COUNT,
        "BuffersBitSet is not able to store all enum Buffers values");
 
    bool mVisible;
 
    // settings for each primitive
    std::array<BitSet16, toUnderlying(Primitive::COUNT)> mSettings;
 
public:
    using BuffersBitSet = vcl::BitSet<BuffersBitSetUnderlyingType>;
 
private:
    static BuffersBitSet buffersAll()
    {
        BuffersBitSet all;
        all.set();
        return all;
    }
 
public:
    static const inline BuffersBitSet BUFFERS_NONE = BuffersBitSet();
 
    static const inline BuffersBitSet BUFFERS_ALL = buffersAll();
 
    enum class Points {
        VISIBLE      = VCL_MRS_DRAW_POINTS,
        SHAPE_PIXEL  = VCL_MRS_POINTS_PIXEL,
        SHAPE_CIRCLE = VCL_MRS_POINTS_CIRCLE,
        SHAPE_SPHERE = VCL_MRS_POINTS_SPHERE,
        SHADING_NONE = VCL_MRS_POINTS_SHADING_NONE,
        SHADING_VERT = VCL_MRS_POINTS_SHADING_VERT,
        COLOR_VERTEX = VCL_MRS_POINTS_COLOR_VERTEX,
        COLOR_MESH   = VCL_MRS_POINTS_COLOR_MESH,
        COLOR_USER   = VCL_MRS_POINTS_COLOR_USER,
 
        COUNT
    };
 
    enum class Surface {
        VISIBLE          = VCL_MRS_DRAW_SURF,
        SHADING_NONE     = VCL_MRS_SURF_SHADING_NONE,
        SHADING_FLAT     = VCL_MRS_SURF_SHADING_FLAT,
        SHADING_SMOOTH   = VCL_MRS_SURF_SHADING_SMOOTH,
        COLOR_VERTEX     = VCL_MRS_SURF_COLOR_VERTEX,
        COLOR_FACE       = VCL_MRS_SURF_COLOR_FACE,
        COLOR_VERTEX_TEX = VCL_MRS_SURF_TEX_VERTEX,
        COLOR_WEDGE_TEX  = VCL_MRS_SURF_TEX_WEDGE,
        COLOR_MESH       = VCL_MRS_SURF_COLOR_MESH,
        COLOR_USER       = VCL_MRS_SURF_COLOR_USER,
 
        COUNT
    };
 
    enum class Wireframe {
        VISIBLE      = VCL_MRS_DRAW_WIREFRAME,
        SHADING_NONE = VCL_MRS_WIREFRAME_SHADING_NONE,
        SHADING_VERT = VCL_MRS_WIREFRAME_SHADING_VERT,
        COLOR_VERTEX = VCL_MRS_WIREFRAME_COLOR_VERT,
        COLOR_MESH   = VCL_MRS_WIREFRAME_COLOR_MESH,
        COLOR_USER   = VCL_MRS_WIREFRAME_COLOR_USER,
 
        COUNT
    };
 
    enum class Edges {
        VISIBLE        = VCL_MRS_DRAW_EDGES,
        SHADING_NONE   = VCL_MRS_EDGES_SHADING_NONE,
        SHADING_FLAT   = VCL_MRS_EDGES_SHADING_FLAT,
        SHADING_SMOOTH = VCL_MRS_EDGES_SHADING_SMOOTH,
        COLOR_VERTEX   = VCL_MRS_EDGES_COLOR_VERTEX,
        COLOR_EDGE     = VCL_MRS_EDGES_COLOR_EDGE,
        COLOR_MESH     = VCL_MRS_EDGES_COLOR_MESH,
        COLOR_USER     = VCL_MRS_EDGES_COLOR_USER,
 
        COUNT
    };
 
    bool visible() const { return mVisible; }
 
    bool& visible() { return mVisible; }
 
    template<Primitive PRIMITIVE>
    BitSet16 settings() const
    {
        return mSettings[toUnderlying(PRIMITIVE)];
    }
 
    template<Primitive PRIMITIVE>
    BitSet16& settings()
    {
        return mSettings[toUnderlying(PRIMITIVE)];
    }
 
    BitSet16 points() const { return settings<Primitive::POINTS>(); }
 
    BitSet16& points() { return settings<Primitive::POINTS>(); }
 
    BitSet16 surface() const { return settings<Primitive::SURFACE>(); }
 
    BitSet16& surface() { return settings<Primitive::SURFACE>(); }
 
    BitSet16 wireframe() const { return settings<Primitive::WIREFRAME>(); }
 
    BitSet16& wireframe() { return settings<Primitive::WIREFRAME>(); }
 
    BitSet16 edges() const { return settings<Primitive::EDGES>(); }
 
    BitSet16& edges() { return settings<Primitive::EDGES>(); }
 
    void reset()
    {
        mVisible = false;
        for (auto& s : mSettings)
            s.reset();
    }
 
    bool operator==(const MeshRenderInfo& o) const
    {
        return mVisible == o.mVisible && mSettings == o.mSettings;
    }
 
    MeshRenderInfo& operator&=(const MeshRenderInfo& o)
    {
        mVisible &= o.mVisible;
        for (const auto& [s, os] : std::views::zip(mSettings, o.mSettings)) {
            s &= os;
        }
        return *this;
    }
 
    MeshRenderInfo& operator|=(const MeshRenderInfo& o)
    {
        mVisible |= o.mVisible;
        for (const auto& [s, os] : std::views::zip(mSettings, o.mSettings)) {
            s |= os;
        }
        return *this;
    }
 
    MeshRenderInfo& operator^=(const MeshRenderInfo& o)
    {
        mVisible ^= o.mVisible;
        for (const auto& [s, os] : std::views::zip(mSettings, o.mSettings)) {
            s ^= os;
        }
        return *this;
    }
 
    template<Primitive PRIMITIVE>
    constexpr static auto exclusiveRange(auto value)
    {
        const auto& ranges = exclusiveRanges<PRIMITIVE>();
        return getExclusiveRange(value, ranges);
    }
 
    constexpr static auto pointsExclusiveRange(auto value)
    {
        return exclusiveRange<Primitive::POINTS>(value);
    }
 
    constexpr static auto surfaceExclusiveRange(auto value)
    {
        return exclusiveRange<Primitive::SURFACE>(value);
    }
 
    constexpr static auto wireframeExclusiveRange(auto value)
    {
        return exclusiveRange<Primitive::WIREFRAME>(value);
    }
 
    constexpr static auto edgesExclusiveRange(auto value)
    {
        return exclusiveRange<Primitive::EDGES>(value);
    }
 
private:
    inline static constexpr const auto POINTS_EXCLUSIVE_RANGES =
        detail::makeExclusiveReangesArray<Points>(
            Points::SHAPE_PIXEL,  // first
            Points::SHAPE_SPHERE, // last
            Points::SHADING_NONE, // first
            Points::SHADING_VERT, // last
            Points::COLOR_VERTEX, // first
            Points::COLOR_USER);  // last
 
    inline static constexpr const auto SURFACE_EXCLUSIVE_RANGES =
        detail::makeExclusiveReangesArray<Surface>(
            Surface::SHADING_NONE,   // first
            Surface::SHADING_SMOOTH, // last
            Surface::COLOR_VERTEX,   // first
            Surface::COLOR_USER);    // last
 
    inline static constexpr const auto WIREFRAME_EXCLUSIVE_RANGES =
        detail::makeExclusiveReangesArray<Wireframe>(
            Wireframe::SHADING_NONE, // first
            Wireframe::SHADING_VERT, // last
            Wireframe::COLOR_VERTEX, // first
            Wireframe::COLOR_USER);  // last
 
    inline static constexpr const auto EDGES_EXCLUSIVE_RANGES =
        detail::makeExclusiveReangesArray<Edges>(
            Edges::SHADING_NONE,   // first
            Edges::SHADING_SMOOTH, // last
            Edges::COLOR_VERTEX,   // first
            Edges::COLOR_USER);    // last
 
    template<Primitive PRIMITIVE>
    inline static constexpr auto& exclusiveRanges()
    {
        if constexpr (PRIMITIVE == Primitive::POINTS) {
            return POINTS_EXCLUSIVE_RANGES;
        }
        else if constexpr (PRIMITIVE == Primitive::SURFACE) {
            return SURFACE_EXCLUSIVE_RANGES;
        }
        else if constexpr (PRIMITIVE == Primitive::WIREFRAME) {
            return WIREFRAME_EXCLUSIVE_RANGES;
        }
        else if constexpr (PRIMITIVE == Primitive::EDGES) {
            return EDGES_EXCLUSIVE_RANGES;
        }
        else {
            static_assert(PRIMITIVE, "Unknown Primitive");
        }
    }
 
    constexpr static auto getExclusiveRange(auto value, const auto& array)
    {
        for (uint i = 0; i < array.size(); i += 2) {
            if (toUnderlying(value) >= toUnderlying(array[i]) &&
                toUnderlying(value) <= toUnderlying(array[i + 1])) {
                return std::pair(
                    toUnderlying(array[i]), toUnderlying(array[i + 1]));
            }
        }
        return std::pair(toUnderlying(value), toUnderlying(value));
    }
};
 
} // namespace vcl
 
#endif // VCL_RENDER_DRAWABLE_MESH_MESH_RENDER_INFO_H