mesh_render_settings.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_SETTINGS_H
#define VCL_RENDER_DRAWABLE_MESH_MESH_RENDER_SETTINGS_H
 
#include "mesh_render_info.h"
 
#include <vclib/mesh.h>
#include <vclib/space/core.h>
 
namespace vcl {
 
class MeshRenderSettings
{
    using MRI = MeshRenderInfo;
 
    MeshRenderInfo mCapability; // capabilities of the mesh
    MeshRenderInfo mDrawMode;   // current rendering settings
 
    float mPointWidth        = 3;
    float mPointUserColor[4] = {1, 1, 0, 1}; // TODO: change to uint?
    uint  mSurfUserColor     = 0xFF808080;   // abgr
    int   mWrfWidth          = 1;
    float mWrfUserColor[4]   = {0, 0, 0, 1}; // TODO: change to uint?
    int   mEdgesWidth        = 1;
    uint  mEdgesUserColor    = 0xFF000000; // abgr
 
public:
    MeshRenderSettings() = default;
 
    template<MeshConcept MeshType>
    MeshRenderSettings(const MeshType& m)
    {
        setRenderCapabilityFrom(m);
        setDefaultSettingsFromCapability();
    }
 
    MeshRenderInfo drawMode() const { return mDrawMode; }
 
    bool operator==(const MeshRenderSettings&) const = default;
 
    bool operator!=(const MeshRenderSettings&) const = default;
 
    // rendering option capabilities of the mesh
 
    bool canBeVisible() const { return mCapability.visible(); }
 
    template<MeshRenderInfo::Primitive PRIMITIVE, typename Enum>
    bool can(Enum val) const
    {
        assert(val < Enum::COUNT);
        return mCapability.settings<PRIMITIVE>()[toUnderlying(val)];
    }
 
    bool canPoints(MeshRenderInfo::Points p) const
    {
        return can<MRI::Primitive::POINTS>(p);
    }
 
    bool canSurface(MeshRenderInfo::Surface s) const
    {
        return can<MRI::Primitive::SURFACE>(s);
    }
 
    bool canWireframe(MeshRenderInfo::Wireframe w) const
    {
        return can<MRI::Primitive::WIREFRAME>(w);
    }
 
    bool canEdges(MeshRenderInfo::Edges e) const
    {
        return can<MRI::Primitive::EDGES>(e);
    }
 
    // rendering option getters
 
    bool isVisible() const { return mDrawMode.visible(); }
 
    template<MeshRenderInfo::Primitive PRIMITIVE, typename Enum>
    bool is(Enum val) const
    {
        assert(val < Enum::COUNT);
        return mDrawMode.settings<PRIMITIVE>()[toUnderlying(val)];
    }
 
    bool isPoints(MeshRenderInfo::Points p) const
    {
        return is<MRI::Primitive::POINTS>(p);
    }
 
    float pointWidth() const { return mPointWidth; }
 
    vcl::Color pointUserColor() const
    {
        vcl::Color c;
        c.setRedF(mPointUserColor[0]);
        c.setGreenF(mPointUserColor[1]);
        c.setBlueF(mPointUserColor[2]);
        c.setAlphaF(mPointUserColor[3]);
        return c;
    }
 
    const float* pointUserColorData() const { return mPointUserColor; }
 
    bool isSurface(MeshRenderInfo::Surface s) const
    {
        return is<MRI::Primitive::SURFACE>(s);
    }
 
    vcl::Color surfaceUserColor() const
    {
        vcl::Color c;
        c.setAbgr(mSurfUserColor);
        return c;
    }
 
    const uint* surfaceUserColorData() const { return &mSurfUserColor; }
 
    bool isWireframe(MeshRenderInfo::Wireframe w) const
    {
        return is<MRI::Primitive::WIREFRAME>(w);
    }
 
    int wireframeWidth() const { return mWrfWidth; }
 
    vcl::Color wireframeUserColor() const
    {
        vcl::Color c;
        c.setRedF(mWrfUserColor[0]);
        c.setGreenF(mWrfUserColor[1]);
        c.setBlueF(mWrfUserColor[2]);
        c.setAlphaF(mWrfUserColor[3]);
        return c;
    }
 
    const float* wireframeUserColorData() const { return mWrfUserColor; }
 
    bool isEdges(MeshRenderInfo::Edges e) const
    {
        return is<MRI::Primitive::EDGES>(e);
    }
 
    int edgesWidth() const { return mEdgesWidth; }
 
    vcl::Color edgesUserColor() const
    {
        vcl::Color c;
        c.setAbgr(mEdgesUserColor);
        return c;
    }
 
    const uint* edgesUserColorData() const { return &mEdgesUserColor; }
 
    // rendering option setters
 
    bool setVisibility(bool b)
    {
        if (canBeVisible()) {
            mDrawMode.visible() = b;
            return true;
        }
        else {
            return false;
        }
    }
 
    template<MeshRenderInfo::Primitive PRIMITIVE, typename Enum>
    bool set(Enum val, bool b = true)
    {
        if (can<PRIMITIVE>(val)) { // if the capability allows it
            // get the range of the mutual exclusive settings for val
            auto rng = MRI::exclusiveRange<PRIMITIVE>(val);
            // if there are no mutual exclusive settings
            if (rng.first == rng.second) {
                // the setting could be true or false
                // e.g. VISIBLE
                mDrawMode.settings<PRIMITIVE>()[rng.first] = b;
            }
            else {
                // only one setting in the range can be true
                // e.g. the range SHADING_*
                for (auto i = rng.first; i <= rng.second; ++i) {
                    mDrawMode.settings<PRIMITIVE>()[i] = toUnderlying(val) == i;
                }
            }
            return true;
        }
        else {
            return false;
        }
    }
 
    bool setPoints(MeshRenderInfo::Points p, bool b = true)
    {
        return set<MRI::Primitive::POINTS>(p, b);
    }
 
    bool setPointsWidth(float width)
    {
        if (canPoints(MRI::Points::VISIBLE)) {
            mPointWidth = width;
            return true;
        }
        else {
            return false;
        }
    }
 
    bool setPointsUserColor(float r, float g, float b, float a = 1)
    {
        if (canPoints(MRI::Points::VISIBLE)) {
            mPointUserColor[0] = r;
            mPointUserColor[1] = g;
            mPointUserColor[2] = b;
            mPointUserColor[3] = a;
            return true;
        }
        else {
            return false;
        }
    }
 
    bool setPointsUserColor(const vcl::Color& c)
    {
        if (canPoints(MRI::Points::VISIBLE)) {
            mPointUserColor[0] = c.redF();
            mPointUserColor[1] = c.greenF();
            mPointUserColor[2] = c.blueF();
            mPointUserColor[3] = c.alphaF();
            return true;
        }
        else {
            return false;
        }
    }
 
    bool setSurface(MeshRenderInfo::Surface s, bool b = true)
    {
        return set<MRI::Primitive::SURFACE>(s, b);
    }
 
    bool setSurfaceUserColor(float r, float g, float b, float a = 1)
    {
        if (canSurface(MRI::Surface::VISIBLE)) {
            vcl::Color c;
            c.setRedF(r);
            c.setGreenF(g);
            c.setBlueF(b);
            c.setAlphaF(a);
            mSurfUserColor = c.abgr();
            return true;
        }
        else {
            return false;
        }
    }
 
    bool setSurfaceUserColor(const vcl::Color& c)
    {
        if (canSurface(MRI::Surface::VISIBLE)) {
            mSurfUserColor = c.abgr();
            return true;
        }
        else {
            return false;
        }
    }
 
    bool setWireframe(MeshRenderInfo::Wireframe w, bool b = true)
    {
        return set<MRI::Primitive::WIREFRAME>(w, b);
    }
 
    bool setWireframeUserColor(float r, float g, float b, float a = 1)
    {
        if (canWireframe(MRI::Wireframe::VISIBLE)) {
            mWrfUserColor[0] = r;
            mWrfUserColor[1] = g;
            mWrfUserColor[2] = b;
            mWrfUserColor[3] = a;
            return true;
        }
        else {
            return false;
        }
    }
 
    bool setWireframeUserColor(const vcl::Color& c)
    {
        if (canWireframe(MRI::Wireframe::VISIBLE)) {
            mWrfUserColor[0] = c.redF();
            mWrfUserColor[1] = c.greenF();
            mWrfUserColor[2] = c.blueF();
            mWrfUserColor[3] = c.alphaF();
            return true;
        }
        else {
            return false;
        }
    }
 
    bool setWireframeWidth(int width)
    {
        if (canWireframe(MRI::Wireframe::VISIBLE)) {
            mWrfWidth = width;
            return true;
        }
        else {
            return false;
        }
    }
 
    bool setEdges(MeshRenderInfo::Edges e, bool b = true)
    {
        return set<MRI::Primitive::EDGES>(e, b);
    }
 
    bool setEdgesUserColor(float r, float g, float b, float a = 1)
    {
        if (canEdges(MRI::Edges::VISIBLE)) {
            vcl::Color c;
            c.setRedF(r);
            c.setGreenF(g);
            c.setBlueF(b);
            c.setAlphaF(a);
            mEdgesUserColor = c.abgr();
            return true;
        }
        else {
            return false;
        }
    }
 
    bool setEdgesUserColor(const vcl::Color& c)
    {
        if (canEdges(MRI::Edges::VISIBLE)) {
            mEdgesUserColor = c.abgr();
            return true;
        }
        else {
            return false;
        }
    }
 
    bool setEdgesWidth(int width)
    {
        if (canEdges(MRI::Edges::VISIBLE)) {
            mEdgesWidth = width;
            return true;
        }
        else {
            return false;
        }
    }
 
    template<MeshConcept MeshType>
    void setRenderCapabilityFrom(const MeshType& m)
    {
        mCapability.reset();
 
        if (m.vertexNumber() > 0) {
            mCapability.visible() = true;
 
            // -- Points --
            setPointsCapability(MRI::Points::VISIBLE);
            setPointsCapability(MRI::Points::SHAPE_PIXEL);
            setPointsCapability(MRI::Points::SHAPE_CIRCLE);
            setPointsCapability(MRI::Points::SHAPE_SPHERE);
            setPointsCapability(MRI::Points::SHADING_NONE);
            setPointsCapability(MRI::Points::COLOR_USER);
 
            if constexpr (vcl::HasPerVertexNormal<MeshType>) {
                if (vcl::isPerVertexNormalAvailable(m)) {
                    setPointsCapability(MRI::Points::SHADING_VERT);
                }
            }
 
            if constexpr (vcl::HasPerVertexColor<MeshType>) {
                if (vcl::isPerVertexColorAvailable(m)) {
                    setPointsCapability(MRI::Points::COLOR_VERTEX);
                }
            }
 
            if constexpr (vcl::HasColor<MeshType>) {
                setPointsCapability(MRI::Points::COLOR_MESH);
            }
 
            // -- Surface and Wireframe --
            if constexpr (vcl::HasFaces<MeshType>) {
                if (m.faceNumber() > 0) {
                    setSurfaceCapability(MRI::Surface::VISIBLE);
                    setSurfaceCapability(MRI::Surface::SHADING_NONE);
                    setSurfaceCapability(MRI::Surface::COLOR_USER);
                    setWireframeCapability(MRI::Wireframe::VISIBLE);
                    setWireframeCapability(MRI::Wireframe::SHADING_NONE);
                    setWireframeCapability(MRI::Wireframe::COLOR_USER);
 
                    if constexpr (vcl::HasColor<MeshType>) {
                        setSurfaceCapability(MRI::Surface::COLOR_MESH);
                        setWireframeCapability(MRI::Wireframe::COLOR_MESH);
                    }
 
                    if constexpr (vcl::HasPerFaceNormal<MeshType>) {
                        if (vcl::isPerFaceNormalAvailable(m)) {
                            setSurfaceCapability(MRI::Surface::SHADING_FLAT);
                        }
                    }
 
                    if constexpr (vcl::HasPerVertexNormal<MeshType>) {
                        if (vcl::isPerVertexNormalAvailable(m)) {
                            setSurfaceCapability(MRI::Surface::SHADING_SMOOTH);
                            setWireframeCapability(
                                MRI::Wireframe::SHADING_VERT);
                        }
                    }
 
                    if constexpr (vcl::HasPerFaceColor<MeshType>) {
                        if (vcl::isPerFaceColorAvailable(m))
                            setSurfaceCapability(MRI::Surface::COLOR_FACE);
                    }
 
                    if constexpr (vcl::HasPerVertexColor<MeshType>) {
                        if (vcl::isPerVertexColorAvailable(m)) {
                            setSurfaceCapability(MRI::Surface::COLOR_VERTEX);
                            setWireframeCapability(
                                MRI::Wireframe::COLOR_VERTEX);
                        }
                    }
 
                    if constexpr (vcl::HasTexturePaths<MeshType>) {
                        if constexpr (vcl::HasPerVertexTexCoord<MeshType>) {
                            if (vcl::isPerVertexTexCoordAvailable(m) &&
                                m.textureNumber() > 0)
                                setSurfaceCapability(
                                    MRI::Surface::COLOR_VERTEX_TEX);
                        }
 
                        if constexpr (vcl::HasPerFaceWedgeTexCoords<MeshType>) {
                            if (vcl::isPerFaceWedgeTexCoordsAvailable(m) &&
                                m.textureNumber() > 0)
                                setSurfaceCapability(
                                    MRI::Surface::COLOR_WEDGE_TEX);
                        }
                    }
                }
            }
 
            // -- Edges --
            if constexpr (vcl::HasEdges<MeshType>) {
                if (m.edgeNumber() > 0) {
                    setEdgesCapability(MRI::Edges::VISIBLE);
                    setEdgesCapability(MRI::Edges::SHADING_NONE);
                    setEdgesCapability(MRI::Edges::COLOR_USER);
 
                    if constexpr (vcl::HasColor<MeshType>) {
                        setEdgesCapability(MRI::Edges::COLOR_MESH);
                    }
 
                    if constexpr (vcl::HasPerVertexNormal<MeshType>) {
                        if (vcl::isPerVertexNormalAvailable(m)) {
                            setEdgesCapability(MRI::Edges::SHADING_SMOOTH);
                        }
                    }
 
                    if constexpr (vcl::HasPerEdgeNormal<MeshType>) {
                        if (vcl::isPerEdgeNormalAvailable(m)) {
                            setEdgesCapability(MRI::Edges::SHADING_FLAT);
                        }
                    }
 
                    if constexpr (vcl::HasPerEdgeColor<MeshType>) {
                        if (vcl::isPerEdgeColorAvailable(m))
                            setEdgesCapability(MRI::Edges::COLOR_EDGE);
                    }
 
                    if constexpr (vcl::HasPerVertexColor<MeshType>) {
                        if (vcl::isPerVertexColorAvailable(m)) {
                            setEdgesCapability(MRI::Edges::COLOR_VERTEX);
                        }
                    }
                }
            }
        }
 
        // make sure that the previous draw mode satisfies the new capabilites
        mDrawMode &= mCapability;
    }
 
    void setDefaultSettingsFromCapability()
    {
        mDrawMode.reset();
 
        if (canBeVisible()) {
            setVisibility(true);
 
            setDefaultSurfaceSettingsFromCapability();
            setDefaultWireframeSettingsFromCapability();
            setDefaultPointSettingsFromCapability();
            setDefaultEdgeSettingsFromCapability();
        }
    }
 
private:
    template<MeshRenderInfo::Primitive PRIMITIVE, typename Enum>
    void setCapability(Enum val, bool b = true)
    {
        assert(val < Enum::COUNT);
        mCapability.settings<PRIMITIVE>()[toUnderlying(val)] = b;
    }
 
    void setPointsCapability(MeshRenderInfo::Points p, bool b = true)
    {
        setCapability<MRI::Primitive::POINTS>(p, b);
    }
 
    void setSurfaceCapability(MeshRenderInfo::Surface s, bool b = true)
    {
        setCapability<MRI::Primitive::SURFACE>(s, b);
    }
 
    void setWireframeCapability(MeshRenderInfo::Wireframe w, bool b = true)
    {
        setCapability<MRI::Primitive::WIREFRAME>(w, b);
    }
 
    void setEdgesCapability(MeshRenderInfo::Edges e, bool b = true)
    {
        setCapability<MRI::Primitive::EDGES>(e, b);
    }
 
    void setDefaultPointSettingsFromCapability()
    {
        using enum MRI::Points;
 
        mDrawMode.points().reset();
 
        if (canPoints(VISIBLE)) {
            if (!canSurface(MRI::Surface::VISIBLE))
                setPoints(VISIBLE, true);
            setPoints(SHADING_NONE);
            setPoints(SHAPE_PIXEL);
            if (canPoints(SHADING_VERT)) {
                setPoints(SHADING_VERT);
            }
            if (canPoints(COLOR_VERTEX)) {
                setPoints(COLOR_VERTEX);
            }
            else {
                setPoints(COLOR_USER);
            }
        }
    }
 
    void setDefaultSurfaceSettingsFromCapability()
    {
        using enum MRI::Surface;
 
        mDrawMode.surface().reset();
 
        if (canSurface(VISIBLE)) {
            setSurface(VISIBLE, true);
            // shading
            if (canSurface(SHADING_SMOOTH)) {
                setSurface(SHADING_SMOOTH);
            }
            else if (canSurface(SHADING_FLAT)) {
                setSurface(SHADING_FLAT);
            }
            else {
                setSurface(SHADING_NONE);
            }
            // color
            if (canSurface(COLOR_WEDGE_TEX)) {
                setSurface(COLOR_WEDGE_TEX);
            }
            else if (canSurface(COLOR_VERTEX_TEX)) {
                setSurface(COLOR_VERTEX_TEX);
            }
            else if (canSurface(COLOR_VERTEX)) {
                setSurface(COLOR_VERTEX);
            }
            else if (canSurface(COLOR_FACE)) {
                setSurface(COLOR_FACE);
            }
            // jump mesh color on purpose: it is always available on the mesh,
            // but rarely used and it is likely to be set to 0 (black)
            else {
                setSurface(COLOR_USER);
            }
        }
    }
 
    void setDefaultWireframeSettingsFromCapability()
    {
        using enum MRI::Wireframe;
 
        mDrawMode.wireframe().reset();
 
        if (canWireframe(VISIBLE)) {
            if (canWireframe(SHADING_VERT)) {
                setWireframe(SHADING_VERT);
            }
            else {
                setWireframe(SHADING_NONE);
            }
            // wireframe color (defaults to user defined)
            setWireframe(COLOR_USER);
        }
    }
 
    void setDefaultEdgeSettingsFromCapability()
    {
        using enum MRI::Edges;
 
        mDrawMode.edges().reset();
 
        if (canEdges(VISIBLE)) {
            setEdges(VISIBLE, true);
 
            if (canEdges(SHADING_SMOOTH)) {
                setEdges(SHADING_SMOOTH);
            }
            else if (canEdges(SHADING_FLAT)) {
                setEdges(SHADING_FLAT);
            }
            else {
                setEdges(SHADING_NONE);
            }
 
            if (canEdges(COLOR_VERTEX)) {
                setEdges(COLOR_VERTEX);
            }
            else if (canEdges(COLOR_EDGE)) {
                setEdges(COLOR_EDGE);
            }
            else {
                setEdges(COLOR_USER);
            }
        }
    }
};
 
} // namespace vcl
 
#endif // VCL_RENDER_DRAWABLE_MESH_MESH_RENDER_SETTINGS_H