MRChangeMeshAction.h

Go to the documentation of this file.

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


class ChangeMeshAction : public HistoryAction
{
public:
    using Obj = ObjectMesh;

    ChangeMeshAction( std::string name, const std::shared_ptr<ObjectMesh>& obj ) :
        objMesh_{ obj },
        name_{ std::move( name ) }
    {
        if ( obj )
        {
            if ( auto m = obj->meshPtr() )
                cloneMesh_ = std::make_shared<Mesh>( *m );
        }
    }

    ChangeMeshAction( std::string name, const std::shared_ptr<ObjectMesh>& obj, std::shared_ptr<Mesh> newMesh ) :
        objMesh_{ obj },
        name_{ std::move( name ) }
    {
        if ( obj )
            cloneMesh_ = objMesh_->updateMesh( std::move( newMesh ) );
    }
 
    virtual std::string name() const override
    {
        return name_;
    }
 
    virtual void action( HistoryAction::Type ) override
    {
        if ( !objMesh_ )
            return;
 
        cloneMesh_ = objMesh_->updateMesh( cloneMesh_ );
    }
 
    static void setObjectDirty( const std::shared_ptr<ObjectMesh>& obj )
    {
        if ( obj )
            obj->setDirtyFlags( DIRTY_ALL );
    }
 
    [[nodiscard]] virtual size_t heapBytes() const override
    {
        return name_.capacity() + MR::heapBytes( cloneMesh_ );
    }
 
private:
    std::shared_ptr<ObjectMesh> objMesh_;
    std::shared_ptr<Mesh> cloneMesh_;
 
    std::string name_;
};

class ChangeMeshUVCoordsAction : public HistoryAction
{
public:
    using Obj = ObjectMeshHolder;

    ChangeMeshUVCoordsAction( std::string name, const std::shared_ptr<ObjectMeshHolder>& obj ) :
        objMesh_{ obj },
        name_{ std::move( name ) }
    {
        if ( obj )
        {
            uvCoords_ = obj->getUVCoords();
        }
    }

    ChangeMeshUVCoordsAction( std::string name, const std::shared_ptr<ObjectMeshHolder>& obj, VertUVCoords&& newUvCoords ) :
        objMesh_{ obj },
        name_{ std::move( name ) }
    {
        if ( obj )
        {
            uvCoords_ = std::move( newUvCoords );
            obj->updateUVCoords( uvCoords_ );
        }
    }
 
    virtual std::string name() const override
    {
        return name_;
    }
 
    virtual void action( HistoryAction::Type ) override
    {
        if ( !objMesh_ )
            return;
 
        objMesh_->updateUVCoords( uvCoords_ );
    }
 
    static void setObjectDirty( const std::shared_ptr<ObjectMeshHolder>& obj )
    {
        if ( obj )
            obj->setDirtyFlags( DIRTY_UV );
    }
 
    [[nodiscard]] virtual size_t heapBytes() const override
    {
        return name_.capacity() + uvCoords_.heapBytes();
    }
 
private:
    VertUVCoords uvCoords_;
    std::shared_ptr<ObjectMeshHolder> objMesh_;
    std::string name_;
};

class ChangeTextureAction : public HistoryAction
{
public:
    using Obj = ObjectMeshHolder;

    ChangeTextureAction( std::string name, const std::shared_ptr<ObjectMeshHolder>& obj ) :
        obj_{ obj },
        name_{ std::move( name ) }
    {
        if ( obj )
            textures_ = obj->getTextures();
    }

    ChangeTextureAction( std::string name, const std::shared_ptr<ObjectMeshHolder>& obj, Vector<MeshTexture, TextureId>&& newTextures ) :
        obj_{ obj },
        name_{ std::move( name ) }
    {
        if ( obj )
        {
            textures_ = std::move( newTextures );
            obj->updateTextures( textures_ );
        }
    }
 
    virtual std::string name() const override
    {
        return name_;
    }
 
    virtual void action( HistoryAction::Type ) override
    {
        if ( !obj_ )
            return;
        obj_->updateTextures( textures_ );
    }
 
    static void setObjectDirty( const std::shared_ptr<ObjectMeshHolder>& obj )
    {
        if ( obj )
            obj->setDirtyFlags( DIRTY_TEXTURE );
    }
 
    [[nodiscard]] virtual size_t heapBytes() const override
    {
        return name_.capacity() + MR::heapBytes( textures_ );
    }
 
private:
    std::shared_ptr<ObjectMeshHolder> obj_;
    Vector<MeshTexture, TextureId> textures_;
    std::string name_;
};

class ChangeMeshPointsAction : public HistoryAction
{
public:
    using Obj = ObjectMesh;

    ChangeMeshPointsAction( std::string name, const std::shared_ptr<ObjectMesh>& obj ) :
        objMesh_{ obj },
        name_{ std::move( name ) }
    {
        if ( !objMesh_ )
            return;
        if ( auto m = objMesh_->meshPtr() )
            clonePoints_ = m->points;
    }

    ChangeMeshPointsAction( std::string name, const std::shared_ptr<ObjectMesh>& obj, VertCoords && newCoords ) :
        objMesh_{ obj },
        name_{ std::move( name ) }
    {
        clonePoints_ = std::move( newCoords );
        action( HistoryAction::Type::Redo );
    }
 
    virtual std::string name() const override
    {
        return name_;
    }
 
    virtual void action( HistoryAction::Type ) override
    {
        if ( !objMesh_ )
            return;
 
        if ( auto m = objMesh_->varMesh() )
        {
            std::swap( m->points, clonePoints_ );
            objMesh_->setDirtyFlags( DIRTY_POSITION );
        }
    }
 
    static void setObjectDirty( const std::shared_ptr<ObjectMesh>& obj )
    {
        if ( obj )
            obj->setDirtyFlags( DIRTY_POSITION );
    }
 
    [[nodiscard]] virtual size_t heapBytes() const override
    {
        return name_.capacity() + clonePoints_.heapBytes();
    }
 
    const std::shared_ptr<ObjectMesh> & obj() const { return objMesh_; }
    const VertCoords & clonePoints() const { return clonePoints_; }
 
private:
    std::shared_ptr<ObjectMesh> objMesh_;
    VertCoords clonePoints_;
 
    std::string name_;
};

class ChangeMeshTopologyAction : public HistoryAction
{
public:
    using Obj = ObjectMesh;

    ChangeMeshTopologyAction( std::string name, const std::shared_ptr<ObjectMesh>& obj ) :
        objMesh_{ obj },
        name_{ std::move( name ) }
    {
        if ( !objMesh_ )
            return;
        if ( auto m = objMesh_->meshPtr() )
            cloneTopology_ = m->topology;
    }

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

class ChangeMeshTexturePerFaceAction : public HistoryAction
{
public:
    using Obj = ObjectMeshHolder;

    ChangeMeshTexturePerFaceAction( std::string name, const std::shared_ptr<ObjectMeshHolder>& obj ) :
        objMesh_{ obj },
        name_{ std::move( name ) }
    {
        if ( obj )
        {
            texturePerFace_ = obj->getTexturePerFace();
        }
    }

    ChangeMeshTexturePerFaceAction( std::string name, const std::shared_ptr<ObjectMeshHolder>& obj, Vector<TextureId, FaceId>&& newTexturePerFace ) :
        objMesh_{ obj },
        name_{ std::move( name ) }
    {
        if ( obj )
        {
            texturePerFace_ = std::move( newTexturePerFace );
            obj->updateTexturePerFace( texturePerFace_ );
        }
    }
 
    virtual std::string name() const override
    {
        return name_;
    }
 
    virtual void action( HistoryAction::Type ) override
    {
        if ( !objMesh_ )
            return;
 
        objMesh_->updateTexturePerFace( texturePerFace_ );
    }
 
    static void setObjectDirty( const std::shared_ptr<ObjectMeshHolder>& obj )
    {
        if ( obj )
            obj->setDirtyFlags( DIRTY_TEXTURE_PER_FACE );
    }
 
    [[nodiscard]] virtual size_t heapBytes() const override
    {
        return name_.capacity() + texturePerFace_.heapBytes();
    }
 
private:
    Vector<TextureId, FaceId> texturePerFace_;
    std::shared_ptr<ObjectMeshHolder> objMesh_;
    std::string name_;
};

 
}