MRObjectMeshHolder.h

Go to the documentation of this file.

#pragma once
 
#include "MRPch/MRBindingMacros.h"
#include "MRVisualObject.h"
#include "MRXfBasedCache.h"
#include "MRMeshPart.h"
#include "MRObjectMeshData.h"
#include "MRHeapBytes.h"
#include "MRMeshTexture.h"
 
namespace MR
{
 
 
enum class MRMESH_CLASS MeshVisualizePropertyType
{
    Faces,
    Texture,
    Edges,
    Points,
    SelectedFaces,
    SelectedEdges,
    EnableShading,
    FlatShading,
    OnlyOddFragments,
    BordersHighlight,
    PolygonOffsetFromCamera, 
    _count [[maybe_unused]],
};
template <> struct IsVisualizeMaskEnum<MeshVisualizePropertyType> : std::true_type {};

class MRMESH_CLASS ObjectMeshHolder : public VisualObject
{
public:
    MRMESH_API ObjectMeshHolder();
 
    ObjectMeshHolder( ObjectMeshHolder&& ) noexcept = default;
    ObjectMeshHolder& operator = ( ObjectMeshHolder&& ) noexcept = default;
 
    constexpr static const char* StaticTypeName() noexcept { return "MeshHolder"; }
    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( data_.mesh ); }

    [[nodiscard]]       Mesh* varMeshPtr() { return data_.mesh.get(); }

    [[nodiscard]] const Mesh* meshPtr() const { return data_.mesh.get(); }
 
    #ifdef __GNUC__
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wstrict-aliasing" 
    #endif
    [[deprecated( "use meshPtr() instead" )]]
    const std::shared_ptr< const Mesh >& mesh() const
    { return reinterpret_cast< const std::shared_ptr<const Mesh>& >( data_.mesh ); } 
    #ifdef __GNUC__
    #pragma GCC diagnostic pop
    #endif

    MeshPart meshPart() const { return data_.selectedFaces.any() ? MeshPart{ *data_.mesh, &data_.selectedFaces } : *data_.mesh; }
 
    MRMESH_API virtual std::shared_ptr<Object> clone() const override;
    MRMESH_API virtual std::shared_ptr<Object> shallowClone() const override;
 
    MRMESH_API virtual void setDirtyFlags( uint32_t mask, bool invalidateCaches = true ) override;

    MRMESH_API virtual void setDirtyFlagsFast( uint32_t mask );

    MRMESH_API virtual void invalidateMetricsCache( uint32_t mask );
 
    const FaceBitSet& getSelectedFaces() const { return data_.selectedFaces; }
    MRMESH_API virtual void selectFaces( FaceBitSet newSelection );
    MRMESH_API const Color& getSelectedFacesColor( ViewportId id = {} ) const;
    MRMESH_API virtual void setSelectedFacesColor( const Color& color, ViewportId id = {} );
 
    const UndirectedEdgeBitSet& getSelectedEdges() const { return data_.selectedEdges; }
    MRMESH_API virtual void selectEdges( UndirectedEdgeBitSet newSelection );
    MRMESH_API const Color& getSelectedEdgesColor( ViewportId id = {} ) const;
    MRMESH_API virtual void setSelectedEdgesColor( const Color& color, ViewportId id = {} );
 
    MRMESH_API const ViewportProperty<Color>& getSelectedEdgesColorsForAllViewports() const;
    MRMESH_API virtual void setSelectedEdgesColorsForAllViewports( ViewportProperty<Color> val );
 
    MRMESH_API const ViewportProperty<Color>& getSelectedFacesColorsForAllViewports() const;
    MRMESH_API virtual void setSelectedFacesColorsForAllViewports( ViewportProperty<Color> val );
 
    MRMESH_API const ViewportProperty<Color>& getEdgesColorsForAllViewports() const;
    MRMESH_API virtual void setEdgesColorsForAllViewports( ViewportProperty<Color> val );
 
    MRMESH_API const ViewportProperty<Color>& getPointsColorsForAllViewports() const;
    MRMESH_API virtual void setPointsColorsForAllViewports( ViewportProperty<Color> val );
 
    MRMESH_API const ViewportProperty<Color>& getBordersColorsForAllViewports() const;
    MRMESH_API virtual void setBordersColorsForAllViewports( ViewportProperty<Color> val );

    MRMESH_API void copyAllSolidColors( const ObjectMeshHolder& other );

    const UndirectedEdgeBitSet& creases() const { return data_.creases; }
    MRMESH_API virtual void setCreases( UndirectedEdgeBitSet creases );

    void setFlatShading( bool on )
    { return setVisualizeProperty( on, MeshVisualizePropertyType::FlatShading, ViewportMask::all() ); }
    bool flatShading() const
    { return getVisualizeProperty( MeshVisualizePropertyType::FlatShading, ViewportMask::any() ); }
 
    [[nodiscard]] MRMESH_API bool supportsVisualizeProperty( AnyVisualizeMaskEnum type ) const override;

    MRMESH_API AllVisualizeProperties getAllVisualizeProperties() const override;
    MRMESH_API const ViewportMask& getVisualizePropertyMask( AnyVisualizeMaskEnum type ) const override;

    const ObjectMeshData& data() const { return data_; }

    virtual void setData( ObjectMeshData && data ) { data_ = std::move( data ); setDirtyFlags( DIRTY_ALL ); }

    virtual void updateData( ObjectMeshData& data ) { std::swap( data_, data ); setDirtyFlags( DIRTY_ALL ); }

    const VertColors& getVertsColorMap() const { return data_.vertColors; }

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

    virtual void updateVertsColorMap( VertColors& vertsColorMap ) { std::swap( data_.vertColors, vertsColorMap ); setDirtyFlags( DIRTY_VERTS_COLORMAP ); }
 
    const FaceColors& getFacesColorMap() const { return data_.faceColors; }
    virtual void setFacesColorMap( FaceColors facesColorMap ) { data_.faceColors = std::move( facesColorMap ); setDirtyFlags( DIRTY_PRIMITIVE_COLORMAP ); }
    virtual void updateFacesColorMap( FaceColors& updated ) { std::swap( data_.faceColors, updated ); setDirtyFlags( DIRTY_PRIMITIVE_COLORMAP ); }
 
    MRMESH_API virtual void setEdgeWidth( float edgeWidth );
    float getEdgeWidth() const { return edgeWidth_; }
    MRMESH_API virtual void setPointSize( float size );
    virtual float getPointSize() const { return pointSize_; }
 
    const Color& getEdgesColor( ViewportId id = {} ) const { return edgesColor_.get(id); }
    virtual void setEdgesColor( const Color& color, ViewportId id = {} )
    { edgesColor_.set( color, id ); needRedraw_ = true; }
 
    const Color& getPointsColor( ViewportId id = {} ) const { return pointsColor_.get(id); }
    virtual void setPointsColor( const Color& color, ViewportId id = {} )
    { pointsColor_.set( color, id ); needRedraw_ = true; }
 
    const Color& getBordersColor( ViewportId id = {} ) const { return bordersColor_.get( id ); }
    virtual void setBordersColor( const Color& color, ViewportId id = {} )
    { bordersColor_.set( color, id ); needRedraw_ = true; }

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

    MRMESH_API const MeshTexture& getTexture() const;
    [[deprecated]] MRMESH_API MR_BIND_IGNORE virtual void setTexture( MeshTexture texture );
    [[deprecated]] MRMESH_API MR_BIND_IGNORE virtual void updateTexture( MeshTexture& updated );
    const Vector<MeshTexture, TextureId>& getTextures() const { return textures_; }
    virtual void setTextures( Vector<MeshTexture, TextureId> texture ) { textures_ = std::move( texture );  setDirtyFlags( DIRTY_TEXTURE ); }
    virtual void updateTextures( Vector<MeshTexture, TextureId>& updated ) { std::swap( textures_, updated );  setDirtyFlags( DIRTY_TEXTURE ); }

    virtual void setTexturePerFace( Vector<TextureId, FaceId> texturePerFace ) { data_.texturePerFace = std::move( texturePerFace );  setDirtyFlags( DIRTY_TEXTURE_PER_FACE ); }
    virtual void updateTexturePerFace( Vector<TextureId, FaceId>& texturePerFace ) { std::swap( data_.texturePerFace, texturePerFace );  setDirtyFlags( DIRTY_TEXTURE_PER_FACE ); }
    virtual void addTexture( MeshTexture texture ) { textures_.emplace_back( std::move( texture ) );  setDirtyFlags( DIRTY_TEXTURE_PER_FACE ); }
    const TexturePerFace& getTexturePerFace() const { return data_.texturePerFace; }
 
    const VertUVCoords& getUVCoords() const { return data_.uvCoordinates; }
    virtual void setUVCoords( VertUVCoords uvCoordinates ) { data_.uvCoordinates = std::move( uvCoordinates ); setDirtyFlags( DIRTY_UV ); }
    virtual void updateUVCoords( VertUVCoords& updated ) { std::swap( data_.uvCoordinates, updated ); setDirtyFlags( DIRTY_UV ); }

    MRMESH_API virtual void copyTextureAndColors( const ObjectMeshHolder& src, const VertMap& thisToSrc, const FaceMap& thisToSrcFaces = {} );

    MRMESH_API virtual void copyColors( const ObjectMeshHolder& src, const VertMap& thisToSrc, const FaceMap& thisToSrcFaces = {} );

    const MeshTexture& getAncillaryTexture() const { return ancillaryTexture_; }
    virtual void setAncillaryTexture( MeshTexture texture ) { ancillaryTexture_ = std::move( texture );  setDirtyFlags( DIRTY_TEXTURE ); }
 
    const VertUVCoords& getAncillaryUVCoords() const { return ancillaryUVCoordinates_; }
    virtual void setAncillaryUVCoords( VertUVCoords uvCoordinates ) { ancillaryUVCoordinates_ = std::move( uvCoordinates );  setDirtyFlags( DIRTY_UV ); }
    void updateAncillaryUVCoords( VertUVCoords& updated ) { std::swap( ancillaryUVCoordinates_, updated );  setDirtyFlags( DIRTY_UV ); }
 
    bool hasAncillaryTexture() const { return !ancillaryUVCoordinates_.empty() && !ancillaryTexture_.pixels.empty(); }
    MRMESH_API void clearAncillaryTexture();
 
    MRMESH_API virtual bool getRedrawFlag( ViewportMask viewportMask ) const override;

    [[nodiscard]] MRMESH_API bool isMeshClosed() const;

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

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

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

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

    [[nodiscard]] MRMESH_API double totalArea() const;

    [[nodiscard]] MRMESH_API double selectedArea() const;

    [[nodiscard]] MRMESH_API double volume() const;

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

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

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

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

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

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

    [[nodiscard]] const char * serializeFormat() const { return serializeFormat_; }

    [[nodiscard]] MRMESH_API const char * actualSerializeFormat() const;

    MRMESH_API void setSerializeFormat( const char * newFormat );

    MRMESH_API void resetFrontColor() override;
    MRMESH_API void resetColors() override;
 
    MRMESH_API virtual size_t getModelHash() const override;
    MRMESH_API virtual bool sameModels( const Object& other ) const override;

    using SelectionChangedSignal = Signal<void()>;
    SelectionChangedSignal faceSelectionChangedSignal;
    SelectionChangedSignal edgeSelectionChangedSignal;
    SelectionChangedSignal creasesChangedSignal;

    using MeshChangedSignal = Signal<void( uint32_t mask )>;
    MeshChangedSignal meshChangedSignal;
 
protected:
    ObjectMeshData data_;

    Vector<MeshTexture, TextureId> textures_;
 
    MeshTexture ancillaryTexture_;
    VertUVCoords ancillaryUVCoordinates_; 
 
    mutable std::optional<size_t> numHoles_;
    mutable std::optional<size_t> numComponents_;
    mutable std::optional<size_t> numUndirectedEdges_;
    mutable std::optional<size_t> numHandles_;
    mutable std::optional<bool> meshIsClosed_;
    mutable std::optional<size_t> numSelectedFaces_, numSelectedEdges_, numCreaseEdges_;
    mutable std::optional<double> totalArea_, selectedArea_;
    mutable std::optional<double> volume_;
    mutable std::optional<float> avgEdgeLen_;
    mutable ViewportProperty<XfBasedCache<Box3f>> worldBox_;
 
    ObjectMeshHolder( const ObjectMeshHolder& other ) = default;

    MRMESH_API virtual void swapBase_( Object& other ) override;
    MRMESH_API virtual void swapSignals_( Object& other ) override;
 
    MRMESH_API virtual Expected<std::future<Expected<void>>> serializeModel_( const std::filesystem::path& path ) const override;
 
    MRMESH_API virtual void serializeFields_( Json::Value& root ) const override;
 
    MRMESH_API void deserializeFields_( const Json::Value& root ) override;
 
    MRMESH_API Expected<void> deserializeModel_( const std::filesystem::path& path, ProgressCallback progressCb = {} ) override;
    MRMESH_API virtual Expected<void> setSharedModel_( const Object& other ) override;

    MRMESH_API void setAllVisualizeProperties_( const AllVisualizeProperties& properties, std::size_t& pos ) override;
 
    MRMESH_API virtual Box3f computeBoundingBox_() const override;
 
    MRMESH_API virtual void setupRenderObject_() const override;
 
    ViewportMask showTexture_;
    ViewportMask showFaces_ = ViewportMask::all();
    ViewportMask showEdges_;
    ViewportMask showPoints_;
    ViewportMask showSelectedEdges_ = ViewportMask::all();
    ViewportMask showSelectedFaces_ = ViewportMask::all();
    ViewportMask showBordersHighlight_;
    ViewportMask polygonOffset_;
    ViewportMask flatShading_; 

    ViewportMask shadingEnabled_ = ViewportMask::all();
 
    ViewportMask onlyOddFragments_;
 
    ViewportProperty<Color> edgesColor_;
    ViewportProperty<Color> pointsColor_;
    ViewportProperty<Color> bordersColor_;
    ViewportProperty<Color> edgeSelectionColor_;
    ViewportProperty<Color> faceSelectionColor_;
 
    float edgeWidth_{ 0.5f };
    float pointSize_{ 5.f };
 
private:
    void setDefaultColors_();

    void setDefaultSceneProperties_();
 
    const char * serializeFormat_ = nullptr; 
};

[[nodiscard]] MRMESH_API const std::string & defaultSerializeMeshFormat();

MRMESH_API void setDefaultSerializeMeshFormat( std::string newFormat );
 
}