Merge pull request #44 from teamfisk/EditorUsefulness

Editor refactoring

include/Engine/Collision/CollidableOctreeSystem.h

@@ -8,14 +8,14 @@
 class CollidableOctreeSystem : public ImpureSystem, public PureSystem
 {
 public:
-    CollidableOctreeSystem(EventBroker* eventBroker, Octree<AABB>* octree)
-        : System(eventBroker)
+    CollidableOctreeSystem(World* world, EventBroker* eventBroker, Octree<AABB>* octree)
+        : System(world, eventBroker)
         , PureSystem("Collidable")
         , m_Octree(octree)
     { }
 
-    virtual void Update(World* world, double dt) override;
-    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt) override;
+    virtual void Update(double dt) override;
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
 
 private:
     Octree<AABB>* m_Octree;

include/Engine/Collision/CollisionSystem.h

@@ -13,8 +13,8 @@
 class CollisionSystem : public PureSystem
 {
 public:
-    CollisionSystem(EventBroker* eventBroker, Octree<AABB>* octree)
-        : System(eventBroker)
+    CollisionSystem(World* world, EventBroker* eventBroker, Octree<AABB>* octree)
+        : System(world, eventBroker)
         , PureSystem("Collidable")
         , m_Octree(octree)
         , zPress(false)
@@ -23,7 +23,7 @@ public:
         EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &CollisionSystem::OnKeyUp);
     }
 
-    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt) override;
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
 
 private:
     Octree<AABB>* m_Octree;

include/Engine/Collision/TriggerSystem.h

@@ -14,8 +14,8 @@ class AABB;
 class TriggerSystem : public PureSystem
 {
 public:
-    TriggerSystem(EventBroker* eventBroker, Octree<AABB>* octree)
-        : System(eventBroker)
+    TriggerSystem(World* world, EventBroker* eventBroker, Octree<AABB>* octree)
+        : System(world, eventBroker)
         , PureSystem("Trigger")
         , m_Octree(octree)
     {
@@ -24,7 +24,7 @@ public:
         EVENT_SUBSCRIBE_MEMBER(m_ELeave, &TriggerSystem::OnLeave);
     }
 
-    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt) override;
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
 
 private:
     Octree<AABB>* m_Octree;

include/Engine/Common.h

@@ -4,6 +4,7 @@
 #include <vector>
 #include <map>
 #include <unordered_map>
+#include <algorithm>
 
 #include "Core/Util/Logging.h"
 #include "Core/Util/IfDebug.h"

include/Engine/Core/ComponentInfo.h

@@ -5,12 +5,14 @@
 
 struct ComponentInfo
 {
+    typedef int EnumType;
+
 	struct Meta_t
 	{
 		std::string Annotation;
 		unsigned int Allocation = 0;
         std::map<std::string, std::string> FieldAnnotations;
-        std::map<std::string, std::map<std::string, int>> FieldEnumDefinitions;
+        std::map<std::string, std::map<std::string, EnumType>> FieldEnumDefinitions;
 	};
 
     struct Field_t

include/Engine/Core/ComponentWrapper.h

@@ -18,7 +18,7 @@ struct ComponentWrapper
     const ::EntityID EntityID;
     char* Data;
 
-    int Enum(const char* fieldName, const char* enumKey)
+    ComponentInfo::EnumType Enum(const char* fieldName, const char* enumKey)
     {
         return Info.Meta->FieldEnumDefinitions.at(fieldName).at(enumKey);
     }
@@ -58,7 +58,7 @@ struct ComponentWrapper
 
     public:
         // Return the integer value of an enum type key for this field
-        int Enum(const char* enumKey) { return m_Component->Enum(m_PropertyName.c_str(), enumKey); }
+        ComponentInfo::EnumType Enum(const char* enumKey) { return m_Component->Enum(m_PropertyName.c_str(), enumKey); }
 
         template <typename T>
         operator T&() { return m_Component->Field<T>(m_PropertyName); }

include/Engine/Core/EKeyDown.h

@@ -11,6 +11,9 @@ struct KeyDown : Event
 {
 	/** GLFW key code */
 	int KeyCode;
+    bool ModCtrl;
+    bool ModAlt;
+    bool ModShift;
 };
 
 }

include/Engine/Core/EKeyUp.h

@@ -11,6 +11,9 @@ struct KeyUp : Event
 {
 	/** GLFW key code */
 	int KeyCode;
+    bool ModCtrl;
+    bool ModAlt;
+    bool ModShift;
 };
 
 }

include/Engine/Core/EPause.h

@@ -0,0 +1,22 @@
+#ifndef EPause_h__
+#define EPause_h__
+
+#include "EventBroker.h"
+#include "World.h"
+
+namespace Events
+{
+
+struct Pause : Event 
+{
+    ::World* World;
+};
+
+struct Resume : Event 
+{
+    ::World* World;
+};
+
+}
+
+#endif

include/Engine/Core/EntityWrapper.h

@@ -2,6 +2,7 @@
 #define EntityWrapper_h__
 
 #include <boost/optional.hpp>
+#include <boost/functional/hash.hpp>
 #include "ComponentWrapper.h"
 
 class World;
@@ -23,10 +24,28 @@ struct EntityWrapper
     static const EntityWrapper Invalid;
 
     bool HasComponent(const std::string& componentName);
+    EntityWrapper Parent();
+    bool Valid();
 
-    ComponentWrapper operator[](const std::string& componentName);
-    bool operator==(const EntityWrapper& e);
-    explicit operator EntityID();
+    ComponentWrapper operator[](const char* componentName);
+    bool operator==(const EntityWrapper& e) const;
+    bool operator!=(const EntityWrapper& e) const;
+    explicit operator EntityID() const;
+    operator bool();
 };
 
+namespace std
+{
+	template<> struct hash<EntityWrapper>
+	{
+		std::size_t operator()(const EntityWrapper& e) const
+		{
+            std::size_t seed = 0;
+            boost::hash_combine(seed, e.World);
+            boost::hash_combine(seed, e.ID);
+            return seed;
+		}
+	};
+}
+
 #endif

include/Engine/Core/System.h

@@ -11,14 +11,14 @@ class System
     friend class SystemPipeline;
 
 protected:
-    System()
-        : m_EventBroker(nullptr)
-    { }
-    System(EventBroker* eventBroker)
-        : m_EventBroker(eventBroker)
+    System(World* world, EventBroker) { }
+    System(World* world, EventBroker* eventBroker)
+        : m_World(world)
+        , m_EventBroker(eventBroker)
     { }
     virtual ~System() = default;
 
+    World* m_World;
     EventBroker* m_EventBroker;
 };
 
@@ -34,7 +34,7 @@ protected:
 
     const std::string m_ComponentType;
 
-    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt) = 0;
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cComponent, double dt) = 0;
 };
 
 class ImpureSystem : public virtual System
@@ -45,7 +45,7 @@ protected:
     ImpureSystem() = default;
     virtual ~ImpureSystem() = default;
 
-    virtual void Update(World* world, double dt) = 0;
+    virtual void Update(double dt) = 0;
 };
 
 #endif

include/Engine/Core/SystemPipeline.h

@@ -5,13 +5,19 @@
 #include "EventBroker.h"
 #include "System.h"
 #include "World.h"
+#include "EPause.h"
 
 class SystemPipeline
 {
 public:
-    SystemPipeline(EventBroker* eventBroker)
-        : m_EventBroker(eventBroker)
-    { }
+    SystemPipeline(World* world, EventBroker* eventBroker)
+        : m_World(world)
+        , m_EventBroker(eventBroker)
+    {
+        EVENT_SUBSCRIBE_MEMBER(m_EPause, &SystemPipeline::OnPause);
+        EVENT_SUBSCRIBE_MEMBER(m_EResume, &SystemPipeline::OnResume);
+    }
+
     ~SystemPipeline()
     {
         for (UnorderedSystems& group : m_OrderedSystemGroups) {
@@ -29,7 +35,7 @@ public:
             m_OrderedSystemGroups.resize(updateOrderLevel + 1);
         }
         UnorderedSystems& group = m_OrderedSystemGroups[updateOrderLevel];
-        System* system = new T(m_EventBroker, args...);
+        System* system = new T(m_World, m_EventBroker, args...);
         group.Systems[typeid(T).name()] = system;
 
         PureSystem* pureSystem = dynamic_cast<PureSystem*>(system);
@@ -47,8 +53,12 @@ public:
         }
     }
 
-    void Update(World* world, double dt)
+    void Update(double dt)
     {
+        if (m_Paused) {
+            dt = 0.0;
+        }
+
         for (UnorderedSystems& group : m_OrderedSystemGroups) {
             // Process events
             for (auto& pair : group.Systems) {
@@ -57,18 +67,18 @@ public:
 
             // Update
             for (auto& system : group.ImpureSystems) {
-                system->Update(world, dt);
+                system->Update(dt);
             }
             for (auto& pair : group.PureSystems) {
                 const std::string& componentName = pair.first;
                 auto& systems = pair.second;
-                const ComponentPool* pool = world->GetComponents(componentName);
+                const ComponentPool* pool = m_World->GetComponents(componentName);
                 if (pool == nullptr) {
                     continue;
                 }
                 for (auto& component : *pool) {
                     for (auto& system : systems) {
-                        system->UpdateComponent(world, EntityWrapper(world, component.EntityID), component, dt);
+                        system->UpdateComponent(EntityWrapper(m_World, component.EntityID), component, dt);
                     }
                 }
             }
@@ -76,7 +86,10 @@ public:
     }
 
 private:
+    World* m_World;
     EventBroker* m_EventBroker;
+    bool m_Paused = false;
+
     struct UnorderedSystems
     {
         std::map<std::string, System*> Systems;
@@ -84,6 +97,21 @@ private:
         std::vector<ImpureSystem*> ImpureSystems;
     };
     std::vector<UnorderedSystems> m_OrderedSystemGroups;
+
+    EventRelay<SystemPipeline, Events::Pause> m_EPause;
+    bool OnPause(const Events::Pause& e) { 
+        if (e.World == m_World) { 
+            m_Paused = true; 
+        }
+        return true;
+    }
+    EventRelay<SystemPipeline, Events::Resume> m_EResume;
+    bool OnResume(const Events::Resume& e) {
+        if (e.World == m_World) {
+            m_Paused = false;
+        }
+        return true;
+    }
 };
 
 #endif

include/Engine/Core/UniformScaleSystem.h

@@ -0,0 +1,22 @@
+#ifndef UniformScaleSystem_h__
+#define UniformScaleSystem_h__
+
+#include "../GLM.h"
+#include "System.h"
+#include "../Rendering/ESetCamera.h"
+
+class UniformScaleSystem : public PureSystem
+{
+public:
+    UniformScaleSystem(World* world, EventBroker* eventBroker);
+
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cUniformScale, double dt) override;
+
+private:
+    EntityWrapper m_Camera = EntityWrapper::Invalid;
+
+    EventRelay<UniformScaleSystem, Events::SetCamera> m_ESetCamera;
+    bool OnSetCamera(const Events::SetCamera& e);
+};
+
+#endif

include/Engine/Editor/EditorGUI.h

@@ -0,0 +1,153 @@
+#ifndef EditorGUI_h__
+#define EditorGUI_h__
+
+#include <imgui/imgui.h>
+#define IMGUI_DEFINE_MATH_OPERATORS
+#include <imgui/imgui_internal.h>
+#include <nativefiledialog/nfd.h>
+#include <boost/filesystem.hpp>
+#include <boost/any.hpp>
+#include "../Common.h"
+#include "../GLM.h"
+#include <glm/gtx/common.hpp>
+
+#include "EditorWidgetSystem.h"
+#include "../Core/EventBroker.h"
+#include "../Core/World.h"
+#include "../Core/EntityWrapper.h"
+#include "../Core/ResourceManager.h"
+#include "../Core/EPause.h"
+#include "../Core/EKeyDown.h"
+#include "../Rendering/Texture.h"
+
+class EditorGUI
+{
+public:
+    EditorGUI(World* world, EventBroker* eventBroker);
+
+    enum class WidgetMode
+    {
+        Translate,
+        Rotate,
+        Scale
+    };
+
+    void Draw();
+
+    void SelectEntity(EntityWrapper entity);
+    void SetDirty(EntityWrapper entity);
+
+    // Called when an entity is selected in the entity tree
+    typedef std::function<void(EntityWrapper)> OnEntitySelectedCallback_t;
+    void SetEntitySelectedCallback(OnEntitySelectedCallback_t f) { m_OnEntitySelected = f; }
+    // Called when the user means to import an entity file. 
+    // @param EntityWrapper The entity to parent the imported entity to. The entity will be imported into the world of this entity.
+    // @param boost::filesystem::path The path to the entity to import
+    // @return EntityWrapper The newly created entity
+    typedef std::function<EntityWrapper(EntityWrapper, boost::filesystem::path)> OnEntityImport_t;
+    void SetEntityImportCallback(OnEntityImport_t f) { m_OnEntityImport = f; }
+    // Called when the user means to save an entity to file.
+    // Permitted to throw exceptions on save failure.
+    typedef std::function<void(EntityWrapper, boost::filesystem::path)> OnEntitySave_t;
+    void SetEntitySaveCallback(OnEntitySave_t f) { m_OnEntitySave = f; }
+    // Called when the user means to create a new entity.
+    // @param EntityWrapper The parent of the entity to be created
+    // @return EntityWrapper The newly created entity
+    typedef std::function<EntityWrapper(EntityWrapper)> OnEntityCreate_t;
+    void SetEntityCreateCallback(OnEntityCreate_t f) { m_OnEntityCreate = f; }
+    // Called when the user means to delete an entity.
+    typedef std::function<void(EntityWrapper)> OnEntityDelete_t;
+    void SetEntityDeleteCallback(OnEntityDelete_t f) { m_OnEntityDelete = f; }
+    // Called when the user means to change the parent of an entity.
+    typedef std::function<void(EntityWrapper, EntityWrapper)> OnEntityChangeParent_t;
+    void SetEntityChangeParentCallback(OnEntityChangeParent_t f) { m_OnEntityChangeParent = f; }
+    // 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 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; }
+    // Called when the user means to delete a component off an entity.
+    typedef std::function<void(EntityWrapper, const std::string&)> OnComponentDelete_t;
+    void SetComponentDeleteCallback(OnComponentDelete_t f) { m_OnComponentDelete = f; }
+    // Called when the user selects a widget mode.
+    typedef std::function<void(WidgetMode)> OnWidgetMode_t;
+    void SetWidgetModeCallback(OnWidgetMode_t f) { m_OnWidgetMode = f; }
+
+private:
+    World* m_World;
+    EventBroker* m_EventBroker;
+
+    struct EntityFileInfo
+    {
+        boost::filesystem::path Path;
+        bool Dirty = false;
+    };
+
+    // Config variables
+    const boost::filesystem::path m_DefaultEntityPath = boost::filesystem::path("Schema") / boost::filesystem::path("Entities");
+
+    // State
+    EntityWrapper m_CurrentSelection = EntityWrapper::Invalid;
+    std::unordered_map<EntityWrapper, EntityFileInfo> m_EntityFiles;
+    EntityWrapper m_CurrentlyDragging = EntityWrapper::Invalid;
+    std::string m_LastErrorMessage;
+    WidgetMode m_CurrentWidgetMode = WidgetMode::Translate;
+    std::set<std::string> m_ModalsToOpen;
+    std::map<std::string, boost::any> m_ModalData;
+
+    // Callbacks
+    OnEntitySelectedCallback_t m_OnEntitySelected = nullptr;
+    OnEntityImport_t m_OnEntityImport = nullptr;
+    OnEntitySave_t m_OnEntitySave = nullptr;
+    OnEntityCreate_t m_OnEntityCreate = nullptr;
+    OnEntityDelete_t m_OnEntityDelete = nullptr;
+    OnEntityChangeParent_t m_OnEntityChangeParent = nullptr;
+    OnEntityChangeName_t m_OnEntityChangeName = nullptr;
+    OnComponentAttach_t m_OnComponentAttach = nullptr;
+    OnComponentDelete_t m_OnComponentDelete = nullptr;
+    OnWidgetMode_t m_OnWidgetMode = nullptr;
+
+    // Events
+    EventRelay<EditorGUI, Events::KeyDown> m_EKeyDown;
+    bool OnKeyDown(const Events::KeyDown& e);
+
+    // Utility functions
+    boost::filesystem::path fileOpenDialog();
+    boost::filesystem::path fileSaveDialog();
+    const std::string formatEntityName(EntityWrapper entity);
+    GLuint tryLoadTexture(std::string filePath);
+    void openModal(const std::string& modal);
+
+    // Entity file handling methods
+    void entityImport(World* world);
+    void entitySave(EntityWrapper entity, bool saveAs = false);
+    void entityCreate(World* world, EntityWrapper parent);
+    void entityDelete(EntityWrapper entity);
+    void entityChangeParent(EntityWrapper entity, EntityWrapper parent);
+    
+    // UI drawing methods
+    void drawMenu();
+    void drawTools();
+    void drawEntities(World* world);
+    void drawEntitiesRecursive(World* world, EntityID parent);
+    bool drawEntityNode(EntityWrapper entity);
+    void drawComponents(EntityWrapper entity);
+    bool drawComponentNode(EntityWrapper entity, const ComponentInfo& componentType);
+    bool drawComponentField(ComponentWrapper& c, const ComponentInfo::Field_t& field);
+    bool drawComponentField_Vector(ComponentWrapper &c, const ComponentInfo::Field_t &field);
+    bool drawComponentField_Color(ComponentWrapper &c, const ComponentInfo::Field_t &field);
+    bool drawComponentField_int(ComponentWrapper &c, const ComponentInfo::Field_t &field);
+    bool drawComponentField_enum(ComponentWrapper &c, const ComponentInfo::Field_t &field);
+    bool drawComponentField_float(ComponentWrapper &c, const ComponentInfo::Field_t &field);
+    bool drawComponentField_double(ComponentWrapper &c, const ComponentInfo::Field_t &field);
+    bool drawComponentField_bool(ComponentWrapper &c, const ComponentInfo::Field_t &field);
+    bool drawComponentField_string(ComponentWrapper &c, const ComponentInfo::Field_t &field);
+    void drawModals();
+
+    // Custom UI elements
+    bool createDeleteButton(const std::string& componentType);
+    void createWidgetToolButton(WidgetMode mode);
+};
+
+#endif

include/Engine/Editor/EditorRenderSystem.h

@@ -0,0 +1,27 @@
+#ifndef EditorRenderSystem_h__
+#define EditorRenderSystem_h__
+
+#include "../Core/System.h"
+#include "../Rendering/IRenderer.h"
+#include "../Rendering/ModelJob.h"
+#include "../Rendering/Camera.h"
+#include "../Rendering/ESetCamera.h"
+
+class EditorRenderSystem : public ImpureSystem
+{
+public:
+    EditorRenderSystem(World* world, EventBroker* eventBroker, IRenderer* renderer, RenderFrame* renderFrame);
+
+    virtual void Update(double dt) override;
+
+private:
+    IRenderer* m_Renderer;
+    RenderFrame* m_RenderFrame;
+    Camera* m_EditorCamera;
+    EntityWrapper m_CurrentCamera = EntityWrapper::Invalid;
+
+    EventRelay<EditorRenderSystem, Events::SetCamera> m_ESetCamera;
+    bool OnSetCamera(Events::SetCamera& e);
+};
+
+#endif

include/Engine/Editor/EditorStats.h

@@ -0,0 +1,29 @@
+#include <numeric>
+#include <iomanip>
+#include <imgui/imgui.h>
+#include "../Common.h"
+#include "../GLM.h"
+#include "../OpenGL.h"
+
+class EditorStats
+{
+public:
+    EditorStats();
+    void Draw(double dt);
+
+private:
+    // FPS graph
+    const unsigned int m_SampleSize = 100;
+    unsigned int m_FrameCount = 0;
+    std::vector<double> m_FrameTimes;
+    double m_TimeAccumulator = 0.0;
+    double m_AveragedSamplesPerSecond = 10.0;
+    const unsigned int m_AveragedSampleSize = 100;
+    unsigned int m_CurrentAveragedSampleIndex = 0;
+    std::vector<double> m_AveragedSamples;
+    void drawFPSGraph(double dt);
+
+    void drawRAMUsage(double dt);
+
+    void drawVRAMStats(double dt);
+};

include/Engine/Editor/EditorSystem.h

@@ -1,94 +1,59 @@
-#include <imgui/imgui.h>
-#include <glm/gtx/common.hpp>
-#include <boost/filesystem/path.hpp>
-#include <nativefiledialog/nfd.h>
 #include "../Core/System.h"
-#include "../Core/EMousePress.h"
-#include "../Core/EMouseRelease.h"
-#include "../Core/EMouseMove.h"
-#include "../Core/ConfigFile.h"
-#include "../Input/EInputCommand.h"
 #include "../Rendering/IRenderer.h"
-#include "../Core/Transform.h"
-#include "../Core/EFileDropped.h"
+#include "../Rendering/Camera.h"
+#include "../Rendering/DebugCameraInputController.h"
+#include "../Rendering/ESetCamera.h"
+#include "../Core/World.h"
+#include "../Core/SystemPipeline.h"
+#include "../Core/ResourceManager.h"
 #include "../Core/EntityFilePreprocessor.h"
 #include "../Core/EntityFileParser.h"
 #include "../Core/EntityFileWriter.h"
+#include "../Core/EMouseRelease.h"
+#include "EditorGUI.h"
+#include "EditorStats.h"
 
 class EditorSystem : public ImpureSystem
 {
 public:
-    EditorSystem(EventBroker* eventBroker, IRenderer* renderer);
+    EditorSystem(World* world, EventBroker* eventBroker, IRenderer* renderer, RenderFrame* renderFrame);
+    ~EditorSystem();
 
-    virtual void Update(World* world, double dt) override;
+    void Update(double dt);
 
 private:
     IRenderer* m_Renderer;
-    World* m_World = nullptr;
-    Camera* m_Camera = nullptr;
+    RenderFrame* m_RenderFrame;
+    World* m_EditorWorld;
+    SystemPipeline* m_EditorWorldSystemPipeline;
+    Camera* m_EditorCamera;
+    EntityWrapper m_Camera = EntityWrapper::Invalid;
+    DebugCameraInputController<EditorSystem>* m_DebugCameraInputController;
+    EditorGUI* m_EditorGUI;
+    EditorStats* m_EditorStats;
 
-    bool m_Enabled;
-    bool m_Visible;
-    boost::filesystem::path m_DefaultEntityDir;
-    boost::filesystem::path m_CurrentFile;
-    std::vector<glm::vec2> m_PickingQueue;
+    // State
+    EditorGUI::WidgetMode m_WidgetMode = EditorGUI::WidgetMode::Translate;
+    EntityWrapper m_Widget = EntityWrapper::Invalid;
+    EntityWrapper m_CurrentSelection = EntityWrapper::Invalid;
 
-    enum class WidgetMode
-    {
-        None,
-        Translate,
-        Rotate,
-        Scale
-    } m_WidgetMode = WidgetMode::None;
+    // Utility functions
+    EntityWrapper importEntity(EntityWrapper parent, boost::filesystem::path filePath);
+    void setWidgetMode(EditorGUI::WidgetMode mode);
 
-    enum class WidgetSpace
-    {
-        Local,
-        Global
-    } m_WidgetSpace = WidgetSpace::Global;
+    // GUI callbacks
+    void OnEntitySelected(EntityWrapper entity);
+    void OnEntitySave(EntityWrapper entity, boost::filesystem::path filePath);
+    EntityWrapper OnEntityCreate(EntityWrapper parent);
+    void OnEntityDelete(EntityWrapper entity);
+    void OnEntityChangeParent(EntityWrapper entity, EntityWrapper parent);
+    void OnEntityChangeName(EntityWrapper entity, const std::string& name);
+    void OnComponentAttach(EntityWrapper entity, const std::string& componentType);
+    void OnComponentDelete(EntityWrapper entity, const std::string& componentType);
 
-    EntityID m_Widget = EntityID_Invalid;
-    EntityID m_WidgetX = EntityID_Invalid;
-    EntityID m_WidgetPlaneX = EntityID_Invalid;
-    EntityID m_WidgetY = EntityID_Invalid;
-    EntityID m_WidgetPlaneY = EntityID_Invalid;
-    EntityID m_WidgetZ = EntityID_Invalid;
-    EntityID m_WidgetPlaneZ = EntityID_Invalid;
-    EntityID m_WidgetOrigin = EntityID_Invalid;
-    glm::vec3 m_WidgetCurrentAxis;
-    float m_WidgetPickingDepth = 0.f;
-    glm::vec3 m_WidgetPickingPosition = glm::vec3(0);
-
-    EntityID m_Selection = EntityID_Invalid;
-    EntityID m_LastSelection = EntityID_Invalid;
-    EntityID m_UIDraggingEntity = EntityID_Invalid;
-    glm::vec3 m_Position;
-    std::string m_LastDroppedFile;
-
-    static boost::filesystem::path openDialog(boost::filesystem::path defaultPath);
-    static boost::filesystem::path saveDialog(boost::filesystem::path defaultPath);
-
-    EventRelay<EditorSystem, Events::InputCommand> m_EInputCommand;
-    bool OnInputCommand(const Events::InputCommand& e);
+    // Events
     EventRelay<EditorSystem, Events::MouseRelease> m_EMouseRelease;
     bool OnMouseRelease(const Events::MouseRelease& e);
-    EventRelay<EditorSystem, Events::MousePress> m_EMousePress;
-    bool OnMousePress(const Events::MousePress& e);
-    EventRelay<EditorSystem, Events::MouseMove> m_EMouseMove;
-    bool OnMouseMove(const Events::MouseMove& e);
-    EventRelay<EditorSystem, Events::FileDropped> m_EFileDropped;
-    bool OnFileDropped(const Events::FileDropped& e);
-    
-    void Picking();
-    void createWidget();
-    void updateWidget();
-    void setWidgetMode(WidgetMode newMode);
-    void setWidgetSpace(WidgetSpace space);
-    void drawUI(World* world, double dt);
-    bool createDeleteButton(std::string componentType);
-    bool createEntityNode(World* world, EntityID entity);
-    void changeParent(EntityID entity, EntityID newParent);
-    void fileImport(World* world);
-    void fileSave(World* world);
-    void fileSaveAs(World* world);
+    EventRelay<EditorSystem, Events::WidgetDelta> m_EWidgetDelta;
+    bool OnWidgetDelta(const Events::WidgetDelta& e);
 };

include/Engine/Editor/EditorWidgetSystem.h

@@ -0,0 +1,49 @@
+#ifndef EditorWidgetSystem_h__
+#define EditorWidgetSystem_h__
+
+#include <imgui/imgui.h>
+#include "../GLM.h"
+#include "../Core/System.h"
+#include "../Rendering/IRenderer.h"
+#include "../Rendering/Util/ScreenCoords.h"
+#include "../Core/EMouseMove.h"
+#include "../Core/EMousePress.h"
+#include "../Core/EMouseRelease.h"
+
+namespace Events
+{
+
+struct WidgetDelta : Event
+{
+    glm::vec3 Translation;
+    glm::vec3 Rotation;
+    glm::vec3 Scale;
+};
+
+}
+
+class EditorWidgetSystem : public ImpureSystem, PureSystem
+{
+public:
+    EditorWidgetSystem(World* world, EventBroker* eventBroker, IRenderer* renderer);
+
+    virtual void Update(double dt) override;
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cEditorWidget, double dt) override;
+
+private:
+    IRenderer* m_Renderer;
+
+    // State
+    EntityWrapper m_PickEntity = EntityWrapper::Invalid;
+    PickData m_PickData;
+    glm::vec2 m_MouseDelta;
+
+    EventRelay<EditorWidgetSystem, Events::MouseMove> m_EMouseMove;
+    bool OnMouseMove(const Events::MouseMove& e);
+    EventRelay<EditorWidgetSystem, Events::MousePress> m_EMousePress;
+    bool OnMousePress(const Events::MousePress& e);
+    EventRelay<EditorWidgetSystem, Events::MouseRelease> m_EMouseRelease;
+    bool OnMouseRelease(const Events::MouseRelease& e);
+};
+
+#endif

include/Engine/GLM.h

@@ -7,4 +7,5 @@
 #include <glm/gtx/rotate_vector.hpp>
 #include <glm/gtc/quaternion.hpp>
 #include <glm/gtx/quaternion.hpp>
-#include <glm/gtc/type_ptr.hpp>
+#include <glm/gtc/type_ptr.hpp>
+#include <glm/gtx/projection.hpp>

include/Engine/Rendering/Camera.h

@@ -2,6 +2,7 @@
 #define Camera_h__
 
 #include "../GLM.h"
+#include "../Core/Util/Rectangle.h"
 
 class Camera
 {
@@ -32,7 +33,6 @@ public:
 	glm::mat4 ViewMatrix() const { return m_ViewMatrix; }
     void SetViewMatrix(glm::mat4 val);
 
-
 	float AspectRatio() const { return m_AspectRatio; }
 	void SetAspectRatio(float val);
 
@@ -48,6 +48,8 @@ public:
     void UpdateViewMatrix();
     void UpdateProjectionMatrix();
 
+    glm::vec2 WorldToScreen(glm::vec3 worldCoord, Rectangle resolution);
+
 private:
 
 	glm::vec3 m_Position;

include/Engine/Rendering/DebugCameraInputController.h

@@ -1,5 +1,10 @@
+#ifndef DebugCameraInputController_h__
+#define DebugCameraInputController_h__
+
 #include <imgui/imgui.h>
 #include "../Input/FirstPersonInputController.h"
+#include "../Core/EMousePress.h"
+#include "../Core/EMouseRelease.h"
 
 template <typename EventContext>
 class DebugCameraInputController : public FirstPersonInputController<EventContext>
@@ -7,7 +12,10 @@ class DebugCameraInputController : public FirstPersonInputController<EventContex
 public:
     DebugCameraInputController(EventBroker* eventBroker, unsigned int playerID)
         : FirstPersonInputController(eventBroker, playerID)
-    { }
+    {
+        EVENT_SUBSCRIBE_MEMBER(m_EMousePress, &DebugCameraInputController::OnMousePress);
+        EVENT_SUBSCRIBE_MEMBER(m_EMouseRelease, &DebugCameraInputController::OnMouseRelease);
+    }
 
     void SetPosition(const glm::vec3 position) { m_Position = position; }
     void SetOrientation(const glm::quat orientation) { m_Orientation = orientation; }
@@ -19,17 +27,6 @@ public:
     {
         ImGuiIO& io = ImGui::GetIO();
 
-        if (e.Command == "PrimaryFire") {
-            if (e.Value > 0) {
-                if (!io.WantCaptureMouse) {
-                    LockMouse();
-                }
-            } else {
-                UnlockMouse();
-            }
-            return false;
-        }
-
         if (!io.WantCaptureKeyboard) {
             if (e.Command == "Right") {
                 float value = std::max(-1.f, std::min(e.Value, 1.f));
@@ -63,4 +60,25 @@ protected:
     glm::vec3 m_Velocity = glm::vec3(0, 0, 0);
     float m_BaseSpeed = 2.0f;
     float m_Speed = m_BaseSpeed;
-};
+    EventRelay<EventContext, Events::MousePress> m_EMousePress;
+    bool OnMousePress(const Events::MousePress& e)
+    {
+        if (e.Button == GLFW_MOUSE_BUTTON_2) {
+            ImGuiIO& io = ImGui::GetIO();
+            if (!io.WantCaptureMouse) {
+                LockMouse();
+            }
+        }
+        return true;
+    }
+    EventRelay<EventContext, Events::MouseRelease> m_EMouseRelease;
+    bool OnMouseRelease(const Events::MouseRelease& e)
+    {
+        if (e.Button == GLFW_MOUSE_BUTTON_2) {
+            UnlockMouse();
+        }
+        return true;
+    }
+};
+
+#endif

include/Engine/Rendering/DrawFinalPass.h

@@ -32,7 +32,6 @@ private:
     const LightCullingPass* m_LightCullingPass;
 
     ShaderProgram* m_ForwardPlusProgram;
-
 };
 
 #endif 

include/Engine/Rendering/DrawScenePass.h

@@ -1,42 +0,0 @@
-#ifndef DrawScenePass_h__
-#define DrawScenePass_h__
-
-#include "IRenderer.h"
-#include "DrawScenePassState.h"
-#include "FrameBuffer.h"
-#include "ShaderProgram.h"
-#include "Util/UnorderedMapVec2.h"
-#include "Texture.h"
-
-class DrawScenePass
-{
-public:
-    DrawScenePass(IRenderer* renderer);
-    ~DrawScenePass() { }
-    void InitializeTextures();
-    void InitializeFrameBuffers();
-    void InitializeShaderPrograms();
-
-    void Draw(RenderScene& scene);
-
-    //Getters
-
-
-private:
-    void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
-
-    static bool DepthSort(const std::shared_ptr<RenderJob> &i, const std::shared_ptr<RenderJob> &j)
-    {
-        return (i->Depth < j->Depth);
-    };
-
-    Texture* m_WhiteTexture;
-
-    const IRenderer* m_Renderer;
-
-    ShaderProgram* m_BasicForwardProgram;
-
-
-};
-
-#endif 

include/Engine/Rendering/DrawScenePassState.h

@@ -1,15 +0,0 @@
-#ifndef DrawScenePassState_h__
-#define DrawScenePassState_h__
-
-#include "Rendering/RenderState.h"
-
-class DrawScenePassState : public RenderState
-{
-public:
-    DrawScenePassState();
-    ~DrawScenePassState();
-private:
-
-};
-
-#endif

include/Engine/Rendering/ESetCamera.h

@@ -2,20 +2,14 @@
 #define Events_SetCamera_h__
 
 #include "../Core/EventBroker.h"
-#include "../Core/Entity.h"
-#include <string.h>
+#include "../Core/EntityWrapper.h"
 
 namespace Events
 {
 
 struct SetCamera : Event
 {
-public:
-    SetCamera() { };
-    std::string Name;
-
-private:
-
+    EntityWrapper CameraEntity;
 };
 
 }

include/Engine/Rendering/IRenderer.h

@@ -31,15 +31,6 @@ public:
 	void SetFullscreen(bool fullscreen) { m_Fullscreen = fullscreen; }
 	bool VSYNC() const { return m_VSYNC; }
 	void SetVSYNC(bool vsync) { m_VSYNC = vsync; }
-    ::Camera* Camera() const { return m_Camera; }
-    void SetCamera(::Camera* camera)
-    {
-        if (camera == nullptr) {
-            m_Camera = m_DefaultCamera;
-        } else {
-            m_Camera = camera;
-        }
-    }
 	virtual void Initialize() = 0;
 	virtual void Update(double dt) = 0;
 	virtual void Draw(RenderFrame& rq) = 0;
@@ -54,8 +45,6 @@ protected:
 	int m_GLVersion[2];
 	std::string m_GLVendor;
 	GLFWwindow* m_Window = nullptr;
-    ::Camera* m_DefaultCamera;
-    ::Camera* m_Camera = nullptr;
 };
 
 #endif // Renderer_h__

include/Engine/Rendering/RenderJob.h

@@ -14,7 +14,6 @@ struct RenderJob
     friend class RenderQueue;
 
 public:
-
     float Depth;
 
 protected:

include/Engine/Rendering/RenderQueue.h

@@ -51,11 +51,12 @@ struct PointLightJob : RenderJob
 
 struct RenderScene
 {
-    ::Camera* Camera;
+    ::Camera* Camera = nullptr;
     std::list<std::shared_ptr<RenderJob>> ForwardJobs;
     std::list<std::shared_ptr<RenderJob>> PointLightJobs;
     std::list<std::shared_ptr<RenderJob>> DirectionalLightJobs;
     Rectangle Viewport;
+    bool ClearDepth = false;
 
 	void Clear()
 	{

include/Engine/Rendering/RenderState.h

@@ -16,10 +16,10 @@ public:
     bool Disable(GLenum cap);
     bool CullFace(GLenum mode);
     bool ClearColor(glm::vec4 color);
-    bool Clear(GLbitfield mask);
     bool BindFramebuffer(GLint framebuffer);
     bool BlendEquation(GLenum mode);
     bool BlendFunc(GLenum sfactor, GLenum dfactor);
+    bool DepthMask(GLboolean flag);
 
 private:
     std::vector<std::function<void(void)>> m_ResetFunctions;

include/Engine/Rendering/RenderSystem.h

@@ -20,37 +20,26 @@
 class RenderSystem : public ImpureSystem
 {
 public:
-    RenderSystem(EventBroker* eventBrokerer, const IRenderer* renderer, RenderFrame* renderFrame);
+    RenderSystem(World* world, EventBroker* eventBrokerer, const IRenderer* renderer, RenderFrame* renderFrame);
     ~RenderSystem();
 
-    virtual void Update(World* world, double dt) override;
+    virtual void Update(double dt) override;
 
 private:
-    World* m_World = nullptr;
     const IRenderer* m_Renderer;
-
     RenderFrame* m_RenderFrame;
-    bool m_SwitchCamera = false;
     Camera* m_Camera;
-    DebugCameraInputController<RenderSystem>* m_DebugCameraInputController;
-    
-    std::list<ComponentWrapper> m_CameraComponents;
+    EntityWrapper m_CurrentCamera = EntityWrapper::Invalid;
 
     EventRelay<RenderSystem, Events::SetCamera> m_ESetCamera;
-    bool OnSetCamera(const Events::SetCamera &event);
-    EntityID m_CurrentCamera = EntityID_Invalid;
-
-    void switchCamera(EntityID entity);
-
-    void updateCamera(World* world, double dt);
-    void updateProjectionMatrix(ComponentWrapper& cameraComponent);
-    
-    void fillModels(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
+    bool OnSetCamera(Events::SetCamera &event);
     void fillPointLights(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
     void fillDirectionalLights(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
-
     EventRelay<RenderSystem, Events::InputCommand> m_EInputCommand;
     bool OnInputCommand(const Events::InputCommand& e);
+
+    void fillModels(std::list<std::shared_ptr<RenderJob>>& jobs);
+    void fillLight(std::list<std::shared_ptr<RenderJob>>& jobs);
 };
 
 #endif

include/Engine/Rendering/Renderer.h

@@ -11,7 +11,6 @@
 #include "FrameBuffer.h"
 #include "../Core/World.h"
 #include "PickingPass.h"
-#include "DrawScenePass.h"
 #include "LightCullingPass.h"
 #include "DrawFinalPass.h"
 #include "../Core/EventBroker.h"
@@ -43,7 +42,6 @@ private:
     Model* m_UnitQuad;
     Model* m_UnitSphere;
 
-    DrawScenePass* m_DrawScenePass;
     PickingPass* m_PickingPass;
     LightCullingPass* m_LightCullingPass;
     ImGuiRenderPass* m_ImGuiRenderPass;

include/Game/Systems/CapturePointSystem.h

@@ -17,10 +17,10 @@ class CapturePointSystem : public PureSystem
 {
 public:
     //WARNING: on new map, destroy all info in the vectors, as well as reset all variables (just make new?)
-    CapturePointSystem(EventBroker* eventBroker);
+    CapturePointSystem(World* world, EventBroker* eventBroker);
 
     //updatecomponent
-    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& capturePoint, double dt) override;
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& capturePoint, double dt) override;
 
 private:
     //methods which will take care of specific events

include/Game/Systems/HealthSystem.h

@@ -16,10 +16,10 @@
 class HealthSystem : public PureSystem
 {
 public:
-    HealthSystem(EventBroker* eventBroker);
+    HealthSystem(World* world, EventBroker* eventBroker);
 
     //updatecomponent
-    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt) override;
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
 
 private:
     //methods which will take care of specific events

include/Game/Systems/InterpolationSystem.h

@@ -25,14 +25,14 @@ class InterpolationSystem : public PureSystem
         double interpolationTime;
     };
 public:
-    InterpolationSystem(EventBroker* eventBroker)
-        : System(eventBroker)
+    InterpolationSystem(World* world, EventBroker* eventBroker)
+        : System(world, eventBroker)
         , PureSystem("Transform")
     {
         EVENT_SUBSCRIBE_MEMBER(m_EInterpolate, &InterpolationSystem::OnInterpolate);
     }
     ~InterpolationSystem() { }
-    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& transform, double dt) override;
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& transform, double dt) override;
 private:
     std::unordered_map<EntityID, Transform> m_NextTransform;
     std::unordered_map<EntityID, Transform> m_LastReceivedTransform;

include/Game/Systems/PlayerMovementSystem.h

@@ -5,10 +5,10 @@
 class PlayerMovementSystem : public PureSystem
 {
 public:
-    PlayerMovementSystem(EventBroker* eventBroker)
-        : System(eventBroker)
+    PlayerMovementSystem(World* world, EventBroker* eventBroker)
+        : System(world, eventBroker)
         , PureSystem("Player")
     { }
 
-    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt);
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt);
 };

include/Game/Systems/PlayerSpawnSystem.h

@@ -6,9 +6,9 @@
 class PlayerSpawnSystem : public ImpureSystem
 {
 public:
-    PlayerSpawnSystem(EventBroker* eventBroker);
+    PlayerSpawnSystem(World* world, EventBroker* eventBroker);
 
-    virtual void Update(World* world, double dt) override;
+    virtual void Update(double dt) override;
 
 private:
     EventRelay<PlayerSpawnSystem, Events::InputCommand> m_OnInputCommand;

include/Game/Systems/RaptorCopterSystem.h

@@ -4,14 +4,14 @@
 class RaptorCopterSystem : public PureSystem
 {
 public:
-    RaptorCopterSystem(EventBroker* eventBroker)
-        : System(eventBroker)
+    RaptorCopterSystem(World* world, EventBroker* eventBroker)
+        : System(world, eventBroker)
         , PureSystem("RaptorCopter")
     { }
 
-    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt) override
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override
     {
-        ComponentWrapper& transform = world->GetComponent(component.EntityID, "Transform");
+        ComponentWrapper& transform = m_World->GetComponent(component.EntityID, "Transform");
         (glm::vec3&)transform["Orientation"] += (float)(double)component["Speed"] * (float)dt * (glm::vec3)component["Axis"];
     }
 };

include/Game/Systems/SpawnerSystem.h

@@ -13,7 +13,7 @@
 class SpawnerSystem : public System
 {
 public:
-    SpawnerSystem(EventBroker* eventBroker);
+    SpawnerSystem(World* world, EventBroker* eventBroker);
 
     static EntityWrapper Spawn(EntityWrapper spawner, EntityWrapper parent = EntityWrapper::Invalid);