diff --git a/engine/includes/editor/viewport/viewport.h b/engine/includes/editor/viewport/viewport.h
index e07c5e900..2dea2306d 100644
--- a/engine/includes/editor/viewport/viewport.h
+++ b/engine/includes/editor/viewport/viewport.h
@@ -21,7 +21,7 @@ class ENGINE_EXPORT Viewport : public QWidget {
 public:
     Viewport(QWidget *parent = 0);
 
-    void init();
+    virtual void init();
 
     CameraController *controllder();
     void setController(CameraController *ctrl);
@@ -52,6 +52,8 @@ class ENGINE_EXPORT Viewport : public QWidget {
     QWindow *rhiWindow() { return m_rhiWindow; }
 
 public slots:
+    void onInProgressFlag(bool flag);
+
     void onCursorSet(const QCursor &cursor);
     void onCursorUnset();
 
diff --git a/engine/src/editor/viewport/viewport.cpp b/engine/src/editor/viewport/viewport.cpp
index 3da6b6b26..ee671a213 100644
--- a/engine/src/editor/viewport/viewport.cpp
+++ b/engine/src/editor/viewport/viewport.cpp
@@ -577,6 +577,8 @@ void Viewport::onDraw() {
         return;
     }
 
+    QString name = objectName();
+
     m_frameInProgress = true; // Recursive call protection
 
     if(m_world && m_liveUpdate) {
@@ -695,6 +697,10 @@ void Viewport::setOutlineEnabled(bool enabled) {
     m_outlinePass->setEnabled(enabled);
 }
 
+void Viewport::onInProgressFlag(bool flag) {
+    m_frameInProgress = flag;
+}
+
 void Viewport::addRenderTask(PipelineTask *task) {
     PipelineContext *pipelineContext = m_renderSystem->pipelineContext();
     pipelineContext->insertRenderTask(task, pipelineContext->renderTasks().front());
diff --git a/modules/editor/grapheditor/editor/graph/abstractnodegraph.cpp b/modules/editor/grapheditor/editor/graph/abstractnodegraph.cpp
index ad5c093b3..d8e2e1e2e 100644
--- a/modules/editor/grapheditor/editor/graph/abstractnodegraph.cpp
+++ b/modules/editor/grapheditor/editor/graph/abstractnodegraph.cpp
@@ -358,7 +358,10 @@ void AbstractNodeGraph::loadGraphV0(const QVariantMap &data) {
         GraphNode *node = nodeCreate(type, index);
         if(node) {
             node->setPosition(Vector2(n[gOldX].toInt(), n[gOldY].toInt()));
-            loadUserValues(node, n[gOldValues].toMap());
+
+            node->blockSignals(true);
+            node->loadUserData(n[gOldValues].toMap());
+            node->blockSignals(false);
         }
     }
 
@@ -394,49 +397,7 @@ void AbstractNodeGraph::loadGraphV11(const QDomElement &parent) {
                 QString type = nodeElement.attribute(gType);
                 GraphNode *node = nodeCreate(type, index);
                 if(node) {
-                    node->setPosition(Vector2(nodeElement.attribute(gX).toInt(),
-                                              nodeElement.attribute(gY).toInt()));
-
-                    QVariantMap values;
-                    QDomElement valueElement = nodeElement.firstChildElement("value");
-                    while(!valueElement.isNull()) {
-                        QString type = valueElement.attribute(gType);
-                        QString name = valueElement.attribute(gName);
-                        if(type == "bool") {
-                            values[name] = (valueElement.text() == "true");
-                        } else if(type == "int") {
-                            values[name] = valueElement.text().toInt();
-                        } else if(type == "float") {
-                            values[name] = valueElement.text().toFloat();
-                        } else if(type == "string") {
-                            values[name] = valueElement.text();
-                        } else if(type == "Vector2" || type == "Vector3" || type == "Vector4") {
-                            QVariantList list;
-                            list.push_back(type);
-                            for(auto &it : valueElement.text().split(", ")) {
-                                list.push_back(it.toFloat());
-                            }
-                            values[name] = list;
-                        } else if(type == "Template") {
-                            QVariantList list;
-                            list.push_back(type);
-                            for(auto &it : valueElement.text().split(", ")) {
-                                list.push_back(it);
-                            }
-                            values[name] = list;
-                        } else if(type == "Color") {
-                            QVariantList list;
-                            list.push_back(type);
-                            for(auto &it : valueElement.text().split(", ")) {
-                                list.push_back(it);
-                            }
-                            values[name] = list;
-                        }
-
-                        valueElement = valueElement.nextSiblingElement();
-                    }
-
-                    loadUserValues(node, values);
+                    node->fromXml(nodeElement);
                 }
 
                 nodeElement = nodeElement.nextSiblingElement();
@@ -474,58 +435,15 @@ void AbstractNodeGraph::onNodesLoaded() {
 void AbstractNodeGraph::saveGraph(QDomElement parent, QDomDocument xml) const {
     QDomElement graph = xml.createElement(gGraph);
 
-    QVariantList nodes;
     QVariantList links;
 
-    for(GraphNode *it : qAsConst(m_nodes)) {
-        nodes.push_back(saveNode(it));
-        links.append(saveLinks(it));
-    }
-
     QDomElement nodesElement = xml.createElement(gNodes);
-    for(auto &node : nodes) {
-        QDomElement nodeElement = xml.createElement(gNode);
+    for(auto &node : qAsConst(m_nodes)) {
+        QDomElement nodeElement = node->toXml(xml);
 
-        QVariantMap fields = node.toMap();
-        for(auto &key : fields.keys()) {
-            if(key.toLower() == gValues) {
-                QVariantMap values = fields.value(key).toMap();
-
-                for(auto &value : values.keys()) {
-                    QDomElement valueElement = xml.createElement("value");
-                    valueElement.setAttribute(gName, value);
-
-                    QVariant v = values.value(value);
-                    switch(v.type()) {
-                        case QVariant::List: {
-                            QVariantList list = v.toList();
-                            QString type = list.front().toString();
-                            valueElement.setAttribute(gType, type);
-                            list.pop_front();
-                            QString pack;
-                            for(auto &it : list) {
-                                pack += it.toString() + ", ";
-                            }
-                            pack.resize(pack.size() - 2);
-                            valueElement.appendChild(xml.createTextNode(pack));
-                        } break;
-                        default: {
-                            QString type = v.typeName();
-                            if(type == "QString") {
-                                type = "string";
-                            }
-                            valueElement.setAttribute(gType, type);
-                            valueElement.appendChild(xml.createTextNode(v.toString()));
-                        } break;
-                    }
-
-                    nodeElement.appendChild(valueElement);
-                }
-            } else {
-                nodeElement.setAttribute(key, fields.value(key).toString());
-            }
-        }
         nodesElement.appendChild(nodeElement);
+
+        links.append(saveLinks(node));
     }
 
     QDomElement linksElement = xml.createElement(gLinks);
@@ -546,20 +464,6 @@ void AbstractNodeGraph::saveGraph(QDomElement parent, QDomDocument xml) const {
     parent.appendChild(graph);
 }
 
-QVariantMap AbstractNodeGraph::saveNode(GraphNode *node) const {
-    QVariantMap result;
-    result[gType] = node->typeName().c_str();
-    result[gX] = (int)node->position().x;
-    result[gY] = (int)node->position().y;
-    result[gIndex] = AbstractNodeGraph::node(node);
-
-    QVariantMap values;
-    saveUserValues(node, values);
-    result[gValues] = values;
-
-    return result;
-}
-
 QVariantList AbstractNodeGraph::saveLinks(GraphNode *node) const {
     QVariantList result;
 
@@ -598,16 +502,6 @@ void AbstractNodeGraph::reportMessage(GraphNode *node, const QString &text) {
     emit messageReported(AbstractNodeGraph::node(node), text);
 }
 
-void AbstractNodeGraph::loadUserValues(GraphNode *node, const QVariantMap &values) {
-    node->blockSignals(true);
-    node->loadUserData(values);
-    node->blockSignals(false);
-}
-
-void AbstractNodeGraph::saveUserValues(GraphNode *node, QVariantMap &values) const {
-    node->saveUserData(values);
-}
-
 void AbstractNodeGraph::createLink(int sender, int oport, int receiver, int iport) {
     UndoManager::instance()->push(new CreateLink(sender, oport, receiver, iport, this));
 }
@@ -630,7 +524,7 @@ void AbstractNodeGraph::copyNodes(const std::vector<int32_t> &selection) {
         GraphNode *node = m_nodes.at(it);
 
         if(node) {
-            array.push_back(QJsonValue::fromVariant(saveNode(node)));
+            array.push_back(QJsonValue::fromVariant(node->toVariant()));
         }
     }
 
@@ -718,7 +612,7 @@ void DeleteNodes::redo() {
 
     QVariantList nodes;
     for(auto it : list) {
-        nodes.push_back(m_graph->saveNode(it));
+        nodes.push_back(it->toVariant());
         m_graph->nodeDelete(it);
     }
 
@@ -762,7 +656,10 @@ void PasteNodes::redo () {
         int deltaX = maxX - n[gX].toInt();
         int deltaY = maxY - n[gY].toInt();
         node->setPosition(Vector2(m_x + deltaX, m_y + deltaY));
-        m_graph->loadUserValues(node, n[gValues].toMap());
+
+        node->blockSignals(true);
+        node->loadUserData(n[gValues].toMap());
+        node->blockSignals(false);
 
         m_list.push_back(index);
     }
diff --git a/modules/editor/grapheditor/editor/graph/abstractnodegraph.h b/modules/editor/grapheditor/editor/graph/abstractnodegraph.h
index 64eba367e..89b08c603 100644
--- a/modules/editor/grapheditor/editor/graph/abstractnodegraph.h
+++ b/modules/editor/grapheditor/editor/graph/abstractnodegraph.h
@@ -85,10 +85,9 @@ class NODEGRAPH_EXPORT AbstractNodeGraph : public QObject {
 
     void messageReported(int node, const QString &text);
 
-protected:
-    virtual void loadUserValues(GraphNode *node, const QVariantMap &values);
-    virtual void saveUserValues(GraphNode *node, QVariantMap &values) const;
+    void menuVisible(bool visible);
 
+protected:
     QVariantMap loadXmlMap(const QDomElement &parent);
     QVariantList loadXmlList(const QDomElement &parent);
 
@@ -99,7 +98,6 @@ class NODEGRAPH_EXPORT AbstractNodeGraph : public QObject {
 
     virtual void saveGraph(QDomElement parent, QDomDocument xml) const;
 
-    QVariantMap saveNode(GraphNode *node) const;
     QVariantList saveLinks(GraphNode *node) const;
 
     friend class PasteNodes;
diff --git a/modules/editor/grapheditor/editor/graph/graphnode.cpp b/modules/editor/grapheditor/editor/graph/graphnode.cpp
index f03570e0d..598dc5131 100644
--- a/modules/editor/grapheditor/editor/graph/graphnode.cpp
+++ b/modules/editor/grapheditor/editor/graph/graphnode.cpp
@@ -1,10 +1,13 @@
 #include "graphnode.h"
 
 #include <QMetaProperty>
+#include <QDomElement>
 
 #include <components/recttransform.h>
 
 #include <editor/assetconverter.h>
+
+#include "abstractnodegraph.h"
 #include "graphwidgets/nodewidget.h"
 
 Q_DECLARE_METATYPE(Vector2)
@@ -13,6 +16,18 @@ Q_DECLARE_METATYPE(Vector4)
 
 namespace  {
     const char *gNodeWidget("NodeWidget");
+
+    const char *gType("type");
+    const char *gName("name");
+
+    const char *gNode("node");
+    const char *gValue("value");
+
+    const char *gValues("values");
+
+    const char *gX("x");
+    const char *gY("y");
+    const char *gIndex("index");
 }
 
 GraphNode::GraphNode() :
@@ -113,6 +128,152 @@ void GraphNode::onNameChanged() {
     }
 }
 
+// to be deleted in eoy of 2025
+QVariantMap GraphNode::toVariant() {
+    QVariantMap result;
+    result[gType] = m_typeName.c_str();
+    result[gX] = (int)m_pos.x;
+    result[gY] = (int)m_pos.y;
+    result[gIndex] = m_graph->node(this);
+
+    QVariantMap values;
+    saveUserData(values);
+    result[gValues] = values;
+
+    return result;
+}
+
+QDomElement GraphNode::fromVariant(const QVariant &value, QDomDocument &xml) {
+    QDomElement valueElement = xml.createElement(gValue);
+
+    switch(value.userType()) {
+        case QMetaType::QColor: {
+            valueElement.setAttribute(gType, "Color");
+
+            QColor col = value.value<QColor>();
+            valueElement.appendChild(xml.createTextNode(QString::number(col.red()) + ", " + col.green() + ", " + col.blue() + ", " + col.alpha()));
+        } break;
+        default: {
+            if(value.canConvert<Template>()) {
+                valueElement.setAttribute(gType, "Template");
+
+                Template tmp = value.value<Template>();
+                valueElement.appendChild(xml.createTextNode(tmp.path + ", " + tmp.type));
+            } else if(value.canConvert<Vector2>()) {
+                valueElement.setAttribute(gType, "Vector2");
+
+                Vector2 vec = value.value<Vector2>();
+                valueElement.appendChild(xml.createTextNode(QString::number(vec.x) + ", " + vec.y));
+            } else if(value.canConvert<Vector3>()) {
+                valueElement.setAttribute(gType, "Vector3");
+
+                Vector3 vec = value.value<Vector3>();
+                valueElement.appendChild(xml.createTextNode(QString::number(vec.x) + ", " + vec.y + ", " + vec.z));
+            } else if(value.canConvert<Vector4>()) {
+                valueElement.setAttribute(gType, "Vector3");
+
+                Vector4 vec = value.value<Vector4>();
+                valueElement.appendChild(xml.createTextNode(QString::number(vec.x) + ", " + vec.y + ", " + vec.z + ", " + vec.w));
+            } else {
+                QString type = value.typeName();
+                if(type == "QString") {
+                    type = "string";
+                }
+                valueElement.setAttribute(gType, type);
+                valueElement.appendChild(xml.createTextNode(value.toString()));
+            }
+        } break;
+    }
+
+    return valueElement;
+}
+
+QVariant GraphNode::toVariant(const QString &value, const QString &type) {
+    QVariant result;
+
+    if(type == "bool") {
+        result = (value == "true");
+    } else if(type == "int") {
+        result = value.toInt();
+    } else if(type == "float") {
+        result = value.toFloat();
+    } else if(type == "string") {
+        result = value;
+    } else if(type == "Vector2") {
+        QStringList list = value.split(", ");
+
+        result = QVariant::fromValue(Vector2(list.at(0).toFloat(),
+                                             list.at(1).toFloat()));
+    } else if(type == "Vector3") {
+        QStringList list = value.split(", ");
+
+        result = QVariant::fromValue(Vector3(list.at(0).toFloat(),
+                                             list.at(1).toFloat(),
+                                             list.at(2).toFloat()));
+    } else if(type == "Vector4") {
+        QStringList list = value.split(", ");
+
+        result = QVariant::fromValue(Vector4(list.at(0).toFloat(),
+                                             list.at(1).toFloat(),
+                                             list.at(2).toFloat(),
+                                             list.at(3).toFloat()));
+    } else if(type == "Template") {
+        QStringList list = value.split(", ");
+
+        result = QVariant::fromValue(Template(list.at(0), list.at(1).toUInt()));
+    } else if(type == "Color") {
+        QStringList list = value.split(", ");
+
+        result = QColor(list.at(0).toInt(), list.at(1).toInt(),
+                        list.at(2).toInt(), list.at(3).toInt());
+    }
+
+    return result;
+}
+
+QDomElement GraphNode::toXml(QDomDocument &xml) {
+    QDomElement node = xml.createElement(gNode);
+
+    node.setAttribute(gX, (int)m_pos.x);
+    node.setAttribute(gY, (int)m_pos.y);
+    node.setAttribute(gIndex, m_graph->node(this));
+    node.setAttribute(gType, m_typeName.c_str());
+
+    const QMetaObject *meta = metaObject();
+    for(int i = 0; i < meta->propertyCount(); i++) {
+        QMetaProperty property = meta->property(i);
+        if(property.isUser(this)) {
+            QDomElement valueElement = fromVariant(property.read(this), xml);
+            valueElement.setAttribute(gName, property.name());
+
+            node.appendChild(valueElement);
+        }
+    }
+
+    return node;
+}
+
+void GraphNode::fromXml(const QDomElement &element) {
+    setPosition(Vector2(element.attribute(gX).toInt(),
+                        element.attribute(gY).toInt()));
+
+    blockSignals(true);
+
+    QVariantMap values;
+    QDomElement valueElement = element.firstChildElement(gValue);
+    while(!valueElement.isNull()) {
+        QString type = valueElement.attribute(gType);
+        QString name = valueElement.attribute(gName);
+
+        setProperty(qPrintable(name), toVariant(valueElement.text(), type));
+
+        valueElement = valueElement.nextSiblingElement();
+    }
+
+    blockSignals(false);
+}
+
+// to be deleted in eoy of 2025
 void GraphNode::saveUserData(QVariantMap &data) {
     const QMetaObject *meta = metaObject();
     for(int i = 0; i < meta->propertyCount(); i++) {
@@ -171,6 +332,7 @@ void GraphNode::saveUserData(QVariantMap &data) {
     }
 }
 
+// to be deleted in eoy of 2025
 void GraphNode::loadUserData(const QVariantMap &data) {
     for(QString key : data.keys()) {
         if(static_cast<QMetaType::Type>(data[key].type()) == QMetaType::QVariantList) {
@@ -179,17 +341,17 @@ void GraphNode::loadUserData(const QVariantMap &data) {
             QString type = array.first().toString();
             if(type == "Color") {
                 setProperty(qPrintable(key), QColor(array.at(1).toInt(), array.at(2).toInt(),
-                                                    array.at(3).toInt(), array.at(4).toInt()));
+                                                    array.at(3).toInt(), array.at(4).toInt() ));
             } else if(type == "Template") {
                 setProperty(qPrintable(key), QVariant::fromValue(Template(array.at(1).toString(),
-                                                                          array.at(2).toUInt())));
+                                                                          array.at(2).toUInt() )));
             } else if(type == "Vector2") {
                 setProperty(qPrintable(key), QVariant::fromValue(Vector2(array.at(1).toFloat(),
-                                                                         array.at(2).toFloat())));
+                                                                         array.at(2).toFloat() )));
             } else if(type == "Vector3") {
                 setProperty(qPrintable(key), QVariant::fromValue(Vector3(array.at(1).toFloat(),
                                                                          array.at(2).toFloat(),
-                                                                         array.at(3).toFloat())));
+                                                                         array.at(3).toFloat() )));
             } else if(type == "Vector4") {
                 setProperty(qPrintable(key), QVariant::fromValue(Vector4(array.at(1).toFloat(),
                                                                          array.at(2).toFloat(),
diff --git a/modules/editor/grapheditor/editor/graph/graphnode.h b/modules/editor/grapheditor/editor/graph/graphnode.h
index 52793ba31..b34b4e1a9 100644
--- a/modules/editor/grapheditor/editor/graph/graphnode.h
+++ b/modules/editor/grapheditor/editor/graph/graphnode.h
@@ -20,6 +20,9 @@ class AbstractNodeGraph;
 class GraphNode;
 class Widget;
 
+class QDomElement;
+class QDomDocument;
+
 class NODEGRAPH_EXPORT NodePort {
 public:
     explicit NodePort(GraphNode *node, bool out, uint32_t type, int32_t pos, std::string name, const Vector4 &color, QVariant var = QVariant()) :
@@ -90,6 +93,11 @@ class NODEGRAPH_EXPORT GraphNode : public QObject {
 
     std::vector<NodePort> &ports();
 
+    virtual QVariantMap toVariant();
+
+    virtual QDomElement toXml(QDomDocument &xml);
+    virtual void fromXml(const QDomElement &element);
+
     virtual void saveUserData(QVariantMap &data);
     virtual void loadUserData(const QVariantMap &data);
 
@@ -97,6 +105,9 @@ class NODEGRAPH_EXPORT GraphNode : public QObject {
     void updated();
 
 protected:
+    QVariant toVariant(const QString &value, const QString &type);
+    QDomElement fromVariant(const QVariant &value, QDomDocument &xml);
+
     void onNameChanged();
 
 protected:
diff --git a/modules/editor/grapheditor/editor/graph/graphview.cpp b/modules/editor/grapheditor/editor/graph/graphview.cpp
index 78e7ba39e..46e1fac92 100644
--- a/modules/editor/grapheditor/editor/graph/graphview.cpp
+++ b/modules/editor/grapheditor/editor/graph/graphview.cpp
@@ -17,6 +17,8 @@
 #include <components/camera.h>
 #include <components/recttransform.h>
 
+#include <pipelinecontext.h>
+#include <pipelinetask.h>
 #include <systems/rendersystem.h>
 
 #include <editor/viewport/cameracontroller.h>
@@ -136,6 +138,7 @@ void GraphView::setGraph(AbstractNodeGraph *graph) {
 
     connect(graph, &AbstractNodeGraph::graphUpdated, this, &GraphView::onGraphUpdated);
     connect(graph, &AbstractNodeGraph::graphLoaded, this, &GraphView::onGraphLoaded);
+    connect(graph, &AbstractNodeGraph::menuVisible, this, &GraphView::onInProgressFlag);
 
     // Create menu
     for(auto &it : graph->nodeList()) {
@@ -330,6 +333,7 @@ void GraphView::reselect() {
 }
 
 void GraphView::showMenu() {
+    onInProgressFlag(true);
     if(m_createMenu->exec(QCursor::pos()) == nullptr) {
         m_linksRender->setCreationLink(nullptr);
     }
@@ -369,4 +373,5 @@ void GraphView::onComponentSelected() {
     }
 
     m_createMenu->hide();
+    onInProgressFlag(false);
 }
diff --git a/modules/editor/motiontools/converter/animationcontrollergraph.cpp b/modules/editor/motiontools/converter/animationcontrollergraph.cpp
index 8a4338019..e8a516c96 100644
--- a/modules/editor/motiontools/converter/animationcontrollergraph.cpp
+++ b/modules/editor/motiontools/converter/animationcontrollergraph.cpp
@@ -8,9 +8,6 @@
 
 namespace {
     const char *gEntry("Entry");
-    const char *gName("Name");
-    const char *gClip("Clip");
-    const char *gLoop("Loop");
 
     const char *gMachine("Machine");
 
@@ -93,6 +90,7 @@ GraphNode *AnimationControllerGraph::nodeCreate(const QString &path, int &index)
     }
 
     connect(node, &BaseState::updated, this, &AnimationControllerGraph::graphUpdated);
+
     node->setObjectName(path);
     node->setGraph(this);
     node->setTypeName(qPrintable(path));
@@ -126,29 +124,6 @@ AnimationControllerGraph::Link *AnimationControllerGraph::linkCreate(GraphNode *
     return AbstractNodeGraph::linkCreate(sender, oport, receiver, iport);
 }
 
-void AnimationControllerGraph::loadUserValues(GraphNode *node, const QVariantMap &values) {
-    node->setObjectName(values[gName].toString());
-
-    BaseState *ptr = dynamic_cast<BaseState *>(node);
-    if(ptr) {
-        Template tpl;
-        tpl.path = values[gClip].toString();
-        tpl.type = ptr->clip().type;
-        ptr->setClip(tpl);
-        ptr->setLoop(values[gLoop].toBool());
-    }
-}
-
-void AnimationControllerGraph::saveUserValues(GraphNode *node, QVariantMap &values) const {
-    values[gName] = node->objectName();
-
-    BaseState *state = dynamic_cast<BaseState *>(node);
-    if(state) {
-        values[gClip] = state->clip().path;
-        values[gLoop] = state->loop();
-    }
-}
-
 Variant AnimationControllerGraph::object() const {
     VariantList result;
 
diff --git a/modules/editor/motiontools/converter/animationcontrollergraph.h b/modules/editor/motiontools/converter/animationcontrollergraph.h
index b839e934e..5bb712859 100644
--- a/modules/editor/motiontools/converter/animationcontrollergraph.h
+++ b/modules/editor/motiontools/converter/animationcontrollergraph.h
@@ -22,9 +22,6 @@ class AnimationControllerGraph : public AbstractNodeGraph {
     GraphNode *nodeCreate(const QString &path, int &index) override;
     Link *linkCreate(GraphNode *sender, NodePort *oport, GraphNode *receiver, NodePort *iport) override;
 
-    void loadUserValues(GraphNode *node, const QVariantMap &values) override;
-    void saveUserValues(GraphNode *node, QVariantMap &values) const override;
-
 protected:
     Variant data() const;
 
diff --git a/modules/editor/motiontools/converter/basestate.cpp b/modules/editor/motiontools/converter/basestate.cpp
index e276e9a45..41da3e8d6 100644
--- a/modules/editor/motiontools/converter/basestate.cpp
+++ b/modules/editor/motiontools/converter/basestate.cpp
@@ -2,6 +2,12 @@
 
 #include <resources/animationclip.h>
 
+namespace {
+    const char *gName("Name");
+    const char *gClip("Clip");
+    const char *gLoop("Loop");
+}
+
 BaseState::BaseState() :
         m_path(Template("", MetaType::type<AnimationClip *>())),
         m_loop(false) {
@@ -40,3 +46,20 @@ Vector2 BaseState::defaultSize() const {
 Vector4 BaseState::color() const {
     return Vector4(0.141f, 0.384f, 0.514f, 1.0f);
 }
+
+void BaseState::saveUserData(QVariantMap &data) {
+    data[gName] = objectName();
+
+    data[gClip] = clip().path;
+    data[gLoop] = loop();
+}
+
+void BaseState::loadUserData(const QVariantMap &data) {
+    setObjectName(data[gName].toString());
+
+    Template tpl;
+    tpl.path = data[gClip].toString();
+    tpl.type = clip().type;
+    setClip(tpl);
+    setLoop(data[gLoop].toBool());
+}
diff --git a/modules/editor/motiontools/converter/basestate.h b/modules/editor/motiontools/converter/basestate.h
index bfba69c0f..c0e4305b2 100644
--- a/modules/editor/motiontools/converter/basestate.h
+++ b/modules/editor/motiontools/converter/basestate.h
@@ -28,7 +28,11 @@ class BaseState : public StateNode {
     Vector2 defaultSize() const override;
     Vector4 color() const override;
 
-public:
+private:
+    void saveUserData(QVariantMap &data) override;
+    void loadUserData(const QVariantMap &data) override;
+
+private:
     Template m_path;
 
     bool m_loop;