MRPartialChangeMeshAction.h

Go to the documentation of this file.

#pragma once
 
#include "MRHistoryAction.h"
#include "MRMesh.h"
#include "MRMeshDiff.h"
#include "MRObjectMesh.h"
#include "MRHeapBytes.h"
#include <cassert>
 
namespace MR
{


struct CmpOld {};
inline constexpr CmpOld cmpOld;

struct SetNew {};
inline constexpr SetNew setNew;

class PartialChangeMeshAction : public HistoryAction
{
public:
    PartialChangeMeshAction( std::string name, std::shared_ptr<ObjectMesh> obj, CmpOld, const Mesh &oldMesh ) :
        objMesh_{ std::move( obj ) },
        name_{ std::move( name ) }
    {
        assert( objMesh_ );
        if ( objMesh_ && objMesh_->meshPtr() )
            meshDiff_ = MeshDiff( *objMesh_->meshPtr(), oldMesh );
    }

    PartialChangeMeshAction( std::string name, std::shared_ptr<ObjectMesh> obj, SetNew, std::shared_ptr<Mesh>&& newMesh ) :
        objMesh_{ std::move( obj ) },
        name_{ std::move( name ) }
    {
        assert( objMesh_ && newMesh );
        if ( objMesh_ )
        {
            auto oldMesh = objMesh_->updateMesh( std::move( newMesh ) );
            if ( oldMesh && objMesh_->meshPtr() )
                meshDiff_ = MeshDiff( *objMesh_->meshPtr(), *oldMesh );
        }
    }
 
    virtual std::string name() const override
    {
        return name_;
    }
 
    virtual void action( HistoryAction::Type ) override
    {
        if ( !objMesh_ )
            return;
 
        auto m = objMesh_->varMesh();
        assert( m );
        if ( !m )
            return;
 
        meshDiff_.applyAndSwap( *m );
        objMesh_->setDirtyFlags( DIRTY_ALL );
    }
 
    [[nodiscard]] virtual size_t heapBytes() const override
    {
        return name_.capacity() + meshDiff_.heapBytes();
    }
 
private:
    std::shared_ptr<ObjectMesh> objMesh_;
    MeshDiff meshDiff_;
 
    std::string name_;
};

class PartialChangeMeshPointsAction : public HistoryAction
{
public:
    PartialChangeMeshPointsAction( std::string name, std::shared_ptr<ObjectMesh> obj, CmpOld, const VertCoords& oldPoints ) :
        objMesh_{ std::move( obj ) },
        name_{ std::move( name ) }
    {
        assert( objMesh_ );
        if ( !objMesh_ )
            return;
 
        if ( auto m = objMesh_->varMesh() )
            pointsDiff_ = VertCoordsDiff( m->points, oldPoints );
    }

    PartialChangeMeshPointsAction( std::string name, std::shared_ptr<ObjectMesh> obj, SetNew, VertCoords&& newPoints ) :
        objMesh_{ std::move( obj ) },
        name_{ std::move( name ) }
    {
        assert( objMesh_ );
        if ( !objMesh_ )
            return;
 
        if ( auto m = objMesh_->varMesh() )
        {
            pointsDiff_ = VertCoordsDiff( newPoints, m->points );
            m->points = std::move( newPoints );
            objMesh_->setDirtyFlags( DIRTY_POSITION );
        }
    }
 
    virtual std::string name() const override
    {
        return name_;
    }
 
    virtual void action( HistoryAction::Type ) override
    {
        if ( !objMesh_ )
            return;
 
        auto m = objMesh_->varMesh();
        assert( m );
        if ( !m )
            return;
 
        pointsDiff_.applyAndSwap( m->points );
        objMesh_->setDirtyFlags( DIRTY_POSITION );
    }
 
    [[nodiscard]] virtual size_t heapBytes() const override
    {
        return name_.capacity() + pointsDiff_.heapBytes();
    }
 
private:
    std::shared_ptr<ObjectMesh> objMesh_;
    VertCoordsDiff pointsDiff_;
 
    std::string name_;
};

class PartialChangeMeshTopologyAction : public HistoryAction
{
public:
    PartialChangeMeshTopologyAction( std::string name, std::shared_ptr<ObjectMesh> obj, CmpOld, const MeshTopology& oldTopology ) :
        objMesh_{ std::move( obj ) },
        name_{ std::move( name ) }
    {
        assert( objMesh_ );
        if ( !objMesh_ )
            return;
 
        if ( auto m = objMesh_->varMesh() )
            topologyDiff_ = MeshTopologyDiff( m->topology, oldTopology );
    }

    PartialChangeMeshTopologyAction( std::string name, std::shared_ptr<ObjectMesh> obj, SetNew, MeshTopology&& newTopology ) :
        objMesh_{ std::move( obj ) },
        name_{ std::move( name ) }
    {
        assert( objMesh_ );
        if ( !objMesh_ )
            return;
 
        if ( auto m = objMesh_->varMesh() )
        {
            topologyDiff_ = MeshTopologyDiff( newTopology, m->topology );
            m->topology = std::move( newTopology );
            objMesh_->setDirtyFlags( DIRTY_FACE );
        }
    }
 
    virtual std::string name() const override
    {
        return name_;
    }
 
    virtual void action( HistoryAction::Type ) override
    {
        if ( !objMesh_ )
            return;
 
        auto m = objMesh_->varMesh();
        assert( m );
        if ( !m )
            return;
 
        topologyDiff_.applyAndSwap( m->topology );
        objMesh_->setDirtyFlags( DIRTY_FACE );
    }
 
    [[nodiscard]] virtual size_t heapBytes() const override
    {
        return name_.capacity() + topologyDiff_.heapBytes();
    }
 
private:
    std::shared_ptr<ObjectMesh> objMesh_;
    MeshTopologyDiff topologyDiff_;
 
    std::string name_;
};

 
}