MRObject.h

Go to the documentation of this file.

#pragma once
 
#include "MRAffineXf3.h"
#include "MRBitSet.h"
#include "MRBox.h"
#include "MRExpected.h"
#include "MRProgressCallback.h"
#include "MRSignal.h"
#include "MRViewportProperty.h"
 
#include <array>
#include <filesystem>
#include <future>
#include <memory>
#include <set>
#include <vector>
 
namespace Json
{
class Value;
}
 
namespace MR
{
 
class ObjectChildrenHolder
{
public:
    ObjectChildrenHolder() = default;
    ObjectChildrenHolder( const ObjectChildrenHolder & ) noexcept {}
    ObjectChildrenHolder & operator = ( const ObjectChildrenHolder & ) noexcept { return *this; }
    MRMESH_API ObjectChildrenHolder( ObjectChildrenHolder && ) noexcept;
    MRMESH_API ObjectChildrenHolder & operator = ( ObjectChildrenHolder && ) noexcept;
    MRMESH_API ~ObjectChildrenHolder();
 
    // returns this Object as shared_ptr
    // finds it among its parent's recognized children
    [[nodiscard]] MRMESH_API std::shared_ptr<Object> getSharedPtr() const;
 
    [[nodiscard]] MRMESH_API size_t heapBytes() const;
 
protected:
    ObjectChildrenHolder * parent_ = nullptr;
    std::vector< std::shared_ptr< Object > > children_; 
    std::vector< std::weak_ptr< Object > > bastards_; 
};
 
class MRMESH_CLASS Object : public ObjectChildrenHolder
{
public:
    Object() = default;
    Object( Object && ) noexcept = default;
    Object & operator = ( Object && ) noexcept = default;
    virtual ~Object() = default;
 
    // return name of subtype for serialization purposes
    constexpr static const char* TypeName() noexcept { return "Object"; }
    virtual const char* typeName() const { return TypeName(); }
 
    constexpr static const char* ClassName() noexcept { return "Object"; }
    virtual std::string className() const { return ClassName(); }
 
    constexpr static const char* ClassNameInPlural() noexcept { return "Objects"; }
    virtual std::string classNameInPlural() const { return ClassNameInPlural(); }
 
    template <typename T>
    T * asType() { return dynamic_cast<T*>( this ); }
    template <typename T>
    const T * asType() const { return dynamic_cast<const T*>( this ); }
 
    const std::string & name() const { return name_; }
    virtual void setName( std::string name ) { name_ = std::move( name ); }
 
    MRMESH_API std::shared_ptr<const Object> find( const std::string_view & name ) const;
    std::shared_ptr<Object> find( const std::string_view & name ) { return std::const_pointer_cast<Object>( const_cast<const Object*>( this )->find( name ) ); }
 
    template <typename T>
    std::shared_ptr<const T> find() const;
    template <typename T>
    std::shared_ptr<T> find() { return std::const_pointer_cast<T>( const_cast<const Object*>( this )->find<T>() ); }
 
    template <typename T>
    std::shared_ptr<const T> find( const std::string_view & name ) const;
    template <typename T>
    std::shared_ptr<T> find( const std::string_view & name ) { return std::const_pointer_cast<T>( const_cast<const Object*>( this )->find<T>( name ) ); }
 
    const AffineXf3f & xf( ViewportId id = {}, bool * isDef = nullptr ) const { return xf_.get( id, isDef ); }
    MRMESH_API virtual void setXf( const AffineXf3f& xf, ViewportId id = {} );
    MRMESH_API virtual void resetXf( ViewportId id = {} );
 
    const ViewportProperty<AffineXf3f> & xfsForAllViewports() const { return xf_; }
    virtual void setXfsForAllViewports( ViewportProperty<AffineXf3f> xf ) { xf_ = std::move( xf ); }
 
    MRMESH_API AffineXf3f worldXf( ViewportId id = {}, bool * isDef = nullptr ) const;
    MRMESH_API void setWorldXf( const AffineXf3f& xf, ViewportId id = {} );
 
    MRMESH_API virtual void applyScale( float scaleFactor );
 
    MRMESH_API ViewportMask globalVisibilityMask() const;
    bool globalVisibility( ViewportMask viewportMask = ViewportMask::any() ) const { return !( globalVisibilityMask() & viewportMask ).empty(); }
    MRMESH_API void setGlobalVisibility( bool on, ViewportMask viewportMask = ViewportMask::any() );
 
    bool isLocked() const { return locked_; }
    virtual void setLocked( bool on ) { locked_ = on; }
 
    [[nodiscard]] bool isParentLocked() const { return parentLocked_; }
    virtual void setParentLocked( bool lock ) { parentLocked_ = lock; }
 
    const Object * parent() const { return static_cast<const Object *>( parent_ ); }
    Object * parent() { return static_cast<Object *>( parent_ ); }
 
    MRMESH_API bool isAncestor( const Object* ancestor ) const;
 
    [[nodiscard]] MRMESH_API Object* findCommonAncestor( Object& other );
    [[nodiscard]] const Object* findCommonAncestor( const Object& other ) const
    {
        return const_cast<Object &>( *this ).findCommonAncestor( const_cast<Object &>( other ) );
    }
 
    MRMESH_API virtual bool detachFromParent();
    const std::vector<std::shared_ptr<Object>>& children() { return children_; }
 
    #ifdef __GNUC__
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wstrict-aliasing" // Fingers crossed.
    #endif
    const std::vector<std::shared_ptr<const Object>>& children() const { return reinterpret_cast<const std::vector< std::shared_ptr< const Object > > &>( children_ ); }
    #ifdef __GNUC__
    #pragma GCC diagnostic pop
    #endif
 
    MRMESH_API virtual bool addChild( std::shared_ptr<Object> child, bool recognizedChild = true );
    MRMESH_API virtual bool addChildBefore( std::shared_ptr<Object> newChild, const std::shared_ptr<Object> & existingChild );
    bool removeChild( const std::shared_ptr<Object>& child ) { return removeChild( child.get() ); }
    MRMESH_API virtual bool removeChild( Object* child );
    MRMESH_API virtual void removeAllChildren();
    MRMESH_API void sortChildren();
 
    MRMESH_API virtual bool select( bool on );
    virtual bool isSelected() const { return selected_; }
 
    MRMESH_API virtual void setAncillary( bool ancillary );
    bool isAncillary() const { return ancillary_; }
    MRMESH_API bool isGlobalAncillary() const;
 
    MRMESH_API void setVisible( bool on, ViewportMask viewportMask = ViewportMask::all() );
    bool isVisible( ViewportMask viewportMask = ViewportMask::any() ) const { return !( visibilityMask() & viewportMask ).empty(); }
    MRMESH_API virtual void setVisibilityMask( ViewportMask viewportMask );
    virtual ViewportMask visibilityMask() const { return visibilityMask_; }
 
    virtual bool getRedrawFlag( ViewportMask ) const { return needRedraw_; }
    void resetRedrawFlag() const { needRedraw_ = false; }
 
    MRMESH_API std::shared_ptr<Object> cloneTree() const;
    MRMESH_API virtual std::shared_ptr<Object> clone() const;
    MRMESH_API std::shared_ptr<Object> shallowCloneTree() const;
    MRMESH_API virtual std::shared_ptr<Object> shallowClone() const;
 
    MRMESH_API virtual std::vector<std::string> getInfoLines() const;
 
    // This would be automatically skipped in the bindings anyway because of the `Json::Value` parameter.
    // But skipping it here prevents the vector-of-futures type from being registered, which is helpful.
    // TODO: figure out how to automate this (add a flag to the parser to outright reject functions based on their parameter and return types).
    MRMESH_API MR_BIND_IGNORE Expected<std::vector<std::future<Expected<void>>>> serializeRecursive( const std::filesystem::path& path, Json::Value& root, int childId ) const;
 
    MRMESH_API Expected<void> deserializeRecursive( const std::filesystem::path& path, const Json::Value& root,
        ProgressCallback progressCb = {}, int* objCounter = nullptr );
 
    MRMESH_API void swap( Object& other );
 
    virtual Box3f getWorldBox( ViewportId = {} ) const { return {}; } 
    MRMESH_API Box3f getWorldTreeBox( ViewportId = {} ) const;
 
    [[nodiscard]] virtual bool hasVisualRepresentation() const { return false; }
 
    [[nodiscard]] virtual bool hasModel() const { return false; }
 
    const std::set<std::string>& tags() const { return tags_; }
    MRMESH_API bool addTag( std::string tag );
    MRMESH_API bool removeTag( const std::string& tag );
 
    [[nodiscard]] MRMESH_API virtual size_t heapBytes() const;
 
    using XfChangedSignal = Signal<void()>;
    XfChangedSignal worldXfChangedSignal;
protected:
    struct ProtectedStruct{ explicit ProtectedStruct() = default; };
public:
    Object( ProtectedStruct, const Object& obj ) : Object( obj ) {}
 
protected:
    Object( const Object& obj ) = default;
 
    MRMESH_API virtual void swapBase_( Object& other );
    MRMESH_API virtual void swapSignals_( Object& other );
 
    MRMESH_API virtual Expected<std::future<Expected<void>>> serializeModel_( const std::filesystem::path& path ) const;
 
    MRMESH_API virtual void serializeFields_( Json::Value& root ) const;
 
    MRMESH_API virtual Expected<void> deserializeModel_( const std::filesystem::path& path, ProgressCallback progressCb = {} );
 
    MRMESH_API virtual void deserializeFields_( const Json::Value& root );
 
    std::string name_;
    ViewportProperty<AffineXf3f> xf_;
    ViewportMask visibilityMask_ = ViewportMask::all(); // Prefer to not read directly. Use the getter, as it can be overridden.
    bool locked_ = false;
    bool parentLocked_ = false;
    bool selected_{ false };
    bool ancillary_{ false };
    mutable bool needRedraw_{false};
    std::set<std::string> tags_;
 
    // This calls `onWorldXfChanged_()` for all children recursively, which in turn emits `worldXfChangedSignal`.
    // This isn't virtual because it wouldn't be very useful, because it doesn't call itself on the children
    //   (it doesn't use a true recursion, instead imitiating one, presumably to save stack space, though this is unlikely to be an issue).
    MRMESH_API void sendWorldXfChangedSignal_();
    // Emits `worldXfChangedSignal`, but derived classes can add additional behavior to it.
    MRMESH_API virtual void onWorldXfChanged_();
};
 
template <typename T>
std::shared_ptr<const T> Object::find() const
{
    for ( const auto & child : children_ )
        if ( auto res = std::dynamic_pointer_cast<T>( child ) )
            return res;
    return {}; // not found
}
 
template <typename T>
std::shared_ptr<const T> Object::find( const std::string_view & name ) const
{
    for ( const auto & child : children_ )
        if ( child->name() == name )
            if ( auto res = std::dynamic_pointer_cast<T>( child ) )
                return res;
    return {}; // not found
}
 
 
}