matrix4.hpp

Go to the documentation of this file.

#pragma once

 
#include <array>
#include <cstddef>
 
#include "orrery/core/vec3.hpp"
 
namespace orrery::viz {

struct Vec4 {
    float x{};
    float y{};
    float z{};
    float w{};
 
    [[nodiscard]] constexpr bool operator==(const Vec4&) const = default;
};

struct Mat4 {
    std::array<float, 16> values{};
 
    [[nodiscard]] constexpr float element(std::size_t row, std::size_t column) const noexcept {
        return values[(column * 4) + row];
    }
 
    [[nodiscard]] constexpr bool operator==(const Mat4&) const = default;
};
 
[[nodiscard]] constexpr Mat4 identity() noexcept {
    return Mat4{{1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1}};
}

[[nodiscard]] constexpr Mat4 operator*(const Mat4& a, const Mat4& b) noexcept {
    Mat4 product;
    for (std::size_t column = 0; column < 4; ++column) {
        for (std::size_t row = 0; row < 4; ++row) {
            float sum = 0;
            for (std::size_t index = 0; index < 4; ++index) {
                sum += a.element(row, index) * b.element(index, column);
            }
            product.values[(column * 4) + row] = sum;
        }
    }
    return product;
}
 
[[nodiscard]] constexpr Vec4 operator*(const Mat4& matrix, const Vec4& vector) noexcept {
    const std::array<float, 4> in{vector.x, vector.y, vector.z, vector.w};
    std::array<float, 4> out{};
    for (std::size_t row = 0; row < 4; ++row) {
        for (std::size_t column = 0; column < 4; ++column) {
            out[row] += matrix.element(row, column) * in[column];
        }
    }
    return {out[0], out[1], out[2], out[3]};
}

[[nodiscard]] constexpr Vec4 homogeneous(core::Vec3 point) noexcept {
    return {static_cast<float>(point.x), static_cast<float>(point.y), static_cast<float>(point.z),
            1};
}

[[nodiscard]] Mat4 look_at(core::Vec3 eye, core::Vec3 centre, core::Vec3 up) noexcept;

[[nodiscard]] Mat4 perspective(float vertical_field_of_view, float aspect_ratio, float near,
                               float far) noexcept;
 
} // namespace orrery::viz