WIP multiedit

Source/AtomicEditor/Editors/SceneEditor3D/Gizmo3D.cpp

@@ -175,10 +175,7 @@ void Gizmo3D::Use()
     {
         if (dragging_)
         {
-            VariantMap eventData;
-            eventData[SceneEditSerializable::P_SERIALIZABLE] = editNodes[0];
-            eventData[SceneEditSerializable::P_OPERATION] = 1;
-            scene_->SendEvent(E_SCENEEDITSERIALIZABLE, eventData);
+            scene_->SendEvent(E_SCENEEDITEND);
             dragging_ = false;
         }
 

Source/AtomicEditor/Editors/SceneEditor3D/SceneEditHistory.cpp

@@ -1,25 +1,23 @@
 
-#include <Atomic/IO/Log.h>
-#include <Atomic/Core/Timer.h>
-#include <Atomic/Scene/Scene.h>
-#include <Atomic/Scene/Component.h>
-#include <Atomic/Scene/SceneEvents.h>
+#include "SceneEditor3D.h"
 
-#include "../../EditorMode/AEEditorEvents.h"
-
-#include "SceneEditOps.h"
 #include "SceneEditor3DEvents.h"
+#include "SceneEditOp.h"
+#include "SceneSelection.h"
 #include "SceneEditHistory.h"
 
 namespace AtomicEditor
 {
 
-SceneEditHistory::SceneEditHistory(Context* context, Scene* scene) :
-    Object(context),
-    scene_(scene)
+SceneEditHistory::SceneEditHistory(Context* context, SceneEditor3D* sceneEditor) : Object(context),
+    sceneEditor_(sceneEditor),
+    curSelEditOp_(0)
 {
-    SubscribeToEvent(scene_, E_SCENEEDITSERIALIZABLE, HANDLER(SceneEditHistory, HandleSceneEditSerializable));    
-    SubscribeToEvent(scene_, E_SCENEEDITNODEADDEDREMOVED, HANDLER(SceneEditHistory, HandleSceneEditNodeAddedRemoved));
+    SubscribeToEvent(sceneEditor_->GetScene(), E_SCENENODESELECTED, HANDLER(SceneEditHistory, HandleSceneNodeSelected));
+
+    SubscribeToEvent(sceneEditor_->GetScene(), E_SCENEEDITBEGIN, HANDLER(SceneEditHistory, HandleSceneEditBegin));
+    SubscribeToEvent(sceneEditor_->GetScene(), E_SCENEEDITEND, HANDLER(SceneEditHistory, HandleSceneEditEnd));
+
 }
 
 SceneEditHistory::~SceneEditHistory()
@@ -27,84 +25,62 @@ SceneEditHistory::~SceneEditHistory()
 
 }
 
-void SceneEditHistory::AddUndoOp(SceneEditOp* op)
+void SceneEditHistory::HandleSceneEditBegin(StringHash eventType, VariantMap& eventData)
 {
-    undoHistory_.Push(op);
+    assert(0);
+    BeginSelectionEdit();
+}
 
-    scene_->SendEvent(E_SCENEEDITSCENEMODIFIED);
+void SceneEditHistory::HandleSceneEditEnd(StringHash eventType, VariantMap& eventData)
+{
+    EndSelectionEdit();
+}
 
-    for (unsigned i = 0; i < redoHistory_.Size(); i++)
-    {
-        delete redoHistory_[i];
-    }
+void SceneEditHistory::BeginSelectionEdit()
+{
+    assert(!curSelEditOp_);
 
-    redoHistory_.Clear();
+    Vector<SharedPtr<Node>>& nodes = sceneEditor_->GetSelection()->GetNodes();
+    if (!nodes.Size())
+        return;
+
+    curSelEditOp_ = new SelectionEditOp(nodes);
 }
 
-void SceneEditHistory::HandleSceneEditSerializableUndoRedo(StringHash eventType, VariantMap& eventData)
+void SceneEditHistory::AddUndoOp(SelectionEditOp* op)
 {
-    SharedPtr<Serializable> serial(static_cast<Serializable*>(eventData[SceneEditSerializableUndoRedo::P_SERIALIZABLE].GetPtr()));
+    undoHistory_.Push(op);
+
+    sceneEditor_->GetScene()->SendEvent(E_SCENEEDITSCENEMODIFIED);
 
-    if (editStates_.Contains(serial))
+    for (unsigned i = 0; i < redoHistory_.Size(); i++)
     {
-        scene_->SendEvent(E_SCENEEDITSCENEMODIFIED);
-        editStates_[serial] = eventData[SceneEditSerializableUndoRedo::P_STATE].GetVectorBuffer();
+        delete redoHistory_[i];
     }
-}
 
-void SceneEditHistory::HandleSceneEditNodeAddedRemoved(StringHash eventType, VariantMap& eventData)
-{
-    bool added = eventData[SceneEditNodeAddedRemoved::P_ADDED].GetBool();
-    Node* node = static_cast<Node*>(eventData[SceneEditNodeAddedRemoved::P_NODE].GetPtr());
-    NodeAddedRemovedOp* op = new NodeAddedRemovedOp(node, added);
-    AddUndoOp(op);
+    redoHistory_.Clear();
 }
 
-void SceneEditHistory::HandleSceneEditSerializable(StringHash eventType, VariantMap& eventData)
+void SceneEditHistory::EndSelectionEdit()
 {
+    if (!curSelEditOp_)
+        return;
 
-    int editop = eventData[SceneEditSerializable::P_OPERATION].GetInt();
-
-    SharedPtr<Serializable> serial(static_cast<Serializable*>(eventData[SceneEditSerializable::P_SERIALIZABLE].GetPtr()));
+    curSelEditOp_->RegisterEdit();
 
-    if (editop == 0) // begin
+    if (curSelEditOp_->Commit())
     {
-        if (editStates_.Contains(serial))
-            return;
-
-        SubscribeToEvent(serial, E_SCENEEDITSERIALIZABLEUNDOREDO, HANDLER(SceneEditHistory, HandleSceneEditSerializableUndoRedo));
-        VectorBuffer& vb = editStates_[serial];
-        vb.Clear();
-        serial->Serializable::Save(vb);
-        vb.Seek(0);
+        AddUndoOp(curSelEditOp_);
     }
-    else if (editop == 1) // change
+    else
     {
-        if (!editStates_.Contains(serial))
-            return;
-
-        VectorBuffer& beginState = editStates_[serial];
-        VectorBuffer deltaState;
-        serial->Serializable::Save(deltaState);
-        deltaState.Seek(0);
-
-        if (beginState.GetSize() != deltaState.GetSize() ||
-                memcmp(beginState.GetData(), deltaState.GetData(), deltaState.GetSize()))
-        {
-            SerializableEditOp* op = new SerializableEditOp(serial, beginState, deltaState);
-            AddUndoOp(op);
-            editStates_[serial] = deltaState;
-        }
+        delete curSelEditOp_;
     }
-    else if (editop == 2) // end
-    {
-        if (!editStates_.Contains(serial))
-            return;
 
-        UnsubscribeFromEvent(serial, E_SCENEEDITSERIALIZABLEUNDOREDO);
+    curSelEditOp_ = 0;
+
+    BeginSelectionEdit();
 
-        editStates_.Erase(serial);
-    }
 }
 
 void SceneEditHistory::Undo()
@@ -112,13 +88,21 @@ void SceneEditHistory::Undo()
     if (!undoHistory_.Size())
         return;
 
-    SceneEditOp* op = undoHistory_.Back();
+    SelectionEditOp* op = undoHistory_.Back();
     undoHistory_.Pop();
 
     op->Undo();
 
     redoHistory_.Push(op);
 
+    if (curSelEditOp_)
+    {
+        delete curSelEditOp_;
+        curSelEditOp_ = 0;
+    }
+
+    BeginSelectionEdit();
+
 }
 
 void SceneEditHistory::Redo()
@@ -126,13 +110,35 @@ void SceneEditHistory::Redo()
     if (!redoHistory_.Size())
         return;
 
-    SceneEditOp* op = redoHistory_.Back();
+    SelectionEditOp* op = redoHistory_.Back();
     redoHistory_.Pop();
 
     op->Redo();
 
     undoHistory_.Push(op);
 
+    if (curSelEditOp_)
+    {
+        delete curSelEditOp_;
+        curSelEditOp_ = 0;
+    }
+
+    BeginSelectionEdit();
+
+
 }
 
+
+void SceneEditHistory::HandleSceneNodeSelected(StringHash eventType, VariantMap& eventData)
+{
+    if (curSelEditOp_)
+    {
+        EndSelectionEdit();
+    }
+    else
+        BeginSelectionEdit();
 }
+
+
+}
+

Source/AtomicEditor/Editors/SceneEditor3D/SceneEditHistory.h

@@ -10,47 +10,44 @@
 #include <Atomic/Core/Object.h>
 
 using namespace Atomic;
-namespace Atomic
-{
-
-class Serializable;
-class Scene;
-
-}
 
 namespace AtomicEditor
 {
 
-class SceneEditOp;
+class SceneEditor3D;
+class SelectionEditOp;
 
-/// Simple scene history to support undo/redo via snapshots of scene state
 class SceneEditHistory: public Object
 {
     OBJECT(SceneEditHistory);
 
 public:
 
-    SceneEditHistory(Context* context, Scene* scene);
+    SceneEditHistory(Context* context, SceneEditor3D* sceneEditor);
     virtual ~SceneEditHistory();
 
+    void BeginSelectionEdit();
+    void EndSelectionEdit();
+
     void Undo();
     void Redo();
 
 private:
 
-    void HandleSceneEditSerializable(StringHash eventType, VariantMap& eventData);
-    void HandleSceneEditSerializableUndoRedo(StringHash eventType, VariantMap& eventData);
-    void HandleSceneEditNodeAddedRemoved(StringHash eventType, VariantMap& eventData);
+    void HandleSceneNodeSelected(StringHash eventType, VariantMap& eventData);
+    void HandleSceneEditBegin(StringHash eventType, VariantMap& eventData);
+    void HandleSceneEditEnd(StringHash eventType, VariantMap& eventData);
 
-    void AddUndoOp(SceneEditOp* op);
+    void AddUndoOp(SelectionEditOp* op);
 
-    WeakPtr<Scene> scene_;
+    SharedPtr<SceneEditor3D> sceneEditor_;
 
-    HashMap< SharedPtr<Serializable>, VectorBuffer > editStates_;
+    SelectionEditOp* curSelEditOp_;
 
-    PODVector<SceneEditOp*> undoHistory_;
-    PODVector<SceneEditOp*> redoHistory_;
+    PODVector<SelectionEditOp*> undoHistory_;
+    PODVector<SelectionEditOp*> redoHistory_;
 
 };
 
 }
+

Source/AtomicEditor/Editors/SceneEditor3D/SceneEditOp.cpp

@@ -0,0 +1,227 @@
+
+#include <Atomic/IO/Log.h>
+#include <Atomic/Scene/Node.h>
+#include <Atomic/Scene/Component.h>
+
+#include "SceneEditOp.h"
+
+namespace AtomicEditor
+{
+
+SelectionEditOp::SelectionEditOp(Vector<SharedPtr<Node>>& nodes) : SceneEditOp(SCENEEDIT_SELECTION)
+{
+    // Generate initial snapshot
+    for (unsigned i = 0; i < nodes.Size(); i++)
+    {
+        Node* node = nodes[i];
+
+        if (node->IsTemporary())
+            continue;
+
+        EditNode* enode = new EditNode();
+        enode->node_ = node;
+        enode->parentBegin_ = enode->parentEnd_ = node->GetParent();
+        node->Serializable::Save(enode->stateBegin_);
+        enode->stateBegin_.Seek(0);
+        enode->stateEnd_ = enode->stateBegin_;
+
+        const Vector<SharedPtr<Component>>& components = node->GetComponents();
+
+        for (unsigned j = 0; j < components.Size(); j++)
+        {
+            Component* component = components[j];
+
+            if (component->IsTemporary())
+                continue;
+
+            EditComponent* ecomponent = new EditComponent();
+            ecomponent->component_ = component;
+            ecomponent->nodeBegin_ = ecomponent->nodeEnd_ = node;
+            component->Serializable::Save(ecomponent->stateBegin_);
+            ecomponent->stateBegin_.Seek(0);
+            ecomponent->stateEnd_ = ecomponent->stateBegin_;
+
+            enode->components_.Push(ecomponent);
+        }
+
+        editNodes_.Push(enode);
+
+    }
+}
+
+SelectionEditOp::~SelectionEditOp()
+{
+
+    for (unsigned i = 0; i < editNodes_.Size(); i++)
+    {
+        EditNode* enode = editNodes_[i];
+        for (unsigned j = 0; j < enode->components_.Size(); j++)
+            delete enode->components_[j];
+        delete enode;
+    }
+
+}
+
+bool SelectionEditOp::Commit()
+{
+    // See if any nodes, components have been edited
+    for (unsigned i = 0; i < editNodes_.Size(); i++)
+    {
+        EditNode* enode = editNodes_[i];
+
+        if (enode->parentBegin_ != enode->parentEnd_)
+            return true;
+
+        if (enode->stateBegin_.GetSize() != enode->stateEnd_.GetSize() ||
+                memcmp(enode->stateBegin_.GetData(), enode->stateEnd_.GetData(), enode->stateBegin_.GetSize()))
+        {
+            return true;
+        }
+
+        for (unsigned j = 0; j < enode->components_.Size(); j++)
+        {
+            EditComponent* ecomponent = enode->components_[j];
+
+            if (ecomponent->stateBegin_.GetSize() != ecomponent->stateEnd_.GetSize() ||
+                    memcmp(ecomponent->stateBegin_.GetData(), ecomponent->stateEnd_.GetData(), ecomponent->stateBegin_.GetSize()))
+            {
+                return true;
+            }
+        }
+
+    }
+
+    return false;
+
+}
+
+void SelectionEditOp::RegisterEdit()
+{
+    for (unsigned i = 0; i < editNodes_.Size(); i++)
+    {
+        EditNode* enode = editNodes_[i];
+        enode->stateEnd_.Clear();
+        enode->node_->Serializable::Save(enode->stateEnd_);
+        enode->stateEnd_.Seek(0);
+        enode->parentEnd_ = enode->node_->GetParent();
+
+        for (unsigned j = 0; j < enode->components_.Size(); j++)
+        {
+            EditComponent* ecomponent = enode->components_[j];
+            ecomponent->stateEnd_.Clear();
+            ecomponent->component_->Serializable::Save(ecomponent->stateEnd_);
+            ecomponent->stateEnd_.Seek(0);
+            ecomponent->nodeEnd_ = ecomponent->component_->GetNode();
+        }
+
+    }
+
+}
+
+bool SelectionEditOp::Undo()
+{
+
+    for (unsigned i = 0; i < editNodes_.Size(); i++)
+    {
+        EditNode* enode = editNodes_[i];
+
+        Node* node = enode->node_;
+
+        if (!node->Serializable::Load(enode->stateBegin_))
+        {
+            LOGERRORF("Unable to Undo node serializable");
+            return false;
+        }
+
+        enode->stateBegin_.Seek(0);
+
+        if (node->GetParent() != enode->parentBegin_)
+        {
+            node->Remove();
+            if(enode->parentBegin_.NotNull())
+                enode->parentBegin_->AddChild(node);
+        }
+
+        for (unsigned j = 0; j < enode->components_.Size(); j++)
+        {
+            EditComponent* ecomponent = enode->components_[j];
+            Component* component = ecomponent->component_;
+
+            if (!component->Serializable::Load(ecomponent->stateBegin_))
+            {
+                LOGERRORF("Unable to Undo component serializable");
+                return false;
+            }
+
+            ecomponent->stateBegin_.Seek(0);
+
+            if (component->GetNode() != ecomponent->nodeBegin_)
+            {
+                component->Remove();
+                if (ecomponent->nodeBegin_.NotNull())
+                    ecomponent->nodeBegin_->AddComponent(component, 0, REPLICATED);
+            }
+
+        }
+
+    }
+
+    return true;
+}
+
+bool SelectionEditOp::Redo()
+{
+    for (unsigned i = 0; i < editNodes_.Size(); i++)
+    {
+        EditNode* enode = editNodes_[i];
+
+        Node* node = enode->node_;
+
+        if (!node->Serializable::Load(enode->stateEnd_))
+        {
+            LOGERRORF("Unable to Redo node serializable");
+            return false;
+        }
+
+        enode->stateEnd_.Seek(0);
+
+        if (node->GetParent() != enode->parentEnd_)
+        {
+            node->Remove();
+            if(enode->parentEnd_.NotNull())
+                enode->parentEnd_->AddChild(node);
+        }
+
+        for (unsigned j = 0; j < enode->components_.Size(); j++)
+        {
+            EditComponent* ecomponent = enode->components_[j];
+            Component* component = ecomponent->component_;
+
+            if (!component->Serializable::Load(ecomponent->stateEnd_))
+            {
+                LOGERRORF("Unable to Redo component serializable");
+                return false;
+            }
+
+            ecomponent->stateEnd_.Seek(0);
+
+            if (component->GetNode() != ecomponent->nodeEnd_)
+            {
+                component->Remove();
+                if (ecomponent->nodeEnd_.NotNull())
+                {
+                    ecomponent->nodeEnd_->AddComponent(component, 0, REPLICATED);
+                }
+
+            }
+
+        }
+
+    }
+
+    return true;
+}
+
+
+}
+

Source/AtomicEditor/Editors/SceneEditor3D/SceneEditOp.h

@@ -0,0 +1,86 @@
+//
+// Copyright (c) 2014-2015, THUNDERBEAST GAMES LLC All rights reserved
+// LICENSE: Atomic Game Engine Editor and Tools EULA
+// Please see LICENSE_ATOMIC_EDITOR_AND_TOOLS.md in repository root for
+// license information: https://github.com/AtomicGameEngine/AtomicGameEngine
+//
+
+#pragma once
+
+#include <Atomic/Core/Object.h>
+#include <Atomic/IO/VectorBuffer.h>
+
+namespace Atomic
+{
+class Node;
+class Component;
+}
+
+using namespace Atomic;
+
+namespace AtomicEditor
+{
+
+enum SceneEditType
+{
+    SCENEEDIT_UNKNOWN = 0,
+    SCENEEDIT_SELECTION
+};
+
+class SceneEditOp
+{
+
+public:
+
+    SceneEditOp(SceneEditType type) { type_ = type; }
+    virtual ~SceneEditOp() { }
+
+    virtual bool Undo() = 0;
+    virtual bool Redo() = 0;
+
+    SceneEditType type_;
+
+};
+
+class SelectionEditOp : public SceneEditOp
+{
+
+public:
+
+    SelectionEditOp(Vector<SharedPtr<Node>>& nodes);
+    ~SelectionEditOp();
+
+    bool Undo();
+    bool Redo();
+
+    void RegisterEdit();
+
+    bool Commit();
+
+private:
+
+    struct EditComponent
+    {
+        SharedPtr<Component> component_;
+        SharedPtr<Node> nodeBegin_;
+        SharedPtr<Node> nodeEnd_;
+        VectorBuffer stateBegin_;
+        VectorBuffer stateEnd_;
+    };
+
+    struct EditNode
+    {
+        SharedPtr<Node> node_;
+        SharedPtr<Node> parentBegin_;
+        SharedPtr<Node> parentEnd_;
+        VectorBuffer stateBegin_;
+        VectorBuffer stateEnd_;
+        PODVector<EditComponent*> components_;
+    };
+
+    PODVector<EditNode*> editNodes_;
+
+};
+
+}
+

Source/AtomicEditor/Editors/SceneEditor3D/SceneEditOps.cpp

@@ -1,109 +0,0 @@
-
-#include <Atomic/IO/Log.h>
-#include <Atomic/Scene/Node.h>
-#include <Atomic/Scene/Component.h>
-
-#include "SceneEditOps.h"
-#include "SceneEditor3DEvents.h"
-
-namespace AtomicEditor
-{
-
-
-NodeEditOp::NodeEditOp(Node* node)
-{
-    node_ = node;
-
-    // parent at the time of the operation
-    parent_ = node->GetParent();
-}
-
-NodeAddedRemovedOp::NodeAddedRemovedOp(Node* node, bool added) : NodeEditOp(node),
-    added_(added)
-{
-    type_ = SCENEEDIT_NODE_ADDED_REMOVED;
-}
-
-bool NodeAddedRemovedOp::Undo()
-{
-    if (added_)
-    {
-        node_->Remove();
-    }
-    else
-    {
-        parent_->AddChild(node_);
-    }
-
-    return true;
-}
-
-bool NodeAddedRemovedOp::Redo()
-{
-    if (added_)
-    {
-        parent_->AddChild(node_);
-    }
-    else
-    {
-        node_->Remove();
-    }
-
-    return true;
-}
-
-SerializableEditOp::SerializableEditOp(Serializable* serializable, const VectorBuffer& beginState, const VectorBuffer& endState) : SceneEditOp(),
-    serializable_(serializable),
-    beginState_(beginState),
-    endState_(endState)
-{
-    type_ = SCENEEDIT_SERIALIZABLE_EDIT;
-
-    if (!beginState_.GetSize())
-    {
-        LOGERRORF("Zero size beginState");
-    }
-
-    if (!endState_.GetSize())
-    {
-        LOGERRORF("Zero size endState");
-    }
-}
-
-bool SerializableEditOp::Undo()
-{    
-    if (!serializable_->Serializable::Load(beginState_))
-    {
-        LOGERRORF("Error loading beginState");
-    }
-    beginState_.Seek(0);
-
-    VariantMap eventData;
-    eventData[SceneEditSerializableUndoRedo::P_SERIALIZABLE] = serializable_;
-    eventData[SceneEditSerializableUndoRedo::P_UNDO] = true;
-    eventData[SceneEditSerializableUndoRedo::P_STATE] = beginState_;
-    serializable_->SendEvent(E_SCENEEDITSERIALIZABLEUNDOREDO, eventData);
-
-    return true;
-}
-
-bool SerializableEditOp::Redo()
-{
-
-    if (!serializable_->Serializable::Load(endState_))
-    {
-        LOGERRORF("Error loading endState");
-    }
-
-    endState_.Seek(0);
-
-    VariantMap eventData;
-    eventData[SceneEditSerializableUndoRedo::P_SERIALIZABLE] = serializable_;
-    eventData[SceneEditSerializableUndoRedo::P_UNDO] = false;
-    eventData[SceneEditSerializableUndoRedo::P_STATE] = endState_;
-    serializable_->SendEvent(E_SCENEEDITSERIALIZABLEUNDOREDO, eventData);
-
-    return true;
-}
-
-}

Source/AtomicEditor/Editors/SceneEditor3D/SceneEditOps.h

@@ -1,118 +0,0 @@
-//
-// Copyright (c) 2014-2015, THUNDERBEAST GAMES LLC All rights reserved
-// LICENSE: Atomic Game Engine Editor and Tools EULA
-// Please see LICENSE_ATOMIC_EDITOR_AND_TOOLS.md in repository root for
-// license information: https://github.com/AtomicGameEngine/AtomicGameEngine
-//
-
-#pragma once
-
-#include <Atomic/Core/Object.h>
-#include <Atomic/IO/VectorBuffer.h>
-
-namespace Atomic
-{
-
-class Scene;
-class Node;
-class Component;
-class Serializable;
-
-}
-
-using namespace Atomic;
-
-namespace AtomicEditor
-{
-
-enum SceneEditType
-{
-    SCENEEDIT_UNKNOWN = 0,
-    SCENEEDIT_NODE_ADDED_REMOVED,
-    SCENEEDIT_COMPONENT_ADDED_REMOVED,
-    SCENEEDIT_SERIALIZABLE_EDIT,
-};
-
-class SceneEditOp
-{
-
-public:
-
-    SceneEditOp() { type_ = SCENEEDIT_UNKNOWN; }
-    virtual ~SceneEditOp() { }
-
-    virtual bool Undo() = 0;
-    virtual bool Redo() = 0;
-
-    SceneEditType type_;
-
-};
-
-class NodeEditOp : public SceneEditOp
-{
-protected:
-
-    NodeEditOp(Node* node);
-
-public:
-
-    SharedPtr<Node> node_;
-    SharedPtr<Node> parent_;
-
-};
-
-class NodeAddedRemovedOp : public NodeEditOp
-{
-
-public:
-
-    NodeAddedRemovedOp(Node* node, bool added);
-
-    bool added_;
-
-    bool Undo();
-    bool Redo();
-};
-
-class ComponentEditOp : public SceneEditOp
-{
-protected:
-
-    ComponentEditOp(Component* component);
-
-public:
-
-    SharedPtr<Component> component_;
-
-};
-
-class ComponentAddedRemovedOp : public ComponentEditOp
-{
-
-public:
-
-    ComponentAddedRemovedOp(Node* node, bool added);
-
-    bool added_;
-
-    bool Undo();
-    bool Redo();
-};
-
-class SerializableEditOp : public SceneEditOp
-{
-
-public:
-
-    SerializableEditOp(Serializable* serializable, const VectorBuffer& beginState, const VectorBuffer& endState);
-
-    SharedPtr<Serializable> serializable_;
-    VectorBuffer beginState_;
-    VectorBuffer endState_;
-
-    bool Undo();
-    bool Redo();
-};
-
-
-}

Source/AtomicEditor/Editors/SceneEditor3D/SceneEditor3D.cpp

@@ -34,8 +34,8 @@
 #include "../../EditorMode/AEEditorEvents.h"
 
 #include "SceneEditor3D.h"
-#include "SceneEditHistory.h"
 #include "SceneSelection.h"
+#include "SceneEditHistory.h"
 #include "SceneEditor3DEvents.h"
 
 using namespace ToolCore;
@@ -66,6 +66,7 @@ SceneEditor3D ::SceneEditor3D(Context* context, const String &fullpath, UITabCon
 
     selection_ = new SceneSelection(context, this);
     sceneView_ = new SceneView3D(context_, this);
+    editHistory_ = new SceneEditHistory(context, this);
 
     // EARLY ACCESS
     if (fullpath.Find(String("ToonTown")) != String::NPOS)
@@ -117,8 +118,6 @@ SceneEditor3D ::SceneEditor3D(Context* context, const String &fullpath, UITabCon
 
     SubscribeToEvent(scene_, E_SCENEEDITSCENEMODIFIED, HANDLER(SceneEditor3D, HandleSceneEditSceneModified));
 
-    editHistory_ = new SceneEditHistory(context_, scene_);
-
 }
 
 SceneEditor3D::~SceneEditor3D()

Source/AtomicEditor/Editors/SceneEditor3D/SceneEditor3D.h

@@ -37,8 +37,8 @@ using namespace ToolCore;
 namespace AtomicEditor
 {
 
-class SceneEditHistory;
 class SceneSelection;
+class SceneEditHistory;
 
 class SceneEditor3D: public ResourceEditor
 {
@@ -98,11 +98,10 @@ private:
     SharedPtr<Gizmo3D> gizmo3D_;
 
     SharedPtr<SceneSelection> selection_;
+    SharedPtr<SceneEditHistory> editHistory_;
 
     SharedPtr<Node> clipboardNode_;
 
-    SharedPtr<SceneEditHistory> editHistory_;
-
     WeakPtr<ProjectUserPrefs> userPrefs_;
 
 };

Source/AtomicEditor/Editors/SceneEditor3D/SceneEditor3DEvents.h

@@ -37,37 +37,20 @@ EVENT(E_SCENENODESELECTED, SceneNodeSelected)
     PARAM(P_SELECTED, Selected);       // bool
 }
 
-EVENT(E_SCENEEDITSCENEMODIFIED, SceneEditSceneModified)
-{
-
-}
-
-EVENT(E_SCENEEDITNODEADDEDREMOVED, SceneEditNodeAddedRemoved)
+EVENT(E_SCENEEDITBEGIN, SceneEditBegin)
 {
     PARAM(P_SCENE, Scene);             // Scene
-    PARAM(P_NODE, Node);               // Node
-    PARAM(P_ADDED, Added);             // bool
+
 }
 
-EVENT(E_SCENEEDITCOMPONENTADDEDREMOVED, SceneEditComponentAddedRemoved)
+EVENT(E_SCENEEDITEND, SceneEditEnd)
 {
     PARAM(P_SCENE, Scene);             // Scene
-    PARAM(P_COMPONENT, Component);     // Component
-    PARAM(P_ADDED, Added);             // bool
 }
 
-EVENT(E_SCENEEDITSERIALIZABLE, SceneEditSerializable)
+EVENT(E_SCENEEDITSCENEMODIFIED, SceneEditSceneModified)
 {
-    PARAM(P_SERIALIZABLE, Serializable);     // Serializable
-    PARAM(P_OPERATION, Operation);           // int (0: begin, 1: change, 2: end)
-}
 
-EVENT(E_SCENEEDITSERIALIZABLEUNDOREDO, SceneEditSerializableUndoRedo)
-{
-    PARAM(P_SERIALIZABLE, Serializable);     // Serializable
-    PARAM(P_STATE, State);                   // State (VectorBuffer);
-    PARAM(P_UNDO, Undo);                     // bool (true: undo, false: redo)
 }
 
-
 }

Source/AtomicEditor/Editors/SceneEditor3D/SceneView3D.cpp

@@ -601,6 +601,7 @@ void SceneView3D::HandleDragEnded(StringHash eventType, VariantMap& eventData)
 
     if (dragNode_.NotNull())
     {
+        /*
         VariantMap neventData;
         neventData[EditorActiveNodeChange::P_NODE] = dragNode_;
         SendEvent(E_EDITORACTIVENODECHANGE, neventData);
@@ -610,6 +611,7 @@ void SceneView3D::HandleDragEnded(StringHash eventType, VariantMap& eventData)
         editData[SceneEditNodeAddedRemoved::P_NODE] = dragNode_;
         editData[SceneEditNodeAddedRemoved::P_ADDED] = true;
         scene_->SendEvent(E_SCENEEDITNODEADDEDREMOVED, editData);
+        */
 
     }