Use CommonFunctions::DeleteTexture() instead

Restart map

include/Engine/Collision/Collision.h

@@ -12,7 +12,7 @@
 #include "../Core/AABB.h"
 #include "Rendering/RawModelCustom.h"
 //#include "Rendering/RawModelAssimp.h"
-#include "../Core/Transform.h"
+#include "../Core/TransformSystem.h"
 #include "../Core/Entity.h"
 #include "../Core/EntityWrapper.h"
 #include "EntityAABB.h"

include/Engine/Core/ComponentInfo.h

@@ -2,6 +2,7 @@
 #define ComponentInfo_h__
 
 #include "../Common.h"
+#include "Entity.h"
 #include <boost/shared_array.hpp>
 
 struct ComponentInfo
@@ -21,6 +22,7 @@ struct ComponentInfo
     {
         std::string Name;
         std::string Type;
+        unsigned char Index;
         unsigned int Offset;
         unsigned int Stride;
     };
@@ -32,6 +34,16 @@ struct ComponentInfo
     unsigned int Stride = 0;
     boost::shared_array<char> Defaults = nullptr;
 	std::shared_ptr<Meta_t> Meta = nullptr;
+
+    std::size_t GetHeaderSize() const
+    {
+        std::size_t size = 0;
+
+        // A component block starts with an entity ID
+        size += sizeof(EntityID);
+
+        return size;
+    }
 };
 
 template<>

include/Engine/Core/ComponentPool.h

@@ -5,16 +5,15 @@
 #include "MemoryPool.h"
 #include "ComponentInfo.h"
 #include "ComponentWrapper.h"
+#include "DirtySet.h"
 
+
+class ComponentPool;
 class ComponentPoolForwardIterator
 	: public std::iterator<std::forward_iterator_tag, ComponentWrapper>
 {
 public:
-    ComponentPoolForwardIterator(const ComponentInfo& componentInfo, const MemoryPool<char>::iterator begin, const MemoryPool<char>::iterator end) 
+    ComponentPoolForwardIterator(ComponentPool* pool, const MemoryPool<char>::iterator begin, const MemoryPool<char>::iterator end);
-        : m_ComponentInfo(componentInfo)
-        , m_MemoryPoolIterator(begin)
-        , m_MemoryPoolEnd(end)
-    { }
 
 	ComponentPoolForwardIterator(const ComponentPoolForwardIterator& other) = default;
 	ComponentPoolForwardIterator(ComponentPoolForwardIterator&& other) = default;
@@ -27,6 +26,7 @@ public:
 	ComponentWrapper operator*() const;
 
 private:
+    ComponentPool* m_ComponentPool;
     const ComponentInfo& m_ComponentInfo;
 	MemoryPool<char>::iterator m_MemoryPoolIterator;
 	const MemoryPool<char>::iterator m_MemoryPoolEnd;
@@ -34,6 +34,7 @@ private:
 
 class ComponentPool
 {
+    friend class ComponentPoolForwardIterator;
 public:
 	typedef ComponentPoolForwardIterator iterator;
 	typedef ptrdiff_t difference_type;
@@ -42,9 +43,10 @@ public:
 	typedef ComponentWrapper* pointer;
 	typedef ComponentWrapper& reference;
 
-    ComponentPool(const ::ComponentInfo& ci) 
+    ComponentPool(const ::ComponentInfo& ci, World* world) 
         : m_ComponentInfo(ci)
-        , m_Pool(ci.Meta->Allocation, sizeof(EntityID) + ci.Stride)
+        , m_Pool(ci.Meta->Allocation, ci.GetHeaderSize() + ci.Stride)
+        , m_World(world)
     { }
     ~ComponentPool();
 	ComponentPool(const ComponentPool& other);
@@ -61,8 +63,8 @@ public:
     // Delete a component and free its memory
     void Delete(ComponentWrapper& wrapper);
 
-	iterator begin() const;
+    iterator begin();
-	iterator end() const;
+	iterator end();
     size_t size() const;
 
 	//Dumps information about what the pool memory looks like right now 
@@ -80,6 +82,8 @@ private:
     ::ComponentInfo m_ComponentInfo;
     MemoryPool<char> m_Pool;
     std::unordered_map<EntityID, char*> m_EntityToComponent;
+    DirtySet m_DirtySet;
+    World* m_World;
 };
 
 #endif

include/Engine/Core/ComponentWrapper.h

@@ -4,46 +4,32 @@
 #include <boost/shared_array.hpp>
 #include <boost/any.hpp>
 #include "../Common.h"
+#include "../GLM.h"
 #include "Entity.h"
 #include "ComponentInfo.h"
+#include "DirtySet.h"
 #include "Util/Any.h"
 
-template <typename T, typename Enable = void>
+class World;
-struct ComponentField { };
-
-template <typename T>
-struct ComponentField<T, typename std::enable_if<std::is_trivially_copyable<T>::value>::type>
-{
-    static T& Get(const ComponentInfo::Field_t& info, char* data) { return *reinterpret_cast<T*>(data); }
-    static void Set(const ComponentInfo::Field_t& info, char* data, const T& value) { Get(data) = value; }
-};
-
-template <>
-struct ComponentField<std::string, void>
-{
-    static std::string& Get(const ComponentInfo::Field_t& info, char* data) { return **reinterpret_cast<std::string**>(data); }
-    static void Set(const ComponentInfo::Field_t& info, char* data, const std::string& value) { Get(info, data) = value; }
-};
 
 struct ComponentWrapper
 {
-    ComponentWrapper(const ComponentInfo& componentInfo, char* data)
+    ComponentWrapper(const ComponentInfo& componentInfo, char* data, ::DirtyBitField* dirtyBitField, World* world);
-        : Info(componentInfo)
-        , EntityID(*reinterpret_cast<::EntityID*>(data))
-        , Data(data + sizeof(::EntityID))
-    { }
 
+    World* m_World;
     const ComponentInfo& Info;
     const ::EntityID EntityID;
     char* Data;
+    ::DirtyBitField* DirtyBitField = nullptr;
 
-    ComponentInfo::EnumType Enum(const char* fieldName, const char* enumKey)
+    ComponentInfo::EnumType Enum(const char* fieldName, const char* enumKey);
-    {
+
-        return Info.Meta->FieldEnumDefinitions.at(fieldName).at(enumKey);
+    bool Dirty(DirtySetType type, const std::string& fieldName);
-    }
+    void SetDirty(DirtySetType type, const std::string& fieldName, bool dirty = true);
+    void SetAllDirty(const std::string& fieldName, bool dirty = true);
 
     template <typename T>
-    T& Field(std::string name)
+    T& Field(const std::string& name)
     {
         const ComponentInfo::Field_t& field = Info.Fields.at(name);
         if (sizeof(T) > field.Stride) {
@@ -55,13 +41,15 @@ struct ComponentWrapper
     }
 
     template <typename T>
-    void SetField(std::string name, const T value) { Field<T>(name) = value; }
+    void SetField(const std::string& name, const T& value) 
-    //template <typename T>
+    { 
-    //void SetField(std::string name, T& value) { Field<T>(name) = value; }
+        Field<T>(name) = value; 
+        SetAllDirty(name);
+    }
 
     // Specialization for string literals
     template <std::size_t N>
-    void SetField(std::string name, const char(&value)[N]) { Field<std::string>(name) = std::string(value); }
+    void SetField(const std::string& name, const char(&value)[N]) { SetField(name, std::string(value)); }
 
     void Copy(ComponentWrapper& destination)
     {
@@ -95,40 +83,163 @@ struct ComponentWrapper
     struct SubscriptProxy
     {
         friend struct ComponentWrapper;
-    private:
+  
-        SubscriptProxy(ComponentWrapper* component, std::string propertyName)
+    public:
+        SubscriptProxy(ComponentWrapper* component, std::string fieldName)
             : m_Component(component)
-            , m_PropertyName(propertyName)
+            , m_FieldName(fieldName)
         { }
 
         ComponentWrapper* m_Component;
-        std::string m_PropertyName;
+        std::string m_FieldName;
 
     public:
         // Return the integer value of an enum type key for this field
-        ComponentInfo::EnumType Enum(const char* enumKey) { return m_Component->Enum(m_PropertyName.c_str(), enumKey); }
+        ComponentInfo::EnumType Enum(const char* enumKey) { return m_Component->Enum(m_FieldName.c_str(), enumKey); }
+        bool Dirty(DirtySetType type) { return m_Component->Dirty(type, m_FieldName); }
+        void SetDirty(DirtySetType type, bool dirty = true) { m_Component->SetDirty(type, m_FieldName, dirty); }
+        void SetAllDirty(bool dirty = true) { m_Component->SetAllDirty(m_FieldName, dirty); }
 
-        template <typename T>
+        operator const double&() { return m_Component->Field<double>(m_FieldName); }
-        operator T&() { return m_Component->Field<T>(m_PropertyName); }
+        operator const float&() { return m_Component->Field<float>(m_FieldName); }
+        operator const int&() { return m_Component->Field<int>(m_FieldName); }
+        operator const glm::vec3&() { return m_Component->Field<glm::vec3>(m_FieldName); }
+        operator const glm::vec4&() { return m_Component->Field<glm::vec4>(m_FieldName); }
+        operator const glm::quat&() { return m_Component->Field<glm::quat>(m_FieldName); }
+        operator const bool&() { return m_Component->Field<bool>(m_FieldName); }
+        operator const std::string&() { return m_Component->Field<std::string>(m_FieldName); }
 
+        // Don't allow non-const references
+        // If this wasn't deleted, the above overloads would still get called for some reason...
+        template <
+            typename T,
+            typename = typename std::enable_if<!std::is_base_of<::FIELDLOL, T>::value>::type
+        >
+        //operator T&() = delete;
+        operator T&() { static_assert(constexpr(false), "https://github.com/teamfisk/TacticalZ/pull/212"); }
+
+        // Value assignment
         template <typename T>
-        void operator=(const T val) { m_Component->SetField<T>(m_PropertyName, val); }
+        void operator=(const T& val) { m_Component->SetField<T>(m_FieldName, val); }
-        // TODO: Pass by reference and rvalue (universal reference?)
-        //template <typename T>
-        //void operator=(T& val) { m_Component->SetField<T>(m_PropertyName, val); }
 
         // Specialization for string literals
         template <std::size_t N>
-        void operator=(const char(&val)[N]) { m_Component->SetField<N>(m_PropertyName, val); }
+        void operator=(const char(&val)[N]) { m_Component->SetField<N>(m_FieldName, val); }
     };
-    SubscriptProxy operator[](std::string propertyName) { return SubscriptProxy(this, propertyName); }
+    SubscriptProxy operator[](const std::string& propertyName) { return SubscriptProxy(this, propertyName); }
 };
 
+struct FIELDLOL { }; // lol
+
+template <typename T>
+struct FieldBase : FIELDLOL
+{
+    FieldBase(ComponentWrapper::SubscriptProxy& Proxy)
+        : Proxy(Proxy)
+        , Data(Proxy.m_Component->Field<T>(Proxy.m_FieldName))
+    { }
+
+    void SetAllDirty() { Proxy.SetAllDirty(); }
+
+    FieldBase& operator=(const FieldBase& rhs) { Data = rhs.Data; SetAllDirty(); return *this; }
+    FieldBase& operator=(const T& rhs) { Data = rhs; SetAllDirty(); return *this; }
+
+    template <typename T2> FieldBase& operator+=(const T2& rhs) { Data += rhs; SetAllDirty(); return *this; }
+    template <typename T2> FieldBase& operator-=(const T2& rhs) { Data -= rhs; SetAllDirty(); return *this; }
+    template <typename T2> FieldBase& operator*=(const T2& rhs) { Data *= rhs; SetAllDirty(); return *this; }
+    template <typename T2> FieldBase& operator/=(const T2& rhs) { Data /= rhs; SetAllDirty(); return *this; }
+    template <typename T2> FieldBase& operator%=(const T2& rhs) { Data %= rhs; SetAllDirty(); return *this; }
+    template <typename T2> FieldBase& operator&=(const T2& rhs) { Data &= rhs; SetAllDirty(); return *this; }
+    template <typename T2> FieldBase& operator|=(const T2& rhs) { Data |= rhs; SetAllDirty(); return *this; }
+    template <typename T2> FieldBase& operator^=(const T2& rhs) { Data ^= rhs; SetAllDirty(); return *this; }
+    template <typename T2> FieldBase& operator<<=(const T2& rhs) { Data <<= rhs; SetAllDirty(); return *this; }
+    template <typename T2> FieldBase& operator>>=(const T2& rhs) { Data >>= rhs; SetAllDirty(); return *this; }
+
+    T operator+() const { return +Data; }
+    T operator-() const { return -Data; }
+    T operator~() const { return ~Data; }
+
+    FieldBase& operator++() { Data++; SetAllDirty(); return *this; }
+    T operator++(int) { T tmp = Data; operator++(); return tmp; }
+    FieldBase& operator--() { Data--; SetAllDirty(); return *this; }
+    T operator--(int) { T tmp = Data; operator--(); return tmp; }
+
+    operator const T&() const { return Data; }
+    const T& operator*() const { return operator const T&(); }
+
+protected:
+    ComponentWrapper::SubscriptProxy Proxy;
+    T& Data;
+};
+
+template <typename T>
+struct Field : FieldBase<T>
+{
+    using FieldBase<T>::FieldBase;
+    using FieldBase<T>::operator=;
+};
+
+template <>
+struct Field<glm::vec3> : FieldBase<glm::vec3>
+{
+    using FieldBase<glm::vec3>::FieldBase;
+    using FieldBase<glm::vec3>::operator=;
+
+    glm::vec3::value_type x() const { return Data.x; }
+    void x(glm::vec3::value_type val) { Data.x = val; SetAllDirty(); }
+    glm::vec3::value_type y() const { return Data.y; }
+    void y(glm::vec3::value_type val) { Data.y = val; SetAllDirty(); }
+    glm::vec3::value_type z() const { return Data.z; }
+    void z(glm::vec3::value_type val) { Data.z = val; SetAllDirty(); }
+
+    template <typename T> friend glm::vec3 operator+(const Field<glm::vec3>& lhs, const T& rhs) { return static_cast<glm::vec3>(lhs) + glm::vec3(rhs); }
+    template <typename T> friend glm::vec3 operator-(const Field<glm::vec3>& lhs, const T& rhs) { return static_cast<glm::vec3>(lhs) - glm::vec3(rhs); }
+    template <typename T> friend glm::vec3 operator*(const Field<glm::vec3>& lhs, const T& rhs) { return static_cast<glm::vec3>(lhs) * glm::vec3(rhs); }
+    template <typename T> friend glm::vec3 operator/(const Field<glm::vec3>& lhs, const T& rhs) { return static_cast<glm::vec3>(lhs) / glm::vec3(rhs); }
+    template <typename T> friend glm::vec3 operator+(const T& lhs, const Field<glm::vec3>& rhs) { return glm::vec3(lhs) + static_cast<glm::vec3>(rhs); }
+    template <typename T> friend glm::vec3 operator-(const T& lhs, const Field<glm::vec3>& rhs) { return glm::vec3(lhs) - static_cast<glm::vec3>(rhs); }
+    template <typename T> friend glm::vec3 operator*(const T& lhs, const Field<glm::vec3>& rhs) { return glm::vec3(lhs) * static_cast<glm::vec3>(rhs); }
+    template <typename T> friend glm::vec3 operator/(const T& lhs, const Field<glm::vec3>& rhs) { return glm::vec3(lhs) / static_cast<glm::vec3>(rhs); }
+
+    friend glm::vec3& operator+=(glm::vec3& lhs, const Field<glm::vec3>& rhs) { lhs += *rhs; return lhs; }
+};
+
+template <>
+struct Field<glm::vec4> : FieldBase<glm::vec4>
+{
+    //Field(glm::vec4& Data)
+    //    : FieldBase(Data)
+    //{ }
+    using FieldBase<glm::vec4>::FieldBase;
+    using FieldBase<glm::vec4>::operator=;
+
+    glm::vec4::value_type x() const { return Data.x; }
+    void x(glm::vec4::value_type val) { Data.x = val; SetAllDirty(); }
+    glm::vec4::value_type y() const { return Data.y; }
+    void y(glm::vec4::value_type val) { Data.y = val; SetAllDirty(); }
+    glm::vec4::value_type z() const { return Data.z; }
+    void z(glm::vec4::value_type val) { Data.z = val; SetAllDirty(); }
+    glm::vec4::value_type w() const { return Data.w; }
+    void w(glm::vec4::value_type val) { Data.w = val; SetAllDirty(); }
+
+    template <typename T> friend glm::vec4 operator+(const Field<glm::vec4>& lhs, const T& rhs) { return static_cast<glm::vec4>(lhs) + glm::vec4(rhs); }
+    template <typename T> friend glm::vec4 operator-(const Field<glm::vec4>& lhs, const T& rhs) { return static_cast<glm::vec4>(lhs) - glm::vec4(rhs); }
+    template <typename T> friend glm::vec4 operator*(const Field<glm::vec4>& lhs, const T& rhs) { return static_cast<glm::vec4>(lhs) * glm::vec4(rhs); }
+    template <typename T> friend glm::vec4 operator/(const Field<glm::vec4>& lhs, const T& rhs) { return static_cast<glm::vec4>(lhs) / glm::vec4(rhs); }
+    template <typename T> friend glm::vec4 operator+(const T& lhs, const Field<glm::vec4>& rhs) { return glm::vec4(lhs) + static_cast<glm::vec4>(rhs); }
+    template <typename T> friend glm::vec4 operator-(const T& lhs, const Field<glm::vec4>& rhs) { return glm::vec4(lhs) - static_cast<glm::vec4>(rhs); }
+    template <typename T> friend glm::vec4 operator*(const T& lhs, const Field<glm::vec4>& rhs) { return glm::vec4(lhs) * static_cast<glm::vec4>(rhs); }
+    template <typename T> friend glm::vec4 operator/(const T& lhs, const Field<glm::vec4>& rhs) { return glm::vec4(lhs) / static_cast<glm::vec4>(rhs); }
+
+    friend glm::vec4& operator+=(glm::vec4& lhs, const Field<glm::vec4>& rhs) { lhs += *rhs; return lhs; }
+};
+
+
 // A component wrapper that "owns" its data through a shared pointer
 struct SharedComponentWrapper : ComponentWrapper
 {
     SharedComponentWrapper(const ComponentInfo& componentInfo, boost::shared_array<char> data)
-        : ComponentWrapper(componentInfo, data.get())
+        : ComponentWrapper(componentInfo, data.get(), nullptr, nullptr)
         , m_DataReference(data)
     { }
 

include/Engine/Core/DirtySet.h

@@ -0,0 +1,16 @@
+#ifndef DirtySet_h__
+#define DirtySet_h__
+
+#include <set>
+#include "ComponentInfo.h"
+
+enum class DirtySetType
+{
+    Transform,
+    Network
+};
+
+typedef std::unordered_map<DirtySetType, std::set<decltype(ComponentInfo::Field_t::Index)>> DirtyBitField;
+typedef std::unordered_map<EntityID, DirtyBitField> DirtySet;
+
+#endif

include/Engine/Core/ECaptured.h

@@ -1,5 +1,5 @@
-#ifndef ECaptured_h__
+#ifndef Events_Captured_h__
-#define ECaptured_h__
+#define Events_Captured_h__
 
 #include "EventBroker.h"
 #include "../Core/Entity.h"

include/Engine/Core/EEntityDeleted.h

@@ -2,14 +2,14 @@
 #define EEntityDeleted_h__
 
 #include "Event.h"
-#include "Entity.h"
+#include "EntityWrapper.h"
 
 namespace Events
 {
 
 struct EntityDeleted : Event
 {
-    EntityID DeletedEntity;
+    EntityWrapper DeletedEntity;
     // True if the entity deletion was triggered because the entity's parent was deleted before it
     bool Cascaded;
 };

include/Engine/Core/EntityWrapper.h

@@ -45,8 +45,9 @@ struct EntityWrapper
 
 private:
     EntityWrapper firstChildByNameRecursive(const std::string& name, EntityID parent);
-    EntityWrapper cloneRecursive(EntityWrapper entity, EntityWrapper parent);
     void childrenWithComponentRecursive(const std::string& componentType, EntityWrapper& entity, std::vector<EntityWrapper>& childrenWithComponent);
+    static void fillRelationships(std::unordered_multimap<EntityWrapper, EntityWrapper>& relationMap, EntityWrapper entity);
+    static void recreateRelationships(const std::unordered_multimap<EntityWrapper, EntityWrapper>& relationMap, EntityWrapper templateEntity, EntityWrapper parent = EntityWrapper::Invalid);
 };
 
 namespace std

include/Engine/Core/ResourceManager.h

@@ -19,6 +19,7 @@ class Resource
 
 protected:
 	Resource() { }
+    virtual ~Resource() = default;
 
 public:
     //Should be thrown in a Resource's constructor if it cannot complete because another resource is still loading.

include/Engine/Core/SystemPipeline.h

@@ -81,7 +81,7 @@ public:
             for (auto& pair : group.PureSystems) {
                 const std::string& componentName = pair.first;
                 auto& systems = pair.second;
-                const ComponentPool* pool = m_World->GetComponents(componentName);
+                ComponentPool* pool = m_World->GetComponents(componentName);
                 if (pool == nullptr) {
                     continue;
                 }

include/Engine/Core/Transform.h

@@ -1,25 +0,0 @@
-#ifndef Transform_h__
-#define Transform_h__
-
-#include "../GLM.h"
-#include "World.h"
-#include "EntityWrapper.h"
-
-namespace Transform
-{
-
-glm::mat4 AbsoluteTransformation(EntityWrapper entity);
-glm::vec3 AbsolutePosition(EntityWrapper entity);
-glm::vec3 AbsolutePosition(World* world, EntityID entity);
-glm::vec3 AbsoluteOrientationEuler(EntityWrapper entity);
-glm::quat AbsoluteOrientation(EntityWrapper entity);
-glm::quat AbsoluteOrientation(World* world, EntityID entity);
-glm::vec3 AbsoluteScale(EntityWrapper entity);
-glm::vec3 AbsoluteScale(World* world, EntityID entity);
-glm::mat4 ModelMatrix(EntityWrapper entity);
-glm::mat4 ModelMatrix(EntityID entity, World* world);
-glm::vec3 TransformPoint(const glm::vec3& point, const glm::mat4& matrix);
-
-}
-
-#endif

include/Engine/Core/TransformSystem.h

@@ -0,0 +1,39 @@
+#ifndef Transform_h__
+#define Transform_h__
+
+#include "../GLM.h"
+#include "System.h"
+#include "EEntityDeleted.h"
+
+class TransformSystem : public System
+{
+public:
+    TransformSystem(SystemParams params);
+
+    //glm::mat4 AbsoluteTransformation(EntityWrapper entity);
+    static glm::vec3 AbsolutePosition(EntityWrapper entity);
+    static glm::vec3 AbsolutePosition(World* world, EntityID entity);
+    static glm::vec3 AbsoluteOrientationEuler(EntityWrapper entity);
+    static glm::quat AbsoluteOrientation(EntityWrapper entity);
+    static glm::quat AbsoluteOrientation(World* world, EntityID entity);
+    static glm::vec3 AbsoluteScale(EntityWrapper entity);
+    static glm::vec3 AbsoluteScale(World* world, EntityID entity);
+    static glm::mat4 ModelMatrix(EntityWrapper entity);
+    static glm::mat4 ModelMatrix(EntityID entity, World* world);
+    static glm::vec3 TransformPoint(const glm::vec3& point, const glm::mat4& matrix);
+
+    static int RecalculatedPositions;
+    static int RecalculatedOrientations;
+    static int RecalculatedScales;
+
+private:
+    static std::unordered_map<EntityWrapper, glm::vec3> PositionCache;
+    static std::unordered_map<EntityWrapper, glm::quat> OrientationCache;
+    static std::unordered_map<EntityWrapper, glm::vec3> ScaleCache;
+    static std::unordered_map<EntityWrapper, glm::mat4> MatrixCache;
+
+    EventRelay<TransformSystem, Events::EntityDeleted> m_EEntityDeleted;
+    bool OnEntityDeleted(const Events::EntityDeleted& e);
+};
+
+#endif

include/Engine/Core/World.h

@@ -35,7 +35,7 @@ public:
     // Delete a component off an entity
     void DeleteComponent(EntityID entity, const std::string& componentType);
     // Get all components of the specified type
-    const ComponentPool* GetComponents(const std::string& componentType);
+    ComponentPool* GetComponents(const std::string& componentType);
     // Get entity parent
     EntityID GetParent(EntityID entity);
     // Change the parent of an entity

include/Engine/Input/FirstPersonInputController.h

@@ -30,7 +30,7 @@ public:
     virtual bool OnCommand(const Events::InputCommand& e) override;
     virtual void Reset();
 
-    void AssaultDashCheck(double dt, bool isJumping, double assaultDashCoolDownMaxTimer, double& assaultDashCoolDownTimer, EntityID playerID);
+    void AssaultDashCheck(double dt, bool isJumping, double assaultDashCoolDownMaxTimer, Field<double> assaultDashCoolDownTimer, EntityID playerID);
     virtual bool AssaultDashDoubleTapped() const { return m_AssaultDashDoubleTapped; }
     virtual bool PlayerIsDashing() const { return m_PlayerIsDashing; }
     bool SpecialAbilityKeyDown() const { return m_SpecialAbilityKeyDown; }
@@ -358,7 +358,7 @@ bool FirstPersonInputController<EventContext>::OnLockMouse(const Events::LockMou
 }
 
 template <typename EventContext>
-void FirstPersonInputController<EventContext>::AssaultDashCheck(double dt, bool isJumping, double assaultDashCoolDownMaxTimer, double& assaultDashCoolDownTimer, EntityID playerID) {
+void FirstPersonInputController<EventContext>::AssaultDashCheck(double dt, bool isJumping, double assaultDashCoolDownMaxTimer, Field<double> assaultDashCoolDownTimer, EntityID playerID) {
     m_AssaultDashDoubleTapDeltaTime += dt;
     assaultDashCoolDownTimer -= dt;
     //cooldown = assaultDashCoolDownMaxTimer sec, pretend the dash lasts 0.25 sec (for friction to do its work)

include/Engine/Network/Client.h

@@ -32,6 +32,9 @@
 #include "../Game/Events/EDashAbility.h"
 #include "Network/EDisplayServerlist.h"
 #include "Network/EConnectRequest.h"
+#include "Network/EPlayerDisconnected.h"
+#include "Game/Events/EReset.h"
+
 class Client : public Network
 {
 public:
@@ -40,7 +43,7 @@ public:
     ~Client();
 
     void Connect(std::string address, int port);
-    void Update() override;
+    void Update(double dt) override;
 private:
     UDPClient m_Unreliable;
     TCPClient m_Reliable;
@@ -74,10 +77,10 @@ private:
     // Network logic
     PlayerDefinition m_PlayerDefinitions[8];
     SnapshotDefinitions m_NextSnapshot;
-    double m_DurationOfPingTime;
+    double m_DurationOfPingTime = 0;
-    std::clock_t m_StartPingTime;
+    double m_StartPingTime = 0;
-    std::clock_t m_TimeSinceSentInputs;
+    double m_TimeSinceSentInputs = 0;
-    unsigned int m_SendInputIntervalMs;
+    double m_SendInputInterval = 0.033;
     std::vector<Events::InputCommand> m_InputCommandBuffer;
 
     // Private member functions
@@ -100,6 +103,7 @@ private:
     void parseDoubleJump(Packet& packet);
     void parseDashEffect(Packet& packet);
     void parseAmmoPickup(Packet& packet);
+    void parseRemoveWorld(Packet& packet);
     void InterpolateFields(Packet& packet, const ComponentInfo & componentInfo, const EntityID & entityID, const std::string & componentType);
     void parseSnapshot(Packet& packet);
     void identifyPacketLoss();
@@ -109,7 +113,6 @@ private:
     void sendLocalPlayerTransform();
     void becomePlayer();
     void displayServerlist();
-    void removeWorld();
     void createMainMenu();
     // Mapping Logic
     // Returns if local EntityID exist in map
@@ -138,8 +141,8 @@ private:
     UDPClient m_ServerlistRequest;
     std::vector<ServerInfo> m_Serverlist;
     bool m_SearchingForServers = false;
-    std::clock_t m_StartSearchTime;
+    double m_TimeSearched = 0;
-    double m_SearchingTime = 200; // Config I guess
+    double m_SearchingTime = 0.2; // Config I guess
 };
 
 #endif

include/Engine/Network/MessageType.h

@@ -23,6 +23,7 @@ enum class MessageType
     OnDashEffect,
     ServerlistRequest,
     AmmoPickup,
+    RemoveWorld,
     Invalid
 };
 

include/Engine/Network/Network.h

@@ -22,7 +22,7 @@ public:
     Network(World* world, EventBroker* eventBroker);
     virtual ~Network() { };
 
-    virtual void Update() = 0;
+    virtual void Update(double dt) = 0;
 
 protected:
     World* m_World;
@@ -40,6 +40,7 @@ protected:
     void saveToFile();
     void updateNetworkData();
     void popNetworkSegmentOfHeader(Packet& packet);
+    void removeWorld();
 };
 
 #endif

include/Engine/Network/Server.h

@@ -11,6 +11,7 @@
 #include "Network/MessageType.h"
 #include "Network/PlayerDefinition.h"
 #include "Core/World.h"
+#include "Core/EntityFile.h"
 #include "Core/EventBroker.h"
 #include "../Network/Network.h"
 #include "Input/EInputCommand.h"
@@ -24,6 +25,8 @@
 #include "Core/EPlayerDeath.h"
 #include "Network/EPlayerConnected.h"
 #include "Network/EKillDeath.h"
+#include "Core/EWin.h"
+#include "Game/Events/EReset.h"
 
 class Server : public Network
 {
@@ -31,7 +34,7 @@ public:
     Server(World* world, EventBroker* eventBroker, int port);
     ~Server();
 
-    void Update() override;
+    void Update(double dt) override;
 
 private:
     // Network channels
@@ -41,6 +44,7 @@ private:
     // dont forget to set these in the childrens receive logic
     boost::asio::ip::address m_Address;
     int m_Port = 27666;
+    bool m_GameIsOver = false;
     // Sending messages to client logic
     std::map<PlayerID, PlayerDefinition> m_ConnectedPlayers;
     std::vector<PlayerID> m_PlayersToDisconnect;
@@ -48,14 +52,14 @@ private:
     char readBuffer[BUFFERSIZE] = { 0 };
     size_t bytesRead = 0;
     // time for previouse message
-    std::clock_t previousePingMessage = std::clock();
+    double previousPingMessage = 0;
-    std::clock_t previousSnapshotMessage = std::clock();
+    double previousSnapshotMessage = 0;
-    std::clock_t timOutTimer = std::clock();
+    double timeOutTimer = 0;
 
-    // How often we send messages (milliseconds)
+    // How often we send messages (seconds)
-    float pingIntervalMs;
+    double pingInterval = 1;
-    float snapshotInterval;
+    double snapshotInterval = 0.05;
-    int checkTimeOutInterval = 100;
+    double checkTimeOutInterval = 0.1;
     int m_NextPlayerID = 0;
     std::vector<Events::InputCommand> m_InputCommandsToBroadcast;
     //Timers
@@ -71,6 +75,7 @@ private:
     void reliableBroadcast(Packet& packet);
     void unreliableBroadcast(Packet& packet);
     void sendSnapshot();
+    void createWorldSnapshot(Packet& packet);
     void addPlayersToPacket(Packet& packet, EntityID entityID);
     void addChildrenToPacket(Packet& packet, EntityID entityID);
     void addInputCommandsToPacket(Packet& packet);
@@ -83,6 +88,7 @@ private:
     void kick(PlayerID player);
     PlayerID getPlayerIDFromEndpoint();
     PlayerID getPlayerIDFromEntityID(EntityID entityID);
+    void resetMap();
     void parsePlayerTransform(Packet& packet);
     void parseOnInputCommand(Packet& packet);
     void parseClientPing();
@@ -110,6 +116,8 @@ private:
     bool OnAmmoPickup(const Events::AmmoPickup& e);
     EventRelay<Server, Events::PlayerDeath> m_EPlayerDeath;
     bool OnPlayerDeath(const Events::PlayerDeath& e);
+    EventRelay<Server, Events::Win> m_EWin;
+    bool OnWin(const Events::Win& e);
 };
 
 #endif

include/Engine/Rendering/CubeMapPass.h

@@ -3,6 +3,7 @@
 
 #include "IRenderer.h"
 #include "ShaderProgram.h"
+#include "PNG.h"
 
 class CubeMapPass
 {
@@ -21,7 +22,7 @@ private:
     IRenderer* m_Renderer;
     std::string m_PreviusCubeMapTexture;
 
-    std::vector<Texture*> m_CubeMapTextures;
+    std::vector<std::string> m_CubeMapTextures;
 };
 
 #endif 

include/Engine/Rendering/DirectionalLightJob.h

@@ -7,7 +7,7 @@
 #include "../GLM.h"
 #include "../Core/ComponentWrapper.h"
 #include "RenderJob.h"
-#include "../Core/Transform.h"
+#include "../Core/TransformSystem.h"
 #include "../Core/World.h"
 
 struct DirectionalLightJob : RenderJob
@@ -16,7 +16,7 @@ struct DirectionalLightJob : RenderJob
         : RenderJob()
     {
 
-        Direction = glm::vec4(0,0,-1,0) * glm::inverse(Transform::AbsoluteOrientation(m_World, transformComponent.EntityID));
+        Direction = glm::vec4(0,0,-1,0) * glm::inverse(TransformSystem::AbsoluteOrientation(m_World, transformComponent.EntityID));
         //Direction = glm::vec4((glm::vec3)directionalLightComponent["Direction"], 0.f);
         Color = (glm::vec4)directionalLightComponent["Color"];
         Intensity = (double)directionalLightComponent["Intensity"];

include/Engine/Rendering/DrawFinalPass.h

@@ -76,6 +76,7 @@ private:
 	const ShadowPass* m_ShadowPass;
 
     ShaderProgram* m_ForwardPlusProgram;
+	ShaderProgram* m_ForwardPlusNoShadowsProgram;
     ShaderProgram* m_ExplosionEffectProgram;
 	ShaderProgram* m_ExplosionEffectSplatMapProgram;
     ShaderProgram* m_SpriteProgram;

include/Engine/Rendering/ExplosionEffectJob.h

@@ -18,15 +18,17 @@ struct ExplosionEffectJob : ModelJob
     ExplosionEffectJob(ComponentWrapper explosionEffectComponent, ::Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matGroup, ComponentWrapper modelComponent, ::World* world, glm::vec4 fillColor, float fillPercentage, bool isShielded, bool shadow)
         : ModelJob(model, camera, matrix, matGroup, modelComponent, world, fillColor, fillPercentage, isShielded, shadow)
     {
-        ExplosionOrigin = (glm::vec3)explosionEffectComponent["ExplosionOrigin"];
+        ExplosionOrigin = (Field<glm::vec3>)explosionEffectComponent["ExplosionOrigin"];
-        TimeSinceDeath = (double)explosionEffectComponent["TimeSinceDeath"];
+        TimeSinceDeath = (Field<double>)explosionEffectComponent["TimeSinceDeath"];
-        ExplosionDuration = (double)explosionEffectComponent["ExplosionDuration"];
+        ExplosionDuration = (Field<double>)explosionEffectComponent["ExplosionDuration"];
-        EndColor = (glm::vec4)explosionEffectComponent["EndColor"];
+        EndColor = (Field<glm::vec4>)explosionEffectComponent["EndColor"];
-        Randomness = (bool)explosionEffectComponent["Randomness"];
+        Randomness = (Field<bool>)explosionEffectComponent["Randomness"];
-        RandomnessScalar = (double)explosionEffectComponent["RandomnessScalar"];
+        RandomnessScalar = (Field<double>)explosionEffectComponent["RandomnessScalar"];
-        Velocity = (glm::vec2)explosionEffectComponent["Velocity"];
+        Velocity = (Field<glm::vec2>)explosionEffectComponent["Velocity"];
-        ColorByDistance = (bool)explosionEffectComponent["ColorByDistance"];
+        ColorByDistance = (Field<bool>)explosionEffectComponent["ColorByDistance"];
-        ExponentialAccelaration = (bool)explosionEffectComponent["ExponentialAccelaration"];
+        ExponentialAccelaration = (Field<bool>)explosionEffectComponent["ExponentialAccelaration"];
+        Reverse = (Field<bool>)explosionEffectComponent["Reverse"];Reverse = (bool)explosionEffectComponent["Reverse"];
+        ColorDistanceScalar = (Field<double>)explosionEffectComponent["ColorDistanceScalar"];ColorDistanceScalar = (double)explosionEffectComponent["ColorDistanceScalar"];
     };
 
     glm::vec3 ExplosionOrigin;
@@ -38,12 +40,14 @@ struct ExplosionEffectJob : ModelJob
     glm::vec4 EndColor;
     bool Randomness = false;
     
-    float RandomnessScalar = 1.f;
+    double RandomnessScalar = 1.f;
     glm::vec2 Velocity;
     bool ColorByDistance = false;
     //bool ReverseAnimation = false;
     //bool Wireframe = false;
     bool ExponentialAccelaration = false;
+	bool Reverse = false;
+	double ColorDistanceScalar = 1.f;
 
     std::array<float, 50> RandomNumbers = {
         0.3257552917701f,

include/Engine/Rendering/Image.h

@@ -3,6 +3,8 @@
 
 struct Image
 {
+    virtual ~Image() = default;
+
 	enum class ImageFormat
 	{
 		Unknown,

include/Engine/Rendering/ModelJob.h

@@ -12,7 +12,7 @@
 #include "../Core/ResourceManager.h"
 #include "Camera.h"
 #include "../Core/World.h"
-#include "../Core/Transform.h"
+#include "../Core/TransformSystem.h"
 #include "Skeleton.h"
 #include "ShaderProgram.h"
 #include "BlendTree.h"

include/Engine/Rendering/PointLightJob.h

@@ -7,7 +7,7 @@
 #include "../GLM.h"
 #include "../Core/ComponentWrapper.h"
 #include "RenderJob.h"
-#include "../Core/Transform.h"
+#include "../Core/TransformSystem.h"
 #include "../Core/World.h"
 
 struct PointLightJob : RenderJob
@@ -16,7 +16,7 @@ struct PointLightJob : RenderJob
         : RenderJob()
     {
         Position = glm::vec4((glm::vec3)transformComponent["Position"], 1.0f);
-        Position = glm::vec4(Transform::AbsolutePosition(m_World, transformComponent.EntityID), 1.f);
+        Position = glm::vec4(TransformSystem::AbsolutePosition(m_World, transformComponent.EntityID), 1.f);
         Color = (glm::vec4)pointLightComponent["Color"];
         Radius = (double)pointLightComponent["Radius"];
         Intensity = (double)pointLightComponent["Intensity"];

include/Engine/Rendering/RenderSystem.h

@@ -14,7 +14,7 @@
 #include "ModelJob.h"
 #include "Renderer.h"
 #include "PointLightJob.h"
-#include "../Core/Transform.h"
+#include "../Core/TransformSystem.h"
 #include "../Core/EPlayerSpawned.h"
 #include "../Core/Octree.h"
 #include "../Collision/EntityAABB.h"

include/Engine/Rendering/Renderer.h

@@ -22,7 +22,7 @@
 #include "../Core/EventBroker.h"
 #include "ImGuiRenderPass.h"
 #include "Camera.h"
-#include "../Core/Transform.h"
+#include "../Core/TransformSystem.h"
 #include "imgui/imgui.h"
 #include "TextPass.h"
 #include "Util/CommonFunctions.h"
@@ -71,6 +71,7 @@ private:
     bool m_ResizeWindow = false;
 	int m_SSAO_Quality = 0;
 	int m_GLOW_Quality = 2;
+	bool m_Shadow_Enabled = true;
 
     PickingPass* m_PickingPass;
     LightCullingPass* m_LightCullingPass;

include/Engine/Rendering/ShadowPass.h

@@ -38,6 +38,8 @@ public:
 	void ClearBuffer();
 	void Draw(RenderScene& scene);
 
+	void CheckStatus(bool status);
+
 	void DebugGUI();
 
 	GLuint DepthMap() const { return m_DepthMap; }
@@ -45,6 +47,7 @@ public:
 	std::array<glm::mat4, MAX_SPLITS> LightV() const { return m_LightView; }
 	std::array<float, MAX_SPLITS> FarDistance() const { std::array<float, MAX_SPLITS> f; for (int i = 0; i < MAX_SPLITS; i++) f[i] = m_shadowFrusta[i].FarClip; return f; }
 	int CurrentNrOfSplits() const { return m_CurrentNrOfSplits; }
+	bool EnableShadows() const { return m_EnableShadows; }
 
 	void SetSplitWeight(float split_weight) { m_SplitWeight = split_weight; };
 private:
@@ -75,7 +78,7 @@ private:
 
 	bool m_TransparentObjects = false;
 	bool m_TexturedShadows = false;
-	bool m_EnableShadows = true;
+	bool m_EnableShadows = false;
 
 	int m_CurrentNrOfSplits = 4;
 	float m_SplitWeight = 0.962f;

include/Engine/Rendering/SpriteJob.h

@@ -13,7 +13,7 @@
 #include "../Core/ResourceManager.h"
 #include "Camera.h"
 #include "../Core/World.h"
-#include "../Core/Transform.h"
+#include "../Core/TransformSystem.h"
 #include "Skeleton.h"
 
 struct SpriteJob : RenderJob
@@ -37,7 +37,7 @@ struct SpriteJob : RenderJob
         BlurBackground = (bool)cSprite["BlurBackground"];
 
         Entity = cSprite.EntityID;
-        Position = Transform::AbsolutePosition(world, cSprite.EntityID);
+        Position = TransformSystem::AbsolutePosition(world, cSprite.EntityID);
         Depth = 0;
         if (depthSorted) {
             glm::vec3 viewpos = glm::vec3(camera->ViewMatrix() * glm::vec4(Position, 1));
@@ -50,7 +50,7 @@ struct SpriteJob : RenderJob
         FillColor = fillColor;
         FillPercentage = fillPercentage;
 
-        glm::vec3 scale = Transform::AbsoluteScale(world, cSprite.EntityID);
+        glm::vec3 scale = TransformSystem::AbsoluteScale(world, cSprite.EntityID);
 
         if((bool)cSprite["KeepRatio"] == true) {
             if(scale.y >= scale.x) {

include/Engine/Rendering/TextJob.h

@@ -17,8 +17,8 @@ struct TextJob : RenderJob
         : RenderJob()
     {
         Matrix = matrix;
-        Color = (glm::vec4)textComponent["Color"];
+        Color = (const glm::vec4&)textComponent["Color"];
-        Content = (std::string)textComponent["Content"];
+        Content = (const std::string&)textComponent["Content"];
         Resource = font;
 
         if ((int)textComponent["Alignment"] == textComponent["Alignment"].Enum("Left")) {

include/Engine/Rendering/TextPass.h

@@ -23,6 +23,7 @@ public:
 
 private:
     void renderText(std::string text, Font* font, TextJob::AlignmentEnum alignment, glm::vec4 color, glm::mat4 modelMatrix, glm::mat4 projectionMatrix, glm::mat4 viewMatrix);
+	std::string parseColors(std::string text, std::map<int, glm::vec4>& colorChanges, glm::vec4 originalColor);
 
     Font* font;
     GLuint VAO, VBO;

include/Engine/Rendering/TextureSprite.h

@@ -14,8 +14,6 @@ protected:
 	TextureSprite(std::string path);
 
 public:
-	~TextureSprite();
-
 	void Bind(GLenum textureUnit = GL_TEXTURE0);
 
 	GLuint m_Texture = 0;

include/Engine/Sound/EChangeBGM.h

@@ -0,0 +1,16 @@
+#ifndef Events_ChangeBGM_h__
+#define Events_ChangeBGM_h__
+
+#include <string>
+#include "../Engine/Core/EventBroker.h"
+
+namespace Events
+{
+
+struct ChangeBGM : Event
+{
+    std::string FilePath = "";
+};
+
+}
+#endif // Events_ChangeBGM_h__

include/Engine/Sound/EPlayAnnouncerVoice.h

@@ -0,0 +1,17 @@
+#ifndef Events_PlayAnnouncerVoice_h__
+#define Events_PlayAnnouncerVoice_h__
+
+#include <string>
+#include "../Engine/Core/EventBroker.h"
+
+namespace Events
+{
+
+struct PlayAnonuncerVoice : public Event
+{
+    std::string FilePath = "";
+};
+
+}
+
+#endif

include/Engine/Sound/EPlaySoundOnEntity.h

@@ -12,7 +12,8 @@ namespace Events
 // Sound behavior is thereby specified in the SoundEmitter component.
 struct PlaySoundOnEntity : public Event
 {
-    EntityID EmitterID = 0;
+    EntityWrapper Emitter = EntityWrapper::Invalid;
+    float Gain = 1.f;
     std::string FilePath = "";
 };
 

include/Engine/Sound/ESetAnnouncerGain.h

@@ -0,0 +1,16 @@
+#ifndef Events_SetAnnouncerGain_h__
+#define Events_SetAnnouncerGain_h__
+
+#include "../Engine/Core/EventBroker.h"
+
+namespace Events
+{
+
+struct  SetAnnouncerGain : public Event
+{
+    float Gain = 1;
+};
+
+}
+
+#endif // 

include/Engine/Sound/SoundManager.h

@@ -9,32 +9,35 @@
 #include "OpenAL/al.h"
 #include "OpenAL/alc.h"
 
-#include "imgui/imgui.h"
+#include "../Engine/Core/World.h"
-
+#include "../Engine/Core/EventBroker.h"
-#include "Core/World.h"
-#include "Core/EventBroker.h"
 #include "../Engine/Core/ResourceManager.h"
 #include "../Engine/Core/ConfigFile.h"
-#include "Core/Transform.h" // Absolute transform
+#include "../Engine/Core/TransformSystem.h"
-#include "Sound/Sound.h"
+#include "../Engine/Sound/Sound.h"
 #include "../Engine/Sound/EPlayQueueOnEntity.h"
-#include "Sound/EPlaySoundOnEntity.h"
+#include "../Engine/Sound/EPlaySoundOnEntity.h"
-#include "Sound/EPlaySoundOnPosition.h"
+#include "../Engine/Sound/EPlaySoundOnPosition.h"
-#include "Sound/EPlayBackgroundMusic.h"
+#include "../Engine/Sound/EPlayBackgroundMusic.h"
-#include "Sound/EPauseSound.h"
+#include "../Engine/Sound/EPlayAnnouncerVoice.h"
-#include "Sound/EContinueSound.h"
+#include "../Engine/Sound/EPauseSound.h"
-#include "Sound/EStopSound.h"
+#include "../Engine/Sound/EContinueSound.h"
-#include "Sound/ESetBGMGain.h"
+#include "../Engine/Sound/EStopSound.h"
-#include "Sound/ESetSFXGain.h"
+#include "../Engine/Sound/ESetBGMGain.h"
-#include "Core/EPause.h"
+#include "../Engine/Sound/ESetSFXGain.h"
-#include "Core/EComponentAttached.h"
+#include "../Engine/Sound/ESetAnnouncerGain.h"
+#include "../Engine/Sound/EChangeBGM.h"
+#include "../Engine/Core/EPause.h"
+#include "../Engine/Core/EComponentAttached.h"
 #include "../Core/EPlayerSpawned.h"
 
+
 typedef std::pair<ALuint, std::vector<ALuint>> QueuedBuffers;
 
 enum class SoundType {
     SFX,
-    BGM
+    BGM,
+    Announcer
 };
 
 struct Source
@@ -43,6 +46,7 @@ struct Source
     Sound* SoundResource = nullptr;
     ALuint ALsource;
     SoundType Type;
+    float Duration;
 };
 
 class SoundManager
@@ -74,14 +78,20 @@ private:
     ALenum getSourceState(ALuint source);
     void setGain(Source* source, float gain);
     void setSoundProperties(Source* source, ComponentWrapper* soundComponent);
+    float getDurationSeconds(Source* source);
+    float getTimeOffsetSeconds(Source* source);
 
     // Specific logic
     void playSound(Source* source);
-    // Need to be the same format (sample rate etc)
+    // Needs to be the same format (sample rate etc)
     void playQueue(QueuedBuffers qb);
     void stopSound(Source* source);
     Source* createSource(std::string filePath);
     std::unordered_map<EntityID, Source*> m_Sources;
+    void matchBGMLoop();
+    Source* m_CurrentBGM = nullptr;
+    Source* m_CurrentBGMCombo = nullptr;
+    bool m_DrumLoopHasBeenStarted = false;
 
     // Logic
     World* m_World = nullptr;
@@ -93,6 +103,7 @@ private:
 
     float m_BGMVolumeChannel = 1.0f;
     float m_SFXVolumeChannel = 1.0f;
+    float m_AnnouncerVolumeChannel = 1.0f;
     EntityWrapper m_LocalPlayer = EntityWrapper();
     
     // Events
@@ -102,6 +113,8 @@ private:
     bool OnPlaySoundOnPosition(const Events::PlaySoundOnPosition &e);
     EventRelay<SoundManager, Events::PlayBackgroundMusic> m_EPlayBackgroundMusic;
     bool OnPlayBackgroundMusic(const Events::PlayBackgroundMusic &e);
+    EventRelay<SoundManager, Events::PlayAnonuncerVoice> m_EPlayAnnouncerVoice;
+    bool OnPlayAnnouncerVoice(const Events::PlayAnonuncerVoice& e);
     EventRelay<SoundManager, Events::PauseSound> m_EPauseSound;
     bool OnPauseSound(const Events::PauseSound &e);
     EventRelay<SoundManager, Events::StopSound> m_EStopSound;
@@ -112,6 +125,8 @@ private:
     bool OnSetBGMGain(const Events::SetBGMGain &e);
     EventRelay<SoundManager, Events::SetSFXGain> m_ESetSFXGain; 
     bool OnSetSFXGain(const Events::SetSFXGain &e);
+    EventRelay<SoundManager, Events::SetAnnouncerGain> m_ESetAnnouncerGain;
+    bool OnSetAnnouncerGain(const Events::SetAnnouncerGain& e);
     EventRelay<SoundManager, Events::ComponentAttached> m_EComponentAttached;
     bool OnComponentAttached(const Events::ComponentAttached &e);
     EventRelay<SoundManager, Events::Pause> m_EPause;
@@ -122,6 +137,8 @@ private:
     bool OnPlayerSpawned(const Events::PlayerSpawned &e);
     EventRelay<SoundManager, Events::PlayQueueOnEntity> m_EPlayQueueOnEntity;
     bool OnPlayQueueOnEntity(const Events::PlayQueueOnEntity &e);
+    EventRelay<SoundManager, Events::ChangeBGM> m_EChangeBGM;
+    bool OnChangeBGM(const Events::ChangeBGM &e);
 
 
 };

include/Game/Events/EReset.h

@@ -0,0 +1,16 @@
+#ifndef Events_Reset_h__
+#define Events_Reset_h__
+
+#include "Core/EventBroker.h"
+#include "Core/EntityWrapper.h"
+
+namespace Events
+{
+
+struct Reset : Event
+{
+};
+
+}
+
+#endif

include/Game/Systems/AmmoPickupSystem.h

@@ -2,7 +2,7 @@
 #define AmmoPickupSystem_h__
 
 #include "Core/System.h"
-#include "Core/Transform.h"
+#include "Core/TransformSystem.h"
 #include "Core/ResourceManager.h"
 #include "Core/EntityFile.h"
 #include "Core/EPickupSpawned.h"

include/Game/Systems/CapturePointArrowHUDSystem.h

@@ -7,7 +7,7 @@
 
 #include "Common.h"
 #include "Core/System.h"
-#include "Core/Transform.h"
+#include "Core/TransformSystem.h"
 #include "Core/ECaptured.h"
 
 

include/Game/Systems/CapturePointSystem.h

@@ -9,6 +9,7 @@
 #include "Engine/Collision/ETrigger.h"
 #include "Core/ECaptured.h"
 #include "Core/EWin.h"
+#include "Game/Events/EReset.h"
 
 #include <tuple>
 #include <vector>
@@ -23,6 +24,7 @@ public:
     virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& capturePoint, double dt) override;
 
 private:
+    void Init();
     //methods which will take care of specific events
     EventRelay<CapturePointSystem, Events::TriggerTouch> m_ETriggerTouch;
     bool CapturePointSystem::OnTriggerTouch(const Events::TriggerTouch& e);
@@ -30,6 +32,8 @@ private:
     bool CapturePointSystem::OnTriggerLeave(const Events::TriggerLeave& e);
     EventRelay<CapturePointSystem, Events::Captured> m_ECaptured;
     bool CapturePointSystem::OnCaptured(const Events::Captured& e);
+    EventRelay<CapturePointSystem, Events::Reset> m_EReset;
+    bool CapturePointSystem::OnReset(const Events::Reset& e);
     void ChangeCapturePointModelsVisibility(EntityWrapper &capturePointModels, bool isOwner);
 
     bool m_WinnerWasFound = false;

include/Game/Systems/DamageIndicatorSystem.h

@@ -2,7 +2,7 @@
 #define DamageIndicatorSystem_h__
 
 #include "Core/System.h"
-#include "Core/Transform.h"
+#include "Core/TransformSystem.h"
 #include "Core/ResourceManager.h"
 #include "Core/EntityFile.h"
 #include "Core/EPlayerDamage.h"

include/Game/Systems/ExplosionEffectSystem.h

@@ -3,6 +3,7 @@
 
 #include "Common.h"
 #include "Core/System.h"
+#include "Engine/GLM.h"
 
 class ExplosionEffectSystem : public PureSystem
 {

include/Game/Systems/FloatingEffectSystem.h

@@ -12,8 +12,8 @@ public:
     virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override
     {
         ComponentWrapper& transform = m_World->GetComponent(component.EntityID, "Transform");
-        (double&)component["Time"] += dt;
+        (Field<double>)component["Time"] += dt;
-        (glm::vec3&)transform["Position"] = (float)(double)component["Amplitude"] * glm::sin((glm::two_pi<float>() / (float)(double)component["Period"]) *  (float)(double)component["Time"]) * (glm::vec3)component["Axis"];
+        (Field<glm::vec3>)transform["Position"] = (float)(double)component["Amplitude"] * glm::sin((glm::two_pi<float>() / (float)(double)component["Period"]) *  (float)(double)component["Time"]) * (glm::vec3)component["Axis"];
 
     }
 };

include/Game/Systems/MainMenuSystem.h

@@ -24,6 +24,7 @@ public:
 private:
     IRenderer* m_Renderer;
     void OpenSubMenu(const Events::InputCommand& e);
+    void OpenDropDown(const Events::InputCommand& e);
 
     EventRelay<MainMenuSystem, Events::ButtonClicked> m_EClicked;
     bool OnButtonClick(const Events::ButtonClicked& e);
@@ -36,6 +37,7 @@ private:
 
     std::string m_CurrentCommand = "";
     EntityWrapper m_OpenSubMenu = EntityWrapper::Invalid;
+    EntityWrapper m_DropDown = EntityWrapper::Invalid;
 
 };
 

include/Game/Systems/PickupSpawnSystem.h

@@ -2,7 +2,7 @@
 #define PickupSpawnSystem_h__
 
 #include "Core/System.h"
-#include "Core/Transform.h"
+#include "Core/TransformSystem.h"
 #include "Core/ResourceManager.h"
 #include "Core/EntityFile.h"
 #include "Core/EPickupSpawned.h"

include/Game/Systems/PlayerMovementSystem.h

@@ -33,7 +33,7 @@ private:
     // Used to track afterimages for sprint effect.
     float m_SprintEffectTimer;
     // The logic for making the sound play when player is moving
-    void playerStep(double dt);
+    void playerStep(double dt, EntityWrapper player);
     // Spawn a hexagon at origin of an Entity
     void spawnHexagon(EntityWrapper target);
 

include/Game/Systems/RaptorCopterSystem.h

@@ -1,6 +1,25 @@
 #include "Common.h"
 #include "Core/System.h"
 
+
+
+ //struct FSubscriptProxy
+ //   {
+ //       friend struct ComponentWrapper;
+ //       FSubscriptProxy(ComponentWrapper* component, std::string fieldName)
+ //           : m_Component(component)
+ //           , m_FieldName(fieldName)
+ //       { }
+
+ //       ComponentWrapper* m_Component;
+ //       std::string m_FieldName;
+
+ //   public:
+ //       template <typename T>
+ //       operator Field<T>() { return Field<T>(m_Component->Field<T>(m_FieldName)); }
+
+ //   };
+
 class RaptorCopterSystem : public PureSystem
 {
 public:
@@ -9,9 +28,11 @@ public:
         , PureSystem("RaptorCopter")
     { }
 
-    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cRaptorCopter, double dt) override
     {
-        ComponentWrapper& transform = m_World->GetComponent(component.EntityID, "Transform");
+        ComponentWrapper& cTransform = entity["Transform"];
-        (glm::vec3&)transform["Orientation"] += (float)(double)component["Speed"] * (float)dt * (glm::vec3)component["Axis"];
+        //FSubscriptProxy subOri(&cTransform, "Orientation");
+        //Field<glm::vec3> orientation = subOri;
+        (Field<glm::vec3>)cTransform["Orientation"] += (float)(const double&)cRaptorCopter["Speed"] * (float)dt * (glm::vec3)cRaptorCopter["Axis"];
     }
 };

include/Game/Systems/ScoreScreenSystem.h

@@ -8,6 +8,8 @@
 #include "Core/EPlayerSpawned.h"
 #include "Network/EPlayerConnected.h"
 #include "Network/EPlayerDisconnected.h"
+#include "Game/Events/EReset.h"
+#include "Engine/Input/EInputCommand.h"
 #include "GLM.h"
 
 class ScoreScreenSystem : public PureSystem
@@ -25,6 +27,10 @@ public:
     bool OnPlayerConnected(const Events::PlayerConnected& e);
     EventRelay<ScoreScreenSystem, Events::PlayerDisconnected> m_EPlayerDisconnected;
     bool OnPlayerDisconnected(const Events::PlayerDisconnected& e);
+    EventRelay<ScoreScreenSystem, Events::Reset> m_EReset;
+    bool OnReset(const Events::Reset& e);
+    EventRelay<ScoreScreenSystem, Events::InputCommand> m_EInputCommand;
+    bool OnInputCommand(const Events::InputCommand& e);
 
 private:
     struct PlayerData {

include/Game/Systems/SoundSystem.h

@@ -2,6 +2,7 @@
 #define Systems_SoundSystem_h__
 
 #include <random>
+#include <chrono>
 
 #include "../Engine/Core/System.h"
 #include "../Engine/Core/ResourceManager.h"
@@ -20,9 +21,10 @@
 #include "../Engine/Collision/ETrigger.h"
 #include "../Engine/Sound/EPlaySoundOnEntity.h"
 #include "../Engine/Sound/EPlayBackgroundMusic.h"
+#include "../Engine/Sound/EPlayAnnouncerVoice.h"
 #include "../Game/Events/EDoubleJump.h"
 #include "../Game/Events/EDashAbility.h"
-
+#include "../Engine/Sound/EChangeBGM.h"
 
 class SoundSystem : public PureSystem, ImpureSystem
 {
@@ -33,14 +35,10 @@ public:
 private:
     std::string m_Announcer = "";
     // Logic for playing a sound when a player jumps
-    void playerJumps();
+    void playerJumps(EntityWrapper player);
 
-    // Temporary solution for play test.
+    std::default_random_engine m_RandomGenerator;
-    bool m_DrumsIsPlaying = false;
+    std::uniform_int_distribution<int> m_RandIntDistribution;
-    double m_DrumTimer = 0.0;
-    bool drumTimer(double dt);
-
-    std::default_random_engine generator;
 
     EventRelay<SoundSystem, Events::PlayerSpawned> m_EPlayerSpawned;
     bool OnPlayerSpawned(const Events::PlayerSpawned &e);
@@ -48,10 +46,6 @@ private:
     bool OnInputCommand(const Events::InputCommand &e);
     EventRelay<SoundSystem, Events::DoubleJump> m_EDoubleJump;
     bool OnDoubleJump(const Events::DoubleJump &e);
-    EventRelay<SoundSystem, Events::DashAbility> m_EDashAbility;
-    bool OnDashAbility(const Events::DashAbility &e);
-    EventRelay<SoundSystem, Events::TriggerTouch> m_ETriggerTouch;
-    bool OnTriggerTouch(const Events::TriggerTouch &e);
     EventRelay<SoundSystem, Events::Captured> m_ECaptured;
     bool OnCaptured(const Events::Captured &e);
     EventRelay<SoundSystem, Events::PlayerDamage> m_EPlayerDamage;

include/Game/Systems/SpawnerSystem.h

@@ -6,7 +6,7 @@
 #include "GLM.h"
 #include "Core/System.h"
 #include "Events/ESpawnerSpawn.h"
-#include "Core/Transform.h"
+#include "Core/TransformSystem.h"
 #include "Core/EntityFile.h"
 
 class SpawnerSystem : public System

include/Game/Systems/SpectatorCameraSystem.h

@@ -4,6 +4,7 @@
 #include "Core/System.h"
 #include "Input/EInputCommand.h"
 #include "Network/EPlayerDisconnected.h"
+#include "Game/Events/EReset.h"
 
 class SpectatorCameraSystem : public ImpureSystem
 {
@@ -15,11 +16,14 @@ public:
 private:
     int m_PickedTeam;
     bool m_CamSetToTeamPick;
+    void reset();
 
     EventRelay<SpectatorCameraSystem, Events::InputCommand> m_EInputCommand;
     bool OnInputCommand(const Events::InputCommand& e);
     EventRelay<SpectatorCameraSystem, Events::PlayerDisconnected> m_EDisconnect;
     bool OnDisconnect(const Events::PlayerDisconnected& e);
+    EventRelay<SpectatorCameraSystem, Events::Reset> m_EReset;
+    bool OnReset(const Events::Reset& e);
 };
 
 #endif

include/Game/Systems/Weapon/DefenderWeaponBehaviour.h

@@ -5,6 +5,7 @@
 #include "Collision/Collision.h"
 #include "Core/EPlayerDamage.h"
 #include "Sound/EPlaySoundOnEntity.h"
+#include "Sound/EPlaySoundOnEntity.h"
 
 class DefenderWeaponBehaviour : public WeaponBehaviour<DefenderWeaponBehaviour>
 {

include/Game/Systems/Weapon/WeaponBehaviour.h

@@ -270,7 +270,8 @@ private:
         EntityWrapper thirdPersonAttachment;
         for (auto& attachment : weaponAttachments) {
             ComponentWrapper cWeaponAttachment = attachment["WeaponAttachment"];
-            if ((std::string&)cWeaponAttachment["Weapon"] == m_ComponentType) {
+            Field<std::string> weaponType = cWeaponAttachment["Weapon"];
+            if (*weaponType == m_ComponentType) {
                 ComponentWrapper::SubscriptProxy person = cWeaponAttachment["Person"];
                 if ((ComponentInfo::EnumType)person == person.Enum("FirstPerson")) {
                     firstPersonAttachment = attachment;

resources/DefaultConfig.ini

@@ -39,6 +39,7 @@ ResourceLoading=true
 [Sound]
 BGMVolume=1.0
 SFXVolume=1.0
+AnnouncerVolume=1.0
 Announcer=female
 
 [SSAO]

resources/Schema/Components/CapturePointGameMode.xml

@@ -2,4 +2,5 @@
 <CapturePointGameMode xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="CapturePointGameMode.xsd">
 	<RespawnTime>0.0</RespawnTime>
 	<MaxRespawnTime>8.0</MaxRespawnTime>
+	<ResetCountdown>10.0</ResetCountdown>
 </CapturePointGameMode>

resources/Schema/Components/CapturePointGameMode.xsd

@@ -12,6 +12,9 @@
 				<xs:element name="MaxRespawnTime" type="t:double" minOccurs="0">
 					<xs:annotation><xs:documentation>Players will be spawned when RespawnTime reaches this.</xs:documentation></xs:annotation>
 				</xs:element>
+				<xs:element name="ResetCountdown" type="t:double" minOccurs="0">
+					<xs:annotation><xs:documentation>The map will be reset when time reaches 0.</xs:documentation></xs:annotation>
+				</xs:element>
 			</xs:all>
 		</xs:complexType>
 	</xs:element>

resources/Schema/Components/ExplosionEffect.xml

@@ -1,19 +1,21 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no" ?>
 <ExplosionEffect xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="ExplosionEffect.xsd">
 	<ExplosionOrigin X="0" Y="0" Z="0"/>
-	<TimeSinceDeath>0</TimeSinceDeath>
+	<TimeSinceDeath>0.0</TimeSinceDeath>
-	<ExplosionDuration>2</ExplosionDuration>
+	<ExplosionDuration>2.0</ExplosionDuration>
 	<Speed>1</Speed>
 	<Delay>0</Delay>
 	<!--<Gravity>1</Gravity>-->
 	<!--<GravityForce>1</GravityForce>-->
 	<!--<ObjectRadius>2</ObjectRadius>-->
 	<EndColor R="0" G="0" B="0" A="0"/>
-	<Randomness>0</Randomness>
+	<Randomness>false</Randomness>
-	<RandomnessScalar>1</RandomnessScalar>
+	<RandomnessScalar>1.0</RandomnessScalar>
 	<Velocity X="2" Y="2"/>
-	<ColorByDistance>0</ColorByDistance>
+	<ColorByDistance>false</ColorByDistance>
-	<!--<ReverseAnimation>0</ReverseAnimation>-->
 	<!--<Wireframe>0</Wireframe>-->
-	<ExponentialAccelaration>0</ExponentialAccelaration>
+	<ExponentialAccelaration>false</ExponentialAccelaration>
+	<Pulsate>false</Pulsate>
+	<Reverse>false</Reverse>
+	<ColorDistanceScalar>1.0</ColorDistanceScalar>
 </ExplosionEffect>

resources/Schema/Components/ExplosionEffect.xsd

@@ -44,15 +44,21 @@
 				<xs:element name="ColorByDistance" type="t:bool" minOccurs="0">
 					<xs:annotation><xs:documentation>Change the color by its moved distance instead of by its time</xs:documentation></xs:annotation>
 				</xs:element>
-				<!--<xs:element name="ReverseAnimation" type="t:bool" minOccurs="0">
-					<xs:annotation><xs:documentation>Implosions are cooler</xs:documentation></xs:annotation>
-				</xs:element>-->
 				<!--<xs:element name="Wireframe" type="t:bool" minOccurs="0">
 					<xs:annotation><xs:documentation>Enable/disable wireframe</xs:documentation></xs:annotation>
 				</xs:element>-->
 				<xs:element name="ExponentialAccelaration" type="t:bool" minOccurs="0">
 					<xs:annotation><xs:documentation>Linear/Exponential accelaration</xs:documentation></xs:annotation>
 				</xs:element>
+				<xs:element name="Pulsate" type="t:bool" minOccurs="0">
+					<xs:annotation><xs:documentation>Pulsate the effect</xs:documentation></xs:annotation>
+				</xs:element>
+				<xs:element name="Reverse" type="t:bool" minOccurs="0">
+					<xs:annotation><xs:documentation>Reverse the effect</xs:documentation></xs:annotation>
+				</xs:element>
+				<xs:element name="ColorDistanceScalar" type="t:double" minOccurs="0">
+					<xs:annotation><xs:documentation>Scale the distance of the color change</xs:documentation></xs:annotation>
+				</xs:element>
 			</xs:all>
 		</xs:complexType>
 	</xs:element>

resources/Schema/Components/SoundEmitter.xml

@@ -4,7 +4,7 @@
 	<Gain>1.0</Gain>
 	<Pitch>1.0</Pitch>
 	<Loop>false</Loop>
-	<MaxDistance>20.0</MaxDistance>
+	<MaxDistance>220.0</MaxDistance>
-	<RollOffFactor>1.0</RollOffFactor>
+	<RollOffFactor>10</RollOffFactor>
 	<ReferenceDistance>1.0</ReferenceDistance>
 </SoundEmitter>

resources/Schema/Entities/AmmoPickup.xml

@@ -2,21 +2,26 @@
 <Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
 
   <Components>
-    <c:NetworkComponent/>
     <c:AmmoPickup/>
-    <c:Model>
+    <c:Trigger/>
-      <Resource>Models/Props/PickUps/AmmoPickUp.mesh</Resource>
-    </c:Model>
     <c:RaptorCopter>
       <Speed>8</Speed>
       <Axis X="0" Y="0.100000001" Z="0"/>
     </c:RaptorCopter>
+    <c:Model>
+      <Resource>Models/Props/PickUps/AmmoPickUp.mesh</Resource>
+    </c:Model>
+    <c:NetworkComponent/>
+    <c:PointLight>
+      <Color A="1" B="1" G="0.0823529437" R="1"/>
+      <Radius>1.5</Radius>
+      <Intensity>3</Intensity>
+    </c:PointLight>
     <c:Transform>
-      <Position X="0" Y="2.36784196" Z="0"/>
+      <Position X="0" Y="2.36784196" Z="-0.0281207096"/>
+      <Orientation X="0" Y="18843.5469" Z="0"/>
       <Scale X="0.600000024" Y="0.600000024" Z="0.600000024"/>
-      <Orientation X="0" Y="18717.9453" Z="0"/>
     </c:Transform>
-    <c:Trigger/>
   </Components>
 
   <Children/>

resources/Schema/Entities/CapturePointBorderBlue.xml

@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity name="BlueCapturepointBorde" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Transform>
+      <Position X="0" Y="0.271661639" Z="0"/>
+    </c:Transform>
+  </Components>
+
+  <Children>
+    <Entity name="Bottom">
+      <Components>
+        <c:FloatingEffect>
+          <Period>6</Period>
+          <Time>3</Time>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>0.10000000149011612</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform>
+          <Position X="-0" Y="-8.74227801e-09" Z="-0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/DoubleSidedCylinder.mesh</Resource>
+              <Color A="0.392156869" B="10" G="0.784313738" R="0"/>
+              <Transparent>true</Transparent>
+            </c:Model>
+            <c:Transform>
+              <Position X="0" Y="0.5" Z="0"/>
+              <Scale X="8.19999981" Y="0.0199999996" Z="8.19999981"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="LowerMid">
+      <Components>
+        <c:FloatingEffect>
+          <Period>6</Period>
+          <Time>2</Time>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>0.10000000149011612</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform>
+          <Position X="0" Y="0.0866025388" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/DoubleSidedCylinder.mesh</Resource>
+              <Color A="0.313725501" B="10" G="0.784313738" R="0"/>
+              <Transparent>true</Transparent>
+            </c:Model>
+            <c:Transform>
+              <Position X="0" Y="0.899999976" Z="0"/>
+              <Scale X="8.19999981" Y="0.0199999996" Z="8.19999981"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="UpperMid">
+      <Components>
+        <c:FloatingEffect>
+          <Period>6</Period>
+          <Time>1</Time>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>0.10000000149011612</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform>
+          <Position X="0" Y="0.0866025463" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/DoubleSidedCylinder.mesh</Resource>
+              <Color A="0.196078435" B="10" G="0.784313738" R="0"/>
+              <Transparent>true</Transparent>
+            </c:Model>
+            <c:Transform>
+              <Position X="0" Y="1.29999995" Z="0"/>
+              <Scale X="8.19999981" Y="0.0199999996" Z="8.19999981"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="Top">
+      <Components>
+        <c:FloatingEffect>
+          <Period>6</Period>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>0.10000000149011612</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform/>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/DoubleSidedCylinder.mesh</Resource>
+              <Color A="0.117647059" B="10" G="0.784313738" R="0"/>
+              <Transparent>true</Transparent>
+            </c:Model>
+            <c:Transform>
+              <Position X="0" Y="1.70000005" Z="0"/>
+              <Scale X="8.19999981" Y="0.0199999996" Z="8.19999981"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/CapturePointBorderRed.xml

@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity name="RedCapturepointBorde" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Transform>
+      <Position X="0" Y="0.271661639" Z="0"/>
+    </c:Transform>
+  </Components>
+
+  <Children>
+    <Entity name="Bottom">
+      <Components>
+        <c:FloatingEffect>
+          <Period>6</Period>
+          <Time>3</Time>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>0.10000000149011612</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform>
+          <Position X="-0" Y="-8.74227801e-09" Z="-0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/DoubleSidedCylinder.mesh</Resource>
+              <Color A="0.392156869" B="0" G="0.235294119" R="21.9607849"/>
+              <Transparent>true</Transparent>
+            </c:Model>
+            <c:Transform>
+              <Position X="0" Y="0.5" Z="0"/>
+              <Scale X="8.19999981" Y="0.0199999996" Z="8.19999981"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="LowerMid">
+      <Components>
+        <c:FloatingEffect>
+          <Period>6</Period>
+          <Time>2</Time>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>0.10000000149011612</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform>
+          <Position X="0" Y="0.0866025388" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/DoubleSidedCylinder.mesh</Resource>
+              <Color A="0.313725501" B="0" G="0.235294119" R="21.9607849"/>
+              <Transparent>true</Transparent>
+            </c:Model>
+            <c:Transform>
+              <Position X="0" Y="0.899999976" Z="0"/>
+              <Scale X="8.19999981" Y="0.0199999996" Z="8.19999981"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="UpperMid">
+      <Components>
+        <c:FloatingEffect>
+          <Period>6</Period>
+          <Time>1</Time>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>0.10000000149011612</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform>
+          <Position X="0" Y="0.0866025463" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/DoubleSidedCylinder.mesh</Resource>
+              <Color A="0.196078435" B="0" G="0.235294119" R="21.9607849"/>
+              <Transparent>true</Transparent>
+            </c:Model>
+            <c:Transform>
+              <Position X="0" Y="1.29999995" Z="0"/>
+              <Scale X="8.19999981" Y="0.0199999996" Z="8.19999981"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="Top">
+      <Components>
+        <c:FloatingEffect>
+          <Period>6</Period>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>0.10000000149011612</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform/>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/DoubleSidedCylinder.mesh</Resource>
+              <Color A="0.117647059" B="0" G="0.235294119" R="21.9607849"/>
+              <Transparent>true</Transparent>
+            </c:Model>
+            <c:Transform>
+              <Position X="0" Y="1.70000005" Z="0"/>
+              <Scale X="8.19999981" Y="0.0199999996" Z="8.19999981"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/CapturePointBorderSpectator.xml

@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity name="SpectatorCapturepointBorde" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Transform>
+      <Position X="0" Y="0.271661639" Z="0"/>
+    </c:Transform>
+  </Components>
+
+  <Children>
+    <Entity name="Bottom">
+      <Components>
+        <c:FloatingEffect>
+          <Period>6</Period>
+          <Time>3</Time>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>0.10000000149011612</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform>
+          <Position X="-0" Y="-8.74227801e-09" Z="-0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/DoubleSidedCylinder.mesh</Resource>
+              <Color A="0.392156869" B="8.03921604" G="8.03921604" R="8.03921604"/>
+              <Transparent>true</Transparent>
+            </c:Model>
+            <c:Transform>
+              <Position X="0" Y="0.5" Z="0"/>
+              <Scale X="8.19999981" Y="0.0199999996" Z="8.19999981"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="LowerMid">
+      <Components>
+        <c:FloatingEffect>
+          <Period>6</Period>
+          <Time>2</Time>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>0.10000000149011612</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform>
+          <Position X="0" Y="0.0866025388" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/DoubleSidedCylinder.mesh</Resource>
+              <Color A="0.313725501" B="10" G="8.03921604" R="8.03921604"/>
+              <Transparent>true</Transparent>
+            </c:Model>
+            <c:Transform>
+              <Position X="0" Y="0.899999976" Z="0"/>
+              <Scale X="8.19999981" Y="0.0199999996" Z="8.19999981"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="UpperMid">
+      <Components>
+        <c:FloatingEffect>
+          <Period>6</Period>
+          <Time>1</Time>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>0.10000000149011612</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform>
+          <Position X="0" Y="0.0866025463" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/DoubleSidedCylinder.mesh</Resource>
+              <Color A="0.196078435" B="8.03921604" G="8.03921604" R="8.03921604"/>
+              <Transparent>true</Transparent>
+            </c:Model>
+            <c:Transform>
+              <Position X="0" Y="1.29999995" Z="0"/>
+              <Scale X="8.19999981" Y="0.0199999996" Z="8.19999981"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="Top">
+      <Components>
+        <c:FloatingEffect>
+          <Period>6</Period>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>0.10000000149011612</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform/>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/DoubleSidedCylinder.mesh</Resource>
+              <Color A="0.117647059" B="8.03921604" G="8.03921604" R="8.03921604"/>
+              <Transparent>true</Transparent>
+            </c:Model>
+            <c:Transform>
+              <Position X="0" Y="1.70000005" Z="0"/>
+              <Scale X="8.19999981" Y="0.0199999996" Z="8.19999981"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/FloatingCrystalBlue.xml

@@ -0,0 +1,174 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity name="Origin" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Transform>
+      <Position X="0" Y="14.8518229" Z="0"/>
+    </c:Transform>
+  </Components>
+
+  <Children>
+    <Entity name="Anchor1">
+      <Components>
+        <c:RaptorCopter>
+          <Speed>0.30000001192092896</Speed>
+          <Axis X="0" Y="1" Z="0"/>
+        </c:RaptorCopter>
+        <c:FloatingEffect>
+          <Period>30</Period>
+          <Time>1125.9779108477385</Time>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>3.5</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform>
+          <Position X="-0" Y="-0.711852849" Z="-0"/>
+          <Orientation X="0" Y="455.182343" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/CrystalsLayer1.mesh</Resource>
+              <Color A="1" B="2" G="0.784313738" R="0"/>
+              <Shadow>false</Shadow>
+              <Transparent>true</Transparent>
+            </c:Model>
+            <c:Transform/>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="Anchor2">
+      <Components>
+        <c:RaptorCopter>
+          <Speed>0.5</Speed>
+          <Axis X="0" Y="1" Z="0"/>
+        </c:RaptorCopter>
+        <c:FloatingEffect>
+          <Period>20</Period>
+          <Time>1231.9108979534806</Time>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>3</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform>
+          <Position X="-0" Y="-1.69476664" Z="-0"/>
+          <Orientation X="0" Y="752.229553" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/CrystalsLayer2.mesh</Resource>
+              <Color A="1" B="2" G="0.784313738" R="0"/>
+              <Shadow>false</Shadow>
+              <Transparent>true</Transparent>
+            </c:Model>
+            <c:Transform/>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="Anchor0">
+      <Components>
+        <c:RaptorCopter>
+          <Speed>0.10000000149011612</Speed>
+          <Axis X="0" Y="-1" Z="0"/>
+        </c:RaptorCopter>
+        <c:FloatingEffect>
+          <Period>10</Period>
+          <Time>1278.4275441408811</Time>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>0.5</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform>
+          <Position X="-0" Y="-0.417467505" Z="-0"/>
+          <Orientation X="0" Y="-147.27742" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/CenterCrystal.mesh</Resource>
+              <Color A="1" B="2" G="0.784313738" R="0"/>
+              <Shadow>false</Shadow>
+              <Transparent>true</Transparent>
+            </c:Model>
+            <c:Transform/>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity name="LightOrigin1">
+          <Components>
+            <c:RaptorCopter>
+              <Speed>1</Speed>
+              <Axis X="0.400000006" Y="1" Z="0"/>
+            </c:RaptorCopter>
+            <c:Transform>
+              <Orientation X="330.00589" Y="825.014587" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children>
+            <Entity>
+              <Components>
+                <c:PointLight>
+                  <Color A="1" B="1" G="0.588235319" R="0"/>
+                  <Radius>4.5</Radius>
+                  <Falloff>0.5</Falloff>
+                </c:PointLight>
+                <c:Transform>
+                  <Position X="1.1234858" Y="0.720658064" Z="3.40589333"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+            <Entity>
+              <Components>
+                <c:PointLight>
+                  <Color A="1" B="1" G="0.588235319" R="0"/>
+                  <Radius>4.5</Radius>
+                  <Falloff>0.5</Falloff>
+                </c:PointLight>
+                <c:Transform>
+                  <Position X="0.4723185" Y="0" Z="-4.12240839"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+            <Entity>
+              <Components>
+                <c:PointLight>
+                  <Color A="1" B="1" G="0.588235319" R="0"/>
+                  <Radius>4.5</Radius>
+                  <Falloff>0.5</Falloff>
+                </c:PointLight>
+                <c:Transform>
+                  <Position X="-2.91954184" Y="1.54033804" Z="-0.0577439293"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+            <Entity>
+              <Components>
+                <c:PointLight>
+                  <Color A="1" B="1" G="0.588235319" R="0"/>
+                  <Radius>4.5</Radius>
+                  <Falloff>0.5</Falloff>
+                </c:PointLight>
+                <c:Transform>
+                  <Position X="1.48998797" Y="-3.06706786" Z="-1.78805089"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+          </Children>
+        </Entity>
+      </Children>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/FloatingCrystalRed.xml

@@ -0,0 +1,173 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity name="Origin" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Transform>
+      <Position X="0" Y="14.8518229" Z="0"/>
+    </c:Transform>
+  </Components>
+
+  <Children>
+    <Entity name="Anchor1">
+      <Components>
+        <c:RaptorCopter>
+          <Speed>0.30000001192092896</Speed>
+          <Axis X="0" Y="1" Z="0"/>
+        </c:RaptorCopter>
+        <c:FloatingEffect>
+          <Period>30</Period>
+          <Time>1816.9423460293749</Time>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>3.5</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform>
+          <Position X="-0" Y="-1.38488328" Z="-0"/>
+          <Orientation X="0" Y="662.475891" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/CrystalsLayer1.mesh</Resource>
+              <Color A="1" B="0" G="0.235294119" R="1.09803927"/>
+              <Shadow>false</Shadow>
+            </c:Model>
+            <c:Transform/>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="Anchor2">
+      <Components>
+        <c:RaptorCopter>
+          <Speed>0.5</Speed>
+          <Axis X="0" Y="1" Z="0"/>
+        </c:RaptorCopter>
+        <c:FloatingEffect>
+          <Period>20</Period>
+          <Time>1922.875333135117</Time>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>3</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform>
+          <Position X="0" Y="2.35616231" Z="0"/>
+          <Orientation X="0" Y="1097.71094" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/CrystalsLayer2.mesh</Resource>
+              <Color A="1" B="0" G="0.235294119" R="1.09803927"/>
+              <Shadow>false</Shadow>
+            </c:Model>
+            <c:Transform/>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="Anchor0">
+      <Components>
+        <c:RaptorCopter>
+          <Speed>0.10000000149011612</Speed>
+          <Axis X="0" Y="-1" Z="0"/>
+        </c:RaptorCopter>
+        <c:FloatingEffect>
+          <Period>10</Period>
+          <Time>1969.3919793225175</Time>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>0.5</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform>
+          <Position X="-0" Y="-0.186382934" Z="-0"/>
+          <Orientation X="0" Y="-216.374603" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/CenterCrystal.mesh</Resource>
+              <Color A="1" B="0" G="0.235294119" R="1.09803927"/>
+              <Shadow>false</Shadow>
+            </c:Model>
+            <c:Transform>
+              <Position X="-0" Y="-0" Z="-0"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity name="LightOrigin1">
+          <Components>
+            <c:RaptorCopter>
+              <Speed>1</Speed>
+              <Axis X="0.400000006" Y="1" Z="0"/>
+            </c:RaptorCopter>
+            <c:Transform>
+              <Orientation X="606.394653" Y="1515.97461" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children>
+            <Entity>
+              <Components>
+                <c:PointLight>
+                  <Color A="1" B="0" G="0" R="1"/>
+                  <Radius>4.5</Radius>
+                  <Falloff>0.5</Falloff>
+                </c:PointLight>
+                <c:Transform>
+                  <Position X="1.1234858" Y="0.720658064" Z="3.40589333"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+            <Entity>
+              <Components>
+                <c:PointLight>
+                  <Color A="1" B="0" G="0" R="1"/>
+                  <Radius>4.5</Radius>
+                  <Falloff>0.5</Falloff>
+                </c:PointLight>
+                <c:Transform>
+                  <Position X="0.4723185" Y="0" Z="-4.12240839"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+            <Entity>
+              <Components>
+                <c:PointLight>
+                  <Color A="1" B="0" G="0" R="1"/>
+                  <Radius>4.5</Radius>
+                  <Falloff>0.5</Falloff>
+                </c:PointLight>
+                <c:Transform>
+                  <Position X="-2.91954184" Y="1.54033804" Z="-0.0577439293"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+            <Entity>
+              <Components>
+                <c:PointLight>
+                  <Color A="1" B="0" G="0" R="1"/>
+                  <Radius>4.5</Radius>
+                  <Falloff>0.5</Falloff>
+                </c:PointLight>
+                <c:Transform>
+                  <Position X="1.48998797" Y="-3.06706786" Z="-1.78805089"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+          </Children>
+        </Entity>
+      </Children>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/FloatingCrystalWhite.xml

@@ -0,0 +1,167 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity name="Origin" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Transform>
+      <Position X="0" Y="14.8518229" Z="0"/>
+    </c:Transform>
+  </Components>
+
+  <Children>
+    <Entity name="Anchor1">
+      <Components>
+        <c:RaptorCopter>
+          <Speed>0.30000001192092896</Speed>
+          <Axis X="0" Y="1" Z="0"/>
+        </c:RaptorCopter>
+        <c:FloatingEffect>
+          <Period>30</Period>
+          <Time>1622.3711487379048</Time>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>3.5</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform>
+          <Position X="0" Y="1.66753078" Z="0"/>
+          <Orientation X="0" Y="604.103943" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/CrystalsLayer1.mesh</Resource>
+              <Shadow>false</Shadow>
+            </c:Model>
+            <c:Transform/>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="Anchor2">
+      <Components>
+        <c:RaptorCopter>
+          <Speed>0.5</Speed>
+          <Axis X="0" Y="1" Z="0"/>
+        </c:RaptorCopter>
+        <c:FloatingEffect>
+          <Period>20</Period>
+          <Time>1728.3041358436469</Time>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>3</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform>
+          <Position X="0" Y="1.5237397" Z="0"/>
+          <Orientation X="0" Y="1000.42615" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/CrystalsLayer2.mesh</Resource>
+              <Shadow>false</Shadow>
+            </c:Model>
+            <c:Transform/>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="Anchor0">
+      <Components>
+        <c:RaptorCopter>
+          <Speed>0.10000000149011612</Speed>
+          <Axis X="0" Y="-1" Z="0"/>
+        </c:RaptorCopter>
+        <c:FloatingEffect>
+          <Period>10</Period>
+          <Time>1774.8207820310474</Time>
+          <Axis X="0" Y="1" Z="0"/>
+          <Amplitude>0.5</Amplitude>
+        </c:FloatingEffect>
+        <c:Transform>
+          <Position X="0" Y="0.0561612286" Z="0"/>
+          <Orientation X="0" Y="-196.917053" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>Models/Props/CapturePoint/CenterCrystal.mesh</Resource>
+              <Shadow>false</Shadow>
+              <Transparent>true</Transparent>
+            </c:Model>
+            <c:Transform>
+              <Position X="-0" Y="-0" Z="-0"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity name="LightOrigin1">
+          <Components>
+            <c:RaptorCopter>
+              <Speed>1</Speed>
+              <Axis X="0.400000006" Y="1" Z="0"/>
+            </c:RaptorCopter>
+            <c:Transform>
+              <Orientation X="528.564453" Y="1321.40454" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children>
+            <Entity>
+              <Components>
+                <c:PointLight>
+                  <Radius>4.5</Radius>
+                  <Falloff>0.5</Falloff>
+                </c:PointLight>
+                <c:Transform>
+                  <Position X="1.1234858" Y="0.720658064" Z="3.40589333"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+            <Entity>
+              <Components>
+                <c:PointLight>
+                  <Radius>4.5</Radius>
+                  <Falloff>0.5</Falloff>
+                </c:PointLight>
+                <c:Transform>
+                  <Position X="0.4723185" Y="0" Z="-4.12240839"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+            <Entity>
+              <Components>
+                <c:PointLight>
+                  <Radius>4.5</Radius>
+                  <Falloff>0.5</Falloff>
+                </c:PointLight>
+                <c:Transform>
+                  <Position X="-2.91954184" Y="1.54033804" Z="-0.0577439293"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+            <Entity>
+              <Components>
+                <c:PointLight>
+                  <Radius>4.5</Radius>
+                  <Falloff>0.5</Falloff>
+                </c:PointLight>
+                <c:Transform>
+                  <Position X="1.48998797" Y="-3.06706786" Z="-1.78805089"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+          </Children>
+        </Entity>
+      </Children>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/HealthPickup.xml

@@ -2,21 +2,26 @@
 <Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
 
   <Components>
-    <c:NetworkComponent/>
     <c:HealthPickup/>
-    <c:Model>
+    <c:Trigger/>
-      <Resource>Models/Props/PickUps/HealthPickUp.mesh</Resource>
-    </c:Model>
     <c:RaptorCopter>
       <Speed>8</Speed>
       <Axis X="0" Y="0.100000001" Z="0"/>
     </c:RaptorCopter>
+    <c:Model>
+      <Resource>Models/Props/PickUps/HealthPickUp.mesh</Resource>
+    </c:Model>
+    <c:NetworkComponent/>
+    <c:PointLight>
+      <Color A="1" B="0" G="1" R="1"/>
+      <Radius>1.5</Radius>
+      <Intensity>3</Intensity>
+    </c:PointLight>
     <c:Transform>
-      <Position X="0" Y="2.36784196" Z="0"/>
+      <Position X="0" Y="2.36800003" Z="0"/>
+      <Orientation X="0" Y="19005.3867" Z="0"/>
       <Scale X="0.600000024" Y="0.600000024" Z="0.600000024"/>
-      <Orientation X="0" Y="18767.0273" Z="0"/>
     </c:Transform>
-    <c:Trigger/>
   </Components>
 
   <Children/>

resources/Schema/Entities/OptionMenu.xml

@@ -37,6 +37,7 @@
                   <Model>Models/Core/UnitQuad.mesh</Model>
                   <GlowMap></GlowMap>
                   <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+                  <Visible>false</Visible>
                 </c:Sprite>
                 <c:Transform>
                   <Position X="0.00500000035" Y="0.198000014" Z="0.0199999996"/>
@@ -72,124 +73,69 @@
         </c:Transform>
       </Components>
       <Children>
-        <Entity name="Res1080">
+        <Entity name="Resolution">
+          <Components>
+            <c:Transform>
+              <Scale X="0.100000001" Y="0.100000001" Z="1"/>
+            </c:Transform>
+          </Components>
+          <Children>
+            <Entity name="Sprite">
               <Components>
                 <c:Button/>
-            <c:ConfigBtnResolution>
-              <Width>1920</Width>
-              <Height>1080</Height>
-            </c:ConfigBtnResolution>
                 <c:Sprite>
                   <Model>Models/Core/UnitQuad.mesh</Model>
                   <GlowMap></GlowMap>
                   <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
-              <BlurBackground>true</BlurBackground>
                   <Color A="0.392156869" B="1" G="1" R="1"/>
                 </c:Sprite>
+                <c:InputCmdButton>
+                  <Command>Resolution</Command>
+                  <PressValue>1</PressValue>
+                </c:InputCmdButton>
                 <c:Transform>
-              <Position X="-0.088000007" Y="0" Z="0"/>
+                  <Scale X="2.5999999" Y="0.300000012" Z="1"/>
-              <Scale X="0.0820000023" Y="0.0299999993" Z="1"/>
                 </c:Transform>
               </Components>
+              <Children/>
+            </Entity>
+            <Entity name="TextAndCorner_Origin">
+              <Components>
+                <c:Transform/>
+              </Components>
               <Children>
                 <Entity name="Text">
                   <Components>
                     <c:Text>
-                  <Content>1920x1080</Content>
+                      <Content>Resolution</Content>
                       <Resource>Fonts/DroidSans.ttf,64</Resource>
                       <Color A="1" B="0" G="0" R="0"/>
                       <Alignment>
-                    <Left/>
+                        <Right/>
                       </Alignment>
                     </c:Text>
                     <c:Transform>
-                  <Position X="-0.361000031" Y="-0.562000036" Z="0.0199999996"/>
+                      <Position X="-0.180000007" Y="-0.116000004" Z="0.00500000035"/>
-                  <Scale X="0.180000007" Y="0.469000012" Z="1"/>
+                      <Scale X="0.219000012" Y="0.150000006" Z="1"/>
                     </c:Transform>
                   </Components>
                   <Children/>
                 </Entity>
               </Children>
             </Entity>
-        <Entity name="Res768">
-          <Components>
-            <c:Button/>
-            <c:ConfigBtnResolution>
-              <Width>1366</Width>
-              <Height>768</Height>
-            </c:ConfigBtnResolution>
-            <c:Sprite>
-              <Model>Models/Core/UnitQuad.mesh</Model>
-              <GlowMap></GlowMap>
-              <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
-              <BlurBackground>true</BlurBackground>
-              <Color A="0.392156869" B="1" G="1" R="1"/>
-            </c:Sprite>
-            <c:Transform>
-              <Scale X="0.0820000023" Y="0.0299999993" Z="1"/>
-            </c:Transform>
-          </Components>
-          <Children>
-            <Entity name="Text">
-              <Components>
-                <c:Text>
-                  <Content>1366x768</Content>
-                  <Resource>Fonts/DroidSans.ttf,64</Resource>
-                  <Color A="1" B="0" G="0" R="0"/>
-                  <Alignment>
-                    <Left/>
-                  </Alignment>
-                </c:Text>
-                <c:Transform>
-                  <Position X="-0.380000025" Y="-0.561999977" Z="0.0199999996"/>
-                  <Scale X="0.180000007" Y="0.469000012" Z="1"/>
-                </c:Transform>
-              </Components>
-              <Children/>
-            </Entity>
           </Children>
         </Entity>
-        <Entity name="Res720">
+        <Entity name="ResolutionSpawner">
           <Components>
-            <c:Button/>
+            <c:Spawner>
-            <c:ConfigBtnResolution>
+              <EntityFile>Schema/Entities/Resolution_Options.xml</EntityFile>
-              <Width>1280</Width>
+            </c:Spawner>
-              <Height>720</Height>
+            <c:Transform/>
-            </c:ConfigBtnResolution>
-            <c:Sprite>
-              <Model>Models/Core/UnitQuad.mesh</Model>
-              <GlowMap></GlowMap>
-              <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
-              <BlurBackground>true</BlurBackground>
-              <Color A="0.392156869" B="1" G="1" R="1"/>
-            </c:Sprite>
-            <c:Transform>
-              <Position X="0.088000007" Y="0" Z="0"/>
-              <Scale X="0.0820000023" Y="0.0299999993" Z="1"/>
-            </c:Transform>
-          </Components>
-          <Children>
-            <Entity name="Text">
-              <Components>
-                <c:Text>
-                  <Content>1280x720</Content>
-                  <Resource>Fonts/DroidSans.ttf,64</Resource>
-                  <Color A="1" B="0" G="0" R="0"/>
-                  <Alignment>
-                    <Left/>
-                  </Alignment>
-                </c:Text>
-                <c:Transform>
-                  <Position X="-0.387000024" Y="-0.561999977" Z="0.0199999996"/>
-                  <Scale X="0.180000007" Y="0.469000012" Z="1"/>
-                </c:Transform>
           </Components>
           <Children/>
         </Entity>
       </Children>
     </Entity>
   </Children>
-    </Entity>
-  </Children>
 
 </Entity>

resources/Schema/Entities/Resolution_Options

@@ -0,0 +1,128 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity name="Resolution_Options" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Transform/>
+  </Components>
+
+  <Children>
+    <Entity name="Res1080">
+      <Components>
+        <c:Button/>
+        <c:ConfigBtnResolution>
+          <Width>1920</Width>
+          <Height>1080</Height>
+        </c:ConfigBtnResolution>
+        <c:Sprite>
+          <Model>Models/Core/UnitQuad.mesh</Model>
+          <GlowMap></GlowMap>
+          <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+          <BlurBackground>true</BlurBackground>
+          <Color A="0.392156869" B="1" G="1" R="1"/>
+        </c:Sprite>
+        <c:Transform>
+          <Position X="-0.088000007" Y="-0.0350000001" Z="0"/>
+          <Scale X="0.0820000023" Y="0.0299999993" Z="1"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="Text">
+          <Components>
+            <c:Text>
+              <Content>1920x1080</Content>
+              <Resource>Fonts/DroidSans.ttf,64</Resource>
+              <Color A="1" B="0" G="0" R="0"/>
+              <Alignment>
+                <Left/>
+              </Alignment>
+            </c:Text>
+            <c:Transform>
+              <Position X="-0.361000031" Y="-0.562000036" Z="0.0199999996"/>
+              <Scale X="0.180000007" Y="0.469000012" Z="1"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="Res768">
+      <Components>
+        <c:Button/>
+        <c:ConfigBtnResolution>
+          <Width>1366</Width>
+          <Height>768</Height>
+        </c:ConfigBtnResolution>
+        <c:Sprite>
+          <Model>Models/Core/UnitQuad.mesh</Model>
+          <GlowMap></GlowMap>
+          <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+          <BlurBackground>true</BlurBackground>
+          <Color A="0.392156869" B="1" G="1" R="1"/>
+        </c:Sprite>
+        <c:Transform>
+          <Position X="0" Y="-0.0350000001" Z="0"/>
+          <Scale X="0.0820000023" Y="0.0299999993" Z="1"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="Text">
+          <Components>
+            <c:Text>
+              <Content>1366x768</Content>
+              <Resource>Fonts/DroidSans.ttf,64</Resource>
+              <Color A="1" B="0" G="0" R="0"/>
+              <Alignment>
+                <Left/>
+              </Alignment>
+            </c:Text>
+            <c:Transform>
+              <Position X="-0.380000025" Y="-0.561999977" Z="0.0199999996"/>
+              <Scale X="0.180000007" Y="0.469000012" Z="1"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="Res720">
+      <Components>
+        <c:Button/>
+        <c:ConfigBtnResolution>
+          <Width>1280</Width>
+          <Height>720</Height>
+        </c:ConfigBtnResolution>
+        <c:Sprite>
+          <Model>Models/Core/UnitQuad.mesh</Model>
+          <GlowMap></GlowMap>
+          <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+          <BlurBackground>true</BlurBackground>
+          <Color A="0.392156869" B="1" G="1" R="1"/>
+        </c:Sprite>
+        <c:Transform>
+          <Position X="0.088000007" Y="-0.0350000001" Z="0"/>
+          <Scale X="0.0820000023" Y="0.0299999993" Z="1"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="Text">
+          <Components>
+            <c:Text>
+              <Content>1280x720</Content>
+              <Resource>Fonts/DroidSans.ttf,64</Resource>
+              <Color A="1" B="0" G="0" R="0"/>
+              <Alignment>
+                <Left/>
+              </Alignment>
+            </c:Text>
+            <c:Transform>
+              <Position X="-0.387000024" Y="-0.561999977" Z="0.0199999996"/>
+              <Scale X="0.180000007" Y="0.469000012" Z="1"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/Resolution_Options.xml

@@ -0,0 +1,149 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity name="Resolution_Options" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Transform>
+      <Position X="0" Y="0" Z="0.0180000011"/>
+    </c:Transform>
+  </Components>
+
+  <Children>
+    <Entity name="Background">
+      <Components>
+        <c:Sprite>
+          <DepthSort>false</DepthSort>
+          <Model>Models/Core/UnitQuad.mesh</Model>
+          <GlowMap></GlowMap>
+          <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+          <Color A="1" B="0.117647059" G="0.117647059" R="0.117647059"/>
+        </c:Sprite>
+        <c:Transform>
+          <Position X="-0.00700000022" Y="-0.0310000014" Z="-0.0270000007"/>
+          <Scale X="0.292000026" Y="0.064000003" Z="1"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="Res1080">
+      <Components>
+        <c:Button/>
+        <c:ConfigBtnResolution>
+          <Width>1920</Width>
+          <Height>1080</Height>
+        </c:ConfigBtnResolution>
+        <c:Sprite>
+          <DepthSort>false</DepthSort>
+          <Model>Models/Core/UnitQuad.mesh</Model>
+          <GlowMap></GlowMap>
+          <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+          <BlurBackground>true</BlurBackground>
+          <Color A="0.392156869" B="1" G="1" R="1"/>
+        </c:Sprite>
+        <c:Transform>
+          <Position X="-0.088000007" Y="-0.0350000001" Z="0"/>
+          <Scale X="0.0820000023" Y="0.0299999993" Z="1"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="Text">
+          <Components>
+            <c:Text>
+              <Content>1920x1080</Content>
+              <Resource>Fonts/DroidSans.ttf,64</Resource>
+              <Color A="1" B="0" G="0" R="0"/>
+              <Alignment>
+                <Left/>
+              </Alignment>
+            </c:Text>
+            <c:Transform>
+              <Position X="-0.361000031" Y="-0.562000036" Z="0.0199999996"/>
+              <Scale X="0.180000007" Y="0.469000012" Z="1"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="Res768">
+      <Components>
+        <c:Button/>
+        <c:ConfigBtnResolution>
+          <Width>1366</Width>
+          <Height>768</Height>
+        </c:ConfigBtnResolution>
+        <c:Sprite>
+          <DepthSort>false</DepthSort>
+          <Model>Models/Core/UnitQuad.mesh</Model>
+          <GlowMap></GlowMap>
+          <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+          <BlurBackground>true</BlurBackground>
+          <Color A="0.392156869" B="1" G="1" R="1"/>
+        </c:Sprite>
+        <c:Transform>
+          <Position X="0" Y="-0.0350000001" Z="0"/>
+          <Scale X="0.0820000023" Y="0.0299999993" Z="1"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="Text">
+          <Components>
+            <c:Text>
+              <Content>1366x768</Content>
+              <Resource>Fonts/DroidSans.ttf,64</Resource>
+              <Color A="1" B="0" G="0" R="0"/>
+              <Alignment>
+                <Left/>
+              </Alignment>
+            </c:Text>
+            <c:Transform>
+              <Position X="-0.380000025" Y="-0.561999977" Z="0.0199999996"/>
+              <Scale X="0.180000007" Y="0.469000012" Z="1"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="Res720">
+      <Components>
+        <c:Button/>
+        <c:ConfigBtnResolution>
+          <Width>1280</Width>
+          <Height>720</Height>
+        </c:ConfigBtnResolution>
+        <c:Sprite>
+          <DepthSort>false</DepthSort>
+          <Model>Models/Core/UnitQuad.mesh</Model>
+          <GlowMap></GlowMap>
+          <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+          <BlurBackground>true</BlurBackground>
+          <Color A="0.392156869" B="1" G="1" R="1"/>
+        </c:Sprite>
+        <c:Transform>
+          <Position X="0.088000007" Y="-0.0350000001" Z="0"/>
+          <Scale X="0.0820000023" Y="0.0299999993" Z="1"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="Text">
+          <Components>
+            <c:Text>
+              <Content>1280x720</Content>
+              <Resource>Fonts/DroidSans.ttf,64</Resource>
+              <Color A="1" B="0" G="0" R="0"/>
+              <Alignment>
+                <Left/>
+              </Alignment>
+            </c:Text>
+            <c:Transform>
+              <Position X="-0.387000024" Y="-0.561999977" Z="0.0199999996"/>
+              <Scale X="0.180000007" Y="0.469000012" Z="1"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/ServerIdentity.xml

@@ -17,7 +17,6 @@
             <c:Text>
               <Content>123.123.123.123</Content>
               <Resource>Fonts/DroidSans.ttf,64</Resource>
-              <Color A="1" B="0" G="0" R="0"/>
               <Alignment>
                 <Left/>
               </Alignment>
@@ -28,7 +27,7 @@
               <Field>IP</Field>
             </c:TextFieldReader>
             <c:Transform>
-              <Position X="-0.200000003" Y="-0.100000001" Z="0"/>
+              <Position X="-0.200000003" Y="-0.100000001" Z="0.00700000022"/>
               <Scale X="0.649999976" Y="0.649999976" Z="1"/>
             </c:Transform>
           </Components>
@@ -39,7 +38,6 @@
             <c:Text>
               <Content>65999</Content>
               <Resource>Fonts/DroidSans.ttf,64</Resource>
-              <Color A="1" B="0" G="0" R="0"/>
               <Alignment>
                 <Left/>
               </Alignment>
@@ -50,7 +48,7 @@
               <Field>Port</Field>
             </c:TextFieldReader>
             <c:Transform>
-              <Position X="4.70000029" Y="-0.100000001" Z="0"/>
+              <Position X="4.70000029" Y="-0.100000001" Z="0.00700000022"/>
               <Scale X="0.649999976" Y="0.649999976" Z="1"/>
             </c:Transform>
           </Components>
@@ -61,7 +59,6 @@
             <c:Text>
               <Content>UnkownServer</Content>
               <Resource>Fonts/DroidSans.ttf,64</Resource>
-              <Color A="1" B="0" G="0" R="0"/>
               <Alignment>
                 <Left/>
               </Alignment>
@@ -72,7 +69,7 @@
               <Field>ServerName</Field>
             </c:TextFieldReader>
             <c:Transform>
-              <Position X="-8.60000038" Y="-0.100000001" Z="0"/>
+              <Position X="-8.60000038" Y="-0.100000001" Z="0.00700000022"/>
             </c:Transform>
           </Components>
           <Children/>
@@ -82,7 +79,6 @@
             <c:Text>
               <Content>0</Content>
               <Resource>Fonts/DroidSans.ttf,64</Resource>
-              <Color A="1" B="0" G="0" R="0"/>
               <Alignment>
                 <Left/>
               </Alignment>
@@ -93,7 +89,7 @@
               <Field>PlayersConnected</Field>
             </c:TextFieldReader>
             <c:Transform>
-              <Position X="7.80000019" Y="0" Z="0"/>
+              <Position X="7.80000019" Y="0" Z="0.00700000022"/>
             </c:Transform>
           </Components>
           <Children/>
@@ -102,14 +98,15 @@
           <Components>
             <c:Button/>
             <c:Sprite>
+              <DepthSort>false</DepthSort>
+              <Model>Models/Core/UnitQuad.mesh</Model>
+              <GlowMap></GlowMap>
               <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
               <BlurBackground>true</BlurBackground>
-              <GlowMap></GlowMap>
+              <Color A="0.392156869" B="0.392156869" G="0.392156869" R="0.392156869"/>
-              <DepthSort>false</DepthSort>
-              <Color A="0.588235319" B="1" G="1" R="1"/>
             </c:Sprite>
             <c:Transform>
-              <Position X="0.100000001" Y="0.496000022" Z="0"/>
+              <Position X="0.100000001" Y="0.496000022" Z="0.00700000022"/>
               <Scale X="18.1000004" Y="2" Z="1"/>
             </c:Transform>
           </Components>
@@ -117,6 +114,75 @@
         </Entity>
       </Children>
     </Entity>
+    <Entity name="Corners">
+      <Components>
+        <c:Transform>
+          <Position X="0" Y="0" Z="0.00700000022"/>
+          <Scale X="0.200000003" Y="0.200000003" Z="1"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="TopLeft">
+          <Components>
+            <c:Sprite>
+              <Model>Models/Core/UnitQuad.mesh</Model>
+              <GlowMap></GlowMap>
+              <DiffuseTexture>Textures/HUD/ButtonCorner_16.png</DiffuseTexture>
+              <Linear>false</Linear>
+            </c:Sprite>
+            <c:Transform>
+              <Position X="-43.9590034" Y="6.70000029" Z="0"/>
+              <Orientation X="0" Y="0" Z="1.57079637"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity name="BottomLeft">
+          <Components>
+            <c:Sprite>
+              <Model>Models/Core/UnitQuad.mesh</Model>
+              <GlowMap></GlowMap>
+              <DiffuseTexture>Textures/HUD/ButtonCorner_16.png</DiffuseTexture>
+              <Linear>false</Linear>
+            </c:Sprite>
+            <c:Transform>
+              <Position X="-43.9589996" Y="-1.75600004" Z="0"/>
+              <Orientation X="0" Y="0" Z="3.14499998"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity name="BottomRight">
+          <Components>
+            <c:Sprite>
+              <Model>Models/Core/UnitQuad.mesh</Model>
+              <GlowMap></GlowMap>
+              <DiffuseTexture>Textures/HUD/ButtonCorner_16.png</DiffuseTexture>
+              <Linear>false</Linear>
+            </c:Sprite>
+            <c:Transform>
+              <Position X="44.8320007" Y="-1.75600004" Z="0"/>
+              <Orientation X="0" Y="0" Z="4.71218538"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity name="TopRight">
+          <Components>
+            <c:Sprite>
+              <Model>Models/Core/UnitQuad.mesh</Model>
+              <GlowMap></GlowMap>
+              <DiffuseTexture>Textures/HUD/ButtonCorner_16.png</DiffuseTexture>
+              <Linear>false</Linear>
+            </c:Sprite>
+            <c:Transform>
+              <Position X="44.8320007" Y="6.69999981" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
   </Children>
 
 </Entity>

resources/Schema/Entities/ServerList.xml

@@ -30,21 +30,6 @@
         </Entity>
       </Children>
     </Entity>
-    <Entity name="Background">
-      <Components>
-        <c:Sprite>
-          <Model>Models/Core/UnitQuad.mesh</Model>
-          <GlowMap></GlowMap>
-          <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
-          <BlurBackground>true</BlurBackground>
-          <Color A="0.196078435" B="0" G="0" R="0"/>
-        </c:Sprite>
-        <c:Transform>
-          <Scale X="0.300000012" Y="0.5" Z="1"/>
-        </c:Transform>
-      </Components>
-      <Children/>
-    </Entity>
     <Entity name="RefreshButton">
       <Components>
         <c:Button/>
@@ -87,20 +72,6 @@
         <c:Transform/>
       </Components>
       <Children>
-        <Entity name="UnderLine">
-          <Components>
-            <c:Sprite>
-              <Model>Models/Core/UnitQuad.mesh</Model>
-              <GlowMap></GlowMap>
-              <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
-            </c:Sprite>
-            <c:Transform>
-              <Position X="0.00500000035" Y="0.198000014" Z="0.0199999996"/>
-              <Scale X="0.270000011" Y="0.00100000005" Z="1"/>
-            </c:Transform>
-          </Components>
-          <Children/>
-        </Entity>
         <Entity name="Text">
           <Components>
             <c:Text>
@@ -117,6 +88,112 @@
           </Components>
           <Children/>
         </Entity>
+        <Entity name="UnderLine">
+          <Components>
+            <c:Sprite>
+              <Model>Models/Core/UnitQuad.mesh</Model>
+              <GlowMap></GlowMap>
+              <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+              <Visible>false</Visible>
+            </c:Sprite>
+            <c:Transform>
+              <Position X="0.00500000035" Y="0.198000014" Z="0.0199999996"/>
+              <Scale X="0.270000011" Y="0.00100000005" Z="1"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="Background_Origin">
+      <Components>
+        <c:Transform/>
+      </Components>
+      <Children>
+        <Entity name="Background">
+          <Components>
+            <c:Sprite>
+              <Model>Models/Core/UnitQuad.mesh</Model>
+              <GlowMap></GlowMap>
+              <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+              <BlurBackground>true</BlurBackground>
+              <Color A="0.196078435" B="0" G="0" R="0"/>
+            </c:Sprite>
+            <c:Transform>
+              <Scale X="0.300000012" Y="0.5" Z="1"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity name="Corners">
+          <Components>
+            <c:Transform>
+              <Position X="0" Y="0" Z="0.0100000007"/>
+              <Scale X="0.00499999989" Y="0.00499999989" Z="1"/>
+            </c:Transform>
+          </Components>
+          <Children>
+            <Entity name="TopLeft">
+              <Components>
+                <c:Sprite>
+                  <Model>Models/Core/UnitQuad.mesh</Model>
+                  <GlowMap></GlowMap>
+                  <DiffuseTexture>Textures/HUD/ButtonCorner_16.png</DiffuseTexture>
+                  <Linear>false</Linear>
+                </c:Sprite>
+                <c:Transform>
+                  <Position X="-29.0360012" Y="49.0510025" Z="0"/>
+                  <Orientation X="0" Y="0" Z="1.57079637"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+            <Entity name="BottomLeft">
+              <Components>
+                <c:Sprite>
+                  <Model>Models/Core/UnitQuad.mesh</Model>
+                  <GlowMap></GlowMap>
+                  <DiffuseTexture>Textures/HUD/ButtonCorner_16.png</DiffuseTexture>
+                  <Linear>false</Linear>
+                </c:Sprite>
+                <c:Transform>
+                  <Position X="-29.0050011" Y="-48.927002" Z="0"/>
+                  <Orientation X="0" Y="0" Z="3.14499998"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+            <Entity name="BottomRight">
+              <Components>
+                <c:Sprite>
+                  <Model>Models/Core/UnitQuad.mesh</Model>
+                  <GlowMap></GlowMap>
+                  <DiffuseTexture>Textures/HUD/ButtonCorner_16.png</DiffuseTexture>
+                  <Linear>false</Linear>
+                </c:Sprite>
+                <c:Transform>
+                  <Position X="29.0750008" Y="-48.9350014" Z="0"/>
+                  <Orientation X="0" Y="0" Z="4.71218538"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+            <Entity name="TopRight">
+              <Components>
+                <c:Sprite>
+                  <Model>Models/Core/UnitQuad.mesh</Model>
+                  <GlowMap></GlowMap>
+                  <DiffuseTexture>Textures/HUD/ButtonCorner_16.png</DiffuseTexture>
+                  <Linear>false</Linear>
+                </c:Sprite>
+                <c:Transform>
+                  <Position X="29.0750008" Y="49.0650024" Z="0"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+          </Children>
+        </Entity>
       </Children>
     </Entity>
   </Children>

resources/Shaders/ExplosionEffect.geom.glsl

@@ -15,6 +15,11 @@ uniform float RandomnessScalar;
 uniform vec2 Velocity;
 uniform bool ColorByDistance;
 uniform bool ExponentialAccelaration;
+uniform bool Reverse;
+uniform float ColorDistanceScalar;
+//uniform bool Gravity;
+//uniform bool Rotation;
+//uniform bool MaxRadius;
 
 in VertexData{
 	vec3 Position;
@@ -41,32 +46,43 @@ out VertexData{
 layout(triangles) in;
 layout(triangle_strip, max_vertices = 3) out;
 
+float EqualTo(float x, float y) {
+  return 1.0 - abs(sign(x - y));
+}
+
+float NotEqualTo(float x, float y) {
+  return abs(sign(x - y));
+}
+
+float GreaterThan(float x, float y) {
+  return max(sign(x - y), 0.0);
+}
+
+float LessThan(float x, float y) {
+  return max(sign(y - x), 0.0);
+}
+
+float GreaterEqualTo(float x, float y) {
+  return 1.0 - LessThan(x, y);
+}
+
+float LessEqualTo(float x, float y) {
+  return 1.0 - GreaterThan(x, y);
+}
+
 // returns a "random" number based on input parameter
 float GetRandomNumber(int polygon_index)
 {
-	int randomIndex = int(mod(polygon_index, 50));
+	return RandomNumbers[int(mod(polygon_index, 50))];
-	
-	return RandomNumbers[randomIndex];
 }
 
-float randomNumber = 0.0;
+vec3 CalcCenterOfTriangle(vec3 vertex0, vec3 vertex1, vec3 vertex2)
-float randomDistance = 0.0;
-
-void main()
 {
 	// calculate middle of vectors
-	vec3 v1 = Input[1].Position - Input[0].Position;
+	vec3 dir1 = normalize(vertex1 - vertex0);
-	vec3 v2 = Input[2].Position - Input[0].Position;
+	vec3 dir2 = normalize(vertex2 - vertex0);
-	vec3 v3 = Input[2].Position - (v1 / 2);
-	vec3 v4 = Input[1].Position - (v2 / 2);
 	
-	// calculate intersection
+	vec3 vecA = vertex2 - vertex1; //o2 - o1
-	
-	// normalize direction
-	vec3 dir1 = normalize(v1);
-	vec3 dir2 = normalize(v2);
-	
-	vec3 vecA = Input[2].Position - Input[1].Position; //o2 - o1
 	vec3 vecB = cross(dir1, dir2);
 	
 	mat3 matrisA = mat3(vecA, dir2, vecB);
@@ -77,133 +93,89 @@ void main()
 	float s = determinant(matrisA) / lengthA;
 	
 	// center position of triangle
-	vec3 centerOfTriangle = Input[1].Position + (s * dir1);
+	return vertex1 + (s * dir1);
+}
+
+void PassThingsThrough(int index)
+{
+	// pass through vertex data
+	Output.Normal = Input[index].Normal;
+	Output.Position = Input[index].Position;
+	Output.TextureCoordinate = Input[index].TextureCoordinate;
+	Output.Tangent = Input[index].Tangent;
+	Output.BiTangent = Input[index].BiTangent;
+	Output.ExplosionColor = EndColor;	
+}
+
+void main()
+{
+	vec3 centerOfTriangle = CalcCenterOfTriangle(Input[0].Position, Input[1].Position, Input[2].Position);
 		
 	// center position of triangle to origin vector
 	vec3 origin2TriangleCenterVector = centerOfTriangle - ExplosionOrigin;
 	vec3 normalizedOrigin2TriangleCenterVector = normalize(origin2TriangleCenterVector);
 	
+	// distance between origin and the center of the current triangle
+	float origin2TriangleCenterDistance = length(origin2TriangleCenterVector);	
+	
 	// time percentage until end of explosion (0.0-1.0)
 	float timePercetage = TimeSinceDeath / ExplosionDuration;
 	
-		// get a random number if randomness is enabled, otherwise the random number will be zero and won't affect the other algorithms
+	// get a random number if randomness is enabled, otherwise the random distance will be zero and won't affect the other algorithms
-	if (Randomness == true)
+	float randomDistance = float(Randomness) * GetRandomNumber(gl_PrimitiveIDIn) * RandomnessScalar;
-	{
-		randomDistance = GetRandomNumber(gl_PrimitiveIDIn) * RandomnessScalar;
-	}
 	
 	vec2 randomVelocity = Velocity * (randomDistance + 1.0);
 	
 	// accelaration to use on current frame. is a interpolation between start and end value
 	float currentVelocity = mix(randomVelocity.x, randomVelocity.y, timePercetage);
 	
-	if (ExponentialAccelaration == true)
+	// if the accelaration should be exponential
-	{
+	currentVelocity = currentVelocity * max(currentVelocity * float(ExponentialAccelaration), 1.0);
-		currentVelocity = pow(currentVelocity, 2) / 2.0;
-	}
 	
-	// distance between origin and the center of the current triangle
+	// the distance the blast has moved since the beginning, i.e. its radius
-	float origin2TriangleCenterDistance = length(origin2TriangleCenterVector);
+	float blastWave = TimeSinceDeath * currentVelocity;
 	
 	// the distance from origin to the triangle center with eventual randomness added
-	float fullDistanceWithRandomness = origin2TriangleCenterDistance + randomDistance;
+	float origin2TriangleCenterDistanceWithRandomness = origin2TriangleCenterDistance + randomDistance;
 	
-	// vector from the triangle center to the explosion's shockwave
+	vec3 triangleCenter2ExplosionRadius = (normalizedOrigin2TriangleCenterVector * blastWave) - (normalizedOrigin2TriangleCenterVector * origin2TriangleCenterDistanceWithRandomness);
-	vec3 triangleCenter2ExplosionRadius = (normalizedOrigin2TriangleCenterVector * (TimeSinceDeath * currentVelocity)) - (normalizedOrigin2TriangleCenterVector * fullDistanceWithRandomness);
 
-	// if the triangle is inside the blast radius...
+	// if the triangle is inside the blast's radius...
-	if (fullDistanceWithRandomness <= (TimeSinceDeath * currentVelocity))
+	float isInsideBlastRadius = LessEqualTo(origin2TriangleCenterDistanceWithRandomness, blastWave);
-	{
-		float maxRadius = max(TimeSinceDeath * currentVelocity, (ExplosionDuration * currentVelocity));
 	
-		float a = (randomVelocity.y - randomVelocity.x) / ExplosionDuration;
+	// calculate the max distance (s) the triangle will move
-		//float t = sqrt((2 * origin2TriangleCenterDistance) / a);
+	float accelaration = (randomVelocity.y - randomVelocity.x) / ExplosionDuration;
+	float maxDistance = (randomVelocity.x * ExplosionDuration) + (0.5 * accelaration * ExplosionDuration * ExplosionDuration);
 	
 	// if explosion color should be affected by distance instead of time...
 	if (ColorByDistance == true)
 	{
-			// calculate the max distance (s) the triangle will move
+		Output.ExplosionPercentageElapsed = (length(triangleCenter2ExplosionRadius) / maxDistance) * isInsideBlastRadius * ColorDistanceScalar;
-			float s = (randomVelocity.x * ExplosionDuration) + (0.5 * a * pow(ExplosionDuration, 2));
-			float te = (length(triangleCenter2ExplosionRadius) / s);
-			
-			Output.ExplosionColor = EndColor;
-			Output.ExplosionPercentageElapsed = te;
-
 	}
 	else
 	{
-			Output.ExplosionColor = EndColor;
 		Output.ExplosionPercentageElapsed = timePercetage;
-
 	}
 	
-		// for every vertex on the triangle...
+	vec3 ExplodedPosition;
 	for (int i = 0; i < gl_in.length(); i++)
 	{
 		// move the triangle to the blast radius
-			vec3 ExplodedPosition = Input[i].Position + triangleCenter2ExplosionRadius;
+		ExplodedPosition = Input[i].Position + (triangleCenter2ExplosionRadius * isInsideBlastRadius);
 
 		// pass through vertex data
-			Output.Normal = Input[i].Normal;
+		PassThingsThrough(i);
-			Output.Position = Input[i].Position;
+			for (int j = 0; j < MAX_SPLITS; j++)
-			Output.TextureCoordinate = Input[i].TextureCoordinate;
+			{
-			Output.Tangent = Input[i].Tangent;
+				Output.PositionLightSpace[j] = Input[i].PositionLightSpace[j];
-			Output.BiTangent = Input[i].BiTangent;
+			}
 			for (int j = 0; j < MAX_SPLITS; j++)
 			{
 				Output.PositionLightSpace[j] = Input[i].PositionLightSpace[j];
 			}
 		
-			// convert to model space for the gravity to always be in -y
+		// convert to window space 
-			vec4 ExplodedPositionInModelSpace = M * vec4(ExplodedPosition, 1.0);
+		gl_Position = P * V * M * vec4(ExplodedPosition, 1.0);
-			
-			// if there is gravity, apply it
-			//if (Gravity == true)
-			//{				
-			//	// ---DO THIS----> //ExplodedPositionInModelSpace.y = ExplodedPositionInModelSpace.y - TimeSinceHit;
-			//	
-			//	ExplodedPositionInModelSpace.y = ExplodedPositionInModelSpace.y - pow(TimeSinceDeath, 2);
-			//}
-			
-			// convert to screen space 
-			gl_Position = P*V * ExplodedPositionInModelSpace;
 		EmitVertex();
 	}
-	}
-	else
-	{
-		// if explosion color should be affected by distance instead of time...
-		if (ColorByDistance == true)
-		{
-			Output.ExplosionColor = EndColor;
-			Output.ExplosionPercentageElapsed = 0.0;
-		}
-		else
-		{
-			Output.ExplosionColor = EndColor;
-			Output.ExplosionPercentageElapsed = timePercetage;
-
-		}
-		
-		// for every vertex on the triangle...
-		for(int i = 0; i < gl_in.length(); i++)
-		{
-			// pass through vertex data
-			Output.Normal = Input[i].Normal;
-			Output.Position = Input[i].Position;
-			Output.TextureCoordinate = Input[i].TextureCoordinate;
-			Output.Tangent = Input[i].Tangent;
-			Output.BiTangent = Input[i].BiTangent;
-			for (int j = 0; j < MAX_SPLITS; j++)
-			{
-				Output.PositionLightSpace[j] = Input[i].PositionLightSpace[j];
-			}
-
-			// no change in position, pass through vertex
-			gl_Position = gl_in[i].gl_Position;
-			EmitVertex();
-		}
-	}
-	
-	//EndPrimitive();
 }

resources/Shaders/ForwardPlusNoShadows.frag.glsl

@@ -0,0 +1,204 @@
+#version 430
+
+#define MIN_AMBIENT_LIGHT 0.3
+#define MAX_SPLITS 4
+
+uniform mat4 VM;
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform vec4 Color;
+uniform vec4 DiffuseColor;
+uniform vec2 ScreenDimensions;
+uniform vec4 FillColor;
+uniform vec4 AmbientColor;
+uniform float FillPercentage;
+uniform float GlowIntensity;
+uniform vec3 CameraPosition;
+uniform int SSAOQuality;
+uniform float FarDistance[MAX_SPLITS];
+
+uniform vec2 DiffuseUVRepeat;
+uniform vec2 NormalUVRepeat;
+uniform vec2 SpecularUVRepeat;
+uniform vec2 GlowUVRepeat;
+layout (binding = 0) uniform sampler2D AOTexture;
+layout (binding = 1) uniform sampler2D DiffuseTexture;
+layout (binding = 2) uniform sampler2D NormalMapTexture;
+layout (binding = 3) uniform sampler2D SpecularMapTexture;
+layout (binding = 4) uniform sampler2D GlowMapTexture;
+layout (binding = 5) uniform samplerCube CubeMap;
+
+#define TILE_SIZE 16
+
+struct LightSource {
+	vec4 Position;
+	vec4 Direction;
+	vec4 Color;
+	float Radius;
+	float Intensity;
+	float Falloff;
+	int Type;
+};
+
+layout (std430, binding = 1) buffer LightBuffer
+{
+	LightSource List[];
+} LightSources;
+
+struct LightGrid {
+	float Start;
+	float Amount;
+	vec2 Padding;
+};
+
+layout (std430, binding = 2) buffer LightGridBuffer
+{
+	LightGrid Data[];
+} LightGrids;
+
+layout (std430, binding = 4) buffer LightIndexBuffer
+{
+	float LightIndex[];
+};
+
+in VertexData{
+	vec3 Position;
+	vec3 Normal;
+	vec3 Tangent;
+	vec3 BiTangent;
+	vec2 TextureCoordinate;
+	vec4 ExplosionColor;
+	float ExplosionPercentageElapsed;
+	vec4 PositionLightSpace[MAX_SPLITS];
+}Input;
+
+out vec4 sceneColor;
+out vec4 bloomColor;
+
+struct LightResult {
+	vec4 Diffuse;
+	vec4 Specular;
+};
+
+float CalcAttenuation(float radius, float dist, float falloff) {
+	return 1.0 - smoothstep(radius * falloff, radius, dist);
+}
+
+vec4 CalcSpecular(vec4 lightColor, vec4 viewVec,  vec4 lightVec, vec4 normal) {
+	vec4 R = normalize( reflect(-lightVec, normal));
+	float RdotV = max( dot(R, viewVec), 0.0);
+	return lightColor * pow(RdotV, 90.0);
+}
+
+vec4 CalcDiffuse(vec4 lightColor, vec4 lightVec, vec4 normal) {
+	float power = max( dot(normal, lightVec), 0.0);
+	return lightColor * power;
+}
+
+LightResult CalcPointLightSource(vec4 lightPos, float lightRadius, vec4 lightColor, float intensity, vec4 viewVec, vec4 position, vec4 normal, float falloff)
+{
+	vec4 L = lightPos - position;
+	float dist = length(L);
+	L = normalize(L);
+
+	float attenuation = CalcAttenuation(lightRadius, dist, falloff);
+
+	LightResult result;
+	result.Diffuse = CalcDiffuse(lightColor, L, normal) * attenuation * intensity;
+	result.Specular = CalcSpecular(lightColor, viewVec, L, normal) * attenuation *  intensity;
+	return result;
+}
+
+LightResult CalcDirectionalLightSource(vec4 direction, vec4 color, float intensity, vec4 viewVec, vec4 vertNormal)
+{
+	vec4 L = normalize( -vec4(direction.xyz, 0) );
+
+	LightResult result;
+	result.Diffuse = CalcDiffuse(color, L, vertNormal) * intensity;
+	result.Specular = CalcSpecular(color, viewVec, L, vertNormal) * intensity;
+	return result;
+}
+
+vec4 CalcNormalMappedValue(vec3 normal, vec3 tangent, vec3 bitangent, vec2 textureCoordinate, sampler2D normalMap)
+{
+	mat3 TBN = mat3(tangent, bitangent, normal);
+	vec3 NormalMap = texture(normalMap, textureCoordinate).xyz * 2.0 - vec3(1.0);
+	return vec4(TBN * normalize(NormalMap), 0.0);
+}
+
+void main()
+{
+	float ao = texelFetch(AOTexture, ivec2(gl_FragCoord.xy) >> int(SSAOQuality), 0).r;
+	ao = (clamp(1.0 - (1.0 - ao), 0.0, 1.0) + MIN_AMBIENT_LIGHT) /  (1.0 + MIN_AMBIENT_LIGHT);
+	vec4 diffuseTexel = texture2D(DiffuseTexture, Input.TextureCoordinate * DiffuseUVRepeat);
+	vec4 glowTexel = texture2D(GlowMapTexture, Input.TextureCoordinate * GlowUVRepeat);
+	vec4 specularTexel = texture2D(SpecularMapTexture, Input.TextureCoordinate * SpecularUVRepeat);
+	vec4 position = VM * vec4(Input.Position, 1.0); 
+	vec4 normal = V * CalcNormalMappedValue(Input.Normal, Input.Tangent, Input.BiTangent, Input.TextureCoordinate * NormalUVRepeat, NormalMapTexture);
+	normal = normalize(normal);
+	//vec4 normal = normalize(V  * vec4(Input.Normal, 0.0));
+	vec4 viewVec = normalize(-position);
+	vec3 I = normalize(vec3(M * vec4(Input.Position, 1.0)) - CameraPosition);
+	vec3 R = reflect(-I, Input.Normal);
+	//R = vec3(P * vec4(R, 1.0));
+	vec4 reflectionColor = texture(CubeMap, R);
+
+	vec2 tilePos;
+	tilePos.x = int(gl_FragCoord.x/TILE_SIZE);
+	tilePos.y = int(gl_FragCoord.y/TILE_SIZE);
+
+	LightResult totalLighting;
+	totalLighting.Diffuse = vec4(AmbientColor.rgb * ao, 1.0);
+	int currentTile = int(floor(gl_FragCoord.x/TILE_SIZE) + (floor(gl_FragCoord.y/TILE_SIZE) * int(ScreenDimensions.x/TILE_SIZE)));
+
+	int start = int(LightGrids.Data[currentTile].Start);
+	int amount = int(LightGrids.Data[currentTile].Amount);
+	
+	for(int i = start; i < start + amount; i++) {
+
+		int l = int(LightIndex[i]);
+		LightSource light = LightSources.List[l];
+
+		LightResult light_result;
+		//These if statements should be removed.
+		if(light.Type == 1) { // point
+			light_result = CalcPointLightSource(V * light.Position, light.Radius, light.Color, light.Intensity, viewVec, position, normal, light.Falloff);
+		} else if (light.Type == 2) { //Directional
+			light_result = CalcDirectionalLightSource(V * light.Direction, light.Color, light.Intensity, viewVec, normal);
+		}
+		totalLighting.Diffuse += vec4(light_result.Diffuse.rgb * ao, light_result.Diffuse.a);
+		totalLighting.Specular += vec4(light_result.Specular.rgb * ao, light_result.Specular.a);
+	}
+
+	vec4 color_result = mix((Color * diffuseTexel * DiffuseColor), Input.ExplosionColor, Input.ExplosionPercentageElapsed);
+	color_result = color_result * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel));
+	float specularResult = (specularTexel.r + specularTexel.g + specularTexel.b)/3.0;
+	vec4 reflectionTotal = reflectionColor * (1-specularTexel.a) * color_result.a * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel));
+	color_result = color_result * clamp(1/specularTexel.a, 0, 1) + reflectionTotal;
+	//vec4 color_result = (DiffuseColor + Input.ExplosionColor) * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel)) * diffuseTexel * Color;
+	
+
+	float pos = ((P * vec4(Input.Position, 1)).y + 1.0)/2.0;
+
+	if(pos <= FillPercentage) {
+		color_result += FillColor;
+	}
+	sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1));
+	//sceneColor = CommonUniforms.testColour;
+	//sceneColor = vec4(reflectionColor.xyz, 1);
+	color_result.xyz += glowTexel.xyz*GlowIntensity;
+
+	bloomColor = vec4(max(color_result.xyz - 1.0, 0.0), clamp(color_result.a, 0, 1));
+
+	//Tiled Debug Code
+	/*
+	if(int(gl_FragCoord.x)%16 == 0 || int(gl_FragCoord.y)%16 == 0 ) {
+		sceneColor += vec4(0.5, 0, 0, 0);
+	} else {
+		sceneColor += vec4(LightGrids.Data[int(tilePos.x + tilePos.y*80)].Amount/LightSources.List.length(), 0, 0, 1);
+	}
+	*/
+}
+
+

src/Engine/Collision/Collision.cpp

@@ -151,9 +151,9 @@ bool RayVsModel(const Ray& ray,
     const glm::mat4& modelMatrix)
 {
     for (int i = 0; i < modelIndices.size();) {
-        glm::vec3 v0 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
+        glm::vec3 v0 = TransformSystem::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
-        glm::vec3 v1 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
+        glm::vec3 v1 = TransformSystem::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
-        glm::vec3 v2 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
+        glm::vec3 v2 = TransformSystem::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
         if (RayVsTriangle(ray, v0, v1, v2)) {
             return true;
         }
@@ -204,9 +204,9 @@ bool RayVsModel(const Ray& ray,
     outDistance = INFINITY;
     bool hit = false;
     for (int i = 0; i < modelIndices.size();) {
-        glm::vec3 v0 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
+        glm::vec3 v0 = TransformSystem::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
-        glm::vec3 v1 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
+        glm::vec3 v1 = TransformSystem::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
-        glm::vec3 v2 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
+        glm::vec3 v2 = TransformSystem::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
         float dist = outDistance;
         float u;
         float v;
@@ -565,9 +565,9 @@ Output AABBvsTriangles(const AABB& box,
     glm::vec3 originalBoxVelocity(boxVelocity);
     for (int i = 0; i < modelIndices.size(); ) {
         std::array<glm::vec3, 3> triVertices = {
-            Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix),
+            TransformSystem::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix),
-            Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix),
+            TransformSystem::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix),
-            Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix)
+            TransformSystem::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix)
         };
         glm::vec3 outVec;
         bool collideWithGround = isOnGround;
@@ -655,9 +655,9 @@ boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity, bool takeM
     AABB modelSpaceBox;
     if (entity.HasComponent("AABB") && !takeModelBox) {
         ComponentWrapper& cAABB = entity["AABB"];
-        modelSpaceBox = EntityAABB::FromOriginSize((glm::vec3)cAABB["Origin"], (glm::vec3)cAABB["Size"]);
+        modelSpaceBox = EntityAABB::FromOriginSize((const glm::vec3&)cAABB["Origin"], (const glm::vec3&)cAABB["Size"]);
     } else if (entity.HasComponent("Model")) {
-        std::string res = entity["Model"]["Resource"];
+        const std::string& res = entity["Model"]["Resource"];
         if (res.empty()) {
             return boost::none;
         }
@@ -674,7 +674,7 @@ boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity, bool takeM
         return boost::none;
     }
 
-    glm::mat4 modelMat = Transform::AbsoluteTransformation(entity);
+    glm::mat4 modelMat = TransformSystem::ModelMatrix(entity);
     glm::vec3 mini(INFINITY);
     glm::vec3 maxi(-INFINITY);
     glm::vec3 maxCorner = modelSpaceBox.MaxCorner();
@@ -685,7 +685,7 @@ boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity, bool takeM
         corner.x = bits.test(0) ? maxCorner.x : minCorner.x;
         corner.y = bits.test(1) ? maxCorner.y : minCorner.y;
         corner.z = bits.test(2) ? maxCorner.z : minCorner.z;
-        corner = Transform::TransformPoint(corner, modelMat);
+        corner = TransformSystem::TransformPoint(corner, modelMat);
         mini = glm::min(mini, corner);
         maxi = glm::max(maxi, corner);
     }
@@ -703,7 +703,7 @@ boost::optional<EntityAABB> AbsoluteAABBExplosionEffect(EntityWrapper& entity)
     if (!modelBox) {
         return boost::none;
     }
-    bool isRandom = (bool)entity["ExplosionEffect"]["Randomness"];
+    Field<bool> isRandom = entity["ExplosionEffect"]["Randomness"];
     float random = isRandom ? (float)(double)entity["ExplosionEffect"]["RandomnessScalar"] : 0;
     glm::vec3 origin = (glm::vec3)entity["ExplosionEffect"]["ExplosionOrigin"];
     glm::vec3 randomVel = (glm::vec3)entity["ExplosionEffect"]["Velocity"];
@@ -741,7 +741,7 @@ boost::optional<EntityAABB> EntityFirstHitByRay(const Ray& ray, std::vector<Enti
             continue;
         }
         float u, v;
-        if (RayVsModel(ray, model->Vertices(), model->m_RawModel->m_Indices, Transform::ModelMatrix(entityBox.Entity), outDistance, u, v)) {
+        if (RayVsModel(ray, model->Vertices(), model->m_RawModel->m_Indices, TransformSystem::ModelMatrix(entityBox.Entity), outDistance, u, v)) {
             outIntersectPos = ray.Origin() + outDistance * ray.Direction();
             return entityBox;
         }

src/Engine/Collision/CollisionSystem.cpp

@@ -49,7 +49,7 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
                             continue;
                         }
                         float u, v;
-                        hit = Collision::RayVsModel(ray, model->Vertices(), model->m_Indices, Transform::ModelMatrix(boxB.Entity), dist, u, v);
+                        hit = Collision::RayVsModel(ray, model->Vertices(), model->m_Indices, TransformSystem::ModelMatrix(boxB.Entity), dist, u, v);
                     } else {
                         hit = Collision::RayVsAABB(ray, boxB, dist);
                     }
@@ -58,12 +58,12 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
                         //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;
+                        (Field<glm::vec3>)cTransform["Position"] += resolve;
                         boxA = *Collision::EntityAbsoluteAABB(entity);
                         if (resolve.y > 0) {
                             everHitTheGround = true;
-                            (bool)cPhysics["IsOnGround"] = true;
+                            cPhysics["IsOnGround"] = true;
-                            ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
+                            ((Field<glm::vec3>)cPhysics["Velocity"]).y(0.f);
                         }
                         break;
                     }
@@ -82,7 +82,7 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
 
             if (boxB.Entity.HasComponent("Model") && Collision::AABBVsAABB(boxA, boxB)) {
                 // Here we know boxB is a entity with Collideable, AABB, and Model.
-                if (!((bool)boxB.Entity["Model"]["Visible"])) {
+                if (!((const bool&)boxB.Entity["Model"]["Visible"])) {
                     // Don't collide against invisible models.
                     continue;
                 }
@@ -93,14 +93,14 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
                     continue;
                 }
 
-                glm::mat4 modelMatrix = Transform::ModelMatrix(boxB.Entity);
+                glm::mat4 modelMatrix = TransformSystem::ModelMatrix(boxB.Entity);
 
                 glm::vec3 inOutVelocity = (glm::vec3)cPhysics["Velocity"];
                 bool isOnGround = (bool)cPhysics["IsOnGround"];
                 float verticalStepHeight = (float)(double)cPhysics["VerticalStepHeight"];
                 if (Collision::AABBvsTriangles(boxA, model->Vertices(), model->m_Indices, modelMatrix, inOutVelocity, verticalStepHeight, isOnGround, resolutionVector)) {
                     //Move the position to previous position if it is not moving in the xz-plane, else resolve with the resolution vector.
-                    (glm::vec3&)cTransform["Position"] += resolutionVector;
+                    (Field<glm::vec3>)cTransform["Position"] += resolutionVector;
                     boxA = *Collision::EntityAbsoluteAABB(entity);
                     cPhysics["Velocity"] = inOutVelocity;
                     if (isOnGround) {
@@ -110,12 +110,12 @@ 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;
+                (Field<glm::vec3>)cTransform["Position"] += resolutionVector;
                 boxA = *Collision::EntityAbsoluteAABB(entity);
                 if (resolutionVector.y > 0) {
                     everHitTheGround = true;
                     (bool)cPhysics["IsOnGround"] = true;
-                    ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
+                    ((Field<glm::vec3>)cPhysics["Velocity"]).y(0.f);
                 }
             }
         }

src/Engine/Collision/TriggerSystem.cpp

@@ -15,7 +15,7 @@ void TriggerSystem::UpdateComponent(EntityWrapper& triggerEntity, ComponentWrapp
     if (triggerEntity.HasComponent("Model")) {
         try {
             triggerModel = ResourceManager::Load<RawModel, true>(triggerEntity["Model"]["Resource"]);
-            triggerModelMat = Transform::ModelMatrix(triggerEntity);
+            triggerModelMat = TransformSystem::ModelMatrix(triggerEntity);
         } catch (const std::exception&) {
         }
     }

src/Engine/Core/ComponentPool.cpp

@@ -1,9 +1,17 @@
 #include "Core/ComponentPool.h"
 
+ComponentPoolForwardIterator::ComponentPoolForwardIterator(ComponentPool* pool, const MemoryPool<char>::iterator begin, const MemoryPool<char>::iterator end)
+    : m_ComponentPool(pool)
+    , m_ComponentInfo(pool->m_ComponentInfo)
+    , m_MemoryPoolIterator(begin)
+    , m_MemoryPoolEnd(end)
+{ }
+
 ComponentWrapper ComponentPoolForwardIterator::operator*() const
 {
     char* data = &(*m_MemoryPoolIterator);
-    ComponentWrapper wrapper(m_ComponentInfo, data);
+    EntityID entity = *reinterpret_cast<EntityID*>(data);
+    ComponentWrapper wrapper(m_ComponentInfo, data, &m_ComponentPool->m_DirtySet[entity], m_ComponentPool->m_World);
     return wrapper;
 }
 
@@ -44,7 +52,7 @@ ComponentPool::ComponentPool(const ComponentPool& other)
     // Duplicate strings
     for (auto& name : m_ComponentInfo.StringFields) {
         for (auto& c : *this) {
-            std::string& val = c[name];
+            Field<std::string> val = c[name];
             ComponentWrapper::SolidifyStrings(c);
         }
     }
@@ -71,7 +79,7 @@ ComponentWrapper ComponentPool::Allocate(EntityID entity)
     memcpy(data, &entity, sizeof(EntityID));
 
     m_EntityToComponent[entity] = data;
-    ComponentWrapper component(m_ComponentInfo, data);
+    ComponentWrapper component(m_ComponentInfo, data, &m_DirtySet[entity], m_World);
 
     // Copy defaults
     memcpy(component.Data, m_ComponentInfo.Defaults.get(), m_ComponentInfo.Stride);
@@ -82,7 +90,9 @@ ComponentWrapper ComponentPool::Allocate(EntityID entity)
 
 ComponentWrapper ComponentPool::GetByEntity(EntityID ent)
 {
-     return ComponentWrapper(m_ComponentInfo, m_EntityToComponent.at(ent));
+    auto data = m_EntityToComponent.at(ent);
+    auto bitField = &m_DirtySet[ent];
+    return ComponentWrapper(m_ComponentInfo, data, bitField, m_World);
 }
 
 bool ComponentPool::KnowsEntity(EntityID ent)
@@ -95,16 +105,17 @@ void ComponentPool::Delete(ComponentWrapper& wrapper)
     ComponentWrapper::Destroy(wrapper.Info, wrapper.Data);
     m_EntityToComponent.erase(wrapper.EntityID);
     m_Pool.Free(wrapper.Data - sizeof(EntityID));
+    m_DirtySet.erase(wrapper.EntityID);
 }
 
-ComponentPool::iterator ComponentPool::begin() const
+ComponentPool::iterator ComponentPool::begin()
 {
-    return iterator(m_ComponentInfo, m_Pool.begin(), m_Pool.end());
+    return iterator(this, m_Pool.begin(), m_Pool.end());
 }
 
-ComponentPool::iterator ComponentPool::end() const
+ComponentPool::iterator ComponentPool::end()
 {
-    return iterator(m_ComponentInfo, m_Pool.end(), m_Pool.end());
+    return iterator(this, m_Pool.end(), m_Pool.end());
 }
 
 size_t ComponentPool::size() const

src/Engine/Core/ComponentWrapper.cpp

@@ -0,0 +1,59 @@
+#include "Core/World.h"
+#include "Core/ComponentWrapper.h"
+
+ComponentWrapper::ComponentWrapper(const ComponentInfo& componentInfo, char* data, ::DirtyBitField* dirtyBitField, World* world)
+    : Info(componentInfo)
+    , EntityID(*reinterpret_cast<::EntityID*>(data))
+    , Data(data + componentInfo.GetHeaderSize())
+    , DirtyBitField(dirtyBitField)
+    , m_World(world)
+{}
+
+ComponentInfo::EnumType ComponentWrapper::Enum(const char* fieldName, const char* enumKey)
+{
+    return Info.Meta->FieldEnumDefinitions.at(fieldName).at(enumKey);
+}
+
+bool ComponentWrapper::Dirty(DirtySetType type, const std::string& fieldName)
+{
+    if (DirtyBitField == nullptr) {
+        return true;
+    } else {
+        auto& field = Info.Fields.at(fieldName);
+        return DirtyBitField->operator[](type).count(field.Index) == 1;
+    }
+}
+
+void ComponentWrapper::SetDirty(DirtySetType type, const std::string& fieldName, bool dirty /* = true */)
+{
+    if (DirtyBitField == nullptr) {
+        return;
+    }
+
+    auto& field = Info.Fields.at(fieldName);
+    if (dirty) {
+        DirtyBitField->operator[](type).insert(field.Index);
+        // Because parents affects children when altered, we also need to flag all children as dirty.
+        if (type == DirtySetType::Transform && m_World != nullptr) {
+            auto children = m_World->GetDirectChildren(EntityID);
+            for (auto kv = children.first; kv != children.second; ++kv) {
+                const auto& child = kv->second;
+                if (m_World->HasComponent(child, Info.Name)) {
+                    m_World->GetComponent(child, Info.Name).SetDirty(DirtySetType::Transform, fieldName, true);
+                    if (fieldName == "Orientation" || fieldName == "Scale") {
+                        m_World->GetComponent(child, Info.Name).SetDirty(DirtySetType::Transform, "Position", true);
+                    }
+                }
+            }
+        }
+    } else {
+        DirtyBitField->operator[](type).erase(field.Index);
+    }
+}
+
+void ComponentWrapper::SetAllDirty(const std::string& fieldName, bool dirty /* = true */)
+{
+    for (auto& kv : *DirtyBitField) {
+        SetDirty(kv.first, fieldName);
+    }
+}

src/Engine/Core/EntityWrapper.cpp

@@ -94,8 +94,30 @@ EntityWrapper EntityWrapper::Clone(EntityWrapper parent /*= Invalid*/)
         return EntityWrapper::Invalid;
     }
 
-    EntityWrapper clone = cloneRecursive(*this, EntityWrapper::Invalid);
+    // Create a relationship map of children of this entity
-    this->World->SetParent(clone.ID, parent.ID);
+    std::unordered_multimap<EntityWrapper, EntityWrapper> relationships;
+    fillRelationships(relationships, *this);
+
+    ::World* targetWorld = this->World;
+    if (parent.Valid()) {
+        targetWorld = parent.World;
+    }
+
+    // Create root entity
+    EntityWrapper clone(targetWorld, targetWorld->CreateEntity(parent.ID));
+    // Copy name
+    clone.World->SetName(clone.ID, this->Name());
+    // Clone components
+    for (auto& kv : this->World->GetComponentPools()) {
+        if (kv.second->KnowsEntity(this->ID)) {
+            ComponentWrapper c1 = kv.second->GetByEntity(this->ID);
+            ComponentWrapper c2 = clone.World->AttachComponent(clone.ID, kv.first);
+            c1.Copy(c2);
+        }
+    }
+    // Recreate entity tree
+    recreateRelationships(relationships, *this, clone);
+
     return clone;
 }
 
@@ -207,30 +229,6 @@ 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;
-}
-
 void EntityWrapper::childrenWithComponentRecursive(const std::string& componentType, EntityWrapper& entity, std::vector<EntityWrapper>& childrenWithComponent)
 {
     auto itPair = this->World->GetDirectChildren(entity.ID);
@@ -246,3 +244,35 @@ void EntityWrapper::childrenWithComponentRecursive(const std::string& componentT
         childrenWithComponentRecursive(componentType, child, childrenWithComponent);
     }
 }
+
+void EntityWrapper::fillRelationships(std::unordered_multimap<EntityWrapper, EntityWrapper>& relationMap, EntityWrapper entity)
+{
+    auto children = entity.World->GetDirectChildren(entity.ID);
+    for (auto it = children.first; it != children.second; ++it) {
+        EntityWrapper child(entity.World, it->second);
+        relationMap.insert(std::make_pair(entity, child));
+        fillRelationships(relationMap, child);
+    }
+}
+
+void EntityWrapper::recreateRelationships(const std::unordered_multimap<EntityWrapper, EntityWrapper>& relationMap, EntityWrapper templateEntity, EntityWrapper parent /*= EntityWrapper::Invalid*/)
+{
+    // Recursively create children
+    auto children = relationMap.equal_range(templateEntity);
+    for (auto it = children.first; it != children.second; ++it) {
+        EntityWrapper child = it->second;
+        // Create clone entity
+        EntityWrapper clone(parent.World, parent.World->CreateEntity(parent.ID));
+        // Copy name
+        clone.World->SetName(clone.ID, child.Name());
+        // Clone components
+        for (auto& kv : child.World->GetComponentPools()) {
+            if (kv.second->KnowsEntity(child.ID)) {
+                ComponentWrapper c1 = kv.second->GetByEntity(child.ID);
+                ComponentWrapper c2 = clone.World->AttachComponent(clone.ID, kv.first);
+                c1.Copy(c2);
+            }
+        }
+        recreateRelationships(relationMap, child, clone);
+    }
+}

src/Engine/Core/EntityXMLFilePreprocessor.cpp

@@ -125,6 +125,7 @@ void EntityXMLFilePreprocessor::parseComponentInfo()
         auto modelGroup = modelGroupParticle->getModelGroupTerm();
 
         // <xs:element... 
+        unsigned char fieldIndex = 0;
         unsigned int fieldOffset = 0;
         auto particles = modelGroup->getParticles();
         for (unsigned int i = 0; i < particles->size(); ++i) {
@@ -182,12 +183,14 @@ void EntityXMLFilePreprocessor::parseComponentInfo()
             auto& field = compInfo.Fields[name];
             field.Name = name;
             field.Type = effectiveType;
+            field.Index = fieldIndex;
             field.Offset = fieldOffset;
             field.Stride = stride;
             compInfo.FieldsInOrder.push_back(name);
             if (field.Type == "string") {
                 compInfo.StringFields.push_back(name);
             }
+            fieldIndex += 1;
             fieldOffset += stride;
         }
 

src/Engine/Core/Transform.cpp

@@ -1,103 +1,162 @@
-#include "Core/Transform.h"
+#include "Core/TransformSystem.h"
 
-glm::mat4 Transform::AbsoluteTransformation(EntityWrapper entity)
+std::unordered_map<EntityWrapper, glm::vec3> TransformSystem::PositionCache;
+std::unordered_map<EntityWrapper, glm::quat> TransformSystem::OrientationCache;
+std::unordered_map<EntityWrapper, glm::vec3> TransformSystem::ScaleCache;
+std::unordered_map<EntityWrapper, glm::mat4> TransformSystem::MatrixCache;
+
+int TransformSystem::RecalculatedPositions = 0;
+int TransformSystem::RecalculatedOrientations = 0;
+int TransformSystem::RecalculatedScales = 0;
+
+TransformSystem::TransformSystem(SystemParams params)
+    : System(params)
 {
-    glm::mat4 t = glm::mat4(1.f);
+    EVENT_SUBSCRIBE_MEMBER(m_EEntityDeleted, &TransformSystem::OnEntityDeleted);
-
-    while (entity.Valid()) {
-        t = glm::translate((glm::vec3&)entity["Transform"]["Position"]) * glm::toMat4(glm::quat((glm::vec3&)entity["Transform"]["Orientation"])) * glm::scale((glm::vec3&)entity["Transform"]["Scale"]) * t;
-        entity = entity.Parent();
-    }
-
-    return t;
 }
 
-glm::vec3 Transform::AbsolutePosition(EntityWrapper entity)
+bool TransformSystem::OnEntityDeleted(const Events::EntityDeleted& e)
 {
-    return AbsolutePosition(entity.World, entity.ID);
+    // Clean up deleted entity
+    PositionCache.erase(e.DeletedEntity);
+    OrientationCache.erase(e.DeletedEntity);
+    ScaleCache.erase(e.DeletedEntity);
+    MatrixCache.erase(e.DeletedEntity);
+    return true;
 }
 
-glm::vec3 Transform::AbsolutePosition(World* world, EntityID entity)
+//glm::mat4 Transform::AbsoluteTransformation(EntityWrapper entity)
-{
+//{
-    glm::vec3 position;
+//    glm::mat4 t = glm::mat4(1.f);
+//
+//    while (entity.Valid()) {
+//        t = glm::translate((const glm::vec3&)entity["Transform"]["Position"]) * glm::toMat4(glm::quat((const glm::vec3&)entity["Transform"]["Orientation"])) * glm::scale((const glm::vec3&)entity["Transform"]["Scale"]) * t;
+//        entity = entity.Parent();
+//    }
+//
+//    return t;
+//}
 
-    while (entity != EntityID_Invalid) {
+glm::vec3 TransformSystem::AbsolutePosition(World* world, EntityID entity)
-        ComponentWrapper transform = world->GetComponent(entity, "Transform");
+{
-        EntityID parent = world->GetParent(entity);
+    return TransformSystem::AbsolutePosition(EntityWrapper(world, entity));
-        position += Transform::AbsoluteScale(world, parent) * (Transform::AbsoluteOrientation(world, parent) * (glm::vec3)transform["Position"]);
+}
-        entity = parent;
+
+glm::vec3 TransformSystem::AbsolutePosition(EntityWrapper entity)
+{
+    if (!entity.Valid()) {
+        return glm::vec3();
     }
 
+    auto cacheIt = PositionCache.find(entity);
+    ComponentWrapper cTransform = entity["Transform"];
+    ComponentWrapper::SubscriptProxy cTransformPosition = cTransform["Position"];
+    if (cacheIt != PositionCache.end() && !cTransformPosition.Dirty(DirtySetType::Transform)) {
+        return cacheIt->second;
+    } else {
+        EntityWrapper parent = entity.Parent();
+        // Calculate position
+        glm::vec3 position = AbsolutePosition(parent) + TransformSystem::AbsoluteOrientation(parent) * (TransformSystem::AbsoluteScale(parent) * (const glm::vec3&)cTransformPosition);
+        // Cache it
+        PositionCache[entity] = position;
+        RecalculatedPositions++;
+        // Unset dirty flag
+        cTransformPosition.SetDirty(DirtySetType::Transform, false);
         return position;
+    }
 }
 
-glm::vec3 Transform::AbsoluteOrientationEuler(EntityWrapper entity)
+glm::vec3 TransformSystem::AbsoluteOrientationEuler(EntityWrapper entity)
 {
     glm::vec3 orientation;
 
     while (entity.Valid()) {
         ComponentWrapper transform = entity["Transform"];
-        orientation += (glm::vec3)transform["Orientation"];
+        orientation += (Field<glm::vec3>)transform["Orientation"];
         entity = entity.Parent();
     }
 
     return orientation;
 }
 
-glm::quat Transform::AbsoluteOrientation(EntityWrapper entity)
+glm::quat TransformSystem::AbsoluteOrientation(World* world, EntityID entity)
 {
-    return AbsoluteOrientation(entity.World, entity.ID);
+    return TransformSystem::AbsoluteOrientation(EntityWrapper(world, entity));
 }
 
-glm::quat Transform::AbsoluteOrientation(World* world, EntityID entity)
+glm::quat TransformSystem::AbsoluteOrientation(EntityWrapper entity)
 {
-    glm::quat orientation;
+    if (!entity.Valid()) {
-
+        return glm::quat();
-    while (entity != EntityID_Invalid) {
-        ComponentWrapper transform = world->GetComponent(entity, "Transform");
-        orientation = glm::quat((glm::vec3)transform["Orientation"]) * orientation;
-        entity = world->GetParent(entity);
     }
 
+    auto cacheIt = OrientationCache.find(entity);
+    ComponentWrapper cTransform = entity["Transform"];
+    ComponentWrapper::SubscriptProxy cTransformOrientation = cTransform["Orientation"];
+    if (cacheIt != OrientationCache.end() && !cTransformOrientation.Dirty(DirtySetType::Transform)) {
+        return cacheIt->second;
+    } else {
+        EntityWrapper parent = entity.Parent();
+        // Calculate orientation
+        glm::quat orientation = AbsoluteOrientation(parent) * glm::quat((const glm::vec3&)cTransformOrientation);
+        // Cache it
+        OrientationCache[entity] = orientation;
+        RecalculatedOrientations++;
+        // Unset dirty flag
+        cTransformOrientation.SetDirty(DirtySetType::Transform, false);
         return orientation;
+    }
 }
 
-glm::vec3 Transform::AbsoluteScale(EntityWrapper entity)
+glm::vec3 TransformSystem::AbsoluteScale(World* world, EntityID entity)
 {
-    return AbsoluteScale(entity.World, entity.ID);
+    return TransformSystem::AbsoluteScale(EntityWrapper(world, entity));
 }
 
-glm::vec3 Transform::AbsoluteScale(World* world, EntityID entity)
+glm::vec3 TransformSystem::AbsoluteScale(EntityWrapper entity)
 {
-    glm::vec3 scale(1.f);
+    if (!entity.Valid()) {
-
+        return glm::vec3(1.f);
-    while (entity != EntityID_Invalid) {
-        ComponentWrapper transform = world->GetComponent(entity, "Transform");
-        scale *= (glm::vec3)transform["Scale"];
-        entity = world->GetParent(entity);
     }
 
+    auto cacheIt = ScaleCache.find(entity);
+    ComponentWrapper cTransform = entity["Transform"];
+    ComponentWrapper::SubscriptProxy cTransformScale = cTransform["Scale"];
+    if (cacheIt != ScaleCache.end() && !cTransformScale.Dirty(DirtySetType::Transform)) {
+        return cacheIt->second;
+    } else {
+        EntityWrapper parent = entity.Parent();
+        // Calculate scale
+        glm::vec3 scale = AbsoluteScale(parent) * (const glm::vec3&)cTransformScale;
+        // Cache it
+        ScaleCache[entity] = scale;
+        RecalculatedPositions++;
+        // Unset dirty flag
+        cTransformScale.SetDirty(DirtySetType::Transform, false);
         return scale;
+    }
 }
 
-glm::mat4 Transform::ModelMatrix(EntityWrapper entity)
+glm::mat4 TransformSystem::ModelMatrix(EntityID entityID, World* world)
 {
-    return ModelMatrix(entity.ID, entity.World);
+    return ModelMatrix(EntityWrapper(world, entityID));
 }
 
-glm::mat4 Transform::ModelMatrix(EntityID entity, World* world)
+glm::mat4 TransformSystem::ModelMatrix(EntityWrapper entity)
 {
-    return AbsoluteTransformation(EntityWrapper(world, entity));
+    auto cacheIt = MatrixCache.find(entity);
-
+    ComponentWrapper cTransform = entity["Transform"];
-    //glm::vec3 position = Transform::AbsolutePosition(world, entity);
+    bool isDirty = cTransform["Position"].Dirty(DirtySetType::Transform) || cTransform["Orientation"].Dirty(DirtySetType::Transform) || cTransform["Scale"].Dirty(DirtySetType::Transform);
-    //glm::quat orientation = Transform::AbsoluteOrientation(world, entity);
+    if (cacheIt != MatrixCache.end() && !isDirty) {
-    //glm::vec3 scale = Transform::AbsoluteScale(world, entity);
+        return cacheIt->second;
-
+    } else {
-    //glm::mat4 modelMatrix = glm::translate(glm::mat4(), position) * glm::toMat4(orientation) * glm::scale(scale);
+        glm::mat4 matrix = glm::translate(AbsolutePosition(entity)) * glm::toMat4(AbsoluteOrientation(entity)) * glm::scale(AbsoluteScale(entity));
-    //return modelMatrix;
+        MatrixCache[entity] = matrix;
+        return matrix;
+    }
 }
 
-glm::vec3 Transform::TransformPoint(const glm::vec3& point, const glm::mat4& matrix)
+glm::vec3 TransformSystem::TransformPoint(const glm::vec3& point, const glm::mat4& matrix)
 {
     return glm::vec3(matrix * glm::vec4(point.x, point.y, point.z, 1));
 }

src/Engine/Core/TransformSystem.cpp

@@ -0,0 +1,162 @@
+#include "Core/TransformSystem.h"
+
+std::unordered_map<EntityWrapper, glm::vec3> TransformSystem::PositionCache;
+std::unordered_map<EntityWrapper, glm::quat> TransformSystem::OrientationCache;
+std::unordered_map<EntityWrapper, glm::vec3> TransformSystem::ScaleCache;
+std::unordered_map<EntityWrapper, glm::mat4> TransformSystem::MatrixCache;
+
+int TransformSystem::RecalculatedPositions = 0;
+int TransformSystem::RecalculatedOrientations = 0;
+int TransformSystem::RecalculatedScales = 0;
+
+TransformSystem::TransformSystem(SystemParams params)
+    : System(params)
+{
+    EVENT_SUBSCRIBE_MEMBER(m_EEntityDeleted, &TransformSystem::OnEntityDeleted);
+}
+
+bool TransformSystem::OnEntityDeleted(const Events::EntityDeleted& e)
+{
+    // Clean up deleted entity
+    PositionCache.erase(e.DeletedEntity);
+    OrientationCache.erase(e.DeletedEntity);
+    ScaleCache.erase(e.DeletedEntity);
+    MatrixCache.erase(e.DeletedEntity);
+    return true;
+}
+
+//glm::mat4 Transform::AbsoluteTransformation(EntityWrapper entity)
+//{
+//    glm::mat4 t = glm::mat4(1.f);
+//
+//    while (entity.Valid()) {
+//        t = glm::translate((const glm::vec3&)entity["Transform"]["Position"]) * glm::toMat4(glm::quat((const glm::vec3&)entity["Transform"]["Orientation"])) * glm::scale((const glm::vec3&)entity["Transform"]["Scale"]) * t;
+//        entity = entity.Parent();
+//    }
+//
+//    return t;
+//}
+
+glm::vec3 TransformSystem::AbsolutePosition(World* world, EntityID entity)
+{
+    return TransformSystem::AbsolutePosition(EntityWrapper(world, entity));
+}
+
+glm::vec3 TransformSystem::AbsolutePosition(EntityWrapper entity)
+{
+    if (!entity.Valid()) {
+        return glm::vec3();
+    }
+
+    auto cacheIt = PositionCache.find(entity);
+    ComponentWrapper cTransform = entity["Transform"];
+    ComponentWrapper::SubscriptProxy cTransformPosition = cTransform["Position"];
+    if (cacheIt != PositionCache.end() && !cTransformPosition.Dirty(DirtySetType::Transform)) {
+        return cacheIt->second;
+    } else {
+        EntityWrapper parent = entity.Parent();
+        // Calculate position
+        glm::vec3 position = AbsolutePosition(parent) + TransformSystem::AbsoluteOrientation(parent) * (TransformSystem::AbsoluteScale(parent) * (const glm::vec3&)cTransformPosition);
+        // Cache it
+        PositionCache[entity] = position;
+        RecalculatedPositions++;
+        // Unset dirty flag
+        cTransformPosition.SetDirty(DirtySetType::Transform, false);
+        return position;
+    }
+}
+
+glm::vec3 TransformSystem::AbsoluteOrientationEuler(EntityWrapper entity)
+{
+    glm::vec3 orientation;
+
+    while (entity.Valid()) {
+        ComponentWrapper transform = entity["Transform"];
+        orientation += (Field<glm::vec3>)transform["Orientation"];
+        entity = entity.Parent();
+    }
+
+    return orientation;
+}
+
+glm::quat TransformSystem::AbsoluteOrientation(World* world, EntityID entity)
+{
+    return TransformSystem::AbsoluteOrientation(EntityWrapper(world, entity));
+}
+
+glm::quat TransformSystem::AbsoluteOrientation(EntityWrapper entity)
+{
+    if (!entity.Valid()) {
+        return glm::quat();
+    }
+
+    auto cacheIt = OrientationCache.find(entity);
+    ComponentWrapper cTransform = entity["Transform"];
+    ComponentWrapper::SubscriptProxy cTransformOrientation = cTransform["Orientation"];
+    if (cacheIt != OrientationCache.end() && !cTransformOrientation.Dirty(DirtySetType::Transform)) {
+        return cacheIt->second;
+    } else {
+        EntityWrapper parent = entity.Parent();
+        // Calculate orientation
+        glm::quat orientation = AbsoluteOrientation(parent) * glm::quat((const glm::vec3&)cTransformOrientation);
+        // Cache it
+        OrientationCache[entity] = orientation;
+        RecalculatedOrientations++;
+        // Unset dirty flag
+        cTransformOrientation.SetDirty(DirtySetType::Transform, false);
+        return orientation;
+    }
+}
+
+glm::vec3 TransformSystem::AbsoluteScale(World* world, EntityID entity)
+{
+    return TransformSystem::AbsoluteScale(EntityWrapper(world, entity));
+}
+
+glm::vec3 TransformSystem::AbsoluteScale(EntityWrapper entity)
+{
+    if (!entity.Valid()) {
+        return glm::vec3(1.f);
+    }
+
+    auto cacheIt = ScaleCache.find(entity);
+    ComponentWrapper cTransform = entity["Transform"];
+    ComponentWrapper::SubscriptProxy cTransformScale = cTransform["Scale"];
+    if (cacheIt != ScaleCache.end() && !cTransformScale.Dirty(DirtySetType::Transform)) {
+        return cacheIt->second;
+    } else {
+        EntityWrapper parent = entity.Parent();
+        // Calculate scale
+        glm::vec3 scale = AbsoluteScale(parent) * (const glm::vec3&)cTransformScale;
+        // Cache it
+        ScaleCache[entity] = scale;
+        RecalculatedPositions++;
+        // Unset dirty flag
+        cTransformScale.SetDirty(DirtySetType::Transform, false);
+        return scale;
+    }
+}
+
+glm::mat4 TransformSystem::ModelMatrix(EntityID entityID, World* world)
+{
+    return ModelMatrix(EntityWrapper(world, entityID));
+}
+
+glm::mat4 TransformSystem::ModelMatrix(EntityWrapper entity)
+{
+    //auto cacheIt = MatrixCache.find(entity);
+    //ComponentWrapper cTransform = entity["Transform"];
+    //bool isDirty = cTransform["Position"].Dirty(DirtySetType::Transform) || cTransform["Orientation"].Dirty(DirtySetType::Transform) || cTransform["Scale"].Dirty(DirtySetType::Transform);
+    //if (cacheIt != MatrixCache.end() && !isDirty && false) {
+    //    return cacheIt->second;
+    //} else {
+        glm::mat4 matrix = glm::translate(AbsolutePosition(entity)) * glm::toMat4(AbsoluteOrientation(entity)) * glm::scale(AbsoluteScale(entity));
+    //    MatrixCache[entity] = matrix;
+        return matrix;
+    //}
+}
+
+glm::vec3 TransformSystem::TransformPoint(const glm::vec3& point, const glm::mat4& matrix)
+{
+    return glm::vec3(matrix * glm::vec4(point.x, point.y, point.z, 1));
+}

src/Engine/Core/UniformScaleSystem.cpp

@@ -13,8 +13,8 @@ void UniformScaleSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper
         return;
     }
 
-    float distance = glm::length((glm::vec3)entity["Transform"]["Position"] - (glm::vec3&)m_Camera["Transform"]["Position"]);
+    float distance = glm::length((glm::vec3)entity["Transform"]["Position"] - (const glm::vec3&)m_Camera["Transform"]["Position"]);
-    entity["Transform"]["Scale"] = (glm::vec3&)cUniformScale["Scale"] * distance;
+    entity["Transform"]["Scale"] = (const glm::vec3&)cUniformScale["Scale"] * distance;
 }
 
 bool UniformScaleSystem::OnSetCamera(const Events::SetCamera& e)

src/Engine/Core/World.cpp

@@ -48,7 +48,7 @@ bool World::ValidEntity(EntityID entity) const
 void World::RegisterComponent(const ComponentInfo& ci)
 {
     if (m_ComponentPools.find(ci.Name) == m_ComponentPools.end()) {
-        m_ComponentPools[ci.Name] = new ComponentPool(ci);
+        m_ComponentPools[ci.Name] = new ComponentPool(ci, this);
     }
 }
 
@@ -95,7 +95,7 @@ void World::DeleteComponent(EntityID entity, const std::string& componentType)
     }
 }
 
-const ComponentPool* World::GetComponents(const std::string& componentType)
+ComponentPool* World::GetComponents(const std::string& componentType)
 {
     auto it = m_ComponentPools.find(componentType);
     return (it != m_ComponentPools.end()) ? it->second : nullptr;
@@ -223,7 +223,7 @@ void World::deleteEntityRecursive(EntityID entity, bool cascaded /*= false*/)
 
     if (m_EventBroker != nullptr) {
         Events::EntityDeleted e;
-        e.DeletedEntity = entity;
+        e.DeletedEntity = EntityWrapper(this, entity);
         e.Cascaded = cascaded;
         m_EventBroker->Publish(e);
     }

src/Engine/Editor/EditorGUI.cpp

@@ -381,6 +381,10 @@ bool EditorGUI::drawComponentField(ComponentWrapper& c, const ComponentInfo::Fie
         ImGui::TextDisabled(field.Type.c_str());
     }
 
+    if (dirty) {
+        c[field.Name].SetAllDirty();
+    }
+
     ImGui::PopID();
 
     return dirty;

src/Engine/Editor/EditorRenderSystem.cpp

@@ -52,7 +52,7 @@ void EditorRenderSystem::Update(double dt)
             }
 
             EntityWrapper entity(m_World, cModel.EntityID);
-            glm::mat4 modelMatrix = Transform::ModelMatrix(entity.ID, entity.World);
+            glm::mat4 modelMatrix = TransformSystem::ModelMatrix(entity.ID, entity.World);
             for (auto matGroup : model->MaterialGroups()) {
                 std::shared_ptr<ModelJob> modelJob = std::make_shared<ModelJob>(model, scene.Camera, modelMatrix, matGroup, cModel, entity.World, glm::vec4(0), 0.f, false, false);
                 if (cModel["Transparent"]) {

src/Engine/Editor/EditorSystem.cpp

@@ -75,20 +75,20 @@ void EditorSystem::Update(double dt)
             if (isAnyParentMissingTransform(m_CurrentSelection.ID)) {
                 return;
             }
-            (glm::vec3&)m_Widget["Transform"]["Position"] = Transform::AbsolutePosition(m_CurrentSelection);
+            (Field<glm::vec3>)m_Widget["Transform"]["Position"] = TransformSystem::AbsolutePosition(m_CurrentSelection);
             if (m_WidgetSpace == EditorGUI::WidgetSpace::Local) {
-                (glm::vec3&)m_Widget["Transform"]["Orientation"] = Transform::AbsoluteOrientationEuler(m_CurrentSelection);
+                m_Widget["Transform"]["Orientation"] = TransformSystem::AbsoluteOrientationEuler(m_CurrentSelection);
             } else {
-                (glm::vec3&)m_Widget["Transform"]["Orientation"] = glm::vec3(0, 0, 0);
+                m_Widget["Transform"]["Orientation"] = glm::vec3(0, 0, 0);
             }
         }
         m_EditorWorldSystemPipeline->Update(actualDelta);
 
         ComponentWrapper& cameraTransform = m_EditorCamera["Transform"];
-        glm::vec3& ori = cameraTransform["Orientation"];
+        Field<glm::vec3> ori = cameraTransform["Orientation"];
-        ori.x = m_EditorCameraInputController->Rotation().x;
+        ori.x(m_EditorCameraInputController->Rotation().x);
-        ori.y = m_EditorCameraInputController->Rotation().y;
+        ori.y(m_EditorCameraInputController->Rotation().y);
-        glm::vec3& pos = cameraTransform["Position"];
+        Field<glm::vec3> pos = cameraTransform["Position"];
         pos += m_EditorCameraInputController->Movement() * glm::inverse(glm::quat(ori)) * (float)actualDelta;
     }
 }
@@ -104,7 +104,7 @@ void EditorSystem::Enable()
     eSetCamera.CameraEntity = m_EditorCamera;
     m_EventBroker->Publish(eSetCamera);
     if (m_ActualCamera.Valid()) {
-        (glm::vec3&)m_EditorCamera["Transform"]["Position"] = Transform::AbsolutePosition(m_ActualCamera);
+        (Field<glm::vec3>)m_EditorCamera["Transform"]["Position"] = TransformSystem::AbsolutePosition(m_ActualCamera);
     }
 
     // Pause the world we're editing
@@ -213,19 +213,19 @@ bool EditorSystem::OnWidgetDelta(const Events::WidgetDelta& e)
             glm::vec3 parentScale(1.f);
             EntityWrapper parent = m_CurrentSelection.Parent();
             if (parent.Valid()) {
-                parentOrientation = glm::inverse(Transform::AbsoluteOrientation(parent));
+                parentOrientation = glm::inverse(TransformSystem::AbsoluteOrientation(parent));
-                parentScale = Transform::AbsoluteScale(parent);
+                parentScale = TransformSystem::AbsoluteScale(parent);
             }
-            (glm::vec3&)m_CurrentSelection["Transform"]["Position"] += parentOrientation * e.Translation / parentScale;
+            (Field<glm::vec3>)m_CurrentSelection["Transform"]["Position"] += parentOrientation * e.Translation / parentScale;
         } else if (m_WidgetSpace == EditorGUI::WidgetSpace::Local) {
             glm::vec3 parentScale(1.f);
             EntityWrapper parent = m_CurrentSelection.Parent();
             if (parent.Valid()) {
-                parentScale = Transform::AbsoluteScale(parent);
+                parentScale = TransformSystem::AbsoluteScale(parent);
             }
             glm::quat selectionOri = glm::quat((glm::vec3)m_CurrentSelection["Transform"]["Orientation"]);
             glm::vec3 localTranslation = selectionOri * e.Translation / parentScale;
-            (glm::vec3&)m_CurrentSelection["Transform"]["Position"] += localTranslation;
+            (Field<glm::vec3>)m_CurrentSelection["Transform"]["Position"] += localTranslation;
         }
         m_EditorGUI->SetDirty(m_CurrentSelection);
     }
@@ -312,7 +312,7 @@ void EditorSystem::setWidgetMode(EditorGUI::WidgetMode mode)
         break;
     }
 
-    m_Widget["Transform"]["Position"] = Transform::AbsolutePosition(m_CurrentSelection.World, m_CurrentSelection.ID);
+    m_Widget["Transform"]["Position"] = TransformSystem::AbsolutePosition(m_CurrentSelection.World, m_CurrentSelection.ID);
 }
 
 bool EditorSystem::isAnyParentMissingTransform(EntityID entityID)

src/Engine/Network/Client.cpp

@@ -1,5 +1,5 @@
 #include "Network/Client.h"
-#include "Network/EPlayerDisconnected.h"
+
 using namespace boost::asio::ip;
 
 Client::Client(World* world, EventBroker* eventBroker)
@@ -12,7 +12,7 @@ Client::Client(World* world, EventBroker* eventBroker)
 
     auto config = ResourceManager::Load<ConfigFile>("Config.ini");
     m_PlayerName = config->Get<std::string>("Networking.Name", "Raptorcopter");
-    m_SendInputIntervalMs = config->Get<int>("Networking.SendInputIntervalMs", 33);
+    m_SendInputInterval = config->Get<int>("Networking.SendInputIntervalMs", 33) / 1000.0;
     LOG_INFO("Client initialized");
 
     m_ServerlistRequest.Connect(m_PlayerName, "192.168.1.255", 32554);
@@ -48,7 +48,7 @@ void Client::Connect(std::string address, int port)
     }
 }
 
-void Client::Update()
+void Client::Update(double dt)
 {
     m_EventBroker->Process<Client>();
     while (m_Unreliable.IsSocketAvailable()) {
@@ -85,7 +85,9 @@ void Client::Update()
     }
 
     if (m_SearchingForServers) {
-        if (m_SearchingTime < (1000* (std::clock() - m_StartSearchTime) / (double)CLOCKS_PER_SEC)) {
+        m_TimeSearched += dt;
+        if (m_SearchingTime < m_TimeSearched) {
+            m_TimeSearched = 0;
             m_SearchingForServers = false;
             //displayServerlist();
             Events::DisplayServerlist e;
@@ -96,9 +98,10 @@ void Client::Update()
 
     if (m_IsConnected) {
         // Don't send 1 input in 1 packet, bunch em up.
-        if (m_SendInputIntervalMs < (1000 * (std::clock() - m_TimeSinceSentInputs) / (double)CLOCKS_PER_SEC)) {
+        m_TimeSinceSentInputs += dt;
+        if (m_SendInputInterval <  m_TimeSinceSentInputs) {
             sendInputCommands();
-            m_TimeSinceSentInputs = std::clock();
+            m_TimeSinceSentInputs = 0;
         }
         // HACK: Send absolute player positions for now to avoid desync until we have reliable messages
         sendLocalPlayerTransform();
@@ -159,6 +162,9 @@ void Client::parseMessageType(Packet& packet)
     case MessageType::AmmoPickup:
         parseAmmoPickup(packet);
         break;
+    case MessageType::RemoveWorld:
+        parseRemoveWorld(packet);
+        break;
     default:
         break;
     }
@@ -336,6 +342,13 @@ void Client::parseAmmoPickup(Packet & packet)
     m_EventBroker->Publish(e);
 }
 
+void Client::parseRemoveWorld(Packet & packet)
+{
+    removeWorld();
+    Events::Reset e;
+    m_EventBroker->Publish(e);
+}
+
 void Client::updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID)
 {
     for (auto field : componentInfo.FieldsInOrder) {
@@ -583,7 +596,7 @@ bool Client::OnConnectRequest(const Events::ConnectRequest& e)
 bool Client::OnSearchForServers(const Events::SearchForServers& e)
 {
     m_SearchingForServers = true;
-    m_StartSearchTime = std::clock();
+    m_TimeSearched = 0;
     m_Serverlist.clear();
     Packet packet(MessageType::ServerlistRequest);
     m_ServerlistRequest.Broadcast(packet, 13); // TODO: Config
@@ -627,8 +640,8 @@ void Client::sendLocalPlayerTransform()
     Packet packet(MessageType::PlayerTransform, m_SendPacketID);
 
     ComponentWrapper cTransform = m_LocalPlayer["Transform"];
-    glm::vec3& position = cTransform["Position"];
+    const glm::vec3& position = cTransform["Position"];
-    glm::vec3& orientation = cTransform["Orientation"];
+    const glm::vec3& orientation = cTransform["Orientation"];
     packet.WritePrimitive(position.x);
     packet.WritePrimitive(position.y);
     packet.WritePrimitive(position.z);
@@ -706,19 +719,6 @@ void Client::displayServerlist()
     }
 }
 
-void Client::removeWorld()
-{
-    std::vector<EntityID> childrenToBeDeleted;
-    auto rootEntites = m_World->GetDirectChildren(EntityID_Invalid);
-    for (auto it = rootEntites.first; it != rootEntites.second; it++) {
-        childrenToBeDeleted.push_back(it->second);
-    }
-    for (int i = 0; i < childrenToBeDeleted.size(); ++i) {
-        m_World->DeleteEntity(childrenToBeDeleted[i]);
-    }
-}
-
-
 void Client::createMainMenu()
 {
     auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/StartMenu.xml");

src/Engine/Network/Network.cpp

@@ -9,7 +9,7 @@ Network::Network(World* world, EventBroker* eventBroker)
     m_TimeoutMs = config->Get<int>("Networking.TimeoutMs", 20000);
 }
 
-void Network::Update()
+void Network::Update(double dt)
 { 
     updateNetworkData();
 }
@@ -92,3 +92,15 @@ void Network::popNetworkSegmentOfHeader(Packet & packet)
     packet.ReadPrimitive<int>();
     packet.ReadPrimitive<int>();
 }
+
+void Network::removeWorld()
+{
+    std::vector<EntityID> childrenToBeDeleted;
+    auto rootEntites = m_World->GetDirectChildren(EntityID_Invalid);
+    for (auto it = rootEntites.first; it != rootEntites.second; it++) {
+        childrenToBeDeleted.push_back(it->second);
+    }
+    for (int i = 0; i < childrenToBeDeleted.size(); ++i) {
+        m_World->DeleteEntity(childrenToBeDeleted[i]);
+    }
+}

src/Engine/Network/Packet.cpp

@@ -70,7 +70,7 @@ void Packet::WriteString(const std::string& str)
     size_t sizeOfString = str.size() + 1;
     if (m_Offset + sizeOfString > m_MaxPacketSize) {
         if (m_MaxPacketSize >= 32000) {
-            LOG_WARNING("Package::WriteString(): New size is huge %i bytes\n", m_MaxPacketSize*2);
+            //LOG_WARNING("Package::WriteString(): New size is huge %i bytes\n", m_MaxPacketSize*2);
         }
         resizeData();
     }
@@ -85,7 +85,7 @@ void Packet::WriteData(char * data, int sizeOfData)
 
     if (m_Offset + sizeOfData > m_MaxPacketSize) {
         if (m_MaxPacketSize >= 32000) {
-            LOG_WARNING("Package::WriteData(): New size is huge %i bytes\n", m_MaxPacketSize*2);
+            //LOG_WARNING("Package::WriteData(): New size is huge %i bytes\n", m_MaxPacketSize*2);
         }
         while (m_Offset + sizeOfData > m_MaxPacketSize) {
             resizeData();

src/Engine/Network/Server.cpp

@@ -5,8 +5,8 @@ Server::Server(World* world, EventBroker* eventBroker, int port)
     , m_ServerlistRequest(13)
 {
     ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
-    snapshotInterval = 1000 * config->Get<float>("Networking.SnapshotInterval", 0.05f);
+    snapshotInterval = config->Get<float>("Networking.SnapshotInterval", 0.05);
-    pingIntervalMs = config->Get<float>("Networking.PingIntervalMs", 1000);
+    pingInterval = config->Get<float>("Networking.PingIntervalMs", 1000) / 1000.0;
     m_ServerName = config->Get<std::string>("Networking.Name", "Unnamed");
 
     // Subscribe to events
@@ -17,6 +17,7 @@ Server::Server(World* world, EventBroker* eventBroker, int port)
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &Server::OnPlayerDamage);
     EVENT_SUBSCRIBE_MEMBER(m_EAmmoPickup, &Server::OnAmmoPickup);
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerDeath, &Server::OnPlayerDeath);
+    EVENT_SUBSCRIBE_MEMBER(m_EWin, &Server::OnWin);
     // BindWW
     if (port == 0) {
         port = config->Get<float>("Networking.Port", 27666);
@@ -30,7 +31,7 @@ Server::~Server()
 
 }
 
-void Server::Update()
+void Server::Update(double dt)
 {
     m_Reliable.AcceptNewConnections(m_NextPlayerID, m_ConnectedPlayers);
 
@@ -86,26 +87,44 @@ void Server::Update()
     }
     m_PlayersToDisconnect.clear();
 
-    std::clock_t currentTime = std::clock();
     // Send snapshot
-    if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
+    previousSnapshotMessage += dt;
+    if (snapshotInterval < previousSnapshotMessage) {
         sendSnapshot();
-        previousSnapshotMessage = currentTime;
+        previousSnapshotMessage = 0;
     }
     // Send pings each 
-    if (pingIntervalMs < (1000 * (currentTime - previousePingMessage) / (double)CLOCKS_PER_SEC)) {
+    previousPingMessage += dt;
+    if (pingInterval < previousPingMessage) {
         sendPing();
-        previousePingMessage = currentTime;
+        previousPingMessage = 0;
     }
 
     // Time out logic
-    if (checkTimeOutInterval < (1000 * (currentTime - timOutTimer) / (double)CLOCKS_PER_SEC)) {
+    timeOutTimer += dt;
+    if (checkTimeOutInterval < timeOutTimer) {
         checkForTimeOuts();
-        timOutTimer = currentTime;
+        timeOutTimer = 0;
     }
     m_EventBroker->Process<Server>();
     if (isReadingData) {
-        Network::Update();
+        Network::Update(dt);
+    }
+
+    if (m_GameIsOver) {
+        auto pool = m_World->GetComponents("CapturePointGameMode");
+        if (pool != nullptr && pool->size() > 0) {
+            // Take the first CapturePointGameMode component found.
+            ComponentWrapper& modeComponent = *pool->begin();
+            // Decrease timer.
+            Field<double> timer = modeComponent["ResetCountdown"];
+            timer -= dt;
+            if (timer < 0) {
+                resetMap();
+            }
+        } else {
+            resetMap();
+        }
     }
 }
 
@@ -173,10 +192,16 @@ void Server::sendSnapshot()
     Packet packet(MessageType::Snapshot);
     addInputCommandsToPacket(packet);
     addPlayersToPacket(packet, EntityID_Invalid);
-    //addChildrenToPacket(packet, EntityID_Invalid);
     unreliableBroadcast(packet);
 }
 
+// Send snapshot fields
+void Server::createWorldSnapshot(Packet& packet)
+{
+    addInputCommandsToPacket(packet);
+    addChildrenToPacket(packet, EntityID_Invalid);
+}
+
 void Server::addInputCommandsToPacket(Packet& packet)
 {
     // Number of input commands
@@ -224,7 +249,7 @@ void Server::addPlayersToPacket(Packet & packet, EntityID entityID)
                     for (auto& componentField : componentWrapper.Info.FieldsInOrder) {
                         ComponentInfo::Field_t fieldInfo = componentWrapper.Info.Fields.at(componentField);
                         if (fieldInfo.Type == "string") {
-                            std::string& value = componentWrapper[componentField];
+                            const std::string& value = componentWrapper[componentField];
                             packet.WriteString(value);
                         } else {
                             packet.WriteData(componentWrapper.Data + fieldInfo.Offset, fieldInfo.Stride);
@@ -268,7 +293,7 @@ void Server::addChildrenToPacket(Packet & packet, EntityID entityID)
                 for (auto& componentField : componentWrapper.Info.FieldsInOrder) {
                     ComponentInfo::Field_t fieldInfo = componentWrapper.Info.Fields.at(componentField);
                     if (fieldInfo.Type == "string") {
-                        std::string& value = componentWrapper[componentField];
+                        const std::string& value = componentWrapper[componentField];
                         packet.WriteString(value);
                     } else {
                         packet.WriteData(componentWrapper.Data + fieldInfo.Offset, fieldInfo.Stride);
@@ -379,8 +404,7 @@ void Server::parseTCPConnect(Packet & packet)
     m_Reliable.Send(connnectPacket, m_ConnectedPlayers.at(playerID));
 
     Packet firstSnapshot(MessageType::Snapshot);
-    addInputCommandsToPacket(firstSnapshot);
+    createWorldSnapshot(firstSnapshot);
-    addChildrenToPacket(firstSnapshot, EntityID_Invalid);
     m_Reliable.Send(firstSnapshot);
 
     // Send notification that a player has connected
@@ -489,7 +513,7 @@ bool Server::OnEntityDeleted(const Events::EntityDeleted & e)
 {
     if (!e.Cascaded) {
         Packet packet = Packet(MessageType::EntityDeleted);
-        packet.WritePrimitive<EntityID>(e.DeletedEntity);
+        packet.WritePrimitive<EntityID>(e.DeletedEntity.ID);
         reliableBroadcast(packet);
     }
     return false;
@@ -542,6 +566,13 @@ bool Server::OnPlayerDeath(const Events::PlayerDeath& e)
     return false;
 }
 
+bool Server::OnWin(const Events::Win & e)
+{
+    // Postpone the gameover reset
+    m_GameIsOver = true;
+    return true;
+}
+
 void Server::parseClientPing()
 {
     LOG_INFO("%i: Parsing ping", m_PacketID);
@@ -664,3 +695,19 @@ PlayerID Server::getPlayerIDFromEntityID(EntityID entityID)
     }
     return -1;
 }
+
+void Server::resetMap()
+{
+    m_GameIsOver = false;
+    Events::Reset reset;
+    m_EventBroker->Publish(reset);
+    Packet removeMap(MessageType::RemoveWorld);
+    reliableBroadcast(removeMap);
+    removeWorld();
+    // Hardcoded for now.
+    auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/CP_Rocky2.xml");
+    entityFile->MergeInto(m_World);
+    Packet newWorld(MessageType::Snapshot);
+    createWorldSnapshot(newWorld);
+    reliableBroadcast(newWorld);
+}

src/Engine/Rendering/AnimationSystem.cpp

@@ -73,7 +73,8 @@ void AnimationSystem::UpdateAnimations(double dt)
 
         Model* model;
         try {
-            model = ResourceManager::Load<::Model, true>(modelEntity["Model"]["Resource"]);
+            Field<std::string> res = modelEntity["Model"]["Resource"];
+            model = ResourceManager::Load<::Model, true>(res);
         } catch (const std::exception&) {
             return;
         }
@@ -89,23 +90,23 @@ void AnimationSystem::UpdateAnimations(double dt)
             continue;;
         }
 
-        double animationSpeed = (double)animationC["Speed"];
+        double animationSpeed = (const double&)animationC["Speed"];
 
-        if((bool)animationC["Reverse"]) {
+        if((const bool&)animationC["Reverse"]) {
             animationSpeed *= -1;
         }
 
 
-        if ((bool)animationC["Play"]) {
+        if ((const bool&)animationC["Play"]) {
 
-            double nextTime = (double)animationC["Time"] + animationSpeed * dt;
+            double nextTime = (Field<double>)animationC["Time"] + animationSpeed * dt;
-            if (!(bool)animationC["Loop"]) {
+            if (!(Field<bool>)animationC["Loop"]) {
                 if (nextTime > animation->Duration) {
                     nextTime = animation->Duration;
-                    (bool&)animationC["Play"] = false;
+                    (Field<bool>)animationC["Play"] = false;
                 } else if (nextTime < 0) {
                     nextTime = 0;
-                    (bool&)animationC["Play"] = false;
+                    (Field<bool>)animationC["Play"] = false;
                 }
             } else {
                 if (nextTime > animation->Duration) {
@@ -119,7 +120,7 @@ void AnimationSystem::UpdateAnimations(double dt)
                     }
                 }
             }
-            (double&)animationC["Time"] = nextTime;
+            (Field<double>)animationC["Time"] = nextTime;
         }
     }
 }
@@ -214,15 +215,15 @@ bool AnimationSystem::OnAutoAnimationBlend(Events::AutoAnimationBlend& e)
         if (entity.Valid()) {
             if (entity.HasComponent("Animation")) {
                 const Skeleton::Animation* animation = skeleton->GetAnimation(entity["Animation"]["AnimationName"]);
-                (bool&)entity["Animation"]["Reverse"] = e.Reverse;
+                (Field<bool>)entity["Animation"]["Reverse"] = e.Reverse;
 
                 if (e.Restart) {
                     if (animation != nullptr) {
                         if (e.Restart) {
                             if (e.Reverse) {
-                                (double&)entity["Animation"]["Time"] = animation->Duration;
+                                (Field<double>)entity["Animation"]["Time"] = animation->Duration;
                             } else {
-                                (double&)entity["Animation"]["Time"] = 0.0;
+                                (Field<double>)entity["Animation"]["Time"] = 0.0;
                             }
                         }
                     }
@@ -260,15 +261,15 @@ bool AnimationSystem::OnAutoAnimationBlend(Events::AutoAnimationBlend& e)
             if (entity.Valid()) {
                 if (entity.HasComponent("Animation")) {
                     const Skeleton::Animation* animation = skeleton->GetAnimation(entity["Animation"]["AnimationName"]);
-                    (bool&)entity["Animation"]["Reverse"] = e.Reverse;
+                    entity["Animation"]["Reverse"] = e.Reverse;
 
                     if (e.Restart) {
                         if (animation != nullptr) {
                             if (e.Restart) {
                                 if (e.Reverse) {
-                                    (double&)entity["Animation"]["Time"] = animation->Duration;
+                                    entity["Animation"]["Time"] = animation->Duration;
                                 } else {
-                                    (double&)entity["Animation"]["Time"] = 0.0;
+                                    entity["Animation"]["Time"] = 0.0;
                                 }
                             }
                         }
@@ -283,7 +284,7 @@ bool AnimationSystem::OnAutoAnimationBlend(Events::AutoAnimationBlend& e)
 
 bool AnimationSystem::OnEntityDeleted(Events::EntityDeleted& e)
 {
-    EntityWrapper entity = EntityWrapper(m_World, e.DeletedEntity);
+    EntityWrapper entity = e.DeletedEntity;
 
     if (entity.HasComponent("Model")) {
         Model* model;

src/Engine/Rendering/BlendTree.cpp

@@ -13,7 +13,7 @@ BlendTree::BlendTree(EntityWrapper ModelEntity, Skeleton* skeleton)
         m_Root = new Node();
         m_Root->Entity = ModelEntity;
         m_Root->Name = ModelEntity.Name();
-        m_Root->Pose = m_Skeleton->GetFrameBones(animation, (double)ModelEntity["Animation"]["Time"], (bool)ModelEntity["Animation"]["Additive"]);
+        m_Root->Pose = m_Skeleton->GetFrameBones(animation, (const double&)ModelEntity["Animation"]["Time"], (const bool&)ModelEntity["Animation"]["Additive"]);
         m_Root->Parent = nullptr;
         m_Root->Type = NodeType::Animation;
 
@@ -23,9 +23,9 @@ BlendTree::BlendTree(EntityWrapper ModelEntity, Skeleton* skeleton)
         m_Root->Name = ModelEntity.Name();
         m_Root->Parent = nullptr;
         m_Root->Type = NodeType::Blend;
-        m_Root->Weight = (double)ModelEntity["Blend"]["Weight"];
+        m_Root->Weight = (const double&)ModelEntity["Blend"]["Weight"];
-        m_Root->SubTreeRoot = (bool)ModelEntity["Blend"]["SubTreeRoot"];
+        m_Root->SubTreeRoot = (const bool&)ModelEntity["Blend"]["SubTreeRoot"];
-        (double&)ModelEntity["Blend"]["Weight"] = glm::clamp((double)ModelEntity["Blend"]["Weight"], 0.0, 1.0);
+        ModelEntity["Blend"]["Weight"] = glm::clamp((const double&)ModelEntity["Blend"]["Weight"], 0.0, 1.0);
         m_Root->Child[0] = FillTreeByName(m_Root, (std::string)ModelEntity["Blend"]["Pose1"], ModelEntity);
         m_Root->Child[1] = FillTreeByName(m_Root, (std::string)ModelEntity["Blend"]["Pose2"], ModelEntity);
 
@@ -117,7 +117,7 @@ BlendTree::Node* BlendTree::FillTreeByName(Node* parentNode, std::string name, E
         Node* node = new Node();
         node->Entity = childEntity;
         node->Name = childEntity.Name();
-        node->Pose = m_Skeleton->GetFrameBones(animation, (double)childEntity["Animation"]["Time"], (bool)childEntity["Animation"]["Additive"]);
+        node->Pose = m_Skeleton->GetFrameBones(animation, (const double&)childEntity["Animation"]["Time"], (const bool&)childEntity["Animation"]["Additive"]);
         node->Parent = parentNode;
         node->Type = NodeType::Animation;
         return node;
@@ -128,9 +128,9 @@ BlendTree::Node* BlendTree::FillTreeByName(Node* parentNode, std::string name, E
         node->Name = childEntity.Name();
         node->Parent = parentNode;
         node->Type = NodeType::Blend;
-        (double&)childEntity["Blend"]["Weight"] = glm::clamp((double)childEntity["Blend"]["Weight"], 0.0, 1.0);
+        childEntity["Blend"]["Weight"] = glm::clamp((const double&)childEntity["Blend"]["Weight"], 0.0, 1.0);
-        node->Weight = (double)childEntity["Blend"]["Weight"];
+        node->Weight = (const double&)childEntity["Blend"]["Weight"];
-        node->SubTreeRoot = (bool)childEntity["Blend"]["SubTreeRoot"];
+        node->SubTreeRoot = (const bool&)childEntity["Blend"]["SubTreeRoot"];
         //if (node->Weight < 1.f && node->Weight > 0.f) {
             node->Child[0] = FillTreeByName(node, (std::string)childEntity["Blend"]["Pose1"], childEntity);
             node->Child[1] = FillTreeByName(node, (std::string)childEntity["Blend"]["Pose2"], childEntity);
@@ -210,7 +210,7 @@ BlendTree::AutoBlendInfo BlendTree::AutoBlendStep(AutoBlendInfo blendInfo)
 
             if (entity.Valid()) {
                 if (entity.HasComponent("Blend")) {
-                    (double&)entity["Blend"]["Weight"] = blendInfo.Weight;
+                    entity["Blend"]["Weight"] = blendInfo.Weight;
                 }
             }
         }
@@ -225,7 +225,7 @@ BlendTree::AutoBlendInfo BlendTree::AutoBlendStep(AutoBlendInfo blendInfo)
 
             if (entity.Valid()) {
                 if (entity.HasComponent("Animation")) {
-                    (bool&)entity["Animation"]["Play"] = true;
+                    entity["Animation"]["Play"] = true;
                 }
             }
         }
@@ -259,7 +259,7 @@ BlendTree::AutoBlendInfo BlendTree::AutoBlendStep(AutoBlendInfo blendInfo)
             }
 
             double weight = ((goalWeight - startWeight) * blendInfo.progress) + startWeight;
-            (double&)currentNode->Entity["Blend"]["Weight"] = weight;
+            currentNode->Entity["Blend"]["Weight"] = weight;
             currentNode->Weight = weight;
 
             lastNode = currentNode;
@@ -322,7 +322,7 @@ BlendTree::AutoBlendInfo BlendTree::AutoBlendStep(AutoBlendInfo blendInfo)
                 }
 
                 double weight = ((goalWeight - startWeight) * blendInfo.progress) + startWeight;
-                (double&)currentNode->Entity["Blend"]["Weight"] = weight;
+                currentNode->Entity["Blend"]["Weight"] = weight;
                 currentNode->Weight = weight;
 
                 lastNode = currentNode;