Merge remote-tracking branch 'origin/master' into Importer

# Conflicts:
#	resources/Schema/Entities/RenderingWorld.xml
#	resources/Shaders/ForwardPlus.frag.glsl
#	src/Engine/Editor/EditorSystem.cpp
#	src/Engine/Network/Server.cpp
#	src/Engine/Rendering/DrawFinalPass.cpp
#	src/Tests/OctTreeTestGameClass.cpp
#	src/Tests/OctTreeTestHardCodedTestWorld.h
#	src/Tests/ResourceManagerTest.cpp

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/ComponentPool.h

@@ -61,6 +61,7 @@ public:
 
 	iterator begin() const;
 	iterator end() const;
+    size_t size() 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<<)

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); }
@@ -91,7 +91,7 @@ public:
     void AddProperty(std::string fieldName, T defaultValue)
     {
         m_DefaultValues.push_back(defaultValue);
-        m_ComponentInfo.Fields[fieldName].Name = typeid(T).name();
+        m_ComponentInfo.Fields[fieldName].Type = typeid(T).name();
         m_ComponentInfo.Fields[fieldName].Offset = m_ComponentInfo.Stride;
         m_ComponentInfo.Fields[fieldName].Stride = sizeof(T);
         m_ComponentInfo.Stride += sizeof(T);

include/Engine/Core/ECaptured.h

@@ -0,0 +1,20 @@
+#ifndef ECaptured_h__
+#define ECaptured_h__
+
+#include "EventBroker.h"
+#include "../Core/Entity.h"
+#include "Engine/GLM.h"
+
+namespace Events
+{
+
+    //triggers when a capturePoint has been taken over
+struct Captured : Event
+{
+    int TeamNumberThatCapturedCapturePoint;
+    EntityID CapturePointID;
+};
+
+}
+
+#endif

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/EPlayerDamage.h

@@ -11,8 +11,6 @@ struct PlayerDamage : Event
 {
     double DamageAmount;
     EntityID PlayerDamagedID;
-    //optional TypeOfDamage
-    std::string TypeOfDamage;
 };
 
 }

include/Engine/Core/EShoot.h

@@ -0,0 +1,19 @@
+#ifndef EShoot_h__
+#define EShoot_h__
+
+#include "EventBroker.h"
+#include "../Core/Entity.h"
+#include "Engine/GLM.h"
+
+namespace Events
+{
+
+struct Shoot : Event
+{
+    //ID for who made the shot
+    EntityID shooter;
+};
+
+}
+
+#endif

include/Engine/Core/EWin.h

@@ -0,0 +1,20 @@
+#ifndef EWin_h__
+#define EWin_h__
+
+#include "EventBroker.h"
+#include "../Core/Entity.h"
+#include "Engine/GLM.h"
+
+namespace Events
+{
+
+    //triggers when a team has captured all capturePoints
+struct Win : Event
+{
+    //can be 0 = none, 1,2
+    int TeamThatWon;
+};
+
+}
+
+#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/Octree.h

@@ -1,19 +1,27 @@
 #ifndef Octree_h__
 #define Octree_h__
 
+#include <type_traits>
+
 #include "../Common.h"
 #include "AABB.h"
 
+//Fwd declarations.
 class Ray;
 
+namespace OctSpace
+{
+struct Output;
+struct ContainedObject;
+struct Child;
+}
+
+//T needs to be AABB, or inherit from AABB.
+//T also needs to have a default constructor.
+template<typename T>
 class Octree
 {
 public:
-    struct Output
-    {
-        float CollideDistance;
-    };
-
     Octree() = delete;
     ~Octree();
     //For the root Octree, [octreeBounds] should be a box containing the entire level.
@@ -25,81 +33,201 @@ public:
     Octree(const Octree&& other) = delete;
     Octree& operator= (const Octree& other) = delete;
     //Add a dynamic object (one that moves around) into the tree.
-    void AddDynamicObject(const AABB& box);
+    void AddDynamicObject(const T& object);
     //Add a static object (that does not move) into the tree.
-    void AddStaticObject(const AABB& box);
-    //Get the boxes that are in the same area as the input [box], the boxes are put in [outBoxes].
-    void BoxesInSameRegion(const AABB& box, std::vector<AABB>& outBoxes);
+    void AddStaticObject(const T& object);
+    //Get the objects that are in the same area as the input [box], the objects are put in [outObjects].
+    //The type Box must be AABB, or inherit from AABB.
+    template<typename Box>
+    void ObjectsInSameRegion(const Box& box, std::vector<T>& outObjects);
     //Empty the tree of all objects, static and dynamic.
     void ClearObjects();
     //Empty the tree of all dynamic objects. Static objects remain in the tree.
     void ClearDynamicObjects();
 
     //Returns true if the ray collides with something in the tree. Result is written to [data].
-    bool RayCollides(const Ray& ray, Output& data);
+    bool RayCollides(const Ray& ray, OctSpace::Output& data);
     //Returns true if the box collides with something in the tree. 
     //On collision with a box, that box is written to [outBoxIntersected].
-    //Note: More efficient than calling BoxesInSameRegion from outside and testing there.
+    //Note: More efficient than calling ObjectsInSameRegion from outside and testing there.
     bool BoxCollides(const AABB& boxToTest, AABB& outBoxIntersected);
 
 private:
-    struct Child;    //Fwd declaration;
-    struct ContainedObject
-    {
-        ContainedObject()
-            : Box(AABB())
-            , Checked(false)
-        {}
-        ContainedObject(AABB box)
-            : Box(box)
-            , Checked(false)
-        {}
-        AABB Box;
-        bool Checked;
-    };
-    Child* m_Root;
-    std::vector<ContainedObject> m_StaticObjects;
-    std::vector<ContainedObject> m_DynamicObjects;
-
-    bool m_UpdatedOnce;
-    unsigned int m_BoxID;
-    glm::vec3 m_PrevPos;
-    glm::quat m_PrevOri;
+    OctSpace::Child* m_Root;
+    std::vector<OctSpace::ContainedObject> m_StaticObjects;
+    std::vector<OctSpace::ContainedObject> m_DynamicObjects;
 
     void falsifyObjectChecks();
-
-    struct Child
-    {
-        ~Child();
-        Child(const AABB& octTreeBounds, 
-            int subDivisions, 
-            std::vector<Octree::ContainedObject>& staticObjects, 
-            std::vector<Octree::ContainedObject>& dynamicObjects);
-        Child(const Child& other) = delete;
-        Child(const Child&& other) = delete;
-        Child& operator= (const Child& other) = delete;
-        void AddDynamicObject(const AABB& box);
-        void AddStaticObject(const AABB& box);
-        void BoxesInSameRegion(const AABB& box, std::vector<AABB>& outBoxes) const;
-        void ClearObjects();
-        void ClearDynamicObjects();
-        bool RayCollides(const Ray& ray, Output& data) const;
-        bool BoxCollides(const AABB& boxToTest, AABB& outBoxIntersected) const;
-
-        Child* m_Children[8];
-        //Indices into the lists in Octree.
-        std::vector<int> m_StaticObjIndices;
-        std::vector<int> m_DynamicObjIndices;
-        AABB m_Box;
-        //Reference to the lists in Octree.
-        std::vector<Octree::ContainedObject>& m_StaticObjectsRef;
-        std::vector<Octree::ContainedObject>& m_DynamicObjectsRef;
-
-        inline bool hasChildren() const;
-        int childIndexContainingPoint(const glm::vec3& point) const;
-        std::vector<int> childIndicesContainingBox(const AABB& box) const;
-    };
 };
 
+namespace OctSpace
+{
+
+struct Output
+{
+    float CollideDistance;
+};
+
+struct ContainedObject
+{
+    ContainedObject()
+        : Box(nullptr)
+        , Checked(false)
+    {}
+    template<typename BoxlikeObject>
+    ContainedObject(const BoxlikeObject& box)
+        : Box(new BoxlikeObject(box))
+        , Checked(false)
+    {}
+    std::unique_ptr<AABB> Box;
+    bool Checked;
+};
+
+struct Child
+{
+    ~Child();
+    Child(const AABB& octTreeBounds,
+        int subDivisions,
+        std::vector<ContainedObject>& staticObjects,
+        std::vector<ContainedObject>& dynamicObjects);
+    Child(const Child& other) = delete;
+    Child(const Child&& other) = delete;
+    Child& operator= (const Child& other) = delete;
+    void AddDynamicObject(const AABB& box);
+    void AddStaticObject(const AABB& box);
+    template<typename T, typename Box>
+    void ObjectsInSameRegion(const Box& box, std::vector<T>& outObjects) const;
+    void ClearObjects();
+    void ClearDynamicObjects();
+    bool RayCollides(const Ray& ray, Output& data) const;
+    bool BoxCollides(const AABB& boxToTest, AABB& outBoxIntersected) const;
+
+    Child* m_Children[8];
+    //Indices into the lists in Octree.
+    std::vector<int> m_StaticObjIndices;
+    std::vector<int> m_DynamicObjIndices;
+    AABB m_Box;
+    //Reference to the lists in Octree.
+    std::vector<ContainedObject>& m_StaticObjectsRef;
+    std::vector<ContainedObject>& m_DynamicObjectsRef;
+
+    inline bool hasChildren() const;
+    int childIndexContainingPoint(const glm::vec3& point) const;
+    std::vector<int> childIndicesContainingBox(const AABB& box) const;
+};
+
+}
+
+template<typename T>
+Octree<T>::Octree(const AABB& octTreeBounds, int subDivisions)
+    : m_Root(new OctSpace::Child(octTreeBounds, subDivisions, m_StaticObjects, m_DynamicObjects))
+{
+    static_assert(std::is_base_of<AABB, T>::value, "template argument type T in Octree must be a subclass of AABB.");
+}
+
+template<typename T>
+Octree<T>::~Octree()
+{
+    delete m_Root;
+}
+
+template<typename T>
+void Octree<T>::AddDynamicObject(const T& object)
+{
+    m_Root->AddDynamicObject(object);
+    m_DynamicObjects.emplace_back(object);
+}
+
+template<typename T>
+void Octree<T>::AddStaticObject(const T& object)
+{
+    m_Root->AddStaticObject(object);
+    m_StaticObjects.emplace_back(object);
+}
+
+template<typename T>
+template<typename Box>
+void Octree<T>::ObjectsInSameRegion(const Box& box, std::vector<T>& outObjects)
+{
+    static_assert(std::is_base_of<AABB, Box>::value, "template argument type Box in Octree<T>::ObjectsInSameRegion must be a subclass of AABB.");
+    falsifyObjectChecks();
+    m_Root->ObjectsInSameRegion(box, outObjects);
+}
+
+template<typename T>
+void Octree<T>::ClearObjects()
+{
+    m_StaticObjects.clear();
+    m_DynamicObjects.clear();
+    m_Root->ClearObjects();
+}
+
+template<typename T>
+void Octree<T>::ClearDynamicObjects()
+{
+    m_DynamicObjects.clear();
+    m_Root->ClearDynamicObjects();
+}
+
+template<typename T>
+bool Octree<T>::RayCollides(const Ray& ray, OctSpace::Output& data)
+{
+    falsifyObjectChecks();
+    data.CollideDistance = -1;
+    return m_Root->RayCollides(ray, data);
+}
+
+template<typename T>
+bool Octree<T>::BoxCollides(const AABB& boxToTest, AABB& outBoxIntersected)
+{
+    falsifyObjectChecks();
+    return m_Root->BoxCollides(boxToTest, outBoxIntersected);
+}
+
+template<typename T>
+void Octree<T>::falsifyObjectChecks()
+{
+    for (auto& obj : m_StaticObjects) {
+        obj.Checked = false;
+    }
+    for (auto& obj : m_DynamicObjects) {
+        obj.Checked = false;
+    }
+}
+
+template<typename T, typename Box>
+void OctSpace::Child::ObjectsInSameRegion(const Box& box, std::vector<T>& outObjects) const
+{
+    if (hasChildren()) {
+        for (auto i : childIndicesContainingBox(box)) {
+            m_Children[i]->ObjectsInSameRegion(box, outObjects);
+        }
+    } else {
+        size_t startIndex = outObjects.size();
+        int numDuplicates = 0;
+        outObjects.resize(outObjects.size() + m_StaticObjIndices.size() + m_DynamicObjIndices.size());
+        for (size_t i = 0; i < m_StaticObjIndices.size(); ++i) {
+            ContainedObject& obj = m_StaticObjectsRef[m_StaticObjIndices[i]];
+            if (obj.Checked) {
+                ++numDuplicates;
+            } else {
+                obj.Checked = true;
+                outObjects[startIndex + i - numDuplicates] = *static_cast<T*>(obj.Box.get());
+            }
+        }
+        for (size_t i = 0; i < m_DynamicObjIndices.size(); ++i) {
+            ContainedObject& obj = m_DynamicObjectsRef[m_DynamicObjIndices[i]];
+            if (obj.Checked) {
+                ++numDuplicates;
+            } else {
+                obj.Checked = true;
+                outObjects[startIndex + i - numDuplicates] = *static_cast<T*>(obj.Box.get());
+            }
+        }
+        for (size_t i = 0; i < numDuplicates; ++i) {
+            outObjects.pop_back();
+        }
+    }
+}
 
 #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