transform.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2023  Christopher J. Howard
 *
 * This file is part of Antkeeper source code.
 *
 * Antkeeper source code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Antkeeper source code is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Antkeeper source code.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef ANTKEEPER_MATH_TRANSFORM_HPP
#define ANTKEEPER_MATH_TRANSFORM_HPP
 
#include <engine/math/vector.hpp>
#include <engine/math/quaternion.hpp>
#include <engine/math/matrix.hpp>
 
namespace math {
 
template <class T>
struct transform
{
    using scalar_type = T;
    
    using vector_type = vec3<T>;
    
    using quaternion_type = quat<T>;
    
    using matrix_type = mat4<T>;
    
    vector_type translation;
    
    quaternion_type rotation;
    
    vector_type scale;
    
    [[nodiscard]] constexpr explicit operator matrix_type() const noexcept
    {
        matrix_type matrix = matrix_type(quaternion_type::matrix_type(rotation));
        
        matrix[0][0] *= scale[0];
        matrix[0][1] *= scale[0];
        matrix[0][2] *= scale[0];
        
        matrix[1][0] *= scale[1];
        matrix[1][1] *= scale[1];
        matrix[1][2] *= scale[1];
        
        matrix[2][0] *= scale[2];
        matrix[2][1] *= scale[2];
        matrix[2][2] *= scale[2];
        
        matrix[3][0] = translation[0];
        matrix[3][1] = translation[1];
        matrix[3][2] = translation[2];
        
        return matrix;
    }
    
    [[nodiscard]] inline constexpr matrix_type matrix() const noexcept
    {
        return matrix_type(*this);
    }
    
    /*
     * Type-casts the transform scalars using `static_cast`.
     *
     * @tparam U Target scalar type.
     *
     * @return Type-casted transform.
     */
    template <class U>
    [[nodiscard]] inline constexpr explicit operator transform<U>() const noexcept
    {
        return {vec3<U>(translation), quat<U>(rotation), vec3<U>(scale)};
    }
    
    [[nodiscard]] static inline constexpr transform identity() noexcept
    {
        return {vector_type::zero(), quaternion_type::identity(), vector_type::one()};
    }
};
 
template <class T>
[[nodiscard]] transform<T> inverse(const transform<T>& t) noexcept;
 
template <class T>
[[nodiscard]] transform<T> mul(const transform<T>& x, const transform<T>& y);
 
template <class T>
[[nodiscard]] constexpr vector<T, 3> mul(const transform<T>& t, const vector<T, 3>& v) noexcept;
 
template <class T>
[[nodiscard]] constexpr vector<T, 3> mul(const vector<T, 3>& v, const transform<T>& t) noexcept;
 
template <class T>
transform<T> inverse(const transform<T>& t) noexcept
{
    return {-t.translation * t.rotation, conjugate(t.rotation), T{1} / t.scale};
}
 
template <class T>
transform<T> mul(const transform<T>& x, const transform<T>& y)
{
    return
    {
        mul(x, y.translation),
        normalize(x.rotation * y.rotation),
        x.scale * y.scale
    };
}
 
template <class T>
constexpr vector<T, 3> mul(const transform<T>& t, const vector<T, 3>& v) noexcept
{
    return t.translation + t.rotation * (t.scale * v);
}
 
template <class T>
inline constexpr vector<T, 3> mul(const vector<T, 3>& v, const transform<T>& t) noexcept
{
    return mul(inverse(t), v);
}
 
namespace operators {
 
template <class T>
[[nodiscard]] inline math::transform<T> operator*(const math::transform<T>& x, const math::transform<T>& y)
{
    return mul(x, y);
}
 
template <class T>
[[nodiscard]] inline constexpr math::vec3<T> operator*(const math::transform<T>& t, const math::vec3<T>& v) noexcept
{
    return mul(t, v);
}
 
template <class T>
[[nodiscard]] inline constexpr math::vec3<T> operator*(const math::vec3<T>& v, const math::transform<T>& t) noexcept
{
    return mul(v, t);
}
 
template <class T>
inline math::transform<T>& operator*=(math::transform<T>& x, const math::transform<T>& y)
{
    return (x = x * y);
}
 
} // namespace operators
 
} // namespace math
 
// Bring transform operators into global namespace
using namespace math::operators;
 
#endif // ANTKEEPER_MATH_TRANSFORM_HPP