Transform.hpp

Go to the documentation of this file.

#pragma once
 
#define GLM_ENABLE_EXPERIMENTAL
 
#include "glm/glm.hpp"
#include "glm/gtc/matrix_transform.hpp"
#include "glm/gtx/quaternion.hpp"
 
#include <glm/gtx/string_cast.hpp>
#include <iostream>
 
namespace Object::Component {
struct Transform {
    Transform(glm::vec3 position = glm::vec3(0), glm::vec3 scale = glm::vec3(1),
              glm::quat rotation = glm::quat(1, 0, 0, 0))
        : _position(position), _scale(scale), _rotation(rotation)
    {
    }
 
    Transform(const Transform &) = default;
    Transform(Transform &&) = default;
 
    Transform &operator=(const Transform &) = default;
    Transform &operator=(Transform &&) = default;
 
    // Getters
    inline const glm::vec3 &GetPosition() const { return _position; }
    inline const glm::vec3 &GetScale() const { return _scale; }
    inline const glm::quat &GetRotation() const { return _rotation; }
 
    // Setters
    void SetPosition(const glm::vec3 &newPosition)
    {
        _dirty = true;
        _position = newPosition;
    }
    void SetPosition(float x, float y, float z)
    {
        _dirty = true;
        _position = glm::vec3(x, y, z);
    }
    void SetScale(const glm::vec3 &newScale)
    {
        _dirty = true;
        _scale = newScale;
    }
    void SetScale(float x, float y, float z)
    {
        _dirty = true;
        _scale = glm::vec3(x, y, z);
    }
    void SetRotation(const glm::quat &newRotation)
    {
        _dirty = true;
        _rotation = newRotation;
    }
    void SetRotation(float x, float y, float z, float w)
    {
        _dirty = true;
        _rotation = glm::quat(w, x, y, z);
    }
 
    glm::vec3 GetForwardVector() const { return glm::normalize(_rotation * glm::vec3(0.0f, 0.0f, 1.0f)); }
 
    glm::vec3 GetRightVector() const { return glm::normalize(_rotation * glm::vec3(1.0f, 0.0f, 0.0f)); }
 
    glm::vec3 GetUpVector() const { return glm::normalize(_rotation * glm::vec3(0.0f, 1.0f, 0.0f)); }
    glm::mat4 ComputeTransformationMatrix() const
    {
        if (_dirty)
        {
            _transformationMatrixCache = _BuildTransformationMatrix();
            _dirty = false;
        }
        return _transformationMatrixCache;
    }
 
  private:
    glm::vec3 _position;
    glm::vec3 _scale;
    glm::quat _rotation;
 
    mutable bool _dirty = true;
    mutable glm::mat4 _transformationMatrixCache = glm::mat4(1.0f);
 
    inline glm::mat4 _BuildTransformationMatrix() const
    {
        glm::mat4 translation = glm::translate(glm::mat4(1.0f), _position);
        glm::mat4 rotationMatrix = glm::mat4_cast(_rotation);
        glm::mat4 scaleMatrix = glm::scale(glm::mat4(1.0f), _scale);
        return translation * rotationMatrix * scaleMatrix;
    }
};
} // namespace Object::Component