MRObjectMeshHolder.h

Go to the documentation of this file.

#pragma once
 
#include "MRVisualObject.h"
#include "MRXfBasedCache.h"
#include "MRMeshPart.h"
 
namespace MR
{
 
enum class MRMESH_CLASS MeshVisualizePropertyType
{
    Faces,
    Texture,
    Edges,
    Points,
    SelectedFaces,
    SelectedEdges,
    EnableShading,
    FlatShading,
    OnlyOddFragments,
    BordersHighlight,
    PolygonOffsetFromCamera, // recommended for drawing edges on top of mesh
    _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* TypeName() noexcept { return "MeshHolder"; }
    virtual const char* typeName() const override { return TypeName(); }
 
    MRMESH_API virtual void applyScale( float scaleFactor ) override;
 
    MRMESH_API virtual bool hasVisualRepresentation() const override;
 
    [[nodiscard]] virtual bool hasModel() const override { return bool( mesh_ ); }
 
    const std::shared_ptr< const Mesh >& mesh() const
    { return reinterpret_cast< const std::shared_ptr<const Mesh>& >( mesh_ ); } // reinterpret_cast to avoid making a copy of shared_ptr
 
    MeshPart meshPart() const { return selectedTriangles_.any() ? MeshPart{ *mesh_, &selectedTriangles_ } : *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;
 
    const FaceBitSet& getSelectedFaces() const { return selectedTriangles_; }
    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 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>& getBordersColorsForAllViewports() const;
    MRMESH_API virtual void setBordersColorsForAllViewports( ViewportProperty<Color> val );
 
    const UndirectedEdgeBitSet& creases() const { return 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 FaceColors& getFacesColorMap() const { return facesColorMap_; }
    virtual void setFacesColorMap( FaceColors facesColorMap )
    { facesColorMap_ = std::move( facesColorMap ); dirty_ |= DIRTY_PRIMITIVE_COLORMAP; }
    virtual void updateFacesColorMap( FaceColors& updated )
    { std::swap( facesColorMap_, updated ); dirty_ |= 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;
    // for backward compatibility
    [[deprecated]] MRMESH_API virtual void setTexture( MeshTexture texture );
    [[deprecated]] MRMESH_API virtual void updateTexture( MeshTexture& updated );
    const Vector<MeshTexture, TextureId>& getTextures() const { return textures_; }
    virtual void setTextures( Vector<MeshTexture, TextureId> texture ) { textures_ = std::move( texture ); dirty_ |= DIRTY_TEXTURE; }
    virtual void updateTextures( Vector<MeshTexture, TextureId>& updated ) { std::swap( textures_, updated ); dirty_ |= DIRTY_TEXTURE; }
 
    virtual void setTexturePerFace( Vector<TextureId, FaceId> texturePerFace ) { texturePerFace_ = std::move( texturePerFace ); dirty_ |= DIRTY_TEXTURE_PER_FACE; }
    virtual void updateTexturePerFace( Vector<TextureId, FaceId>& texturePerFace ) { std::swap( texturePerFace_, texturePerFace ); dirty_ |= DIRTY_TEXTURE_PER_FACE; }
    virtual void addTexture( MeshTexture texture ) { textures_.emplace_back( std::move( texture ) ); dirty_ |= DIRTY_TEXTURE_PER_FACE; }
    const TexturePerFace& getTexturePerFace() const { return texturePerFace_; }
    
    const VertUVCoords& getUVCoords() const { return uvCoordinates_; }
    virtual void setUVCoords( VertUVCoords uvCoordinates ) { uvCoordinates_ = std::move( uvCoordinates ); dirty_ |= DIRTY_UV; }
    virtual void updateUVCoords( VertUVCoords& updated ) { std::swap( uvCoordinates_, updated ); dirty_ |= DIRTY_UV; }
 
    MRMESH_API virtual void copyTextureAndColors( const ObjectMeshHolder& src, const VertMap& thisToSrc, const FaceMap& thisToSrcFaces = {} );
 
    MRMESH_API void copyColors( const VisualObject& src, const VertMap& thisToSrc, const FaceMap& thisToSrcFaces = {} ) override;
 
    // ancillary texture can be used to have custom features visualization without affecting real one
    const MeshTexture& getAncillaryTexture() const { return ancillaryTexture_; }
    virtual void setAncillaryTexture( MeshTexture texture ) { ancillaryTexture_ = std::move( texture ); dirty_ |= DIRTY_TEXTURE; }
 
    const VertUVCoords& getAncillaryUVCoords() const { return ancillaryUVCoordinates_; }
    virtual void setAncillaryUVCoords( VertUVCoords uvCoordinates ) { ancillaryUVCoordinates_ = std::move( uvCoordinates ); dirty_ |= DIRTY_UV; }
    void updateAncillaryUVCoords( VertUVCoords& updated ) { std::swap( ancillaryUVCoordinates_, updated ); dirty_ |= DIRTY_UV; }
 
    bool hasAncillaryTexture() const { return !ancillaryUVCoordinates_.empty() && !ancillaryTexture_.pixels.empty(); }
    MRMESH_API void clearAncillaryTexture();
 
    MRMESH_API uint32_t getNeededNormalsRenderDirtyValue( ViewportMask viewportMask ) const;
 
    MRMESH_API virtual bool getRedrawFlag( ViewportMask viewportMask ) const override;
 
    MRMESH_API virtual void resetDirtyExeptMask( uint32_t mask ) const;
 
    [[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 * saveMeshFormat() const { return saveMeshFormat_; }
 
    MRMESH_API void setSaveMeshFormat( const char * newFormat );
 
    using SelectionChangedSignal = Signal<void()>;
    SelectionChangedSignal faceSelectionChangedSignal;
    SelectionChangedSignal edgeSelectionChangedSignal;
    SelectionChangedSignal creasesChangedSignal;
 
protected:
    FaceBitSet selectedTriangles_;
    UndirectedEdgeBitSet selectedEdges_;
    UndirectedEdgeBitSet creases_;
 
    Vector<MeshTexture, TextureId> textures_;
    VertUVCoords uvCoordinates_; 
 
    Vector<TextureId, FaceId> texturePerFace_;
 
    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 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_; 
 
    // really it shoud be one enum Shading {None, Flat, Smooth, Crease}
    // but for back capability it is easier to add global flag
    ViewportMask shadingEnabled_ = ViewportMask::all();
 
    ViewportMask onlyOddFragments_;
 
    ViewportProperty<Color> edgesColor_;
    ViewportProperty<Color> pointsColor_;
    ViewportProperty<Color> bordersColor_;
    ViewportProperty<Color> edgeSelectionColor_;
    ViewportProperty<Color> faceSelectionColor_;
 
    FaceColors facesColorMap_;
    float edgeWidth_{ 0.5f };
    float pointSize_{ 5.f };
 
    std::shared_ptr<Mesh> mesh_;
 
private:
    void setDefaultColors_();
 
    void setDefaultSceneProperties_();
 
    // falls back to the internal format if no CTM format support is available
    // NOTE: CTM format support is available in the MRIOExtras library; make sure to load it if you prefer CTM
    const char * saveMeshFormat_ = ".ctm";
};
 
} // namespace MR