Transform.cpp was deleted since stuff was moved to TransformSystem, takes care of linker warnings.

Dirtybit

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) 
-        : m_ComponentInfo(componentInfo)
-        , m_MemoryPoolIterator(begin)
-        , m_MemoryPoolEnd(end)
-    { }
+    ComponentPoolForwardIterator(ComponentPool* pool, const MemoryPool<char>::iterator begin, const MemoryPool<char>::iterator 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 end() const;
+    iterator begin();
+	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>
-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; }
-};
+class World;
 
 struct ComponentWrapper
 {
-    ComponentWrapper(const ComponentInfo& componentInfo, char* data)
-        : Info(componentInfo)
-        , EntityID(*reinterpret_cast<::EntityID*>(data))
-        , Data(data + sizeof(::EntityID))
-    { }
+    ComponentWrapper(const ComponentInfo& componentInfo, char* data, ::DirtyBitField* dirtyBitField, World* world);
 
+    World* m_World;
     const ComponentInfo& Info;
     const ::EntityID EntityID;
     char* Data;
+    ::DirtyBitField* DirtyBitField = nullptr;
 
-    ComponentInfo::EnumType Enum(const char* fieldName, const char* enumKey)
-    {
-        return Info.Meta->FieldEnumDefinitions.at(fieldName).at(enumKey);
-    }
+    ComponentInfo::EnumType Enum(const char* fieldName, const char* 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; }
-    //template <typename T>
-    //void SetField(std::string name, T& value) { Field<T>(name) = value; }
+    void SetField(const std::string& name, const T& 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 T&() { return m_Component->Field<T>(m_PropertyName); }
+        operator const double&() { return m_Component->Field<double>(m_FieldName); }
+        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); }
-        // TODO: Pass by reference and rvalue (universal reference?)
-        //template <typename T>
-        //void operator=(T& val) { m_Component->SetField<T>(m_PropertyName, val); }
+        void operator=(const T& val) { m_Component->SetField<T>(m_FieldName, 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/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/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/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"];
-        TimeSinceDeath = (double)explosionEffectComponent["TimeSinceDeath"];
-        ExplosionDuration = (double)explosionEffectComponent["ExplosionDuration"];
-        EndColor = (glm::vec4)explosionEffectComponent["EndColor"];
-        Randomness = (bool)explosionEffectComponent["Randomness"];
-        RandomnessScalar = (double)explosionEffectComponent["RandomnessScalar"];
-        Velocity = (glm::vec2)explosionEffectComponent["Velocity"];
-        ColorByDistance = (bool)explosionEffectComponent["ColorByDistance"];
-        ExponentialAccelaration = (bool)explosionEffectComponent["ExponentialAccelaration"];
+        ExplosionOrigin = (Field<glm::vec3>)explosionEffectComponent["ExplosionOrigin"];
+        TimeSinceDeath = (Field<double>)explosionEffectComponent["TimeSinceDeath"];
+        ExplosionDuration = (Field<double>)explosionEffectComponent["ExplosionDuration"];
+        EndColor = (Field<glm::vec4>)explosionEffectComponent["EndColor"];
+        Randomness = (Field<bool>)explosionEffectComponent["Randomness"];
+        RandomnessScalar = (Field<double>)explosionEffectComponent["RandomnessScalar"];
+        Velocity = (Field<glm::vec2>)explosionEffectComponent["Velocity"];
+        ColorByDistance = (Field<bool>)explosionEffectComponent["ColorByDistance"];
+        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"

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"];
-        Content = (std::string)textComponent["Content"];
+        Color = (const glm::vec4&)textComponent["Color"];
+        Content = (const std::string&)textComponent["Content"];
         Resource = font;
 
         if ((int)textComponent["Alignment"] == textComponent["Alignment"].Enum("Left")) {

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

@@ -13,7 +13,7 @@
 #include "../Engine/Core/EventBroker.h"
 #include "../Engine/Core/ResourceManager.h"
 #include "../Engine/Core/ConfigFile.h"
-#include "../Engine/Core/Transform.h"
+#include "../Engine/Core/TransformSystem.h"
 #include "../Engine/Sound/Sound.h"
 #include "../Engine/Sound/EPlayQueueOnEntity.h"
 #include "../Engine/Sound/EPlaySoundOnEntity.h"

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/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;
-        (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<double>)component["Time"] += dt;
+        (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/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");
-        (glm::vec3&)transform["Orientation"] += (float)(double)component["Speed"] * (float)dt * (glm::vec3)component["Axis"];
+        ComponentWrapper& cTransform = entity["Transform"];
+        //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/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/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/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>
-	<ExplosionDuration>2</ExplosionDuration>
+	<TimeSinceDeath>0.0</TimeSinceDeath>
+	<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>
-	<RandomnessScalar>1</RandomnessScalar>
+	<Randomness>false</Randomness>
+	<RandomnessScalar>1.0</RandomnessScalar>
 	<Velocity X="2" Y="2"/>
-	<ColorByDistance>0</ColorByDistance>
-	<!--<ReverseAnimation>0</ReverseAnimation>-->
+	<ColorByDistance>false</ColorByDistance>
 	<!--<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/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,121 +73,66 @@
         </c:Transform>
       </Components>
       <Children>
-        <Entity name="Res1080">
+        <Entity name="Resolution">
           <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" Z="0"/>
-              <Scale X="0.0820000023" Y="0.0299999993" Z="1"/>
+              <Scale X="0.100000001" Y="0.100000001" Z="1"/>
             </c:Transform>
           </Components>
           <Children>
-            <Entity name="Text">
+            <Entity name="Sprite">
               <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:Button/>
+                <c:Sprite>
+                  <Model>Models/Core/UnitQuad.mesh</Model>
+                  <GlowMap></GlowMap>
+                  <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+                  <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.361000031" Y="-0.562000036" Z="0.0199999996"/>
-                  <Scale X="0.180000007" Y="0.469000012" Z="1"/>
+                  <Scale X="2.5999999" Y="0.300000012" Z="1"/>
                 </c:Transform>
               </Components>
               <Children/>
             </Entity>
+            <Entity name="TextAndCorner_Origin">
+              <Components>
+                <c:Transform/>
+              </Components>
+              <Children>
+                <Entity name="Text">
+                  <Components>
+                    <c:Text>
+                      <Content>Resolution</Content>
+                      <Resource>Fonts/DroidSans.ttf,64</Resource>
+                      <Color A="1" B="0" G="0" R="0"/>
+                      <Alignment>
+                        <Right/>
+                      </Alignment>
+                    </c:Text>
+                    <c:Transform>
+                      <Position X="-0.180000007" Y="-0.116000004" Z="0.00500000035"/>
+                      <Scale X="0.219000012" Y="0.150000006" Z="1"/>
+                    </c:Transform>
+                  </Components>
+                  <Children/>
+                </Entity>
+              </Children>
+            </Entity>
           </Children>
         </Entity>
-        <Entity name="Res768">
+        <Entity name="ResolutionSpawner">
           <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>
+            <c:Spawner>
+              <EntityFile>Schema/Entities/Resolution_Options.xml</EntityFile>
+            </c:Spawner>
+            <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" 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>
+          <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>
-              <DepthSort>false</DepthSort>
-              <Color A="0.588235319" B="1" G="1" R="1"/>
+              <Color A="0.392156869" B="0.392156869" G="0.392156869" R="0.392156869"/>
             </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,169 +46,136 @@ 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[randomIndex];
+	return RandomNumbers[int(mod(polygon_index, 50))];
 }
 
-float randomNumber = 0.0;
-float randomDistance = 0.0;
-
-void main()
+vec3 CalcCenterOfTriangle(vec3 vertex0, vec3 vertex1, vec3 vertex2)
 {
 	// calculate middle of vectors
-	vec3 v1 = Input[1].Position - Input[0].Position;
-	vec3 v2 = Input[2].Position - Input[0].Position;
-	vec3 v3 = Input[2].Position - (v1 / 2);
-	vec3 v4 = Input[1].Position - (v2 / 2);
+	vec3 dir1 = normalize(vertex1 - vertex0);
+	vec3 dir2 = normalize(vertex2 - vertex0);
 	
-	// calculate intersection
-	
-	// normalize direction
-	vec3 dir1 = normalize(v1);
-	vec3 dir2 = normalize(v2);
-	
-	vec3 vecA = Input[2].Position - Input[1].Position; //o2 - o1
+	vec3 vecA = vertex2 - vertex1; //o2 - o1
 	vec3 vecB = cross(dir1, dir2);
 	
 	mat3 matrisA = mat3(vecA, dir2, vecB);
 	
 	float lengthA = length(vecB);
 	lengthA = lengthA * lengthA;
-
+	
 	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
-	if (Randomness == true)
-	{
-		randomDistance = GetRandomNumber(gl_PrimitiveIDIn) * RandomnessScalar;
-	}
+	// get a random number if randomness is enabled, otherwise the random distance will be zero and won't affect the other algorithms
+	float randomDistance = float(Randomness) * 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)
-	{
-		currentVelocity = pow(currentVelocity, 2) / 2.0;
-	}
+	// if the accelaration should be exponential
+	currentVelocity = currentVelocity * max(currentVelocity * float(ExponentialAccelaration), 1.0);
 	
-	// distance between origin and the center of the current triangle
-	float origin2TriangleCenterDistance = length(origin2TriangleCenterVector);
+	// the distance the blast has moved since the beginning, i.e. its radius
+	float blastWave = TimeSinceDeath * currentVelocity;
 	
 	// the distance from origin to the triangle center with eventual randomness added
-	float fullDistanceWithRandomness = origin2TriangleCenterDistance + randomDistance;
-
-	// vector from the triangle center to the explosion's shockwave
-	vec3 triangleCenter2ExplosionRadius = (normalizedOrigin2TriangleCenterVector * (TimeSinceDeath * currentVelocity)) - (normalizedOrigin2TriangleCenterVector * fullDistanceWithRandomness);
+	float origin2TriangleCenterDistanceWithRandomness = origin2TriangleCenterDistance + randomDistance;
 	
-	// if the triangle is inside the blast radius...
-	if (fullDistanceWithRandomness <= (TimeSinceDeath * currentVelocity))
+	vec3 triangleCenter2ExplosionRadius = (normalizedOrigin2TriangleCenterVector * blastWave) - (normalizedOrigin2TriangleCenterVector * origin2TriangleCenterDistanceWithRandomness);
+
+	// if the triangle is inside the blast's radius...
+	float isInsideBlastRadius = LessEqualTo(origin2TriangleCenterDistanceWithRandomness, blastWave);
+	
+	// calculate the max distance (s) the triangle will move
+	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)
 	{
-		float maxRadius = max(TimeSinceDeath * currentVelocity, (ExplosionDuration * currentVelocity));
-		
-		float a = (randomVelocity.y - randomVelocity.x) / ExplosionDuration;
-		//float t = sqrt((2 * origin2TriangleCenterDistance) / a);
-		
-		// if explosion color should be affected by distance instead of time...
-		if (ColorByDistance == true)
-		{
-			// calculate the max distance (s) the triangle will move
-			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...
-		for (int i = 0; i < gl_in.length(); i++)
-		{
-			// move the triangle to the blast radius
-			vec3 ExplodedPosition = Input[i].Position + triangleCenter2ExplosionRadius;
-			
-			// 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];
-			}
-			
-			// convert to model space for the gravity to always be in -y
-			vec4 ExplodedPositionInModelSpace = 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();
-		}
+		Output.ExplosionPercentageElapsed = (length(triangleCenter2ExplosionRadius) / maxDistance) * isInsideBlastRadius * ColorDistanceScalar;
 	}
 	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;
+		Output.ExplosionPercentageElapsed = timePercetage;
+	}
+	
+	vec3 ExplodedPosition;
+	for (int i = 0; i < gl_in.length(); i++)
+	{
+		// move the triangle to the blast radius
+		ExplodedPosition = Input[i].Position + (triangleCenter2ExplosionRadius * isInsideBlastRadius);
 
-		}
-		
-		// 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;
+		// pass through vertex data
+		PassThingsThrough(i);
 			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();
-		}
+			for (int j = 0; j < MAX_SPLITS; j++)
+			{
+				Output.PositionLightSpace[j] = Input[i].PositionLightSpace[j];
+			}
+		
+		// convert to window space 
+		gl_Position = P * V * M * vec4(ExplodedPosition, 1.0);
+		EmitVertex();
 	}
-	
-	//EndPrimitive();
-}
+}

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 v1 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
-        glm::vec3 v2 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
+        glm::vec3 v0 = TransformSystem::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
+        glm::vec3 v1 = TransformSystem::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 v1 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
-        glm::vec3 v2 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
+        glm::vec3 v0 = TransformSystem::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
+        glm::vec3 v1 = TransformSystem::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),
-            Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix),
-            Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix)
+            TransformSystem::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix),
+            TransformSystem::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;
-                            ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
+                            cPhysics["IsOnGround"] = true;
+                            ((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);
-    this->World->SetParent(clone.ID, parent.ID);
+    // Create a relationship map of children of this entity
+    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 +0,0 @@
-#include "Core/Transform.h"
-
-glm::mat4 Transform::AbsoluteTransformation(EntityWrapper entity)
-{
-    glm::mat4 t = glm::mat4(1.f);
-
-    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)
-{
-    return AbsolutePosition(entity.World, entity.ID);
-}
-
-glm::vec3 Transform::AbsolutePosition(World* world, EntityID entity)
-{
-    glm::vec3 position;
-
-    while (entity != EntityID_Invalid) {
-        ComponentWrapper transform = world->GetComponent(entity, "Transform");
-        EntityID parent = world->GetParent(entity);
-        position += Transform::AbsoluteScale(world, parent) * (Transform::AbsoluteOrientation(world, parent) * (glm::vec3)transform["Position"]);
-        entity = parent;
-    }
-
-    return position;
-}
-
-glm::vec3 Transform::AbsoluteOrientationEuler(EntityWrapper entity)
-{
-    glm::vec3 orientation;
-
-    while (entity.Valid()) {
-        ComponentWrapper transform = entity["Transform"];
-        orientation += (glm::vec3)transform["Orientation"];
-        entity = entity.Parent();
-    }
-
-    return orientation;
-}
-
-glm::quat Transform::AbsoluteOrientation(EntityWrapper entity)
-{
-    return AbsoluteOrientation(entity.World, entity.ID);
-}
-
-glm::quat Transform::AbsoluteOrientation(World* world, EntityID entity)
-{
-    glm::quat orientation;
-
-    while (entity != EntityID_Invalid) {
-        ComponentWrapper transform = world->GetComponent(entity, "Transform");
-        orientation = glm::quat((glm::vec3)transform["Orientation"]) * orientation;
-        entity = world->GetParent(entity);
-    }
-
-    return orientation;
-}
-
-glm::vec3 Transform::AbsoluteScale(EntityWrapper entity)
-{
-    return AbsoluteScale(entity.World, entity.ID);
-}
-
-glm::vec3 Transform::AbsoluteScale(World* world, EntityID entity)
-{
-    glm::vec3 scale(1.f);
-
-    while (entity != EntityID_Invalid) {
-        ComponentWrapper transform = world->GetComponent(entity, "Transform");
-        scale *= (glm::vec3)transform["Scale"];
-        entity = world->GetParent(entity);
-    }
-
-    return scale;
-}
-
-glm::mat4 Transform::ModelMatrix(EntityWrapper entity)
-{
-    return ModelMatrix(entity.ID, entity.World);
-}
-
-glm::mat4 Transform::ModelMatrix(EntityID entity, World* world)
-{
-    return AbsoluteTransformation(EntityWrapper(world, entity));
-
-    //glm::vec3 position = Transform::AbsolutePosition(world, entity);
-    //glm::quat orientation = Transform::AbsoluteOrientation(world, entity);
-    //glm::vec3 scale = Transform::AbsoluteScale(world, entity);
-
-    //glm::mat4 modelMatrix = glm::translate(glm::mat4(), position) * glm::toMat4(orientation) * glm::scale(scale);
-    //return modelMatrix;
-}
-
-glm::vec3 Transform::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"]);
-    entity["Transform"]["Scale"] = (glm::vec3&)cUniformScale["Scale"] * distance;
+    float distance = glm::length((glm::vec3)entity["Transform"]["Position"] - (const glm::vec3&)m_Camera["Transform"]["Position"]);
+    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"];
-        ori.x = m_EditorCameraInputController->Rotation().x;
-        ori.y = m_EditorCameraInputController->Rotation().y;
-        glm::vec3& pos = cameraTransform["Position"];
+        Field<glm::vec3> ori = cameraTransform["Orientation"];
+        ori.x(m_EditorCameraInputController->Rotation().x);
+        ori.y(m_EditorCameraInputController->Rotation().y);
+        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));
-                parentScale = Transform::AbsoluteScale(parent);
+                parentOrientation = glm::inverse(TransformSystem::AbsoluteOrientation(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

@@ -627,8 +627,8 @@ void Client::sendLocalPlayerTransform()
     Packet packet(MessageType::PlayerTransform, m_SendPacketID);
 
     ComponentWrapper cTransform = m_LocalPlayer["Transform"];
-    glm::vec3& position = cTransform["Position"];
-    glm::vec3& orientation = cTransform["Orientation"];
+    const glm::vec3& position = cTransform["Position"];
+    const glm::vec3& orientation = cTransform["Orientation"];
     packet.WritePrimitive(position.x);
     packet.WritePrimitive(position.y);
     packet.WritePrimitive(position.z);

src/Engine/Network/Server.cpp

@@ -224,7 +224,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 +268,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);
@@ -489,7 +489,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;

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;
-            if (!(bool)animationC["Loop"]) {
+            double nextTime = (Field<double>)animationC["Time"] + animationSpeed * dt;
+            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->SubTreeRoot = (bool)ModelEntity["Blend"]["SubTreeRoot"];
-        (double&)ModelEntity["Blend"]["Weight"] = glm::clamp((double)ModelEntity["Blend"]["Weight"], 0.0, 1.0);
+        m_Root->Weight = (const double&)ModelEntity["Blend"]["Weight"];
+        m_Root->SubTreeRoot = (const bool&)ModelEntity["Blend"]["SubTreeRoot"];
+        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);
-        node->Weight = (double)childEntity["Blend"]["Weight"];
-        node->SubTreeRoot = (bool)childEntity["Blend"]["SubTreeRoot"];
+        childEntity["Blend"]["Weight"] = glm::clamp((const double&)childEntity["Blend"]["Weight"], 0.0, 1.0);
+        node->Weight = (const double&)childEntity["Blend"]["Weight"];
+        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;

src/Engine/Rendering/BlurHUD.cpp

@@ -119,6 +119,21 @@ GLuint BlurHUD::Draw(GLuint texture, RenderScene& scene)
 {
     GLERROR("DrawBloomPass::Draw: Pre");
 
+    bool shouldRun = false;
+    for (auto& job : scene.Jobs.SpriteJob) {
+        auto spriteJob = std::dynamic_pointer_cast<SpriteJob>(job);
+        if (!spriteJob) {
+            continue;
+        }
+        if (!spriteJob->BlurBackground) {
+            continue;
+        }
+        shouldRun = true;
+        break;
+    }
+    if(!shouldRun) {
+        return m_BlackTexture->m_Texture;
+    }
     FillStencil(scene);
 
     RenderState state;
@@ -226,6 +241,7 @@ void BlurHUD::FillStencil(RenderScene& scene)
     GLuint shaderHandle = m_FillDepthStencilProgram->GetHandle();
     glm::mat4 VP = scene.Camera->ProjectionMatrix() * scene.Camera->ViewMatrix();
 
+
     for (auto& job : scene.Jobs.SpriteJob) {
         auto spriteJob = std::dynamic_pointer_cast<SpriteJob>(job);
         if (!spriteJob) {

src/Engine/Rendering/BoneAttachmentSystem.cpp

@@ -55,13 +55,13 @@ void BoneAttachmentSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapp
         glm::vec3 angles = glm::eulerAngles(rotation);
         
         if ((bool)entity["BoneAttachment"]["InheritPosition"]) {
-            (glm::vec3&)entity["Transform"]["Position"] = translation + (glm::vec3)entity["BoneAttachment"]["PositionOffset"];
+            entity["Transform"]["Position"] = translation + (glm::vec3)entity["BoneAttachment"]["PositionOffset"];
         }
         if ((bool)entity["BoneAttachment"]["InheritOrientation"]) {
-            (glm::vec3&)entity["Transform"]["Orientation"] = angles;
+            entity["Transform"]["Orientation"] = angles;
         }
         if ((bool)entity["BoneAttachment"]["InheritScale"]) {
-            (glm::vec3&)entity["Transform"]["Scale"] = scale  * (glm::vec3)entity["BoneAttachment"]["ScaleOffset"];
+            entity["Transform"]["Scale"] = scale  * (glm::vec3)entity["BoneAttachment"]["ScaleOffset"];
         }
     }
 

src/Engine/Rendering/CubeMapPass.cpp

@@ -6,18 +6,16 @@ CubeMapPass::CubeMapPass(IRenderer* renderer)
     LoadTextures("Nevada");
 }
 
-void CubeMapPass::LoadTextures(std::string input)
+void CubeMapPass::LoadTextures(std::string cubemapName)
 {
-    if (m_PreviusCubeMapTexture != input) {
+    if (m_PreviusCubeMapTexture != cubemapName) {
         m_CubeMapTextures.clear();
         for (int i = 0; i < 6; i++) {
-            std::string str;
-            str = "Textures/Test/CubeMap/" + input + "/CubeMapTest0" + std::to_string(i) + ".png";
-            Texture* img = ResourceManager::Load<Texture>(str);
-            m_CubeMapTextures.push_back(img);
+            std::string path = "Textures/Test/CubeMap/" + cubemapName + "/CubeMapTest0" + std::to_string(i) + ".png";
+            m_CubeMapTextures.push_back(path);
         }
         GenerateCubeMapTexture();
-        m_PreviusCubeMapTexture = input;
+        m_PreviusCubeMapTexture = cubemapName;
     }
 }
 
@@ -29,7 +27,9 @@ void CubeMapPass::GenerateCubeMapTexture()
     glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapTexture);
 
     for (int i = 0; i < 6; i++) {
-        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGBA32F, m_CubeMapTextures[0]->Width, m_CubeMapTextures[0]->Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_CubeMapTextures[i]->Data);
+        PNG* img = ResourceManager::Load<PNG>(m_CubeMapTextures[i]);
+        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGBA32F, img->Width, img->Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, img->Data);
+        ResourceManager::Release("PNG", m_CubeMapTextures[i]);
     }
     glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

src/Engine/Rendering/DrawFinalPass.cpp

@@ -1333,7 +1333,12 @@ void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<E
 
     glUniform3fv(glGetUniformLocation(shaderHandle, "ExplosionOrigin"), 1, glm::value_ptr(job->ExplosionOrigin));
 	GLERROR("Bind 6 uniform");
-    glUniform1f(glGetUniformLocation(shaderHandle, "TimeSinceDeath"), job->TimeSinceDeath);
+	if (job->Reverse == false) {
+		glUniform1f(glGetUniformLocation(shaderHandle, "TimeSinceDeath"), job->TimeSinceDeath);
+	}
+	else {
+		glUniform1f(glGetUniformLocation(shaderHandle, "TimeSinceDeath"), (job->ExplosionDuration - job->TimeSinceDeath));
+	}
 	GLERROR("Bind 7 uniform");
     glUniform1f(glGetUniformLocation(shaderHandle, "ExplosionDuration"), job->ExplosionDuration);
 	GLERROR("Bind 8 uniform");
@@ -1351,6 +1356,10 @@ void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<E
 	GLERROR("Bind 14 uniform");
     glUniform1i(glGetUniformLocation(shaderHandle, "ExponentialAccelaration"), job->ExponentialAccelaration);
 	GLERROR("Bind 15 uniform");
+	glUniform1i(glGetUniformLocation(shaderHandle, "Reverse"), job->Reverse);
+	GLERROR("Bind 15-2 uniform");
+	glUniform1f(glGetUniformLocation(shaderHandle, "ColorDistanceScalar"), job->ColorDistanceScalar);
+	GLERROR("Bind 15-3 uniform");
 
     glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(job->Color));
 	GLERROR("Bind 16 uniform");

src/Engine/Rendering/RenderSystem.cpp

@@ -71,7 +71,7 @@ void RenderSystem::fillSprites(std::list<std::shared_ptr<RenderJob>>& jobs, Worl
 			float minScale = (float)(double)indicator["MinScale"];
 			bool hasTeam = indicator["VisibleForSingleTeamOnly"];
 			isIndicator = true;
-			glm::vec3 pos = Transform::AbsolutePosition(entity);
+			glm::vec3 pos = TransformSystem::AbsolutePosition(entity);
 
 
 			EntityWrapper entityTeam;
@@ -138,7 +138,7 @@ void RenderSystem::fillSprites(std::list<std::shared_ptr<RenderJob>>& jobs, Worl
 			modelMatrix[3][2] = pos.z;
 			modelMatrix[3][3] = 1.0f;
 
-			glm::mat4 tranformationMatrix = modelMatrix * glm::scale(Transform::AbsoluteScale(entity));
+			glm::mat4 tranformationMatrix = modelMatrix * glm::scale(TransformSystem::AbsoluteScale(entity));
 			glm::vec4 tmp = tranformationMatrix * glm::vec4(glm::vec3(0.5, 0.5, 0), 1.0f);
 			glm::vec2 projectedTopRight = m_Camera->WorldToScreen(glm::vec3(tmp), m_Renderer->GetViewportSize());
 			tmp = tranformationMatrix * glm::vec4(glm::vec3(-0.5, -0.5, 0), 1.0f);
@@ -151,7 +151,7 @@ void RenderSystem::fillSprites(std::list<std::shared_ptr<RenderJob>>& jobs, Worl
 			modelMatrix = tranformationMatrix;
 		}
 		else {
-			modelMatrix = Transform::ModelMatrix(entity.ID, world);
+			modelMatrix = TransformSystem::ModelMatrix(entity.ID, world);
 		}
 
 
@@ -184,7 +184,7 @@ bool RenderSystem::isEntityVisible(EntityWrapper& entity)
     }
 
     // Hide things parented to local player if they have the HiddenFromLocalPlayer component
-    bool outOfBodyExperience = ResourceManager::Load<ConfigFile>("Config.ini")->Get<bool>("Debug.OutOfBodyExperience", false);
+    bool outOfBodyExperience = false; // ResourceManager::Load<ConfigFile>("Config.ini")->Get<bool>("Debug.OutOfBodyExperience", false);
     if (
         (entity.HasComponent("HiddenForLocalPlayer") || entity.FirstParentWithComponent("HiddenForLocalPlayer").Valid()) 
         && (entity == m_LocalPlayer || entity.IsChildOf(m_LocalPlayer)) 
@@ -250,7 +250,7 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
 
 		bool isShielded = m_World->HasComponent(cModel.EntityID, "Shielded") || m_World->HasComponent(cModel.EntityID, "Player");
 
-        glm::mat4 modelMatrix = Transform::ModelMatrix(cModel.EntityID, m_World);
+        glm::mat4 modelMatrix = TransformSystem::ModelMatrix(cModel.EntityID, m_World);
         //Loop through all materialgroups of a model
         for (auto matGroup : model->MaterialGroups()) {
             //If the model has an explosioneffect component, we will add an explosioneffectjob
@@ -422,7 +422,7 @@ void RenderSystem::fillText(std::list<std::shared_ptr<RenderJob>>& jobs, World*
             }
         }
 
-        glm::mat4 modelMatrix = Transform::ModelMatrix(textComponent.EntityID, world);
+        glm::mat4 modelMatrix = TransformSystem::ModelMatrix(textComponent.EntityID, world);
         std::shared_ptr<TextJob> textJob = std::shared_ptr<TextJob>(new TextJob(modelMatrix, font, textComponent));
         jobs.push_back(textJob);
 
@@ -440,8 +440,8 @@ void RenderSystem::Update(double dt)
 
     // Update the current camera used for rendering
     if (m_CurrentCamera.Valid()) {
-        m_Camera->SetPosition(Transform::AbsolutePosition(m_CurrentCamera));
-        m_Camera->SetOrientation(Transform::AbsoluteOrientation(m_CurrentCamera));
+        m_Camera->SetPosition(TransformSystem::AbsolutePosition(m_CurrentCamera));
+        m_Camera->SetOrientation(TransformSystem::AbsoluteOrientation(m_CurrentCamera));
     }
 
     RenderScene scene;

src/Engine/Rendering/Texture.cpp

@@ -19,7 +19,6 @@ Texture::Texture(std::string path)
     }
    
     // Construct the OpenGL texture
-
     glGenTextures(1, &m_Texture);
     glBindTexture(GL_TEXTURE_2D, m_Texture);
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
@@ -30,6 +29,8 @@ Texture::Texture(std::string path)
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     GLERROR("Texture load");
+
+    ResourceManager::Release("PNG", path);
 }
 
 Texture::~Texture()

src/Engine/Sound/SoundManager.cpp

@@ -119,7 +119,7 @@ void SoundManager::updateEmitters(double dt)
         if (!m_World->ValidEntity(m_World->GetParent(it->first))) {
             return;
         }
-        glm::vec3 nextPos = Transform::AbsolutePosition(m_World, it->first);
+        glm::vec3 nextPos = TransformSystem::AbsolutePosition(m_World, it->first);
         // Calculate velocity
         glm::vec3 velocity = glm::vec3(nextPos - previousPos) / (float)dt;
         setSourcePos(it->second->ALsource, nextPos);
@@ -129,8 +129,8 @@ void SoundManager::updateEmitters(double dt)
         setSoundProperties(it->second, &emitter);
 
         // Path changed
-        if (it->second->SoundResource->Path() != (std::string)emitter["FilePath"]) {
-            it->second->SoundResource = ResourceManager::Load<Sound>((std::string)emitter["FilePath"]);
+        if (it->second->SoundResource->Path() != (const std::string&)emitter["FilePath"]) {
+            it->second->SoundResource = ResourceManager::Load<Sound>((const std::string&)emitter["FilePath"]);
             if (it->second->SoundResource->Buffer() != 0) {
                 playSound(it->second);
             }
@@ -153,11 +153,11 @@ void SoundManager::updateListener(double dt)
         if (listener.IsChildOf(m_LocalPlayer) || listener == m_LocalPlayer) {
             glm::vec3 previousPos;
             alGetListener3f(AL_POSITION, &previousPos.x, &previousPos.y, &previousPos.z); // Get previous pos
-            glm::vec3 nextPos = Transform::AbsolutePosition(listener); // Get next (current) pos
+            glm::vec3 nextPos = TransformSystem::AbsolutePosition(listener); // Get next (current) pos
             glm::vec3 velocity = glm::vec3(nextPos - previousPos) / (float)dt; // Calculate velocity
             setListenerPos(nextPos);
             setListenerVel(velocity);
-            setListenerOri(glm::eulerAngles(Transform::AbsoluteOrientation(listener)));
+            setListenerOri(glm::eulerAngles(TransformSystem::AbsoluteOrientation(listener)));
             break;
         }
     }
@@ -238,14 +238,14 @@ bool SoundManager::OnPlaySoundOnPosition(const Events::PlaySoundOnPosition & e)
     Source* source = createSource(e.FilePath);
     auto emitterID = m_World->CreateEntity();
     auto transform = m_World->AttachComponent(emitterID, "Transform");
-    (glm::vec3&)transform["Position"] = e.Position;
+    transform["Position"] = e.Position;
     auto emitter = m_World->AttachComponent(emitterID, "SoundEmitter");
-    (float&)(double)emitter["Gain"] = e.Gain;
-    (float&)(double)emitter["Pitch"] = e.Pitch;
-    (bool&)emitter["Loop"] = e.Loop;
-    (float&)(double)emitter["MaxDistance"] = e.MaxDistance;
-    (float&)(double)emitter["RollOffFactor"] = e.RollOffFactor;
-    (float&)(double)emitter["ReferenceDistance"] = e.ReferenceDistance;
+    emitter["Gain"] = e.Gain;
+    emitter["Pitch"] = e.Pitch;
+    emitter["Loop"] = e.Loop;
+    emitter["MaxDistance"] = e.MaxDistance;
+    emitter["RollOffFactor"] = e.RollOffFactor;
+    emitter["ReferenceDistance"] = e.ReferenceDistance;
     source->Type = SoundType::SFX;
     m_Sources[emitterID] = source;
     playSound(source);
@@ -279,8 +279,8 @@ bool SoundManager::OnPlayBackgroundMusic(const Events::PlayBackgroundMusic & e)
         }
         auto emitterChild = m_World->CreateEntity((*it).EntityID);
         auto emitter = m_World->AttachComponent(emitterChild, "SoundEmitter");
-        (bool&)emitter["Loop"] = true;
-        (std::string&)emitter["FilePath"] = e.FilePath;
+        emitter["Loop"] = true;
+        emitter["FilePath"] = e.FilePath;
         m_World->AttachComponent(emitterChild, "Transform");
         Source* source = createSource(e.FilePath);
         source->Type = SoundType::BGM;
@@ -301,8 +301,8 @@ bool SoundManager::OnPlayAnnouncerVoice(const Events::PlayAnonuncerVoice& e)
         }
         auto emitterChild = m_World->CreateEntity((*it).EntityID);
         auto emitter = m_World->AttachComponent(emitterChild, "SoundEmitter");
-        (bool&)emitter["Loop"] = false;
-        (std::string&)emitter["FilePath"] = e.FilePath;
+        emitter["Loop"] = false;
+        emitter["FilePath"] = e.FilePath;
         m_World->AttachComponent(emitterChild, "Transform");
         Source* source = createSource(e.FilePath);
         source->Type = SoundType::Announcer;

src/Game/Game.cpp

@@ -53,7 +53,7 @@ Game::Game(int argc, char* argv[])
     ResourceManager::RegisterType<RawModel>("RawModel");
     ResourceManager::RegisterType<Texture>("Texture");
     ResourceManager::RegisterType<TextureSprite>("TextureSprite");
-    ResourceManager::RegisterType<PNG>("Png");
+    ResourceManager::RegisterType<PNG>("PNG");
     ResourceManager::RegisterType<ShaderProgram>("ShaderProgram");
     ResourceManager::RegisterType<EntityFile>("EntityFile");
     ResourceManager::RegisterType<EntityXMLFile>("EntityXMLFile");
@@ -127,6 +127,7 @@ Game::Game(int argc, char* argv[])
     // All systems with orderlevel 0 will be updated first.
     unsigned int updateOrderLevel = 0;
     m_SystemPipeline->AddSystem<InterpolationSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<TransformSystem>(updateOrderLevel);
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<SoundSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<RaptorCopterSystem>(updateOrderLevel);
@@ -250,6 +251,13 @@ void Game::Tick()
     m_RenderFrame->Clear();
     m_EventBroker->Swap();
     m_EventBroker->Clear();
+
+    //LOG_DEBUG("Recalculated positions: %i", TransformSystem::RecalculatedPositions);
+    //LOG_DEBUG("Recalculated orientations: %i", TransformSystem::RecalculatedOrientations);
+    //LOG_DEBUG("Recalculated scales: %i", TransformSystem::RecalculatedScales);
+    TransformSystem::RecalculatedPositions = 0;
+    TransformSystem::RecalculatedOrientations = 0;
+    TransformSystem::RecalculatedScales = 0;
 }
 
 int Game::parseArgs(int argc, char* argv[])

src/Game/Systems/AbilityCooldownHUDSystem.cpp

@@ -28,21 +28,21 @@ void AbilityCooldownHUDSystem::Update(double dt)
                     //If we have a shield ability, we set the right icon
                     abilityName = "ShieldAbility";
                     if (entity.HasComponent("Sprite")) {
-                        (std::string&)entity["Sprite"]["DiffuseTexture"] = "Textures\\Icons\\Abilities\\SheildDots-01.png";
+                        entity["Sprite"]["DiffuseTexture"] = "Textures\\Icons\\Abilities\\SheildDots-01.png";
                     }
                 }
             } else {
                 //If we do have a sprint ability, we change the icon
                 abilityName = "SprintAbility";
                 if (entity.HasComponent("Sprite")) {
-                    (std::string&)entity["Sprite"]["DiffuseTexture"] = "Textures\\Icons\\Abilities\\Dash-01.png";
+                    entity["Sprite"]["DiffuseTexture"] = "Textures\\Icons\\Abilities\\Dash-01.png";
                 }
             }
         } else {
             //If we have a dash ability, we set the icon to the correct one.
             abilityName = "DashAbility";
             if (entity.HasComponent("Sprite")) {
-                (std::string&)entity["Sprite"]["DiffuseTexture"] = "Textures\\Icons\\Abilities\\Superman-01.png";
+                entity["Sprite"]["DiffuseTexture"] = "Textures\\Icons\\Abilities\\Superman-01.png";
             }
         }
 
@@ -57,7 +57,7 @@ void AbilityCooldownHUDSystem::Update(double dt)
 
             if (cooldownTextEntity.Valid()) {
                 if (cooldownTextEntity.HasComponent("Text")) {
-                    std::string t = (std::string&)cooldownTextEntity["Text"]["Content"] = std::to_string(currentAbilityCD).substr(0, 3);
+                    cooldownTextEntity["Text"]["Content"] = std::to_string(currentAbilityCD).substr(0, 3);
                 }
             }
         }

src/Game/Systems/AmmoPickupSystem.cpp

@@ -72,11 +72,11 @@ void AmmoPickupSystem::SetPlayerAmmo(EntityWrapper &player, int ammoGain) {
 
     PlayerClass playerClass = DetermineClass(player);
     if (playerClass == PlayerClass::Defender) {
-        (int&)player["DefenderWeapon"]["Ammo"] = std::min((int)player["DefenderWeapon"]["Ammo"] + ammoGain, maxWeaponAmmo);
+        (Field<int>)player["DefenderWeapon"]["Ammo"] = std::min((int)player["DefenderWeapon"]["Ammo"] + ammoGain, maxWeaponAmmo);
     } else if (playerClass == PlayerClass::Sniper) {
-        (int&)player["SniperWeapon"]["Ammo"] = std::min((int)player["SniperWeapon"]["Ammo"] + ammoGain, maxWeaponAmmo);
+        (Field<int>)player["SniperWeapon"]["Ammo"] = std::min((int)player["SniperWeapon"]["Ammo"] + ammoGain, maxWeaponAmmo);
     } else if (playerClass == PlayerClass::Assault) {
-        (int&)player["AssaultWeapon"]["Ammo"] = std::min((int)player["AssaultWeapon"]["Ammo"] + ammoGain, maxWeaponAmmo);
+        (Field<int>)player["AssaultWeapon"]["Ammo"] = std::min((int)player["AssaultWeapon"]["Ammo"] + ammoGain, maxWeaponAmmo);
     } else {
         //unknown class - ignore
     }

src/Game/Systems/BoostIconsHUDSystem.cpp

@@ -10,9 +10,9 @@ void BoostIconsHUDSystem::UpdateComponent(EntityWrapper& entity, ComponentWrappe
         if (assaultEntity.HasComponent("Fill")) {
             EntityWrapper parentWithAssaultBoost = assaultEntity.FirstParentWithComponent("BoostAssault");
             if (parentWithAssaultBoost.Valid()) {
-                (double&)assaultEntity["Fill"]["Percentage"] = 1.0;
+                assaultEntity["Fill"]["Percentage"] = 1.0;
             } else {
-                (double&)assaultEntity["Fill"]["Percentage"] = 0.0;
+                assaultEntity["Fill"]["Percentage"] = 0.0;
             }
         }
     }
@@ -21,9 +21,9 @@ void BoostIconsHUDSystem::UpdateComponent(EntityWrapper& entity, ComponentWrappe
         if (defenderEntity.HasComponent("Fill")) {
             EntityWrapper parentWithAssaultBoost = defenderEntity.FirstParentWithComponent("BoostDefender");
             if (parentWithAssaultBoost.Valid()) {
-                (double&)defenderEntity["Fill"]["Percentage"] = 1.0;
+                defenderEntity["Fill"]["Percentage"] = 1.0;
             } else {
-                (double&)defenderEntity["Fill"]["Percentage"] = 0.0;
+                defenderEntity["Fill"]["Percentage"] = 0.0;
             }
         }
     }
@@ -32,9 +32,9 @@ void BoostIconsHUDSystem::UpdateComponent(EntityWrapper& entity, ComponentWrappe
         if (sniperEntity.HasComponent("Fill")) {
             EntityWrapper parentWithAssaultBoost = sniperEntity.FirstParentWithComponent("BoostSniper");
             if (parentWithAssaultBoost.Valid()) {
-                (double&)sniperEntity["Fill"]["Percentage"] = 1.0;
+                sniperEntity["Fill"]["Percentage"] = 1.0;
             } else {
-                (double&)sniperEntity["Fill"]["Percentage"] = 0.0;
+                sniperEntity["Fill"]["Percentage"] = 0.0;
             }
         }
     }

src/Game/Systems/CapturePointArrowHUDSystem.cpp

@@ -68,12 +68,12 @@ void CapturePointArrowHUDSystem::Update(double dt)
 
                     if(currentOwner != redTeamEnum) {
                         //This capturePoint is not owned by the red team and is therefor an eligible target for red team
-                        glm::vec3 targetPos = Transform::AbsolutePosition(capturePointEntity);
+                        glm::vec3 targetPos = TransformSystem::AbsolutePosition(capturePointEntity);
                         redTargets.insert(std::pair<int, glm::vec3>(capturePointID, targetPos));
                     }
                     if(currentOwner != blueTeamEnum) {
                         //This capturePoint is not owned by the blue team and is therefor an eligible target for blue team
-                        glm::vec3 targetPos = Transform::AbsolutePosition(capturePointEntity);
+                        glm::vec3 targetPos = TransformSystem::AbsolutePosition(capturePointEntity);
                         blueTargets.insert(std::pair<int, glm::vec3>(capturePointID, targetPos));
                     }
 
@@ -155,16 +155,16 @@ void CapturePointArrowHUDSystem::Update(double dt)
             pos = m_BlueTeamCurrentTarget;
         }
 
-        glm::vec3& arrowOri = arrowEntity["Transform"]["Orientation"];
-        glm::vec3 lookVector = glm::normalize(Transform::AbsolutePosition(arrowEntity) - pos); //Maybe should be player instead
+        Field<glm::vec3> arrowOri = arrowEntity["Transform"]["Orientation"];
+        glm::vec3 lookVector = glm::normalize(TransformSystem::AbsolutePosition(arrowEntity) - pos); //Maybe should be player instead
         float pitch = std::asin(-lookVector.y);
         float yaw = std::atan2(lookVector.x, lookVector.z);
-        arrowOri.x = pitch;
-        arrowOri.y = yaw;
-        arrowOri.z = 0.f;
+        arrowOri.x(pitch);
+        arrowOri.y(yaw);
+        arrowOri.z(0.f);
         EntityWrapper parent = arrowEntity.Parent();
         if (parent.Valid()) {
-            arrowOri -= Transform::AbsoluteOrientationEuler(parent);
+            arrowOri -= TransformSystem::AbsoluteOrientationEuler(parent);
         }
     }
 }
@@ -175,8 +175,8 @@ bool CapturePointArrowHUDSystem::OnCapturePointCaptured(Events::Captured& e)
         return 0;
     }
 
-    m_RedTeamCurrentTarget = Transform::AbsolutePosition(e.RedTeamNextCapturePoint);
-    m_BlueTeamCurrentTarget = Transform::AbsolutePosition(e.BlueTeamNextCapturePoint);
+    m_RedTeamCurrentTarget = TransformSystem::AbsolutePosition(e.RedTeamNextCapturePoint);
+    m_BlueTeamCurrentTarget = TransformSystem::AbsolutePosition(e.BlueTeamNextCapturePoint);
 
     m_InitialtargetsSet = true;
     return 0;

src/Game/Systems/CapturePointHUDSystem.cpp

@@ -49,7 +49,8 @@ void CapturePointHUDSystem::Update(double dt)
                 double currentCaptureTime = (double)entityCP["CapturePoint"]["CaptureTimer"];
                 double progress = glm::abs(currentCaptureTime)/15.0;
                 int currentCapturingTeam = currentCaptureTime > 0 ? redTeam : currentCaptureTime < 0 ? blueTeam : spectatorTeam;
-                ((glm::vec3&)entityHUD["Transform"]["Orientation"]).z = currentCapturingTeam == redTeam ? glm::half_pi<float>()+glm::pi<float>() : glm::half_pi<float>();
+                Field<glm::vec3> orientation = entityHUD["Transform"]["Orientation"];
+                orientation.z(currentCapturingTeam == redTeam ? glm::half_pi<float>()+glm::pi<float>() : glm::half_pi<float>());
                 glm::vec4 fillColor = currentCapturingTeam == redTeam ? glm::vec4(1, 0.f, 0, 0.7f) : glm::vec4(0, 0.2f, 1, 0.7f);
                 entityHUD["Fill"]["Color"] = fillColor;
                 entityHUD["Fill"]["Percentage"] = progress;

src/Game/Systems/CapturePointSystem.cpp

@@ -233,14 +233,14 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
 }
 
 void CapturePointSystem::ChangeCapturePointModelsVisibility(EntityWrapper &capturePointModels, bool isOwner) {
-    (bool&)capturePointModels["Model"]["Visible"] = isOwner;
+    (Field<bool>)capturePointModels["Model"]["Visible"] = isOwner;
     for (auto& capModel : capturePointModels.ChildrenWithComponent("Transform"))
     {
         if (capModel.HasComponent("Model")) {
-            (bool&)capModel["Model"]["Visible"] = isOwner;
+            (Field<bool>)capModel["Model"]["Visible"] = isOwner;
         }
         if (capModel.HasComponent("PointLight")) {
-            (bool&)capModel["PointLight"]["Visible"] = isOwner;
+            (Field<bool>)capModel["PointLight"]["Visible"] = isOwner;
         }
     }
 }

src/Game/Systems/DamageIndicatorSystem.cpp

@@ -87,7 +87,7 @@ float DamageIndicatorSystem::CalculateAngle(EntityWrapper player, glm::vec3 enem
     auto enemyPlayerVector = glm::normalize(playerPosition - enemyPosition);
 
     //get the rotationvector relative to the z-axis
-    auto rotationVectorVec3 = glm::vec3(glm::toMat4(Transform::AbsoluteOrientation(player))*glm::vec4(0, 0, 1, 0));
+    auto rotationVectorVec3 = glm::vec3(glm::toMat4(TransformSystem::AbsoluteOrientation(player))*glm::vec4(0, 0, 1, 0));
     //rotate the direction-vector 90 degrees to get the players side-vector
     auto playerSideVector = glm::vec3(glm::rotateY(rotationVectorVec3, 1.57f));
 

src/Game/Systems/ExplosionEffectSystem.cpp

@@ -2,17 +2,20 @@
 
 void ExplosionEffectSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
 {
-    double& delay = (double)component["Delay"];
+    Field<double> delay = component["Delay"];
     if (delay > 0) {
         delay = std::max(0.0, delay - dt);
     }
 
-    if (delay <= 0) {
-        double& timeSinceDeath = component["TimeSinceDeath"];
-        timeSinceDeath += (double)component["Speed"] * dt;
-        if (timeSinceDeath < 0 || timeSinceDeath > (double)component["ExplosionDuration"]) {
-            timeSinceDeath = 0.0;
-        }
-    }
+	if (delay <= 0) {
+		Field<double> timeSinceDeath = component["TimeSinceDeath"];
+		timeSinceDeath += (Field<double>)component["Speed"] * dt;
+		if (timeSinceDeath < 0) {
+			timeSinceDeath = 0.0;
+		}
+		else if (timeSinceDeath >(const double&)component["ExplosionDuration"]) {
+			timeSinceDeath = (const double&)component["ExplosionDuration"];
+		}
+	}
 }
 

src/Game/Systems/HealthHUDSystem.cpp

@@ -22,19 +22,23 @@ void HealthHUDSystem::Update(double dt)
         if (entityIDParent.HasComponent("Health")) {
 
             if (entity.HasComponent("Text")) {
+                Field<double> health = entityIDParent["Health"]["Health"];
+                Field<double> maxHealth = entityIDParent["Health"]["Health"];
                 std::string s = "";
-                s = s + std::to_string((int)(double)entityIDParent["Health"]["Health"]);
+                s = s + std::to_string((int)health);
                 s = s + "/";
-                s = s + std::to_string((int)(double)entityIDParent["Health"]["MaxHealth"]);
-                float healthPercentage = (double)entityIDParent["Health"]["Health"]/(double)entityIDParent["Health"]["MaxHealth"];
-                //(glm::vec4&)entity["Text"]["Color"] = glm::vec4(1.0 - healthPercentage, 0.f, healthPercentage, glm::vec4(entity["Text"]["Color"]).a);
+                s = s + std::to_string((int)maxHealth);
+                float healthPercentage = health/maxHealth;
+                //(Field<glm::vec4>)entity["Text"]["Color"] = glm::vec4(1.0 - healthPercentage, 0.f, healthPercentage, glm::vec4(entity["Text"]["Color"]).a);
                 entity["Text"]["Content"] = s;
             }
 
             if(entity.HasComponent("Fill")) {
-                float healthPercentage = (double)entityIDParent["Health"]["Health"]/(double)entityIDParent["Health"]["MaxHealth"];
-                (glm::vec4&)entity["Fill"]["Color"] = glm::vec4(1.0 - healthPercentage, 0.f, healthPercentage, glm::vec4(entity["Fill"]["Color"]).a);
-                (double&)entity["Fill"]["Percentage"] = healthPercentage;
+                Field<double> health = entityIDParent["Health"]["Health"];
+                Field<double> maxHealth = entityIDParent["Health"]["Health"];
+                float healthPercentage = health/maxHealth;
+                entity["Fill"]["Color"] = glm::vec4(1.0 - healthPercentage, 0.f, healthPercentage, glm::vec4(entity["Fill"]["Color"]).a);
+                entity["Fill"]["Percentage"] = (double)healthPercentage;
 
             }
         }

src/Game/Systems/HealthSystem.cpp

@@ -21,7 +21,7 @@ bool HealthSystem::OnPlayerDamaged(Events::PlayerDamage& e)
     }
 
     ComponentWrapper cHealth = e.Victim["Health"];
-    double& health = cHealth["Health"];
+    Field<double> health = cHealth["Health"];
     //if player has the boost from a defender, subtract the damage taken by StrengthOfEffect amount
     auto playerBoostDefenderEntity = e.Victim.FirstChildByName("BoostDefender");
     if (playerBoostDefenderEntity.Valid()) {
@@ -56,9 +56,9 @@ bool HealthSystem::OnInputCommand(Events::InputCommand& e)
 bool HealthSystem::OnPlayerHealthPickup(Events::PlayerHealthPickup& e)
 {
     ComponentWrapper cHealth = e.Player["Health"];
-    double& health = cHealth["Health"];
+    Field<double> health = cHealth["Health"];
     health += e.HealthAmount;
-    health = std::min(health, (double)cHealth["MaxHealth"]);
+    health = std::min((double)health, (double)cHealth["MaxHealth"]);
 
     return true;
 }

src/Game/Systems/InterpolationSystem.cpp

@@ -17,7 +17,7 @@ void InterpolationSystem::Update(double dt)
             continue;
         }
         auto& iPosition = kv.second;
-        glm::vec3& position = iPosition.Component[iPosition.Field];
+        Field<glm::tvec3<float, glm::highp>> position = iPosition.Component[iPosition.Field];
 
         iPosition.Alpha += dt;
         float alpha = glm::min(iPosition.Alpha / m_SnapshotInterval, 1.0);
@@ -31,7 +31,7 @@ void InterpolationSystem::Update(double dt)
             continue;
         }
         auto& iOrientation = kv.second;
-        glm::vec3& orientation = iOrientation.Component[iOrientation.Field];
+        Field<glm::vec3> orientation = iOrientation.Component[iOrientation.Field];
 
         iOrientation.Alpha += dt / m_SnapshotInterval;
         iOrientation.Alpha = glm::min(iOrientation.Alpha, 1.0);
@@ -45,7 +45,7 @@ void InterpolationSystem::Update(double dt)
             continue;
         }
         auto& iVelocity = kv.second;
-        glm::vec3& position = iVelocity.Component[iVelocity.Field];
+        Field<glm::vec3> position = iVelocity.Component[iVelocity.Field];
 
         iVelocity.Alpha += dt;
         float alpha = glm::min(iVelocity.Alpha / m_SnapshotInterval, 1.0);
@@ -72,8 +72,8 @@ bool InterpolationSystem::OnInterpolate(Events::Interpolate& e)
         Interpolation<glm::quat> iOrientation(
             cTransform,
             "Orientation",
-            glm::quat((glm::vec3&)cTransform["Orientation"]),
-            glm::quat((glm::vec3&)e.Component["Orientation"])
+            glm::quat((Field<glm::vec3>)cTransform["Orientation"]),
+            glm::quat((Field<glm::vec3>)e.Component["Orientation"])
         );
         m_InterpolateOrientation.erase(e.Entity);
         m_InterpolateOrientation.insert(std::make_pair(e.Entity, iOrientation));

src/Game/Systems/KillFeedSystem.cpp

@@ -13,7 +13,7 @@ void KillFeedSystem::Update(double dt)
         for (int i = 1; i <= 3; i++) {
             EntityWrapper child = entity.FirstChildByName("KillFeed" + std::to_string(i));
             if (child.HasComponent("Text")) {
-                (std::string&)child["Text"]["Content"] = "";
+                (Field<std::string>)child["Text"]["Content"] = "";
             }
         }
         
@@ -27,14 +27,14 @@ void KillFeedSystem::Update(double dt)
             EntityWrapper child = entity.FirstChildByName("KillFeed" + std::to_string(feedIndex));
 
             if (child.HasComponent("Text")) {
-                (std::string&)child["Text"]["Content"] = (*it).Content;
-                (glm::vec4&)child["Text"]["Color"] = (*it).Color;
+                (Field<std::string>)child["Text"]["Content"] = (*it).Content;
+                (Field<glm::vec4>)child["Text"]["Color"] = (*it).Color;
 
                 (*it).TimeToLive -= dt;
 
                 if ((*it).TimeToLive <= 0.f) {
-                    (std::string&)child["Text"]["Content"] = "";
-                    (glm::vec4&)child["Text"]["Color"] = (*it).Color;
+                    (Field<std::string>)child["Text"]["Content"] = "";
+                    (Field<glm::vec4>)child["Text"]["Color"] = (*it).Color;
                     remove = true;
                 }
             }

src/Game/Systems/LifetimeSystem.cpp

@@ -18,7 +18,7 @@ void LifetimeSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cL
         return;
     }
 
-    double& lifetime = cLifetime["Lifetime"];
+    Field<double> lifetime = cLifetime["Lifetime"];
     lifetime -= dt;
 
     if (lifetime <= 0.0) {

src/Game/Systems/MainMenuSystem.cpp

@@ -27,13 +27,15 @@ void MainMenuSystem::OpenSubMenu(const Events::InputCommand& e)
         //No submenu is open, open one.
         for (auto& menu : *menus) {
             EntityWrapper menuEntity = EntityWrapper(m_World, menu.EntityID);
-            auto serverListSpawner = menuEntity.FirstChildByName(e.Command + "Spawner");
-            if (!serverListSpawner.HasComponent("Spawner")) {
+            auto spawner = menuEntity.FirstChildByName(e.Command + "Spawner");
+            if (!spawner.HasComponent("Spawner")) {
                 return;
             }
-            m_OpenSubMenu = SpawnerSystem::Spawn(serverListSpawner, serverListSpawner);
-            Events::SearchForServers event;
-            m_EventBroker->Publish(event);
+            m_OpenSubMenu = SpawnerSystem::Spawn(spawner, spawner);
+            if (e.Command == "Play") {
+                Events::SearchForServers event;
+                m_EventBroker->Publish(event);
+            }
             break;
         }
 
@@ -41,22 +43,53 @@ void MainMenuSystem::OpenSubMenu(const Events::InputCommand& e)
         //Menu is open, but not the right one, delete the old one and open a new one.
         m_World->DeleteEntity(m_OpenSubMenu.ID);
         m_OpenSubMenu = EntityWrapper::Invalid;
+        m_World->DeleteEntity(m_DropDown.ID);
+        m_DropDown = EntityWrapper::Invalid;
 
         for (auto& menu : *menus) {
             EntityWrapper menuEntity = EntityWrapper(m_World, menu.EntityID);
-            auto serverListSpawner = menuEntity.FirstChildByName(e.Command + "Spawner");
-            if (!serverListSpawner.HasComponent("Spawner")) {
+            auto Spawner = menuEntity.FirstChildByName(e.Command + "Spawner");
+            if (!Spawner.HasComponent("Spawner")) {
                 return;
             }
-            m_OpenSubMenu = SpawnerSystem::Spawn(serverListSpawner, serverListSpawner);
-            Events::SearchForServers event;
-            m_EventBroker->Publish(event);
+            m_OpenSubMenu = SpawnerSystem::Spawn(Spawner, Spawner);
+            if(e.Command == "Play") {
+                Events::SearchForServers event;
+                m_EventBroker->Publish(event);
+            }
             break;
         }
     } else {
-        //Serverlist submenu is open, close it.
+        //wanted submenu is open, close it.
         m_World->DeleteEntity(m_OpenSubMenu.ID);
         m_OpenSubMenu = EntityWrapper::Invalid;
+        m_World->DeleteEntity(m_DropDown.ID);
+        m_DropDown = EntityWrapper::Invalid;
+    }
+}
+
+
+void MainMenuSystem::OpenDropDown(const Events::InputCommand& e)
+{
+    auto menus = m_World->GetComponents("Menu");
+    if (menus == nullptr) {
+        return;
+    }
+
+    if (m_DropDown == EntityWrapper::Invalid) {
+        //No submenu is open, open one.
+        for (auto& menu : *menus) {
+            EntityWrapper menuEntity = EntityWrapper(m_World, menu.EntityID);
+            auto spawner = menuEntity.FirstChildByName(e.Command + "Spawner");
+            if (!spawner.HasComponent("Spawner")) {
+                return;
+            }
+            m_DropDown = SpawnerSystem::Spawn(spawner, spawner);
+            break;
+        }
+    } else {
+        m_World->DeleteEntity(m_DropDown.ID);
+        m_DropDown = EntityWrapper::Invalid;
     }
 }
 
@@ -73,8 +106,10 @@ bool MainMenuSystem::OnButtonClick(const Events::ButtonClicked& e)
             m_EventBroker->Publish(event);
         }
     } else if (entity.HasComponent("ConfigBtnResolution")) {
-        
+
         m_Renderer->SetResolution(Rectangle((int)entity["ConfigBtnResolution"]["Width"], (int)entity["ConfigBtnResolution"]["Height"]));
+        m_World->DeleteEntity(m_DropDown.ID);
+        m_DropDown = EntityWrapper::Invalid;
     }
     return true;
 }
@@ -98,6 +133,8 @@ bool MainMenuSystem::OnInputCommand(const Events::InputCommand& e)
         m_EventBroker->Publish(event);
     } else if (e.Command == "Options" && e.Value == 1) {
         OpenSubMenu(e);
+    } else if (e.Command == "Resolution" && e.Value == 1) {
+        OpenDropDown(e);
     }
     return true;
 }

src/Game/Systems/PlayerDeathSystem.cpp

@@ -67,7 +67,7 @@ void PlayerDeathSystem::createDeathEffect(EntityWrapper player)
 bool PlayerDeathSystem::OnEntityDeleted(Events::EntityDeleted& e)
 {
     // We only care about when the local players death effect is removed.
-    if (m_LocalPlayerDeathEffect.ID != e.DeletedEntity) {
+    if (m_LocalPlayerDeathEffect != e.DeletedEntity) {
         return false;
     }
 

src/Game/Systems/PlayerMovementSystem.cpp

@@ -29,7 +29,7 @@ void PlayerMovementSystem::Update(double dt)
             return;
         }
         m_SprintEffectTimer = 0.f;
-        const ComponentPool* pool = m_World->GetComponents("SprintAbility");
+        auto pool = m_World->GetComponents("SprintAbility");
         if (pool == nullptr) {
             return;
         }
@@ -54,7 +54,7 @@ void PlayerMovementSystem::Update(double dt)
                 playerEntityModel.Copy(sprintEffect["Model"]);
                 playerEntityAnimation.Copy(sprintEffect["Animation"]);
                 sprintEffect["ExplosionEffect"]["EndColor"] = (glm::vec4)playerEntityModel["Color"];
-                ((glm::vec4&)sprintEffect["ExplosionEffect"]["EndColor"]).w = 0.f;
+                ((Field<glm::vec4>)sprintEffect["ExplosionEffect"]["EndColor"]).w(0.f);
                 sprintEffect["Animation"]["Speed1"] = 0.0;
                 sprintEffect["Animation"]["Speed2"] = 0.0;
                 sprintEffect["Animation"]["Speed3"] = 0.0;
@@ -77,10 +77,10 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
         // Aim pitch
         EntityWrapper cameraEntity = player.FirstChildByName("Camera");
         if (cameraEntity.Valid()) {
-            glm::vec3& cameraOrientation = cameraEntity["Transform"]["Orientation"];
-            cameraOrientation.x += controller->Rotation().x;
+            Field<glm::vec3> cameraOrientation = cameraEntity["Transform"]["Orientation"];
+            cameraOrientation.x(cameraOrientation.x() + controller->Rotation().x);
             // Limit camera pitch so we don't break our necks
-            cameraOrientation.x = glm::clamp(cameraOrientation.x, -glm::half_pi<float>(), glm::half_pi<float>());
+            cameraOrientation.x(glm::clamp(cameraOrientation.x(), -glm::half_pi<float>(), glm::half_pi<float>()));
 
             // Set third person model aim pitch
             EntityWrapper playerModel = player.FirstChildByName("PlayerModel");
@@ -88,21 +88,21 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
                 EntityWrapper aimPrimaryEntity = playerModel.FirstChildByName("Aim");
                 if(aimPrimaryEntity.Valid()){
                     if(aimPrimaryEntity.HasComponent("Animation")) {
-                        float pitch = cameraOrientation.x;
+                        float pitch = cameraOrientation.x();
                         double time = ((pitch + glm::half_pi<float>()) / glm::pi<float>());
-                        (double&)aimPrimaryEntity["Animation"]["Time"] = time;
+                        (Field<double>)aimPrimaryEntity["Animation"]["Time"] = time;
                     }
                 }
             }
         }
 
         ComponentWrapper& cTransform = player["Transform"];
-        glm::vec3& ori = cTransform["Orientation"];
-        ori.y += controller->Rotation().y;
+        Field<glm::vec3> ori = cTransform["Orientation"];
+        ori.y(ori.y() + controller->Rotation().y);
 
         float playerMovementSpeed = player["Player"]["MovementSpeed"];
         float playerCrouchSpeed = player["Player"]["CrouchSpeed"];
-        glm::vec3& wishDirection = player["Player"]["CurrentWishDirection"];
+        Field<glm::vec3> wishDirection = player["Player"]["CurrentWishDirection"];
         auto playerBoostAssaultEntity = player.FirstChildByName("BoostAssault");
         if (playerBoostAssaultEntity.Valid()) {
             playerMovementSpeed *= (double)playerBoostAssaultEntity["BoostAssault"]["StrengthOfEffect"];
@@ -122,7 +122,8 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
             ComponentWrapper cPhysics = player["Physics"];
             //Assault Dash Check
             if (player.HasComponent("DashAbility")) {
-                controller->AssaultDashCheck(dt, ((glm::vec3)cPhysics["Velocity"]).y != 0.0f, player["DashAbility"]["CoolDownMaxTimer"], player["DashAbility"]["CoolDownTimer"], player.ID);
+                Field<double> coolDownTimer = player["DashAbility"]["CoolDownTimer"];
+                controller->AssaultDashCheck(dt, ((glm::vec3)cPhysics["Velocity"]).y != 0.0f, player["DashAbility"]["CoolDownMaxTimer"], coolDownTimer, player.ID);
             }
             wishDirection = controller->Movement() * glm::inverse(glm::quat(ori));
             //this makes sure you can only dash in the 4 directions: forw,backw,left,right
@@ -136,21 +137,21 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
                 wishSpeed = playerMovementSpeed;
             }
             if (player.ID == m_LocalPlayer.ID) {
-                if (glm::length(wishDirection) == 0) {
+                if (glm::length((glm::vec3)wishDirection) == 0) {
                     // If no key is pressed, reset the distance moved since last step.
                     m_DistanceMoved = 0;
                 }
             }
-            glm::vec3& velocity = cPhysics["Velocity"];
+            Field<glm::vec3> velocity = cPhysics["Velocity"];
             bool isOnGround = (bool)cPhysics["IsOnGround"];
             //ImGui::Text(isOnGround ? "On ground" : "In air");
             //ImGui::Text("velocity: (%f, %f, %f) |%f|", velocity.x, velocity.y, velocity.z, glm::length(velocity));
             glm::vec3 groundVelocity(0.f, 0.f, 0.f);
-            groundVelocity.x = velocity.x;
-            groundVelocity.z = velocity.z;
+            groundVelocity.x = velocity.x();
+            groundVelocity.z = velocity.z();
             //ImGui::Text("groundVelocity: (%f, %f, %f) |%f|", groundVelocity.x, groundVelocity.y, groundVelocity.z, glm::length(groundVelocity));
             //ImGui::Text("wishDirection: (%f, %f, %f) |%f|", wishDirection.x, wishDirection.y, wishDirection.z, glm::length(wishDirection));
-            float currentSpeedProj = glm::dot(groundVelocity, wishDirection);
+            float currentSpeedProj = glm::dot(groundVelocity, (glm::vec3)wishDirection);
             float addSpeed = wishSpeed - currentSpeedProj;
             //ImGui::Text("currentSpeedProj: %f", currentSpeedProj);
             //ImGui::Text("wishSpeed: %f", wishSpeed);
@@ -175,8 +176,8 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
                 if (sniperSprinting) {
                     accelerationSpeed *= (double)player["SprintAbility"]["StrengthOfEffect"];
                 }
-                velocity += accelerationSpeed * wishDirection;
-                ImGui::Text("velocity: (%f, %f, %f) |%f|", velocity.x, velocity.y, velocity.z, glm::length(velocity));
+                velocity += accelerationSpeed * (glm::vec3)wishDirection;
+                ImGui::Text("velocity: (%f, %f, %f) |%f|", velocity.x(), velocity.y(), velocity.z(), glm::length((glm::vec3)velocity));
             }
 
             if (isOnGround) {
@@ -186,7 +187,7 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
             if (controller->Jumping() && !controller->Crouching()) {
                 if (isOnGround) {
                     (bool)cPhysics["IsOnGround"] = false;
-                    velocity.y = player["Player"]["JumpSpeed"];
+                    velocity.y(player["Player"]["JumpSpeed"]);
 
 
                     if (player.Valid()) {
@@ -218,7 +219,7 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
                 } else if (player.HasComponent("DoubleJump") && !controller->DoubleJumping()) {
                     //Enter here if player can double jump and is doing so.
                     (bool)cPhysics["IsOnGround"] = false;
-                    velocity.y = player["DoubleJump"]["DoubleJumpSpeed"];
+                    velocity.y(player["DoubleJump"]["DoubleJumpSpeed"]);
 
                     if (player.Valid()) {
                         EntityWrapper playerModel = player.FirstChildByName("PlayerModel");
@@ -259,7 +260,7 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
             }
 
             if (player.HasComponent("AABB")) {
-                glm::vec3& size = player["AABB"]["Size"];
+                Field<glm::vec3> size = player["AABB"]["Size"];
                 if (controller->Crouching()) {
                     size = glm::vec3(1.f, 1.f, 1.f);
                 } else {
@@ -267,7 +268,8 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
                     if (controller->CrouchingLastFrame() && isOnGround) {
                         // The collision should resolve this anyway, but 
                         // this is more reliable, since the box gets larger.
-                        ((glm::vec3&)cTransform["Position"]).y += 0.3f;
+                        Field<glm::vec3> pos = cTransform["Position"];
+                        pos.y(pos.y() + 0.3f);
                     }
                 }
             }
@@ -285,11 +287,11 @@ void PlayerMovementSystem::updateVelocity(EntityWrapper player, double dt)
     // Only apply velocity to local player
     ComponentWrapper& cTransform = player["Transform"];
     ComponentWrapper& cPhysics = player["Physics"];
-    glm::vec3& velocity = cPhysics["Velocity"];
+    Field<glm::vec3> velocity = cPhysics["Velocity"];
     bool isOnGround = (bool)cPhysics["IsOnGround"];
 
     // Ground friction
-    float speed = glm::length(velocity);
+    float speed = glm::length((glm::vec3)velocity);
     static float groundFriction = 7.f;
     ImGui::InputFloat("groundFriction", &groundFriction);
     static float airFriction = 2.f;
@@ -299,16 +301,16 @@ void PlayerMovementSystem::updateVelocity(EntityWrapper player, double dt)
     if (speed > 0) {
         float drop = speed * friction * (float)dt;
         float multiplier = glm::max(speed - drop, 0.f) / speed;
-        velocity.x *= multiplier;
-        velocity.z *= multiplier;
+        velocity.x(velocity.x() * multiplier);
+        velocity.z(velocity.z() * multiplier);
     }
 
     // Gravity
     if (cPhysics["Gravity"]) {
-        velocity.y -= 9.82f * (float)dt;
+        velocity.y(velocity.y() - (9.82f * (float)dt));
     }
 
-    glm::vec3& position = cTransform["Position"];
+    Field<glm::vec3> position = cTransform["Position"];
     position += velocity * (float)dt;
 }
 
@@ -485,9 +487,9 @@ bool PlayerMovementSystem::OnDashAbility(Events::DashAbility & e)
 
                 dashEffectModel.AttachComponent("ExplosionEffect");
                 dashEffectModel["ExplosionEffect"]["EndColor"] = (glm::vec4)playerModel["Model"]["Color"];
-                ((glm::vec4&)dashEffectModel["ExplosionEffect"]["EndColor"]).w = 0.f;
-                (double&)dashEffectModel["ExplosionEffect"]["ExplosionDuration"] = dashEffect["Lifetime"]["Lifetime"];
-                (glm::vec3&)dashEffectModel["ExplosionEffect"]["ExplosionOrigin"] = glm::vec3(0, 1, 0) + (0.2f * controller->Movement());
+                ((Field<glm::vec4>)dashEffectModel["ExplosionEffect"]["EndColor"]).w = 0.f;
+                (Field<double>)dashEffectModel["ExplosionEffect"]["ExplosionDuration"] = dashEffect["Lifetime"]["Lifetime"];
+                (Field<glm::vec3>)dashEffectModel["ExplosionEffect"]["ExplosionOrigin"] = glm::vec3(0, 1, 0) + (0.2f * controller->Movement());
 
 
 
@@ -495,7 +497,7 @@ bool PlayerMovementSystem::OnDashAbility(Events::DashAbility & e)
                 auto animationChildren = dashEffectModel.ChildrenWithComponent("Animation");
                 
                 for (auto animationEntity : animationChildren) {
-                    (bool&)animationEntity["Animation"]["Play"] = false;
+                    (Field<bool>)animationEntity["Animation"]["Play"] = false;
                 }
                 */
             }

src/Game/Systems/PlayerSpawnSystem.cpp

@@ -25,10 +25,10 @@ void PlayerSpawnSystem::Update(double dt)
         // Take the first CapturePointGameMode component found.
         ComponentWrapper& modeComponent = *pool->begin();
         // Increase timer.
-        double& timer = (double&)modeComponent["RespawnTime"];
+        Field<double> timer = modeComponent["RespawnTime"];
         timer += dt;
         if (m_DbgConfigForceRespawn) {
-            (double&)modeComponent["MaxRespawnTime"] = m_ForcedRespawnTime;
+            (Field<double>)modeComponent["MaxRespawnTime"] = m_ForcedRespawnTime;
         }
         double maxRespawnTime = (double)modeComponent["MaxRespawnTime"];
         EntityWrapper spectatorCam = m_World->GetFirstEntityByName("SpectatorCamera");

src/Game/Systems/ScoreScreenSystem.cpp

@@ -40,13 +40,13 @@ void ScoreScreenSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper&
             if (it->first == ID) {
                 if (it->second.Team != currentTeam) {
                     m_World->DeleteEntity(child.ID);
-                    (int&)entity["ScoreScreen"]["TotalIdentities"] -= 1;
+                    (Field<int>)entity["ScoreScreen"]["TotalIdentities"] -= 1;
                     break;
                 }
                 for (auto it2 = m_DisconnectedIdentities.begin(); it2 != m_DisconnectedIdentities.end(); ++it2) {
                     if (ID == *it2) {
                         m_World->DeleteEntity(child.ID);
-                        (int&)entity["ScoreScreen"]["TotalIdentities"] -= 1;
+                        (Field<int>)entity["ScoreScreen"]["TotalIdentities"] -= 1;
                         it2 = m_DisconnectedIdentities.erase(it2);
                         it = m_PlayerIdentities.erase(it);
 
@@ -59,17 +59,17 @@ void ScoreScreenSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper&
                     break;
                 }
                 //Update Deaths for child
-                (int&)child["ScoreIdentity"]["Kills"] = it->second.Kills;
+                (Field<int>)child["ScoreIdentity"]["Kills"] = it->second.Kills;
                 //Update Kills for child
-                (int&)child["ScoreIdentity"]["Deaths"] = it->second.Deaths;
+                (Field<int>)child["ScoreIdentity"]["Deaths"] = it->second.Deaths;
                 //KD is not updated at the moment.
                 if (it->second.Deaths != 0) {
-                    (double&)child["ScoreIdentity"]["KD"] = it->second.Kills/it->second.Deaths;
+                    (Field<double>)child["ScoreIdentity"]["KD"] = it->second.Kills/it->second.Deaths;
                 }
 
                 //Update position for child
                 glm::vec3 offset = (glm::vec3)entity["ScoreScreen"]["Offset"];
-                (glm::vec3&) child["Transform"]["Position"] = offset * position;
+                (Field<glm::vec3>) child["Transform"]["Position"] = offset * position;
                 position += 1.f;
 
                 break;
@@ -90,16 +90,16 @@ void ScoreScreenSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper&
             EntityWrapper scoreIdentity = entityFile->MergeInto(m_World);
             glm::vec3 offset = (glm::vec3)entity["ScoreScreen"]["Offset"];
             int newPosition = (int)entity["ScoreScreen"]["TotalIdentities"];
-            (glm::vec3&) scoreIdentity["Transform"]["Position"] = offset * (float)newPosition;
+            (Field<glm::vec3>) scoreIdentity["Transform"]["Position"] = offset * (float)newPosition;
             auto cScoreIdentity = scoreIdentity["ScoreIdentity"];
             auto data = it->second;
 
-            (std::string&)cScoreIdentity["Name"] = data.Name;
-            (int&)cScoreIdentity["ID"] = data.ID;
+            (Field<std::string>)cScoreIdentity["Name"] = data.Name;
+            (Field<int>)cScoreIdentity["ID"] = data.ID;
 
             m_World->SetParent(scoreIdentity.ID, entity.ID);
 
-            (int&)entity["ScoreScreen"]["TotalIdentities"] += 1;
+            (Field<int>)entity["ScoreScreen"]["TotalIdentities"] += 1;
 
         }
     }

src/Game/Systems/ServerListSystem.cpp

@@ -33,20 +33,20 @@ bool ServerListSystem::OnServerListRecieved(const Events::DisplayServerlist& e)
         EntityWrapper identitySpawner = serverListEntity.FirstChildByName("ServerIdentitySpawner");
         identitySpawner.DeleteChildren();
 
-        (int&)cServerList["TotalIdentities"] = (int)e.Serverlist.size();
+        (Field<int>)cServerList["TotalIdentities"] = (int)e.Serverlist.size();
         for (int i = 0; i < e.Serverlist.size(); i++) {
             //Create Identities for each server and place them on the right position.
             EntityWrapper newIdentity = SpawnerSystem::Spawn(identitySpawner, identitySpawner);
             EntityWrapper serverIdentityEntity = newIdentity.FirstChildByName("ServerIdentity");
 
             glm::vec3 offset = (glm::vec3)serverListEntity["ServerList"]["Offset"];
-            (glm::vec3&)serverIdentityEntity["Transform"]["Position"] = offset * (float)i;
+            (Field<glm::vec3>)serverIdentityEntity["Transform"]["Position"] = offset * (float)i;
 
             auto& cIdentity = serverIdentityEntity["ServerIdentity"];
-            (std::string&)cIdentity["IP"] = e.Serverlist[i].Address;
-            (std::string&)cIdentity["ServerName"] = e.Serverlist[i].Name;
-            (int&)cIdentity["Port"] = e.Serverlist[i].Port;
-            (int&)cIdentity["PlayersConnected"] = e.Serverlist[i].PlayersConnected;
+            (Field<std::string>)cIdentity["IP"] = e.Serverlist[i].Address;
+            (Field<std::string>)cIdentity["ServerName"] = e.Serverlist[i].Name;
+            (Field<int>)cIdentity["Port"] = e.Serverlist[i].Port;
+            (Field<int>)cIdentity["PlayersConnected"] = e.Serverlist[i].PlayersConnected;
         }
     }
     return 1;

src/Game/Systems/SpawnerSystem.cpp

@@ -76,9 +76,9 @@ EntityWrapper SpawnerSystem::Spawn(EntityWrapper spawner, EntityWrapper parent /
 void SpawnerSystem::transformEntityToSpawnPoint(EntityWrapper spawnedEntity, EntityWrapper spawnPoint)
 {
     // Set its position and orientation to that of the SpawnPoint
-    spawnedEntity["Transform"]["Position"] = Transform::AbsolutePosition(spawnPoint.World, spawnPoint.ID);
+    spawnedEntity["Transform"]["Position"] = TransformSystem::AbsolutePosition(spawnPoint.World, spawnPoint.ID);
     // TODO: Quaternions, bitch
-    spawnedEntity["Transform"]["Orientation"] = glm::eulerAngles(Transform::AbsoluteOrientation(spawnPoint));
+    spawnedEntity["Transform"]["Orientation"] = glm::eulerAngles(TransformSystem::AbsoluteOrientation(spawnPoint));
 }
 
 bool SpawnerSystem::spawnedEntityIsColliding(EntityWrapper spawnedEntity, EntityWrapper spawnPoint, const std::string& dontCollideComponent)
@@ -86,7 +86,7 @@ bool SpawnerSystem::spawnedEntityIsColliding(EntityWrapper spawnedEntity, Entity
     transformEntityToSpawnPoint(spawnedEntity, spawnPoint);
     //Check if the spawned entity collides with anything, and if so, continue to the next spawnpoint.
     EntityAABB spawnedBox = *Collision::EntityAbsoluteAABB(spawnedEntity);
-    const ComponentPool* otherSpawnedEntities = spawnPoint.World->GetComponents(dontCollideComponent);
+    auto otherSpawnedEntities = spawnPoint.World->GetComponents(dontCollideComponent);
     for (const auto& obj : *otherSpawnedEntities) {
         if (spawnedEntity.ID == obj.EntityID) {
             continue;
@@ -113,7 +113,7 @@ bool SpawnerSystem::spawnedEntityIsColliding(EntityWrapper spawnedEntity, Entity
                     spawnedBox,
                     model->Vertices(),
                     model->m_Indices,
-                    Transform::ModelMatrix(otherEntity))) {
+                    TransformSystem::ModelMatrix(otherEntity))) {
                 return true;
             }
         }

src/Game/Systems/TextFieldReader.cpp

@@ -34,7 +34,7 @@ void TextFieldReader::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
     }
     const ComponentInfo::Field_t& field = component.Info.Fields.at(fieldName);
 
-    std::string& text = entity["Text"]["Content"];
+    Field<std::string> text = entity["Text"]["Content"];
 
     if (field.Type == "int") {
         text = boost::lexical_cast<std::string>((const int&)component[fieldName]);

src/Game/Systems/Weapon/AssaultWeaponBehaviour.cpp

@@ -2,7 +2,7 @@
 
 void AssaultWeaponBehaviour::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cWeapon, double dt)
 {
-    double& fireCooldown = cWeapon["FireCooldown"];
+    Field<double> fireCooldown = cWeapon["FireCooldown"];
     fireCooldown = glm::max(0.0, fireCooldown - dt);
 
     WeaponBehaviour::UpdateComponent(entity, cWeapon, dt);
@@ -11,33 +11,33 @@ void AssaultWeaponBehaviour::UpdateComponent(EntityWrapper& entity, ComponentWra
 void AssaultWeaponBehaviour::UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo& wi, double dt)
 {
     // Start reloading automatically if at 0 mag ammo
-    int& magAmmo = cWeapon["MagazineAmmo"];
+    Field<int> magAmmo = cWeapon["MagazineAmmo"];
     if (m_ConfigAutoReload && magAmmo <= 0) {
         OnReload(cWeapon, wi);
     }
 
     // Only start reloading once we're done firing
-    bool& reloadQueued = cWeapon["ReloadQueued"];
-    double& fireCooldown = cWeapon["FireCooldown"];
-    bool& isReloading = cWeapon["IsReloading"];
+    Field<bool> reloadQueued = cWeapon["ReloadQueued"];
+    Field<double> fireCooldown = cWeapon["FireCooldown"];
+    Field<bool> isReloading = cWeapon["IsReloading"];
     if (reloadQueued && fireCooldown <= 0) {
         reloadQueued = fireCooldown;
         isReloading = true;
     }
 
     // Decrement reload timer
-    double& reloadTimer = cWeapon["ReloadTimer"];
+    Field<double> reloadTimer = cWeapon["ReloadTimer"];
     if (isReloading) {
         reloadTimer = glm::max(0.0, reloadTimer - dt);
     }
 
     // Handle reloading
     if (isReloading && reloadTimer <= 0.0) {
-        int& magSize = cWeapon["MagazineSize"];
-        int& ammo = cWeapon["Ammo"];
+        Field<int> magSize = cWeapon["MagazineSize"];
+        Field<int> ammo = cWeapon["Ammo"];
 
         ammo = glm::max(0, ammo - (magSize - magAmmo));
-        magAmmo = glm::min(magSize, ammo);
+        magAmmo = glm::min(*magSize, *ammo);
         isReloading = false;
         if (wi.FirstPersonEntity.Valid()) {
             wi.FirstPersonEntity.FirstChildByName("ViewModel")["Model"]["Visible"] = true;
@@ -53,15 +53,15 @@ void AssaultWeaponBehaviour::UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo&
     
     // Restore view angle
     if (IsClient) {
-        float& currentTravel = cWeapon["CurrentTravel"];
-        float& returnSpeed = cWeapon["ViewReturnSpeed"];
+        Field<float> currentTravel = cWeapon["CurrentTravel"];
+        Field<float> returnSpeed = cWeapon["ViewReturnSpeed"];
         if (currentTravel > 0) {
             float change = returnSpeed * dt;
             currentTravel = glm::max(0.f, currentTravel - change);
             EntityWrapper camera = wi.Player.FirstChildByName("Camera");
             if (camera.Valid()) {
-                glm::vec3& cameraOrientation = camera["Transform"]["Orientation"];
-                cameraOrientation.x -= change;
+                Field<glm::vec3> cameraOrientation = camera["Transform"]["Orientation"];
+                cameraOrientation.x(cameraOrientation.x() - change);
             }
         }
     }
@@ -76,7 +76,7 @@ void AssaultWeaponBehaviour::UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo&
     if (rootNode.Valid()) {
         EntityWrapper blend = rootNode.FirstChildByName("MovementBlend");
         if (blend.Valid()) {
-            (double&)blend["Blend"]["Weight"] = animationWeight;
+            (Field<double>)blend["Blend"]["Weight"] = animationWeight;
         }
     }
 
@@ -101,24 +101,24 @@ void AssaultWeaponBehaviour::OnCeasePrimaryFire(ComponentWrapper cWeapon, Weapon
 
 void AssaultWeaponBehaviour::OnReload(ComponentWrapper cWeapon, WeaponInfo& wi)
 {
-    bool& reloadQueued = cWeapon["ReloadQueued"];
-    bool& isReloading = cWeapon["IsReloading"];
+    Field<bool> reloadQueued = cWeapon["ReloadQueued"];
+    Field<bool> isReloading = cWeapon["IsReloading"];
     if (reloadQueued || isReloading) {
         return;
     }
 
-    int& magAmmo = cWeapon["MagazineAmmo"];
-    int& magSize = cWeapon["MagazineSize"];
+    Field<int> magAmmo = cWeapon["MagazineAmmo"];
+    Field<int> magSize = cWeapon["MagazineSize"];
     if (magAmmo >= magSize) {
         return;
     }
-    int& ammo = cWeapon["Ammo"];
+    Field<int> ammo = cWeapon["Ammo"];
     if (ammo <= 0) {
         return;
     }
 
-    double reloadTime = cWeapon["ReloadTime"];
-    double& reloadTimer = cWeapon["ReloadTimer"];
+    Field<double> reloadTime = cWeapon["ReloadTime"];
+    Field<double> reloadTimer = cWeapon["ReloadTimer"];
    
     // Start reload
     reloadQueued = true;
@@ -183,7 +183,7 @@ void AssaultWeaponBehaviour::fireBullet(ComponentWrapper cWeapon, WeaponInfo& wi
     cWeapon["FireCooldown"] = 60.0 / (double)cWeapon["RPM"];
 
     // Ammo
-    int& magAmmo = cWeapon["MagazineAmmo"];
+    Field<int> magAmmo = cWeapon["MagazineAmmo"];
     if (magAmmo <= 0) {
         return;
     } else {
@@ -194,16 +194,16 @@ void AssaultWeaponBehaviour::fireBullet(ComponentWrapper cWeapon, WeaponInfo& wi
     if (IsClient) {
         EntityWrapper camera = wi.Player.FirstChildByName("Camera");
         if (camera.Valid()) {
-            glm::vec3& cameraOrientation = camera["Transform"]["Orientation"];
+            Field<glm::vec3> cameraOrientation = camera["Transform"]["Orientation"];
             float viewPunch = cWeapon["ViewPunch"];
             float maxTravelAngle = cWeapon["MaxTravelAngle"];
-            float& currentTravel = cWeapon["CurrentTravel"];
+            Field<float> currentTravel = cWeapon["CurrentTravel"];
             if (currentTravel < maxTravelAngle) {
                 float change = viewPunch;
                 if (currentTravel + change > maxTravelAngle) {
                     change = maxTravelAngle - currentTravel;
                 }
-                cameraOrientation.x += change;
+                cameraOrientation.x(cameraOrientation.x() + change);
                 currentTravel += change;
             }
         }
@@ -218,12 +218,12 @@ void AssaultWeaponBehaviour::fireBullet(ComponentWrapper cWeapon, WeaponInfo& wi
     // Tracer
     EntityWrapper tracerSpawner = weaponModelEntity.FirstChildByName("WeaponMuzzle");
     if (tracerSpawner.Valid()) {
-        glm::vec3 origin = Transform::AbsolutePosition(tracerSpawner);
-        glm::vec3 direction = glm::quat(Transform::AbsoluteOrientationEuler(tracerSpawner)) * glm::vec3(0, 0, -1);
+        glm::vec3 origin = TransformSystem::AbsolutePosition(tracerSpawner);
+        glm::vec3 direction = glm::quat(TransformSystem::AbsoluteOrientationEuler(tracerSpawner)) * glm::vec3(0, 0, -1);
         float distance = traceRayDistance(origin, direction);
         EntityWrapper ray = SpawnerSystem::Spawn(tracerSpawner);
         if (ray.Valid()) {
-            ((glm::vec3&)ray["Transform"]["Scale"]).z = distance;
+            ((Field<glm::vec3>)ray["Transform"]["Scale"]).z(distance);
         }
     }
 

src/Game/Systems/Weapon/DefenderWeaponBehaviour.cpp

@@ -2,7 +2,7 @@
 
 void DefenderWeaponBehaviour::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cWeapon, double dt)
 {
-    double& fireCooldown = cWeapon["FireCooldown"];
+    Field<double> fireCooldown = cWeapon["FireCooldown"];
     fireCooldown = glm::max(0.0, fireCooldown - dt);
 
     WeaponBehaviour::UpdateComponent(entity, cWeapon, dt);
@@ -11,21 +11,21 @@ void DefenderWeaponBehaviour::UpdateComponent(EntityWrapper& entity, ComponentWr
 void DefenderWeaponBehaviour::UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo& wi, double dt)
 {
     // Decrement reload timer
-    double& reloadTimer = cWeapon["ReloadTimer"];
+    Field<double> reloadTimer = cWeapon["ReloadTimer"];
     reloadTimer = glm::max(0.0, reloadTimer - dt);
 
     // Start reloading automatically if at 0 mag ammo
-    int& magAmmo = cWeapon["MagazineAmmo"];
+    Field<int> magAmmo = cWeapon["MagazineAmmo"];
     if (m_ConfigAutoReload && magAmmo <= 0) {
         OnReload(cWeapon, wi);
     }
 
     // Handle reloading
-    bool& isReloading = cWeapon["IsReloading"];
+    Field<bool> isReloading = cWeapon["IsReloading"];
     if (isReloading && reloadTimer <= 0.0) {
         double reloadTime = cWeapon["ReloadTime"];
-        int& magSize = cWeapon["MagazineSize"];
-        int& ammo = cWeapon["Ammo"];
+        Field<int> magSize = cWeapon["MagazineSize"];
+        Field<int> ammo = cWeapon["Ammo"];
         if (magAmmo < magSize && ammo > 0) {
             ammo -= 1;
             magAmmo += 1;
@@ -42,15 +42,15 @@ void DefenderWeaponBehaviour::UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo&
 
     // Restore view angle
     if (IsClient) {
-        float& currentTravel = cWeapon["CurrentTravel"];
-        float& returnSpeed = cWeapon["ViewReturnSpeed"];
+        Field<float> currentTravel = cWeapon["CurrentTravel"];
+        Field<float> returnSpeed = cWeapon["ViewReturnSpeed"];
         if (currentTravel > 0) {
             float change = returnSpeed * dt;
             currentTravel = glm::max(0.f, currentTravel - change);
             EntityWrapper camera = wi.Player.FirstChildByName("Camera");
             if (camera.Valid()) {
-                glm::vec3& cameraOrientation = camera["Transform"]["Orientation"];
-                cameraOrientation.x -= change;
+                Field<glm::vec3> cameraOrientation = camera["Transform"]["Orientation"];
+                cameraOrientation.x(cameraOrientation.x() - change);
             }
         }
     }
@@ -76,23 +76,23 @@ void DefenderWeaponBehaviour::OnCeasePrimaryFire(ComponentWrapper cWeapon, Weapo
 
 void DefenderWeaponBehaviour::OnReload(ComponentWrapper cWeapon, WeaponInfo& wi)
 {
-    bool& isReloading = cWeapon["IsReloading"];
+    Field<bool> isReloading = cWeapon["IsReloading"];
     if (isReloading) {
         return;
     }
 
-    int& magAmmo = cWeapon["MagazineAmmo"];
-    int& magSize = cWeapon["MagazineSize"];
+    Field<int> magAmmo = cWeapon["MagazineAmmo"];
+    Field<int> magSize = cWeapon["MagazineSize"];
     if (magAmmo >= magSize) {
         return;
     }
-    int& ammo = cWeapon["Ammo"];
+    Field<int> ammo = cWeapon["Ammo"];
     if (ammo <= 0) {
         return;
     }
 
     double reloadTime = cWeapon["ReloadTime"];
-    double& reloadTimer = cWeapon["ReloadTimer"];
+    Field<double> reloadTimer = cWeapon["ReloadTimer"];
    
     // Start reload
     isReloading = true;
@@ -179,11 +179,11 @@ void DefenderWeaponBehaviour::fireShell(ComponentWrapper cWeapon, WeaponInfo& wi
     cWeapon["FireCooldown"] = 60.0 / (double)cWeapon["RPM"];
 
     // Stop reloading
-    bool& isReloading = cWeapon["IsReloading"];
+    Field<bool> isReloading = cWeapon["IsReloading"];
     isReloading = false;
 
     // Ammo
-    int& magAmmo = cWeapon["MagazineAmmo"];
+    Field<int> magAmmo = cWeapon["MagazineAmmo"];
     if (magAmmo <= 0) {
         return;
     } else {
@@ -208,16 +208,16 @@ void DefenderWeaponBehaviour::fireShell(ComponentWrapper cWeapon, WeaponInfo& wi
     if (IsClient) {
         EntityWrapper camera = wi.Player.FirstChildByName("Camera");
         if (camera.Valid()) {
-            glm::vec3& cameraOrientation = camera["Transform"]["Orientation"];
+            Field<glm::vec3> cameraOrientation = camera["Transform"]["Orientation"];
             float viewPunch = cWeapon["ViewPunch"];
             float maxTravelAngle = cWeapon["MaxTravelAngle"];
-            float& currentTravel = cWeapon["CurrentTravel"];
+            Field<float> currentTravel = cWeapon["CurrentTravel"];
             if (currentTravel < maxTravelAngle) {
                 float change = viewPunch;
                 if (currentTravel + change > maxTravelAngle) {
                     change = maxTravelAngle - currentTravel;
                 }
-                cameraOrientation.x += change;
+                cameraOrientation.x(cameraOrientation.x() + change);
                 currentTravel += change;
             }
         }
@@ -240,13 +240,13 @@ void DefenderWeaponBehaviour::fireShell(ComponentWrapper cWeapon, WeaponInfo& wi
             m_EventBroker->Publish(e);
         }
         for (auto& angles : pelletAngles) {
-            glm::vec3 direction = Transform::AbsoluteOrientation(spawner) * glm::quat(glm::vec3(angles, 0.f)) * glm::vec3(0, 0, -1);
-            float distance = traceRayDistance(Transform::AbsolutePosition(spawner), direction);
+            glm::vec3 direction = TransformSystem::AbsoluteOrientation(spawner) * glm::quat(glm::vec3(angles, 0.f)) * glm::vec3(0, 0, -1);
+            float distance = traceRayDistance(TransformSystem::AbsolutePosition(spawner), direction);
             EntityWrapper ray = SpawnerSystem::Spawn(spawner);
-            ((glm::vec3&)ray["Transform"]["Scale"]).z = (distance / 100.f);
-            glm::vec3& orientation = ray["Transform"]["Orientation"];
-            orientation.x += angles.x;
-            orientation.y += angles.y;
+            ((Field<glm::vec3>)ray["Transform"]["Scale"]).z(distance / 100.f);
+            Field<glm::vec3> orientation = ray["Transform"]["Orientation"];
+            orientation.x(orientation.x() + angles.x);
+            orientation.y(orientation.y() + angles.y);
             glm::vec3 trajectory = direction * distance;
             dealDamage(cWeapon, wi, direction, pelletDamage);
         }
@@ -281,7 +281,7 @@ void DefenderWeaponBehaviour::dealDamage(ComponentWrapper cWeapon, WeaponInfo& w
     
     glm::vec3 maxRange = direction * 2.f;
     EntityWrapper camera = wi.Player.FirstChildByName("Camera");
-    glm::vec3 cameraPosition = Transform::AbsolutePosition(camera);
+    glm::vec3 cameraPosition = TransformSystem::AbsolutePosition(camera);
     if (!camera.Valid()) {
         return;
     }

src/Game/Systems/Weapon/SidearmWeaponBehaviour.cpp

@@ -2,7 +2,7 @@
 
 void SidearmWeaponBehaviour::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cWeapon, double dt)
 {
-    double& cooldown = cWeapon["FireCooldown"];
+    Field<double> cooldown = cWeapon["FireCooldown"];
     if (cooldown > 0) {
         cooldown -= dt;
         if (cooldown < 0) {
@@ -60,18 +60,18 @@ void SidearmWeaponBehaviour::fireBullet(ComponentWrapper cWeapon, WeaponInfo& wi
     // Tracer
     EntityWrapper tracerSpawner = weaponModelEntity.FirstChildByName("WeaponMuzzle");
     if (tracerSpawner.Valid()) {
-        glm::vec3 origin = Transform::AbsolutePosition(tracerSpawner);
-        glm::vec3 direction = Transform::AbsoluteOrientation(tracerSpawner) * glm::vec3(0, 0, -1);
+        glm::vec3 origin = TransformSystem::AbsolutePosition(tracerSpawner);
+        glm::vec3 direction = TransformSystem::AbsoluteOrientation(tracerSpawner) * glm::vec3(0, 0, -1);
         float distance = traceRayDistance(origin, direction);
         EntityWrapper ray = SpawnerSystem::Spawn(tracerSpawner);
-        ((glm::vec3&)ray["Transform"]["Scale"]).z = (distance / 100.f);
+        ((Field<glm::vec3>)ray["Transform"]["Scale"]).z(distance / 100.f);
     }
 }
 
 bool SidearmWeaponBehaviour::canFire(ComponentWrapper cWeapon)
 {
     bool triggerHeld = cWeapon["TriggerHeld"];
-    double& cooldown = cWeapon["FireCooldown"];
+    Field<double> cooldown = cWeapon["FireCooldown"];
     // TODO: Ammo checks
     return triggerHeld && cooldown <= 0.0;
 }

src/Tests/WorldTest.cpp

@@ -30,14 +30,14 @@ BOOST_AUTO_TEST_CASE(WorldTestSingleAllocation, * boost::unit_test::tolerance(0.
     BOOST_TEST(vec3.z == 3.f);
 
     // Change values
-    ((int&)c["TestInteger"]) += 1;
+    ((Field<int>)c["TestInteger"]) += 1;
     BOOST_TEST((int)c["TestInteger"] == 1338);
-    ((double&)c["TestDouble"]) += 1.11;
+    ((Field<double>)c["TestDouble"]) += 1.11;
     std::cout << (double)c["TestDouble"] << std::endl;
     BOOST_TEST((double)c["TestDouble"] == 14.48);
     c["TestString"] = "Siesta";
     BOOST_TEST((std::string)c["TestString"] == "Siesta");
-    ((glm::vec3&)c["TestVec3"]).y += 1.f;
+    ((Field<glm::vec3>)c["TestVec3"]).y += 1.f;
     BOOST_TEST(((glm::vec3)c["TestVec3"]).y == 3.f);
 }
 
@@ -100,16 +100,16 @@ BOOST_AUTO_TEST_CASE(WorldCopy, *utf::tolerance(0.00001))
 
     // Check that built-in types are copied but don't reside in the same memory
     BOOST_CHECK((int)w1_c1["TestInteger"] == (int)w2_c1["TestInteger"]);
-    BOOST_CHECK(&(int&)w1_c1["TestInteger"] != &(int&)w2_c1["TestInteger"]);
+    BOOST_CHECK(&(Field<int>)w1_c1["TestInteger"] != &(Field<int>)w2_c1["TestInteger"]);
     BOOST_CHECK((double)w1_c1["TestDouble"] == (double)w2_c1["TestDouble"]);
-    BOOST_CHECK(&(int&)w1_c1["TestDouble"] != &(int&)w2_c1["TestDouble"]);
+    BOOST_CHECK(&(Field<int>)w1_c1["TestDouble"] != &(Field<int>)w2_c1["TestDouble"]);
     BOOST_CHECK((int)w1_c2["TestInteger"] == (int)w2_c2["TestInteger"]);
-    BOOST_CHECK(&(int&)w1_c2["TestInteger"] != &(int&)w2_c2["TestInteger"]);
+    BOOST_CHECK(&(Field<int>)w1_c2["TestInteger"] != &(Field<int>)w2_c2["TestInteger"]);
     BOOST_CHECK((double)w1_c2["TestDouble"] == (double)w2_c2["TestDouble"]);
-    BOOST_CHECK(&(int&)w1_c2["TestDouble"] != &(int&)w2_c2["TestDouble"]);
+    BOOST_CHECK(&(Field<int>)w1_c2["TestDouble"] != &(Field<int>)w2_c2["TestDouble"]);
     // Check that specially handled strings are fine
     BOOST_CHECK((std::string)w1_c1["TestString"] == (std::string)w2_c1["TestString"]);
-    BOOST_CHECK(&(std::string&)w1_c1["TestString"] != &(std::string&)w2_c1["TestString"]);
+    BOOST_CHECK(&(Field<std::string>)w1_c1["TestString"] != &(Field<std::string>)w2_c1["TestString"]);
     BOOST_CHECK((std::string)w1_c2["TestString"] == (std::string)w2_c2["TestString"]);
-    BOOST_CHECK(&(std::string&)w1_c2["TestString"] != &(std::string&)w2_c2["TestString"]);
+    BOOST_CHECK(&(Field<std::string>)w1_c2["TestString"] != &(Field<std::string>)w2_c2["TestString"]);
 }

tools/MayaExporter/MayaExporter/Material.cpp

@@ -108,7 +108,7 @@ bool Material::findColorTexture(MaterialNode& material_node, MFnDependencyNode&
 			return true;
 
 		} else if (AllConnections[i].node().hasFn(MFn::kLayeredTexture)) {
-			MGlobal::displayInfo(MString() + "find splat map");
+			MGlobal::displayInfo(MString() + "found color splat map");
 			return findSplatTextures(material_node, material_node.ColorMaps, MFnDependencyNode(AllConnections[i].node()));
 		}
 	}
@@ -162,9 +162,9 @@ bool Material::findNormalTexture(MaterialNode& material_node, MFnDependencyNode&
 
 					material_node.NormalMaps.push_back(newTexture);
 					return true;
-				} else if (AllConnections[i].node().hasFn(MFn::kLayeredTexture)) {
-					MGlobal::displayInfo(MString() + "find splat map");
-					return findSplatTextures(material_node, material_node.NormalMaps, MFnDependencyNode(AllConnections[i].node()));
+				} else if (AllBumpConnections[j].node().hasFn(MFn::kLayeredTexture)) {
+					MGlobal::displayInfo(MString() + "found normal splat map");
+					return findSplatTextures(material_node, material_node.NormalMaps, MFnDependencyNode(AllBumpConnections[j].node()));
 				}
 			}
 		}
@@ -218,7 +218,7 @@ bool Material::findSpecularTexture(MaterialNode& material_node, MFnDependencyNod
 				material_node.type = MaterialNode::MaterialType::SingleTextures;
 			return true;
 		} else if (AllConnections[i].node().hasFn(MFn::kLayeredTexture)) {
-			MGlobal::displayInfo(MString() + "find splat map");
+			MGlobal::displayInfo(MString() + "found specular splat map");
 			return findSplatTextures(material_node, material_node.SpecularMaps, MFnDependencyNode(AllConnections[i].node()));
 		}
 	}
@@ -270,7 +270,7 @@ bool Material::findIncandescenceTexture(MaterialNode& material_node, MFnDependen
 			return true;
 
 		} else if (AllConnections[i].node().hasFn(MFn::kLayeredTexture)) {
-			MGlobal::displayInfo(MString() + "find splat map");
+			MGlobal::displayInfo(MString() + "found incandescens splat map");
 			return findSplatTextures(material_node, material_node.IncandescenceMaps, MFnDependencyNode(AllConnections[i].node()));
 		}
 	}