Transform.h

Go to the documentation of this file.

 
#pragma once
 
#include "Component.h"
 
#include "ncmath/MatrixUtilities.h"
 
#include <span>
#include <vector>
 
namespace nc
{
namespace ecs
{
class EcsModule;
}
 
class Transform final : public ComponentBase
{
    public:
        Transform(Entity entity, const Vector3& pos, const Quaternion& rot, const Vector3& scale)
            : ComponentBase(entity),
              m_localMatrix{ComposeMatrix(scale, rot, pos)},
              m_worldMatrix{m_localMatrix}
        {
            NC_ASSERT(!HasAnyZeroElement(scale), "Invalid scale(elements cannot be 0)");
        }
 
        Transform(Entity entity,
                  const Vector3& pos,
                  const Quaternion& rot,
                  const Vector3& scale,
                  DirectX::FXMMATRIX parentTransform)
            : ComponentBase(entity),
              m_localMatrix{ComposeMatrix(scale, rot, pos)},
              m_worldMatrix{m_localMatrix * parentTransform}
        {
            NC_ASSERT(!HasAnyZeroElement(scale), "Invalid scale(elements cannot be 0)");
        }
 
        Transform(Transform&&) = default;
        Transform& operator=(Transform&&) = default;
        ~Transform() = default;
        Transform(const Transform&) = delete;
        Transform& operator=(const Transform&) = delete;
 
        auto Position() const noexcept -> Vector3 { return ToVector3(PositionXM()); }
 
        auto PositionXM() const noexcept -> DirectX::FXMVECTOR { return m_worldMatrix.r[3]; }
 
        auto LocalPosition() const noexcept -> Vector3 { return ToVector3(LocalPositionXM()); }
 
        auto LocalPositionXM() const noexcept -> DirectX::FXMVECTOR { return m_localMatrix.r[3]; }
 
        auto Rotation() const noexcept -> Quaternion { return ToQuaternion(RotationXM()); }
 
        auto RotationXM() const noexcept -> DirectX::XMVECTOR { return DecomposeRotation(m_worldMatrix); }
 
        auto LocalRotation() const noexcept -> Quaternion { return ToQuaternion(LocalRotationXM()); }
 
        auto LocalRotationXM() const noexcept -> DirectX::XMVECTOR { return DecomposeRotation(m_localMatrix); }
 
        auto Scale() const noexcept -> Vector3 { return ToVector3(ScaleXM()); }
 
        auto ScaleXM() const noexcept -> DirectX::XMVECTOR { return DecomposeScale(m_worldMatrix); }
 
        auto LocalScale() const noexcept -> Vector3 { return ToVector3(LocalScaleXM()); }
 
        auto LocalScaleXM() const noexcept -> DirectX::XMVECTOR { return DecomposeScale(m_localMatrix); }
 
        auto TransformationMatrix() const noexcept -> DirectX::FXMMATRIX { return m_worldMatrix; }
 
        auto LocalTransformationMatrix() const noexcept -> DirectX::FXMMATRIX { return m_localMatrix; }
 
        auto ToLocalSpace(const Vector3& vec) const -> Vector3;
 
        auto Up() const noexcept -> Vector3 { return ToVector3(UpXM()); }
 
        auto UpXM() const noexcept -> DirectX::XMVECTOR;
 
        auto Forward() const noexcept -> Vector3 { return ToVector3(ForwardXM()); }
 
        auto ForwardXM() const noexcept -> DirectX::XMVECTOR;
 
        auto Right() const noexcept -> Vector3 { return ToVector3(RightXM()); }
 
        auto RightXM() const noexcept -> DirectX::XMVECTOR;
 
        void Set(const Vector3& pos, const Quaternion& quat, const Vector3& scale);
 
        void Set(const Vector3& pos, const Vector3& angles, const Vector3& scale);
 
        void SetPosition(const Vector3& pos);
 
        void SetRotation(const Quaternion& quat);
 
        void SetRotation(const Vector3& angles);
 
        void SetScale(const Vector3& scale);
 
        void SetPositionAndRotationXM(DirectX::FXMVECTOR position, DirectX::FXMVECTOR orientation)
        {
            const auto scale = DecomposeScale(m_localMatrix);
            m_localMatrix = DirectX::XMMatrixScalingFromVector(scale) *
                            DirectX::XMMatrixRotationQuaternion(orientation);
            m_localMatrix.r[3] = DirectX::XMVectorSetW(position, 1.0f);
            m_dirty = true;
        }
 
        void SetTransformationMatrix(DirectX::FXMMATRIX matrix)
        {
            m_localMatrix = matrix;
            m_dirty = true;
        }
 
        void Translate(const Vector3& vec);
 
        void Translate(DirectX::FXMVECTOR translation);
 
        void TranslateLocalSpace(const Vector3& vec);
 
        void Rotate(const Quaternion& quat);
 
        void Rotate(DirectX::FXMVECTOR quaternion);
 
        void Rotate(const Vector3& axis, float radians);
 
        void RotateAround(const Vector3& point, const Vector3& axis, float radians);
 
        void LookAt(const Vector3& target);
 
    private:
        friend class ecs::EcsModule;
        bool m_dirty = false;
        DirectX::XMMATRIX m_localMatrix;
        DirectX::XMMATRIX m_worldMatrix;
 
        auto IsDirty() const noexcept
        {
            return m_dirty;
        }
 
        void UpdateWorldMatrix()
        {
            m_dirty = false;
            m_worldMatrix = m_localMatrix;
        }
 
        void UpdateWorldMatrix(DirectX::FXMMATRIX parentMatrix)
        {
            m_dirty = false;
            m_worldMatrix = m_localMatrix * parentMatrix;
        }
};
} //end namespace nc