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

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

src/Engine/Core/TransformSystem.cpp

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

src/Engine/Core/UniformScaleSystem.cpp

@@ -13,8 +13,8 @@ void UniformScaleSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper
         return;
     }
 
-    float distance = glm::length((glm::vec3)entity["Transform"]["Position"] - (glm::vec3&)m_Camera["Transform"]["Position"]);
-    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/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/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/Sound/SoundManager.cpp

@@ -120,7 +120,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);
@@ -130,8 +130,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);
             }
@@ -154,11 +154,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;
         }
     }
@@ -239,14 +239,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);
@@ -280,8 +280,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;
@@ -302,8 +302,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

@@ -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,19 +2,19 @@
 
 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;
+		Field<double> timeSinceDeath = component["TimeSinceDeath"];
+		timeSinceDeath += (Field<double>)component["Speed"] * dt;
 		if (timeSinceDeath < 0) {
 			timeSinceDeath = 0.0;
 		}
-		else if (timeSinceDeath >(double)component["ExplosionDuration"]) {
-			timeSinceDeath = (double)component["ExplosionDuration"];
+		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/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"]);
 }