coordinates.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_GEOM_COORDINATES_HPP
#define ANTKEEPER_GEOM_COORDINATES_HPP
 
#include <engine/geom/primitives/point.hpp>
#include <bit>
#include <cstdint>
#include <cmath>
 
namespace geom {
 
enum class triangle_region: std::uint8_t
{
    abc = 0b000,
    
    ab  = 0b100,
    
    bc  = 0b001,
    
    ca  = 0b010,
    
    a   = 0b110,
    
    b   = 0b101,
    
    c   = 0b011
};
 
[[nodiscard]] inline constexpr bool is_face_region(triangle_region region) noexcept
{
    return !static_cast<bool>(region);
}
 
[[nodiscard]] inline constexpr bool is_edge_region(triangle_region region) noexcept
{
    return std::has_single_bit(static_cast<std::uint8_t>(region));
}
 
[[nodiscard]] inline constexpr bool is_vertex_region(triangle_region region) noexcept
{
    return static_cast<bool>(region) && !std::has_single_bit(static_cast<std::uint8_t>(region));
}
 
[[nodiscard]] inline constexpr std::uint8_t edge_index(triangle_region region) noexcept
{
    return static_cast<std::uint8_t>(region) & std::uint8_t{0b11};
}
 
[[nodiscard]] inline constexpr std::uint8_t vertex_index(triangle_region region) noexcept
{
    return std::uint8_t{3} - (static_cast<std::uint8_t>(region) >> 1);
}
 
template <class T>
[[nodiscard]] constexpr triangle_region barycentric_to_region(const point<T, 3>& p) noexcept
{
    std::uint8_t region = static_cast<std::uint8_t>(p.x() <= T{0});
    region |= static_cast<std::uint8_t>(p.y() <= T{0}) << std::uint8_t{1};
    region |= static_cast<std::uint8_t>(p.z() <= T{0}) << std::uint8_t{2};
    return static_cast<triangle_region>(region);
}
 
template <class T>
[[nodiscard]] inline constexpr point<T, 3> barycentric_to_cartesian(const point<T, 3>& p, const point<T, 3>& a, const point<T, 3>& b, const point<T, 3>& c) noexcept
{
    return a * p.x() + b * p.y() + c * p.z();
}
 
template <class T>
[[nodiscard]] constexpr point<T, 3> cartesian_to_barycentric(const point<T, 3>& p, const point<T, 3>& a, const point<T, 3>& b, const point<T, 3>& c) noexcept
{
    point<T, 3> uvw;
    
    // Cross product version:
    const auto ab = b - a;
    const auto ca = a - c;
    const auto ap = p - a;
    const auto n = math::cross(ab, ca);
    const auto d = math::sqr_length(n);
    const auto q = math::cross(n, ap);
    uvw.z() = math::dot(q, ab) / d;
    uvw.y() = math::dot(q, ca) / d;
    uvw.x() = T{1} - uvw.y() - uvw.z();
    
    // Dot product version:
    // const auto ab = b - a;
    // const auto ac = c - a;
    // const auto ap = p - a;
    // const auto ab_dot_ab = math::dot(ab, ab);
    // const auto ab_dot_ac = math::dot(ab, ac);
    // const auto ac_dot_ac = math::dot(ac, ac);
    // const auto ap_dot_ab = math::dot(ap, ab);
    // const auto ap_dot_ac = math::dot(ap, ac);
    // const auto d = ab_dot_ab * ac_dot_ac - ab_dot_ac * ab_dot_ac;
    // uvw.z() = (ab_dot_ab * ap_dot_ac - ab_dot_ac * ap_dot_ab) / d;
    // uvw.y() = (ac_dot_ac * ap_dot_ab - ab_dot_ac * ap_dot_ac) / d;
    // uvw.x() = T{1} - uvw.y() - uvw.z();
    
    return uvw;
}
 
template <class T>
[[nodiscard]] point<T, 3> cartesian_to_spherical(const point<T, 3>& p)
{
    const T xx_yy = p.x() * p.x() + p.y() * p.y();
    
    return
    {
        std::sqrt(xx_yy + p.z() * p.z()),
        std::atan2(p.z(), std::sqrt(xx_yy)),
        std::atan2(p.y(), p.x())
    };
}
 
template <class T>
[[nodiscard]] point<T, 3> spherical_to_cartesian(const point<T, 3>& p)
{
    const T x = p.x() * std::cos(p.y());
    
    return
    {
        x * std::cos(p.z()),
        x * std::sin(p.z()),
        p.x() * std::sin(p.y())
    };
}
 
} // namespace geom
 
#endif // ANTKEEPER_GEOM_COORDINATES_HPP