math.hpp

Go to the documentation of this file.

#pragma once
#if defined(__clang__)
// TODO
#elif defined(__GNUC__) || defined(__GNUG__)
// TODO
#elif defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 6001)  // Using uninitialized memory 'variable'.
#pragma warning(disable : 6287)  // Redundant code: the left and right subexpressions are identical
#pragma warning(disable : 26495) // Variable 'variable' is uninitialized. Always initialize a member variable (type.6).
#endif
 
#include "math/mat.hpp"
#include "math/ray.hpp"
#include "math/intersection.hpp"
#include "math/triangle.hpp"
#include "math/plane.hpp"
#include "math/box.hpp"
#include "math/quaternion.hpp"
#include "math/sphere.hpp"
#include "math/random.hpp"
 
namespace mal_math
{
    namespace numbers = ::std::numbers;
    
    template <AnyVec Vector>
    [[nodiscard]] constexpr vec<Vector::size, std::remove_const_t<typename Vector::type>> reflect(Vector const &normal, Vector const &incident) noexcept
    {
        return incident - 2.0f * dot(normal, incident) * normal;
    }
    [[nodiscard]] constexpr vec<Vector::size, std::remove_const_t<typename Vector::type>> reflect(Vector const &normal, Vector const &incident) noexcept {…}
    
    template <AnyVec Vector>
    [[nodiscard]] constexpr vec<Vector::size, std::remove_const_t<typename Vector::type>> refract(Vector const &normal, Vector const &incident, float eta) noexcept
    {
        auto const cos_theta = dot(normal, incident);
        auto const r_out_perp = eta * (incident - cos_theta * normal);
        auto const r_out_parallel = -std::sqrt(std::abs(1.0f - squared_length(r_out_perp))) * normal;
        return r_out_perp + r_out_parallel;
    }
    [[nodiscard]] constexpr vec<Vector::size, std::remove_const_t<typename Vector::type>> refract(Vector const &normal, Vector const &incident, float eta) noexcept {…}
} // namespace mal_math
 
namespace std {
    template <size_t size_x, typename vector_type>
    struct hash<mal_math::vec<size_x, vector_type>> {
        [[nodiscard]] constexpr size_t operator()(mal_math::vec<size_x, vector_type> const &v) const noexcept {
            size_t seed = 0;
            for (auto const &e : v.data) {
                seed ^= std::hash<vector_type>{}(e)+0x9e3779b9 + (seed << 6) + (seed >> 2);
            }
            return seed;
        }
        [[nodiscard]] constexpr size_t operator()(mal_math::vec<size_x, vector_type> const &v) const noexcept {…}
    };
    struct hash<mal_math::vec<size_x, vector_type>> {…};
    template <size_t size_x, size_t size_y, typename matrix_type>
    struct hash<mal_math::mat<size_x, size_y, matrix_type>> {
        [[nodiscard]] constexpr size_t operator()(mal_math::mat<size_x, size_y, matrix_type> const &m) const noexcept {
            size_t seed = 0;
            for (auto const &e : m.data) {
                seed ^= std::hash<matrix_type>{}(e)+0x9e3779b9 + (seed << 6) + (seed >> 2);
            }
            return seed;
        }
        [[nodiscard]] constexpr size_t operator()(mal_math::mat<size_x, size_y, matrix_type> const &m) const noexcept {…}
    };
    struct hash<mal_math::mat<size_x, size_y, matrix_type>> {…};
    template<typename quaternion_type>
    struct hash<mal_math::qua<quaternion_type>> {
        [[nodiscard]] constexpr size_t operator()(mal_math::qua<quaternion_type> const &q) const noexcept {
            size_t seed = 0;
            for (auto const &e : q.data) {
                seed ^= std::hash<quaternion_type>{}(e)+0x9e3779b9 + (seed << 6) + (seed >> 2);
            }
            return seed;
        }
        [[nodiscard]] constexpr size_t operator()(mal_math::qua<quaternion_type> const &q) const noexcept {…}
    };
    struct hash<mal_math::qua<quaternion_type>> {…};
} // namespace std
#if defined(__clang__)
// TODO
#elif defined(__GNUC__) || defined(__GNUG__)
// TODO
#elif defined(_MSC_VER)
#pragma warning(pop)
#endif