MRObjectLinesHolder.h

Go to the documentation of this file.

#pragma once
#include "MRVisualObject.h"
#include "MRXfBasedCache.h"
#include "MRHeapBytes.h"
#include "MRVector.h"
 
namespace MR
{
 
 
enum class MRMESH_CLASS LinesVisualizePropertyType
{
    Points,
    Smooth,
    Dashed,
    _count [[maybe_unused]],
};
template <> struct IsVisualizeMaskEnum<LinesVisualizePropertyType> : std::true_type {};

using DashPattern = Vector4<uint8_t>;

class MRMESH_CLASS ObjectLinesHolder : public VisualObject
{
public:
    MRMESH_API ObjectLinesHolder();
    ObjectLinesHolder( ObjectLinesHolder&& ) = default;
    ObjectLinesHolder& operator=( ObjectLinesHolder&& ) = default;
 
    constexpr static const char* StaticTypeName() noexcept { return "LinesHolder"; }
    virtual const char* typeName() const override { return StaticTypeName(); }
 
    MRMESH_API virtual void applyScale( float scaleFactor ) override;
 
    MRMESH_API virtual bool hasVisualRepresentation() const override;
 
    [[nodiscard]] virtual bool hasModel() const override { return bool( polyline_ ); }
 
    MRMESH_API virtual std::shared_ptr<Object> clone() const override;
    MRMESH_API virtual std::shared_ptr<Object> shallowClone() const override;

    [[nodiscard]]       Polyline3* varPolylinePtr() { return polyline_.get(); }

    [[nodiscard]] const Polyline3* polylinePtr() const { return polyline_.get(); }
 
    #ifdef __GNUC__
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wstrict-aliasing" 
    #endif
    [[deprecated( "use polylinePtr() instead" )]]
    const std::shared_ptr<const Polyline3>& polyline() const
    { return reinterpret_cast< const std::shared_ptr<const Polyline3>& >( polyline_ ); } 
    #ifdef __GNUC__
    #pragma GCC diagnostic pop
    #endif
 
    MRMESH_API virtual void setDirtyFlags( uint32_t mask, bool invalidateCaches = true ) override;

    MRMESH_API virtual void setDashPattern( const DashPattern& pattern, ViewportId vpId = {} );
    virtual const DashPattern& getDashPattern( ViewportId vpId = {}, bool* isDef = nullptr ) const { return dashPattern_.get( vpId, isDef ); }
 
    MRMESH_API virtual void setLineWidth( float width );
    virtual float getLineWidth() const { return lineWidth_; }
    MRMESH_API virtual void setPointSize( float size );
    virtual float getPointSize() const { return pointSize_; }

    ObjectLinesHolder( ProtectedStruct, const ObjectLinesHolder& obj ) : ObjectLinesHolder( obj ) {}

    const VertColors& getVertsColorMap() const { return vertsColorMap_; }

    virtual void setVertsColorMap( VertColors vertsColorMap ) { vertsColorMap_ = std::move( vertsColorMap ); setDirtyFlags( DIRTY_VERTS_COLORMAP ); }

    virtual void updateVertsColorMap( VertColors& vertsColorMap ) { std::swap( vertsColorMap_, vertsColorMap );  setDirtyFlags( DIRTY_VERTS_COLORMAP ); }
 
    const UndirectedEdgeColors& getLinesColorMap() const { return linesColorMap_; }
    virtual void setLinesColorMap( UndirectedEdgeColors linesColorMap ) { linesColorMap_ = std::move( linesColorMap );  setDirtyFlags( DIRTY_PRIMITIVE_COLORMAP ); }
    virtual void updateLinesColorMap( UndirectedEdgeColors& updated ) { std::swap( linesColorMap_, updated );  setDirtyFlags( DIRTY_PRIMITIVE_COLORMAP ); }
 
    [[nodiscard]] MRMESH_API bool supportsVisualizeProperty( AnyVisualizeMaskEnum type ) const override;
    MRMESH_API AllVisualizeProperties getAllVisualizeProperties() const override;
    MRMESH_API const ViewportMask& getVisualizePropertyMask( AnyVisualizeMaskEnum type ) const override;

    MRMESH_API virtual void copyColors( const ObjectLinesHolder& src, const VertMap& thisToSrc );

    MRMESH_API virtual Box3f getWorldBox( ViewportId = {} ) const override;

    [[nodiscard]] MRMESH_API virtual size_t heapBytes() const override;

    [[nodiscard]] MRMESH_API float avgEdgeLen() const;

    [[nodiscard]] MRMESH_API size_t numUndirectedEdges() const;

    [[nodiscard]] MRMESH_API size_t numComponents() const;

    [[nodiscard]] MRMESH_API float totalLength() const;

    MRMESH_API void resetFrontColor() override;

    using LinesChangedSignal = Signal<void( uint32_t mask )>;
    LinesChangedSignal linesChangedSignal;
 
protected:
    ObjectLinesHolder( const ObjectLinesHolder& other ) = default;

    MRMESH_API virtual void swapBase_( Object& other ) override;

    MRMESH_API virtual void swapSignals_( Object& other ) override;

    MRMESH_API void serializeBaseFields_( Json::Value& root ) const;
    MRMESH_API virtual void serializeFields_( Json::Value& root ) const override;
 
    MRMESH_API Expected<void> deserializeModel_( const std::filesystem::path& path, ProgressCallback progressCb = {} ) override;

    MRMESH_API void deserializeBaseFields_( const Json::Value& root );

    MRMESH_API virtual void deserializeFields_( const Json::Value& root ) override;
 
    MRMESH_API virtual Box3f computeBoundingBox_() const override;
 
    MRMESH_API virtual void setupRenderObject_() const override;

    MRMESH_API void setAllVisualizeProperties_( const AllVisualizeProperties& properties, std::size_t& pos ) override;
 
    mutable std::optional<size_t> numUndirectedEdges_;
    mutable std::optional<size_t> numComponents_;
    mutable std::optional<float> avgEdgeLen_;
    mutable std::optional<float> totalLength_;
    mutable ViewportProperty<XfBasedCache<Box3f>> worldBox_;
 
    VertColors vertsColorMap_;
    UndirectedEdgeColors linesColorMap_;
 
    ViewportMask showPoints_;
    ViewportMask smoothConnections_;
    ViewportMask dashed_;
    ViewportProperty<DashPattern> dashPattern_ = DashPattern::diagonal( 20 );

    float lineWidth_{ 1.0f };
    float pointSize_{ 5.f };
    std::shared_ptr<Polyline3> polyline_;
 
private:
    void setDefaultColors_();

    void setDefaultSceneProperties_();
};
 
 
}