Transform.hpp

#pragma once
//
//  Transform.h
//  RavEngine_Static
//
//  Copyright © 2020 Ravbug. 
//
 
#include "Atomic.hpp"
#include "mathtypes.hpp"
#include "ComponentHandle.hpp"
#include "Queryable.hpp"
#include "Common3D.hpp"
#include "glm/gtx/matrix_decompose.hpp"
#include "DataStructures.hpp"
#include "ComponentWithOwner.hpp"
#include "Arch.hpp"
 
namespace RavEngine {
    struct Transform : public ComponentWithOwner, public Queryable<Transform> {
    protected:
        mutable matrix4 matrix;             // defined as the world space transform of the PARENT
        UnorderedVector<ComponentHandle<Transform>>  children;        //non-owning
        quaternion rotation;
        ComponentHandle<Transform> parent;    //non-owning
        vector3 position, scale;
        mutable bool isDirty : 1 = true;        // used for when the transform hierarchy has been changed
        mutable bool isTickDirty : 1 = true;    // used for when this transform has been updated in the current tick and needs updating in the world's render data
 
        // sanity checking for optimal struct padding
#if RVE_64_BIT
        static_assert(sizeof(matrix) >= sizeof(children), "Invalid struct order");
        static_assert(sizeof(children) >= sizeof(rotation), "Invalid struct order");
        static_assert(sizeof(rotation) >= sizeof(position), "Invalid struct order");
        static_assert(sizeof(parent) >= sizeof(position), "Invalid struct order");
#endif
        
        friend class World;
        
        inline void MarkAsDirty() const{
            isDirty = true;
            isTickDirty = true;
        }
 
        inline void ClearTickDirty() {
            isTickDirty = false;
        }
 
        inline void UpdateChildren()
        {
            MarkAsDirty();
            if (children.size() > 0) [[unlikely]]  {
                constexpr auto update = [](Transform* transform, auto&& updatefn) -> void {
                    transform->MarkAsDirty();
                    auto newParentMatrix = transform->GetWorldMatrix();
                    for (auto& child : transform->children) {
                        auto component = child.get();
                        component->matrix = newParentMatrix;
 
                        updatefn(component, updatefn);
                    }
                    };
                update(this, update);
            }
        }
        
    public:
        inline bool getTickDirty() const{
            return isTickDirty;
        }
        
        Transform(Entity owner, const vector3& inpos, const quaternion& inrot, const vector3& inscale) : ComponentWithOwner(owner), matrix(1){
            SetLocalPosition(inpos);
            SetLocalRotation(inrot);
            SetLocalScale(inscale);
        }
        Transform(Entity owner) : Transform(owner, vector3(0, 0, 0), quaternion(1.0, 0.0, 0.0, 0.0), vector3(1, 1, 1)) {}
        
        MOVE_NO_COPY(Transform);
        
        Transform& SetLocalPosition(const vector3&);
        Transform& SetWorldPosition(const vector3&);
        Transform& LocalTranslateDelta(const vector3&);
        Transform& WorldTranslateDelta(const vector3&);
 
        Transform& SetLocalRotation(const quaternion&);
        Transform& SetWorldRotation(const quaternion&);
        Transform& LocalRotateDelta(const quaternion&);
 
        Transform& SetLocalScale(const vector3&);
        Transform& LocalScaleDelta(const vector3&);
        
        Transform& SetLocalScale(const decimalType& scale){ SetLocalScale(vector3(scale,scale,scale)); return *this;}
 
        vector3 Forward() const;
        vector3 Right() const;
        vector3 Up() const;
        
        vector3 WorldForward() const;
        vector3 WorldRight() const;
        vector3 WorldUp() const;
 
        inline bool HasParent() const{
            return parent.IsValid();
        }
 
        vector3 GetLocalPosition() const;
        vector3 GetWorldPosition() const;
 
        quaternion GetLocalRotation() const;
        quaternion GetWorldRotation() const;
 
        vector3 GetLocalScale() const;
 
        matrix4 GenerateLocalMatrix() const;
        
        matrix4 GetMatrix() const;
 
        matrix4 GetWorldMatrix() const {
            return matrix * GenerateLocalMatrix();
        }
 
        matrix4 GetParentSpaceMatrix() const {
            return matrix;
        }
 
        Transform& AddChild(ComponentHandle<Transform> child);
 
        Transform& RemoveChild(ComponentHandle<Transform> child);
        
        const decltype(children)& GetChildren() const{
            return children;
        }
        
        // destroy everything parented to this
        void Destroy(){
            for(auto& child : children){
                child.GetOwner().Destroy();
            }
        }
};
 
    inline matrix4 Transform::GenerateLocalMatrix() const{
        return glm::translate(matrix4(1), (vector3)position) * glm::toMat4((quaternion)rotation) * glm::scale(matrix4(1), (vector3)scale);
    }
 
    inline vector3 Transform::Forward() const{
        return (quaternion)rotation * vector3_forward;
    }
 
    inline vector3 Transform::Up() const{
        return (quaternion)rotation * vector3_up;
    }
 
    inline vector3 Transform::Right() const{
        return (quaternion)rotation * vector3_right;
    }
 
    inline vector3 Transform::WorldForward() const{
        return GetWorldRotation() * vector3_forward;
    }
 
    inline vector3 Transform::WorldRight() const{
        return GetWorldRotation() * vector3_right;
    }
 
    inline vector3 Transform::WorldUp() const{
        return GetWorldRotation() * vector3_up;
    }
 
    inline Transform& Transform::LocalTranslateDelta(const vector3& delta) {
        //set position value
        position += delta;
        UpdateChildren();
        return *this;
    }
 
    inline Transform& Transform::WorldTranslateDelta(const vector3& delta){
        SetWorldPosition(GetWorldPosition() + delta);
        return *this;
    }
 
    inline Transform& Transform::SetLocalPosition(const vector3& newPos) {
        //set position value
        position = newPos;
        UpdateChildren();
        return *this;
    }
 
    inline Transform& Transform::SetWorldPosition(const vector3& newPos) {
        if (!HasParent()) {
            SetLocalPosition(newPos);
        }
        else {
            //get the world position 
            auto worldpos = GetWorldPosition();
            //get the displacement to the new world coords from the current local position
            auto displacement = newPos - worldpos;
            //update the local pos to that displacement
            LocalTranslateDelta(displacement);
        }
        return *this;
    }
 
    inline Transform& Transform::SetLocalRotation(const quaternion& newRot) {
        rotation = newRot;
        UpdateChildren();
        return *this;
    }
 
    inline Transform& Transform::LocalRotateDelta(const quaternion& delta) {
        // sum two quaternions by multiplying them
        rotation *= delta;
        UpdateChildren();
        return *this;
    }
 
    inline Transform& Transform::SetWorldRotation(const quaternion& newRot) {
        if (!HasParent()) {
            SetLocalRotation(newRot);
        }
        else {
            //get world rotation
            auto worldRot = GetWorldRotation();
            //get the relative world offset
            auto relative = glm::inverse(worldRot) * newRot;
            //apply the rotation
            LocalRotateDelta(relative);
        }
        return *this;
    }
 
    inline Transform& Transform::SetLocalScale(const vector3& newScale) {
        scale = newScale;
        UpdateChildren();
        return *this;
    }
 
    inline Transform& Transform::LocalScaleDelta(const vector3& delta) {
        scale += delta;
        UpdateChildren();
        return *this;
    }
 
    inline vector3 Transform::GetLocalPosition() const
    {
        return position;
    }
 
    inline quaternion Transform::GetLocalRotation() const
    {
        return rotation;
    }
 
    inline vector3 Transform::GetLocalScale() const
    {
        return scale;
    }
 
 
    inline matrix4 Transform::GetMatrix() const {
        return matrix;
    }
 
    inline vector3 Transform::GetWorldPosition() const
    {
        if (!HasParent()) {
            return GetLocalPosition();
        }
        
        return GetParentSpaceMatrix() * vector4(GetLocalPosition(),1);
    }
 
    inline quaternion Transform::GetWorldRotation() const
    {
        if (!HasParent()) {
            return GetLocalRotation();
        }
        
        auto finalMatrix = GetParentSpaceMatrix() * glm::toMat4(GetLocalRotation());
        
        return glm::quat_cast(finalMatrix);
    }
}