MRVisualObject.h

Go to the documentation of this file.

#pragma once
 
#include "MRObject.h"
#include "MRMeshTexture.h"
#include "MRVector.h"
#include "MRColor.h"
#include "MRPositionedText.h"
#include "MRIRenderObject.h"
#include "MRUniquePtr.h"
#include "MREnums.h"
 
namespace MR
{
 
 
// Note! Must use `MRMESH_CLASS` on this enum and all enums that extend this one,
// otherwise you'll get silent wrong behavior on Mac.
enum class MRMESH_CLASS VisualizeMaskType
{
    Visibility,
    InvertedNormals,
    Name,
    Labels,
    CropLabelsByViewportRect,
    ClippedByPlane,
    DepthTest,
    _count [[maybe_unused]],
};
 
// If a type derived from `VisualObject` wants to extend `VisualizeMaskType`, it must create a separate enum and specialize this to `true` for it.
// NOTE! All those enums can start from 0, don't worry about collisions.
template <typename T> struct IsVisualizeMaskEnum : std::false_type {};
template <> struct IsVisualizeMaskEnum<VisualizeMaskType> : std::true_type {};
 
// Wraps `IsVisualizeMaskEnum` and adds some sanity checks.
template <typename T>
concept AnyVisualizeMaskEnumType =
    IsVisualizeMaskEnum<T>::value &&
    std::is_same_v<std::underlying_type_t<T>, int> &&
    std::is_same_v<T, std::remove_cvref_t<T>>;
 
// Stores a `VisualizeMaskType` or any other enum that extends it (i.e. which specializes `IsVisualizeMaskEnum`).
// To extract the value, do this:
//     if ( auto value = x.tryGet<MyEnum>() )
//     {
//         switch ( *value )
//         {
//             case MyEnum::foo: ...
//             case MyEnum::bar: ...
//         }
//     }
//     else // forward to the parent class
class AnyVisualizeMaskEnum
{
    std::type_index type_;
    int value_ = 0;
 
public:
    template <AnyVisualizeMaskEnumType T>
    AnyVisualizeMaskEnum( T value ) : type_( typeid(T) ), value_( decltype(value_)( value ) ) {}
 
    template <AnyVisualizeMaskEnumType T>
    [[nodiscard]] std::optional<T> tryGet() const
    {
        if ( type_ == typeid(T) )
            return T( value_ );
        else
            return {};
    }
};
 
using AllVisualizeProperties = std::vector<ViewportMask>;
 
enum DirtyFlags
{
    DIRTY_NONE = 0x0000,
    DIRTY_POSITION = 0x0001,
    DIRTY_UV = 0x0002,
    DIRTY_VERTS_RENDER_NORMAL = 0x0004, //< gl normals
    DIRTY_FACES_RENDER_NORMAL = 0x0008, 
    DIRTY_CORNERS_RENDER_NORMAL = 0x0010, 
    DIRTY_RENDER_NORMALS = DIRTY_VERTS_RENDER_NORMAL | DIRTY_FACES_RENDER_NORMAL | DIRTY_CORNERS_RENDER_NORMAL,
    DIRTY_SELECTION = 0x0020,
    DIRTY_TEXTURE = 0x0040,
    DIRTY_PRIMITIVES = 0x0080,
    DIRTY_FACE = DIRTY_PRIMITIVES,
    DIRTY_VERTS_COLORMAP = 0x0100,
    DIRTY_PRIMITIVE_COLORMAP = 0x0200,
    DIRTY_FACES_COLORMAP = DIRTY_PRIMITIVE_COLORMAP,
    DIRTY_TEXTURE_PER_FACE = 0x0400,
    DIRTY_MESH = 0x07FF,
    DIRTY_BOUNDING_BOX = 0x0800,
    DIRTY_BORDER_LINES = 0x1000,
    DIRTY_EDGES_SELECTION = 0x2000,
    DIRTY_CACHES = DIRTY_BOUNDING_BOX,
    DIRTY_ALL = 0x3FFF
};
 
struct Dirty
{
    uint32_t f{DIRTY_ALL};
    operator uint32_t&() { return f; }
    operator uint32_t() const { return f; }
 
    Dirty() noexcept = default;
    Dirty( const Dirty& ) noexcept {}
    Dirty( Dirty&& ) noexcept = default;
    Dirty& operator =( const Dirty& ) noexcept { return *this; }
    Dirty& operator =( Dirty&& ) noexcept = default;
    Dirty& operator =( uint32_t b ) noexcept { f = b; return *this; }
};
 
class MRMESH_CLASS VisualObject : public Object
{
public:
    MRMESH_API VisualObject();
 
    VisualObject( VisualObject&& ) = default;
    VisualObject& operator = ( VisualObject&& ) = default;
    virtual ~VisualObject() = default;
 
    constexpr static const char* TypeName() noexcept { return "VisualObject"; }
    virtual const char* typeName() const override { return TypeName(); }
 
    std::string getClassName() const override { return "Visual Object"; }
    std::string getClassNameInPlural() const override { return "Visual Objects"; }
 
    [[nodiscard]] MRMESH_API virtual bool supportsVisualizeProperty( AnyVisualizeMaskEnum type ) const;
    MRMESH_API void setVisualizeProperty( bool value, AnyVisualizeMaskEnum type, ViewportMask viewportMask );
    MRMESH_API virtual void setVisualizePropertyMask( AnyVisualizeMaskEnum type, ViewportMask viewportMask );
    MRMESH_API bool getVisualizeProperty( AnyVisualizeMaskEnum type, ViewportMask viewportMask ) const;
    MRMESH_API virtual const ViewportMask& getVisualizePropertyMask( AnyVisualizeMaskEnum type ) const;
    MRMESH_API void toggleVisualizeProperty( AnyVisualizeMaskEnum type, ViewportMask viewportMask );
 
    MRMESH_API virtual AllVisualizeProperties getAllVisualizeProperties() const;
    void setAllVisualizeProperties( const AllVisualizeProperties& properties )
    {
        std::size_t counter = 0;
        setAllVisualizeProperties_( properties, counter );
    }
 
    [[deprecated( "please use ObjectLabel mechanism instead" )]]
    void showLabels( bool on ) { return setVisualizeProperty( on, VisualizeMaskType::Labels, ViewportMask::all() ); }
    [[deprecated( "please use ObjectLabel mechanism instead" )]]
    bool showLabels() const { return getVisualizeProperty( VisualizeMaskType::Labels, ViewportMask::any() ); }
 
    void showName( bool on ) { return setVisualizeProperty( on, VisualizeMaskType::Name, ViewportMask::all() ); }
    bool showName() const { return getVisualizeProperty( VisualizeMaskType::Name, ViewportMask::any() ); }
 
    MRMESH_API const Color& getFrontColor( bool selected = true, ViewportId viewportId = {} ) const;
    MRMESH_API virtual void setFrontColor( const Color& color, bool selected, ViewportId viewportId = {} );
 
    MRMESH_API virtual const ViewportProperty<Color>& getFrontColorsForAllViewports( bool selected = true ) const;
    MRMESH_API virtual void setFrontColorsForAllViewports( ViewportProperty<Color> val, bool selected = true );
 
    MRMESH_API virtual const ViewportProperty<Color>& getBackColorsForAllViewports() const;
    MRMESH_API virtual void setBackColorsForAllViewports( ViewportProperty<Color> val );
 
    MRMESH_API const Color& getBackColor( ViewportId viewportId = {} ) const;
    MRMESH_API virtual void setBackColor( const Color& color, ViewportId viewportId = {} );
 
    MRMESH_API const uint8_t& getGlobalAlpha( ViewportId viewportId = {} ) const;
    MRMESH_API virtual void setGlobalAlpha( uint8_t alpha, ViewportId viewportId = {} );
 
    MRMESH_API virtual const ViewportProperty<uint8_t>& getGlobalAlphaForAllViewports() const;
    MRMESH_API virtual void setGlobalAlphaForAllViewports( ViewportProperty<uint8_t> val );
 
    [[deprecated( "please use ObjectLabel mechanism instead" )]]
    MRMESH_API const Color& getLabelsColor( ViewportId viewportId = {} ) const;
    [[deprecated( "please use ObjectLabel mechanism instead" )]]
    MRMESH_API virtual void setLabelsColor( const Color& color, ViewportId viewportId = {} );
 
    [[deprecated( "please use ObjectLabel mechanism instead" )]]
    MRMESH_API const ViewportProperty<Color>& getLabelsColorsForAllViewports() const;
 
    [[deprecated( "please use ObjectLabel mechanism instead" )]]
    MRMESH_API virtual void setLabelsColorsForAllViewports( ViewportProperty<Color> val );
 
    MRMESH_API virtual void setDirtyFlags( uint32_t mask, bool invalidateCaches = true );
    MRMESH_API uint32_t getDirtyFlags() const { return dirty_; }
    MRMESH_API void resetDirty() const;
 
    MRMESH_API Box3f getBoundingBox() const;
    MRMESH_API virtual Box3f getWorldBox( ViewportId = {} ) const override;
    virtual bool getRedrawFlag( ViewportMask viewportMask ) const override
    {
        return Object::getRedrawFlag( viewportMask ) ||
            ( isVisible( viewportMask ) &&
              ( dirty_ & ( ~( DIRTY_CACHES ) ) ) );
    }
 
    bool isPickable( ViewportMask viewportMask = ViewportMask::any() ) const{return !(pickable_ & viewportMask).empty();}
    MRMESH_API virtual void setPickable( bool on, ViewportMask viewportMask = ViewportMask::all() );
 
    const VertColors& getVertsColorMap() const { return vertsColorMap_; }
    virtual void setVertsColorMap( VertColors vertsColorMap ) { vertsColorMap_ = std::move( vertsColorMap ); dirty_ |= DIRTY_VERTS_COLORMAP; }
    virtual void updateVertsColorMap( VertColors& vertsColorMap ) { std::swap( vertsColorMap_, vertsColorMap ); dirty_ |= DIRTY_VERTS_COLORMAP; }
 
    ColoringType getColoringType() const { return coloringType_; }
 
    MRMESH_API virtual void setColoringType( ColoringType coloringType );
 
    MRMESH_API virtual void copyColors( const VisualObject & src, const VertMap & thisToSrc, const FaceMap& thisToSrcFaces = {} );
 
    float getShininess() const { return shininess_; }
    virtual void setShininess( float shininess ) { shininess_ = shininess; needRedraw_ = true; }
 
    float getSpecularStrength() const { return specularStrength_; }
    virtual void setSpecularStrength( float specularStrength ) { specularStrength_ = specularStrength; needRedraw_ = true; }
 
    float getAmbientStrength() const { return ambientStrength_; }
    virtual void setAmbientStrength( float ambientStrength ) { ambientStrength_ = ambientStrength; needRedraw_ = true; }
 
    [[deprecated( "please use ObjectLabel mechanism instead" )]]
    const std::vector<PositionedText>& getLabels() const { return labels_; }
    [[deprecated( "please use ObjectLabel mechanism instead" )]]
    virtual void setLabels( std::vector<PositionedText> labels ) { labels_ = std::move( labels ); needRedraw_ = true; }
 
    MRMESH_API virtual std::shared_ptr<Object> clone() const override;
    MRMESH_API virtual std::shared_ptr<Object> shallowClone() const override;
 
    MRMESH_API virtual bool render( const ModelRenderParams& ) const;
    MRMESH_API virtual void renderForPicker( const ModelBaseRenderParams&, unsigned ) const;
    MRMESH_API virtual void renderUi( const UiRenderParams& params ) const;
 
    VisualObject( ProtectedStruct, const VisualObject& obj ) : VisualObject( obj ) {}
 
    [[nodiscard]] MRMESH_API virtual size_t heapBytes() const override;
    MRMESH_API virtual std::vector<std::string> getInfoLines() const override;
 
    [[nodiscard]] MRMESH_API bool useDefaultScenePropertiesOnDeserialization() const { return useDefaultScenePropertiesOnDeserialization_; }
    MRMESH_API void setUseDefaultScenePropertiesOnDeserialization( bool useDefaultScenePropertiesOnDeserialization )
    { useDefaultScenePropertiesOnDeserialization_ = useDefaultScenePropertiesOnDeserialization; }
 
protected:
    VisualObject( const VisualObject& obj ) = default;
 
    MRMESH_API virtual void swapBase_( Object& other ) override;
 
    virtual void setupRenderObject_() const {}
 
    mutable UniquePtr<IRenderObject> renderObj_;
    mutable Dirty dirty_;
 
    ViewportMask clipByPlane_;
    ViewportMask showLabels_;
    ViewportMask showName_;
    ViewportMask cropLabels_ = ViewportMask::all();
    ViewportMask pickable_ = ViewportMask::all(); 
    ViewportMask invertNormals_; 
    ViewportMask depthTest_ = ViewportMask::all();
 
    ViewportProperty<Color> labelsColor_ = {};
 
    float shininess_{35.0f}; 
    float specularStrength_{ 0.5f }; // reflection intensity
    float ambientStrength_{ 0.1f }; //non - directional light intensity
 
    ColoringType coloringType_{ColoringType::SolidColor};
    VertColors vertsColorMap_;
    ViewportProperty<Color> selectedColor_;
    ViewportProperty<Color> unselectedColor_;
    ViewportProperty<Color> backFacesColor_;
    ViewportProperty<uint8_t> globalAlpha_{ 255 };
 
    std::vector<PositionedText> labels_;
 
    bool useDefaultScenePropertiesOnDeserialization_{ false };
 
    MRMESH_API ViewportMask& getVisualizePropertyMask_( AnyVisualizeMaskEnum type );
 
    MRMESH_API virtual void serializeFields_( Json::Value& root ) const override;
 
    MRMESH_API void deserializeFields_( const Json::Value& root ) override;
 
    virtual Box3f computeBoundingBox_() const { return Box3f(); }
 
    MRMESH_API void boundingBoxToInfoLines_( std::vector<std::string> & res ) const;
 
    MRMESH_API virtual void setAllVisualizeProperties_( const AllVisualizeProperties& properties, std::size_t& pos );
 
    // Derived classes should use this to implement `setAllVisualizeProperties()`.
    template <AnyVisualizeMaskEnumType T>
    void setAllVisualizePropertiesForEnum( const AllVisualizeProperties& properties, std::size_t& pos )
    {
        for ( int i = 0; i < int( T::_count ); i++ )
            setVisualizePropertyMask( T( i ), properties[pos++] );
    }
    // Derived classes should use this to implement `getAllVisualizeProperties()`.
    template <AnyVisualizeMaskEnumType T>
    void getAllVisualizePropertiesForEnum( AllVisualizeProperties& properties ) const
    {
        properties.reserve( properties.size() + std::size_t( T::_count ) );
        for ( int i = 0; i < int( ( T::_count ) ); i++ )
            properties.push_back( getVisualizePropertyMask( T( i ) ) );
    }
 
private:
    mutable Box3f boundingBoxCache_;
 
    void setDefaultColors_();
 
    void setDefaultSceneProperties_();
};
 
 
} // namespace MR