TransformSystem.h

#pragma once
 
#include "Systems/ComponentSystem.h"
 
#include "Components/Core/TransformComponent.h"
 
#include <glm/gtc/quaternion.hpp>
#include <glm/gtx/transform.hpp>
 
namespace Cogs
{
  namespace Core
  {
    struct LocalTransform : public glm::mat4
    {
    };
 
    struct WorldTransform : public glm::mat4
    {
    };
 
    struct TransformState
    {
      bool cached = false;
      bool changed = false;
    };
 
    class COGSCORE_DLL_API TransformSystem : public ComponentSystemWithDataPools<TransformComponent, LocalTransform, WorldTransform, TransformState>
    {
    public:
      TransformSystem(Memory::Allocator * allocator, SizeType capacity) : ComponentSystemWithDataPools(allocator, capacity) {}
 
      void handleOriginUpdate(class Context* context);
 
      void update(class Context * context) override;
 
      void updateLocalTransform(const TransformComponent & component)
      {
        auto offset = component.parent ? glm::vec3(0, 0, 0) : glm::vec3(component.coordinates - origin);
 
        if (component.transformFlags) {
          getLocalTransform(&component) = glm::translate(glm::mat4(1.f), offset) * component.transform;
        } else {
          getLocalTransform(&component) = glm::translate(glm::mat4(1.f), offset + component.position) *
            glm::mat4_cast(component.rotation) * glm::scale(component.scale);
        }
      }
 
      /*
        Set an explicit local transform to the given component.
      */
      void setLocalTransform(TransformComponent* component, const glm::mat4& matrix);
 
      void updateTransformData(const TransformComponent & component)
      {
        getData<TransformState>(&component).cached = false;
 
        updateLocalTransform(component);
        updateLocalToWorldTransform(component, true);
      }
 
      void setOrigin(const glm::dvec3& newOrigin) { originUpdate = newOrigin; }
 
      glm::dvec3 getOrigin() const { return origin; }
 
      glm::mat4 & getLocalToWorld(const TransformComponent * component)
      {
        return getData<WorldTransform>(component);
      }
 
      glm::mat4 & getLocalTransform(const TransformComponent * component)
      {
        return getData<LocalTransform>(component);
      }
 
      void setTransform(TransformComponent * component, glm::mat4 transformMatrix)
      {
        getLocalToWorld(component) = transformMatrix;
 
        component->unsetFlag(ComponentModel::ComponentFlags::Changed);
      }
 
      void copyTransform(const TransformComponent * source, TransformComponent * destination)
      {
        setTransform(destination, getLocalToWorld(source));
      }
 
      bool hasChanged(const TransformComponent * component)
      {
        return getData<TransformState>(component).changed;
      }
 
      void updateLocalToWorldTransform(const TransformComponent & component, bool dirty = false);
 
      inline glm::vec3 engineFromWorldCoords(glm::dvec3 c) { return glm::vec3(c - origin); }
      inline glm::dvec3 worldFromEngineCoords(glm::vec3 c) { return origin + glm::dvec3(c); }
 
    private:
      glm::dvec3 origin = glm::dvec3(0.0);          
      glm::dvec3 originUpdate = glm::dvec3(0.0);    
    };
  }
}