Broken undo

Death explosion should always get triggered now.

include/Engine/Collision/CollisionSystem.h

@@ -24,6 +24,7 @@ public:
 private:
     Octree<EntityAABB>* m_Octree;
     std::vector<EntityAABB> m_OctreeResult;
+    std::unordered_map<EntityWrapper, glm::vec3> m_PrevPositions;
 };
 
 #endif

include/Engine/Core/ComponentPool.h

@@ -65,6 +65,8 @@ public:
 	iterator end() const;
     size_t size() const;
 
+    std::size_t MemoryUsage() const;
+
 	//Dumps information about what the pool memory looks like right now 
 	//into an output stream (e.g. file/std::cout, anything that has an operator<<)
 	//Interpret the data in the memory as InterpretType.

include/Engine/Core/EntityWrapper.h

@@ -27,8 +27,10 @@ struct EntityWrapper
     bool HasComponent(const std::string& componentType);
     void AttachComponent(const char* componentName);
     EntityWrapper Parent();
+    EntityWrapper BaseParent();
     EntityWrapper FirstChildByName(const std::string& name);
     EntityWrapper FirstParentWithComponent(const std::string& componentType);
+    EntityWrapper Clone(EntityWrapper parent = EntityWrapper::Invalid);
     bool IsChildOf(EntityWrapper potentialParent);
     bool Valid() const;
 
@@ -39,6 +41,7 @@ struct EntityWrapper
 
 private:
     EntityWrapper firstChildByNameRecursive(const std::string& name, EntityID parent);
+    EntityWrapper cloneRecursive(EntityWrapper entity, EntityWrapper parent);
 };
 
 namespace std

include/Engine/Core/MemoryPool.h

@@ -194,6 +194,11 @@ public:
 		return m_ExtraMemory.size();
 	}
 
+    std::size_t MemoryUsage() const
+    {
+        return size() * m_Stride;
+    }
+
 	//Dumps information about what the pool memory looks like right now 
 	//into an output stream (e.g. file/std::cout, anything that has an operator<<)
 	//Interpret the data in the memory as InterpretType.

include/Engine/Core/World.h

@@ -18,7 +18,7 @@ public:
     World(const World& other);
 
     // Create empty entity
-    EntityID CreateEntity(EntityID parent = 0);
+    EntityID CreateEntity(EntityID parent = EntityID_Invalid);
     // Delete entity and all components within
     void DeleteEntity(EntityID entity);
     // Check if an entity exists
@@ -40,7 +40,7 @@ public:
     // Change the parent of an entity
     void SetParent(EntityID entity, EntityID parent);
     // Get children of an entity
-    const std::pair<std::unordered_multimap<EntityID, EntityID>::const_iterator, std::unordered_multimap<EntityID, EntityID>::const_iterator> GetChildren(EntityID entity);
+    const std::pair<std::unordered_multimap<EntityID, EntityID>::const_iterator, std::unordered_multimap<EntityID, EntityID>::const_iterator> GetDirectChildren(EntityID entity);
     // Get all component pools
     const std::unordered_map<std::string, ComponentPool*>& GetComponentPools() const { return m_ComponentPools; }
     // Get the entity children map
@@ -50,6 +50,9 @@ public:
     // Get the textual name of an entity
     std::string GetName(EntityID entity) const;
 
+    // Get an approximate number for component pool memory usage
+    std::size_t MemoryUsage() const;
+
 private:
     EventBroker* m_EventBroker = nullptr;
     EntityID m_CurrentEntityID = 0;

include/Engine/Editor/EditorGUI.h

@@ -73,6 +73,12 @@ public:
     // Called when the user means to rename an entity.
     typedef std::function<void(EntityWrapper, const std::string&)> OnEntityChangeName_t;
     void SetEntityChangeNameCallback(OnEntityChangeName_t f) { m_OnEntityChangeName = f; }
+    // Called when the user pastes an entity previously "copied"
+    // @param EntityWrapper The entity to copy
+    // @param EntityWrapper The entity to parent the new copy to
+    // @return The new copy of the entity
+    typedef std::function<EntityWrapper(EntityWrapper, EntityWrapper)> OnEntityPaste_t;
+    void SetEntityPasteCallback(OnEntityPaste_t f) { m_OnEntityPaste = f; }
     // Called when the user means to attach a new component to an entity.
     typedef std::function<void(EntityWrapper, const std::string&)> OnComponentAttach_t;
     void SetComponentAttachCallback(OnComponentAttach_t f) { m_OnComponentAttach = f; }
@@ -85,7 +91,13 @@ public:
     // Called when the user selects a widget space.
     typedef std::function<void(WidgetSpace)> OnWidgetSpace_t;
     void SetWidgetSpaceCallback(OnWidgetSpace_t f) { m_OnWidgetSpace = f; }
-
+    // Called when anything is modified making the world dirty
+    // @param EntityWrapper The entity that was changed and marked as dirty
+    typedef std::function<void(EntityWrapper)> OnDirty_t;
+    void SetDirtyCallback(OnDirty_t f) { m_OnDirty = f; }
+    // Called when the user wishes to undo
+    typedef std::function<void()> OnUndo_t;
+    void SetUndoCallback(OnUndo_t f) { m_OnUndo = f; }
 private:
     World* m_World;
     EventBroker* m_EventBroker;
@@ -111,6 +123,7 @@ private:
     std::string m_DroppedFile = "";
     bool m_Paused = false;
     bool m_MouseLocked = false;
+    EntityWrapper m_CopyTarget = EntityWrapper::Invalid;
 
     // Callbacks
     OnEntitySelectedCallback_t m_OnEntitySelected = nullptr;
@@ -124,6 +137,9 @@ private:
     OnComponentDelete_t m_OnComponentDelete = nullptr;
     OnWidgetMode_t m_OnWidgetMode = nullptr;
     OnWidgetSpace_t m_OnWidgetSpace = nullptr;
+    OnEntityPaste_t m_OnEntityPaste = nullptr;
+    OnDirty_t m_OnDirty = nullptr;
+    OnUndo_t m_OnUndo = nullptr;
 
     // Events
     EventRelay<EditorGUI, Events::KeyDown> m_EKeyDown;

include/Engine/Editor/EditorSystem.h

@@ -36,6 +36,7 @@ private:
     EditorCameraInputController<EditorSystem>* m_EditorCameraInputController;
     EditorGUI* m_EditorGUI;
     EditorStats* m_EditorStats;
+    std::vector<World> m_UndoLevels;
 
     // State
     double m_LastTime = 0.f;
@@ -44,6 +45,7 @@ private:
     EditorGUI::WidgetSpace m_WidgetSpace = EditorGUI::WidgetSpace::Global;
     EntityWrapper m_Widget = EntityWrapper::Invalid;
     EntityWrapper m_CurrentSelection = EntityWrapper::Invalid;
+    bool m_SaveUndoLevel = false; // Only save undo state once per update
 
     // Utility functions
     EntityWrapper importEntity(EntityWrapper parent, boost::filesystem::path filePath);
@@ -56,9 +58,12 @@ private:
     void OnEntityDelete(EntityWrapper entity);
     void OnEntityChangeParent(EntityWrapper entity, EntityWrapper parent);
     void OnEntityChangeName(EntityWrapper entity, const std::string& name);
+    EntityWrapper OnEntityPaste(EntityWrapper entityToCopy, EntityWrapper parent);
     void OnComponentAttach(EntityWrapper entity, const std::string& componentType);
     void OnComponentDelete(EntityWrapper entity, const std::string& componentType);
     void OnWidgetSpace(EditorGUI::WidgetSpace widgetSpace);
+    void OnDirty(EntityWrapper entity);
+    void OnUndo();
 
     // Events
     EventRelay<EditorSystem, Events::MousePress> m_EMousePress;

include/Engine/Network/Client.h

@@ -19,6 +19,7 @@
 #include "Core/World.h"
 #include "Core/EventBroker.h"
 #include "Core/ConfigFile.h"
+#include "Core/EPlayerDeath.h"
 #include "Input/EInputCommand.h"
 #include "Core/EPlayerDamage.h"
 #include "../Game/Events/EDoubleJump.h"

resources/Schema/Components/Physics.xml

@@ -2,7 +2,6 @@
 <Physics xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Physics.xsd">
 	<Velocity X="0" Y="0" Z="0"/>
 	<Gravity>true</Gravity>
-	<PrevOrigin X="-9876.5" Y="-9876.5" Z="-9876.5"/>
 	<IsOnGround>false</IsOnGround>
 	<VerticalStepHeight>0.33</VerticalStepHeight>
 </Physics>

resources/Schema/Components/Physics.xsd

@@ -13,7 +13,6 @@
 					<xs:annotation><xs:documentation>m/s^2</xs:documentation></xs:annotation>
 				</xs:element>
 				<xs:element name="Gravity" type="t:bool" minOccurs="0"/>
-				<xs:element name="PrevOrigin" type="t:Vector" minOccurs="0"/>
 				<xs:element name="IsOnGround" type="t:bool" minOccurs="0"/>
 				<xs:element name="VerticalStepHeight" type="t:double" minOccurs="0">
 					<xs:annotation><xs:documentation>The largest height of a "stair-step" that can be walked over</xs:documentation></xs:annotation>

resources/Schema/Entities/Empty.xml

@@ -5,6 +5,20 @@
     <c:Transform/>
   </Components>
 
-  <Children/>
+  <Children>
+    <Entity>
+      <Components>
+        <c:Transform/>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Transform/>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+  </Children>
 
 </Entity>

resources/Schema/Entities/Player.xml

@@ -13,7 +13,6 @@
     <c:DashAbility/>
     <c:Health/>
     <c:Physics>
-      <PrevOrigin X="0" Y="0.772000015" Z="0"/>
       <Velocity X="2.30999646e-23" Y="0" Z="1.05272533e-23"/>
     </c:Physics>
     <c:Player>

resources/Schema/Entities/PlayerRed.xml

@@ -13,7 +13,6 @@
     <c:DashAbility/>
     <c:Health/>
     <c:Physics>
-      <PrevOrigin X="0" Y="0.772000015" Z="0"/>
       <Velocity X="2.30999646e-23" Y="0" Z="1.05272533e-23"/>
     </c:Physics>
     <c:Player>

src/Engine/Collision/CollisionSystem.cpp

@@ -16,51 +16,51 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
     EntityAABB& boxA = *boundingBox;
     bool everHitTheGround = false;
 
-    glm::vec3 size = boxA.Size();
-    float diameter = std::min(size.x, size.z);
-    glm::vec3 prevOrigin = (glm::vec3)cPhysics["PrevOrigin"];
-    glm::vec3 toCurrentPos = boxA.Origin() - prevOrigin;
-    float rayLength = glm::length(toCurrentPos) + 0.5f*diameter;
-    //If the entity has moved farther than the size of its box, we need to handle it specially.
-    bool traceCollision = rayLength > diameter;
-    //hack solution: If prevOrigin is less than -9000 in all dimensions, 
-    //then it means it is not set, i.e. this is the first collision check for the entity.
-    if (traceCollision && glm::any(glm::greaterThan((glm::vec3)cPhysics["PrevOrigin"], glm::vec3(-9000.f)))) {
-        Ray ray(prevOrigin, toCurrentPos);
-        m_OctreeResult.clear();
-        m_Octree->ObjectsPossiblyHitByRay(ray, m_OctreeResult);
-        for (auto& boxB : m_OctreeResult) {
-            if (boxA.Entity == boxB.Entity) {
-                continue;
-            }
-            bool hit;
-            float dist;
-            if (boxB.Entity.HasComponent("Model")) {
-                RawModel* model;
-                std::string res = (std::string)boxB.Entity["Model"]["Resource"];
-                try {
-                    model = ResourceManager::Load<RawModel, true>(res);
-                } catch (const std::exception&) {
+    auto prevPosIt = m_PrevPositions.find(entity);
+    if (prevPosIt != m_PrevPositions.end()) {
+        glm::vec3 size = boxA.Size();
+        float diameter = std::min(size.x, size.z);
+        glm::vec3 prevOrigin = prevPosIt->second;
+        glm::vec3 toCurrentPos = boxA.Origin() - prevOrigin;
+        float rayLength = glm::length(toCurrentPos) + 0.5f*diameter;
+        //If the entity has moved farther than the size of its box, we need to handle it specially.
+        if (rayLength > diameter) {
+            Ray ray(prevOrigin, toCurrentPos);
+            m_OctreeResult.clear();
+            m_Octree->ObjectsPossiblyHitByRay(ray, m_OctreeResult);
+            for (auto& boxB : m_OctreeResult) {
+                if (boxA.Entity == boxB.Entity) {
                     continue;
                 }
-                float u, v;
-                hit = Collision::RayVsModel(ray, model->Vertices(), model->m_Indices, Transform::ModelMatrix(boxB.Entity), dist, u, v);
-            } else {
-                hit = Collision::RayVsAABB(ray, boxB, dist);
-            }
-            if (hit && dist < rayLength) {
-                //Set the entity to where it was colliding, minus the maximum box size. 
-                //TODO: Perhaps this should be done slightly more properly.
-                glm::vec3 newOriginPos = ray.Origin() + (dist - 0.707107f*diameter) * ray.Direction();
-                glm::vec3 resolve = newOriginPos - boxA.Origin();
-                (glm::vec3&)cTransform["Position"] += resolve;
-                boxA = *Collision::EntityAbsoluteAABB(entity);
-                if (resolve.y > 0) {
-                    everHitTheGround = true;
-                    (bool)cPhysics["IsOnGround"] = true;
-                    ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
+                bool hit;
+                float dist;
+                if (boxB.Entity.HasComponent("Model")) {
+                    RawModel* model;
+                    std::string res = (std::string)boxB.Entity["Model"]["Resource"];
+                    try {
+                        model = ResourceManager::Load<RawModel, true>(res);
+                    } catch (const std::exception&) {
+                        continue;
+                    }
+                    float u, v;
+                    hit = Collision::RayVsModel(ray, model->Vertices(), model->m_Indices, Transform::ModelMatrix(boxB.Entity), dist, u, v);
+                } else {
+                    hit = Collision::RayVsAABB(ray, boxB, dist);
+                }
+                if (hit && dist < rayLength) {
+                    //Set the entity to where it was colliding, minus the maximum box size. 
+                    //TODO: Perhaps this should be done slightly more properly.
+                    glm::vec3 newOriginPos = ray.Origin() + (dist - 0.707107f*diameter) * ray.Direction();
+                    glm::vec3 resolve = newOriginPos - boxA.Origin();
+                    (glm::vec3&)cTransform["Position"] += resolve;
+                    boxA = *Collision::EntityAbsoluteAABB(entity);
+                    if (resolve.y > 0) {
+                        everHitTheGround = true;
+                        (bool)cPhysics["IsOnGround"] = true;
+                        ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
+                    }
+                    break;
                 }
-                break;
             }
         }
     }
@@ -90,6 +90,7 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
             float verticalStepHeight = (float)(double)cPhysics["VerticalStepHeight"];
             if (Collision::AABBvsTriangles(boxA, model->Vertices(), model->m_Indices, modelMatrix, inOutVelocity, verticalStepHeight, isOnGround, resolutionVector)) {
                 (glm::vec3&)cTransform["Position"] += resolutionVector;
+                boxA = *Collision::EntityAbsoluteAABB(entity);
                 cPhysics["Velocity"] = inOutVelocity;
                 if (isOnGround) {
                     everHitTheGround = true;
@@ -99,6 +100,7 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
         } else if (Collision::AABBVsAABB(boxA, boxB, resolutionVector)) {
             //Enter here if boxB has no Model.
             (glm::vec3&)cTransform["Position"] += resolutionVector;
+            boxA = *Collision::EntityAbsoluteAABB(entity);
             if (resolutionVector.y > 0) {
                 everHitTheGround = true;
                 (bool)cPhysics["IsOnGround"] = true;
@@ -112,5 +114,5 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
         (bool)cPhysics["IsOnGround"] = false;
     }
 
-    (glm::vec3&)cPhysics["PrevOrigin"] = boxA.Origin();
+    m_PrevPositions[entity] = boxA.Origin();
 }

src/Engine/Core/ComponentPool.cpp

@@ -112,6 +112,11 @@ size_t ComponentPool::size() const
     return m_Pool.size();
 }
 
+std::size_t ComponentPool::MemoryUsage() const
+{
+    return m_Pool.MemoryUsage();
+}
+
 template <typename InterpretType /*= char*/>
 void ComponentPool::Dump() const
 {

src/Engine/Core/EntityWrapper.cpp

@@ -34,6 +34,15 @@ EntityWrapper EntityWrapper::Parent()
     }
 }
 
+EntityWrapper EntityWrapper::BaseParent()
+{
+    EntityWrapper baseParent = Parent();
+    while (baseParent.Parent().Valid()) {
+        baseParent = baseParent.Parent();
+    }
+    return baseParent;
+}
+
 EntityWrapper EntityWrapper::FirstChildByName(const std::string& name)
 {
     return firstChildByNameRecursive(name, this->ID);
@@ -51,6 +60,17 @@ EntityWrapper EntityWrapper::FirstParentWithComponent(const std::string& compone
     return EntityWrapper::Invalid;
 }
 
+EntityWrapper EntityWrapper::Clone(EntityWrapper parent /*= Invalid*/)
+{
+    if (!Valid()) {
+        return EntityWrapper::Invalid;
+    }
+
+    EntityWrapper clone = cloneRecursive(*this, EntityWrapper::Invalid);
+    this->World->SetParent(clone.ID, parent.ID);
+    return clone;
+}
+
 bool EntityWrapper::IsChildOf(EntityWrapper potentialParent)
 {
     EntityWrapper entity = *this;
@@ -111,7 +131,7 @@ EntityWrapper EntityWrapper::firstChildByNameRecursive(const std::string& name,
         return EntityWrapper::Invalid;
     }
 
-    auto itPair = this->World->GetChildren(parent);
+    auto itPair = this->World->GetDirectChildren(parent);
     if (itPair.first == itPair.second) {
         return EntityWrapper::Invalid;
     }
@@ -131,3 +151,27 @@ EntityWrapper EntityWrapper::firstChildByNameRecursive(const std::string& name,
     return EntityWrapper::Invalid;
 }
 
+EntityWrapper EntityWrapper::cloneRecursive(EntityWrapper entity, EntityWrapper parent)
+{
+    EntityWrapper clone = EntityWrapper(entity.World, entity.World->CreateEntity(parent.ID));
+    entity.World->SetName(clone.ID, entity.Name());
+
+    // Clone components
+    for (auto& kv : entity.World->GetComponentPools()) {
+        if (kv.second->KnowsEntity(entity.ID)) {
+            ComponentWrapper c1 = kv.second->GetByEntity(entity.ID);
+            ComponentWrapper c2 = entity.World->AttachComponent(clone.ID, kv.first);
+            c1.Copy(c2);
+        }
+    }
+
+    // Clone children
+    auto children = entity.World->GetDirectChildren(entity.ID);
+    for (auto it = children.first; it != children.second; ++it) {
+        EntityWrapper child(entity.World, it->second);
+        cloneRecursive(child, clone);
+    }
+      
+    return clone;
+}
+

src/Engine/Core/World.cpp

@@ -127,7 +127,7 @@ void World::SetParent(EntityID entity, EntityID parent)
     m_EntityChildren.insert(std::make_pair(parent, entity));
 }
 
-const std::pair<std::unordered_multimap<EntityID, EntityID>::const_iterator, std::unordered_multimap<EntityID, EntityID>::const_iterator> World::GetChildren(EntityID entity)
+const std::pair<std::unordered_multimap<EntityID, EntityID>::const_iterator, std::unordered_multimap<EntityID, EntityID>::const_iterator> World::GetDirectChildren(EntityID entity)
 {
     return m_EntityChildren.equal_range(entity);
 }
@@ -151,6 +151,17 @@ std::string World::GetName(EntityID entity) const
     }
 }
 
+std::size_t World::MemoryUsage() const
+{
+    std::size_t mem = 0;
+
+    for (auto& kv : m_ComponentPools) {
+        mem += kv.second->MemoryUsage();
+    }
+
+    return mem;
+}
+
 EntityID World::generateEntityID()
 {
     // TODO: Make EntityID generation smarter

src/Engine/Editor/EditorGUI.cpp

@@ -598,6 +598,28 @@ bool EditorGUI::OnKeyDown(const Events::KeyDown& e)
         entityImport(m_World);
     }
 
+    if (e.ModCtrl && e.KeyCode == GLFW_KEY_C) {
+        m_CopyTarget = m_CurrentSelection;
+    }
+
+    if (e.ModCtrl && e.KeyCode == GLFW_KEY_Z) {
+        if (m_OnUndo != nullptr) {
+            m_OnUndo();
+            if (!m_CurrentSelection.Valid()) {
+                SelectEntity(EntityWrapper::Invalid);
+            }
+        }
+    }
+
+    if (e.ModCtrl && e.KeyCode == GLFW_KEY_V) {
+        if (m_OnEntityPaste != nullptr) {
+            EntityWrapper copy = m_OnEntityPaste(m_CopyTarget, m_CurrentSelection);
+            if (copy != EntityWrapper::Invalid) {
+                SelectEntity(copy);
+            }
+        }
+    }
+
     if (e.KeyCode == GLFW_KEY_DELETE) {
         if (m_CurrentSelection.Valid()) {
             entityDelete(m_CurrentSelection);
@@ -761,13 +783,13 @@ bool EditorGUI::compareCharArray(const char* c1, const char* c2)
 
 void EditorGUI::SetDirty(EntityWrapper entity)
 {
-    EntityWrapper baseParent = entity;
-    while (baseParent.Parent().Valid()) {
-        baseParent = baseParent.Parent();
-    }
+    EntityWrapper baseParent = entity.BaseParent();
     if (m_EntityFiles.find(baseParent) != m_EntityFiles.end()) {
         m_EntityFiles.at(baseParent).Dirty = true;
     }
+    if (m_OnDirty != nullptr) {
+        m_OnDirty(entity);
+    }
 }
 
 void EditorGUI::entityImport(World* world)
@@ -817,6 +839,7 @@ void EditorGUI::entityCreate(World* world, EntityWrapper parent)
             parent.World = world;
         }
         EntityWrapper newEntity = m_OnEntityCreate(parent);
+        SetDirty(newEntity);
         SelectEntity(newEntity);
     }
 }
@@ -832,9 +855,9 @@ void EditorGUI::entityDelete(EntityWrapper entity)
         if (boost::any_cast<EntityWrapper>(m_ModalData[modalName]) == entity) {
             EntityWrapper parent = entity.Parent();
             if (m_OnEntityDelete != nullptr) {
-                SetDirty(entity);
                 m_OnEntityDelete(entity);
                 m_EntityFiles.erase(entity);
+                SetDirty(parent);
             }
             if (!m_CurrentSelection.Valid()) {
                 SelectEntity(parent);
@@ -851,8 +874,8 @@ void EditorGUI::entityChangeParent(EntityWrapper entity, EntityWrapper parent)
     }
 
     if (m_OnEntityChangeParent != nullptr) {
-        SetDirty(entity);
         m_OnEntityChangeParent(entity, parent);
+        SetDirty(entity);
         LOG_DEBUG("Changed parent of %i to %i", entity.ID, parent.ID);
     }
 }

src/Engine/Editor/EditorSystem.cpp

@@ -28,10 +28,13 @@ EditorSystem::EditorSystem(SystemParams params, IRenderer* renderer, RenderFrame
     m_EditorGUI->SetEntityDeleteCallback(std::bind(&EditorSystem::OnEntityDelete, this, std::placeholders::_1));
     m_EditorGUI->SetEntityChangeParentCallback(std::bind(&EditorSystem::OnEntityChangeParent, this, std::placeholders::_1, std::placeholders::_2));
     m_EditorGUI->SetEntityChangeNameCallback(std::bind(&EditorSystem::OnEntityChangeName, this, std::placeholders::_1, std::placeholders::_2));
+    m_EditorGUI->SetEntityPasteCallback(std::bind(&EditorSystem::OnEntityPaste, this, std::placeholders::_1, std::placeholders::_2));
     m_EditorGUI->SetComponentAttachCallback(std::bind(&EditorSystem::OnComponentAttach, this, std::placeholders::_1, std::placeholders::_2));
     m_EditorGUI->SetComponentDeleteCallback(std::bind(&EditorSystem::OnComponentDelete, this, std::placeholders::_1, std::placeholders::_2));
     m_EditorGUI->SetWidgetModeCallback(std::bind(&EditorSystem::setWidgetMode, this, std::placeholders::_1));
     m_EditorGUI->SetWidgetSpaceCallback(std::bind(&EditorSystem::OnWidgetSpace, this, std::placeholders::_1));
+    m_EditorGUI->SetDirtyCallback(std::bind(&EditorSystem::OnDirty, this, std::placeholders::_1));
+    m_EditorGUI->SetUndoCallback(std::bind(&EditorSystem::OnUndo, this));
 
     EVENT_SUBSCRIBE_MEMBER(m_EMousePress, &EditorSystem::OnMousePress);
     EVENT_SUBSCRIBE_MEMBER(m_EWidgetDelta, &EditorSystem::OnWidgetDelta);
@@ -86,6 +89,11 @@ void EditorSystem::Update(double dt)
         glm::vec3& pos = cameraTransform["Position"];
         pos += m_EditorCameraInputController->Movement() * glm::inverse(glm::quat(ori)) * (float)actualDelta;
     }
+
+    if (m_SaveUndoLevel) {
+        m_UndoLevels.push_back(*m_World);
+        m_SaveUndoLevel = false;
+    }
 }
 
 void EditorSystem::Enable()
@@ -160,6 +168,11 @@ void EditorSystem::OnEntityChangeName(EntityWrapper entity, const std::string& n
     }
 }
 
+EntityWrapper EditorSystem::OnEntityPaste(EntityWrapper entityToCopy, EntityWrapper parent)
+{
+    return entityToCopy.Clone(parent);
+}
+
 void EditorSystem::OnComponentAttach(EntityWrapper entity, const std::string& componentType)
 {
     if (entity.Valid()) {
@@ -179,6 +192,19 @@ void EditorSystem::OnWidgetSpace(EditorGUI::WidgetSpace widgetSpace)
     m_WidgetSpace = widgetSpace;
 }
 
+void EditorSystem::OnDirty(EntityWrapper entity)
+{
+    m_SaveUndoLevel = true;
+}
+
+void EditorSystem::OnUndo()
+{
+    // The last "undo level" is always the most recent change
+    if (m_UndoLevels.size() >= 2) {
+        *m_World = m_UndoLevels.at(m_UndoLevels.size() - 2);
+    }
+}
+
 bool EditorSystem::OnMousePress(const Events::MousePress& e)
 {
     ImGuiIO& io = ImGui::GetIO();

src/Engine/Network/Client.cpp

@@ -261,8 +261,14 @@ void Client::parseEntityDeletion(Packet & packet)
     if (m_ServerIDToClientID.find(entityToDelete) != m_ServerIDToClientID.end()) {
         EntityID localEntity = m_ServerIDToClientID.at(entityToDelete);
         if (m_World->ValidEntity(localEntity)) {
-            m_World->DeleteEntity(localEntity);
-            deleteFromServerClientMaps(entityToDelete, localEntity);
+            if (m_World->HasComponent(localEntity,"Player")) {
+                Events::PlayerDeath e;
+                e.Player = EntityWrapper(m_World, localEntity);
+                m_EventBroker->Publish(e);
+            } else {
+                m_World->DeleteEntity(localEntity);
+                deleteFromServerClientMaps(entityToDelete, localEntity);
+            }
         }
     }
 }

src/Engine/Network/Server.cpp

@@ -186,7 +186,7 @@ void Server::addInputCommandsToPacket(Packet& packet)
 
 void Server::addPlayersToPacket(Packet & packet, EntityID entityID)
 {
-    auto itPair = m_World->GetChildren(entityID);
+    auto itPair = m_World->GetDirectChildren(entityID);
     std::unordered_map<std::string, ComponentPool*> worldComponentPools = m_World->GetComponentPools();
     // Loop through every child
     for (auto it = itPair.first; it != itPair.second; it++) {
@@ -234,7 +234,7 @@ void Server::addPlayersToPacket(Packet & packet, EntityID entityID)
 
 void Server::addChildrenToPacket(Packet & packet, EntityID entityID)
 {
-    auto itPair = m_World->GetChildren(entityID);
+    auto itPair = m_World->GetDirectChildren(entityID);
     std::unordered_map<std::string, ComponentPool*> worldComponentPools = m_World->GetComponentPools();
     // Loop through every child
     for (auto it = itPair.first; it != itPair.second; it++) {
@@ -601,7 +601,7 @@ void Server::parsePlayerTransform(Packet& packet)
 
 bool Server::shouldSendToClient(EntityWrapper childEntity)
 {
-    auto children = m_World->GetChildren(childEntity.ID);
+    auto children = m_World->GetDirectChildren(childEntity.ID);
     for (auto it = children.first; it != children.second; it++) {
         EntityWrapper child(m_World, it->second);
         if(child.HasComponent("CapturePoint")) {

src/Engine/Rendering/CubeMapPass.cpp

@@ -17,6 +17,7 @@ void CubeMapPass::LoadTextures(std::string input)
             m_CubeMapTextures.push_back(img);
         }
         GenerateCubeMapTexture();
+        m_PreviusCubeMapTexture = input;
     }
 }
 

src/Game/Systems/SpawnerSystem.cpp

@@ -36,7 +36,7 @@ EntityWrapper SpawnerSystem::Spawn(EntityWrapper spawner, EntityWrapper parent /
     }
 
     // Find any SpawnPoints existing as children of spawner
-    auto children = spawner.World->GetChildren(spawner.ID);
+    auto children = spawner.World->GetDirectChildren(spawner.ID);
     std::vector<EntityWrapper> spawnPoints;
     for (auto kv = children.first; kv != children.second; ++kv) {
         const EntityID& child = kv->second;