MRPlane3.h

Go to the documentation of this file.

#pragma once
 
#include "MRVector3.h"
 
#include <iosfwd>
#if MR_HAS_REQUIRES
#include "MRVectorTraits.h"
#include <concepts>
#endif
 
namespace MR
{
 
 
template <typename T>
struct Plane3
{
    Vector3<T> n;
    T d = 0;
 
    constexpr Plane3() noexcept = default;
    constexpr Plane3( const Vector3<T> & n, T d ) noexcept : n( n ), d( d ) { }
 
    template <typename U> MR_REQUIRES_IF_SUPPORTED( !std::is_same_v<T, U> )
    constexpr explicit Plane3( const Plane3<U> & p ) noexcept : n( p.n ), d( T( p.d ) ) { }
 
    [[nodiscard]] constexpr static Plane3 fromDirAndPt( const Vector3<T> & n, const Vector3<T> & p ) { return { n, dot( n, p ) }; }
 
    [[nodiscard]] T distance( const Vector3<T> & x ) const { return dot( n, x ) - d; }
 
    [[nodiscard]] Plane3 operator -() const { return Plane3( -n, -d ); }
    [[nodiscard]] const Plane3 & operator +() const { return *this; }
    [[nodiscard]] Plane3 normalized() const
    {
        const auto len = n.length();
        if ( len <= 0 )
            return {};
        const auto rlen = 1 / len;
        return Plane3{ rlen * n, rlen * d };
    }
 
    [[nodiscard]] Vector3<T> project( const Vector3<T> & p ) const { return p - distance( p ) / n.lengthSq() * n; }
 
    friend std::ostream& operator<<( std::ostream& s, const Plane3& pl )
    {
        return s << pl.n << '\n' << pl.d;
    }
 
    friend std::istream& operator>>( std::istream& s, Plane3& pl )
    {
        return s >> pl.n >> pl.d;
    }
};
 
 
template <typename T>
[[nodiscard]] inline Plane3<T> invTransformed( const Plane3<T> & pl, const AffineXf3<T> & ixf )
{
    return Plane3<T>{ ixf.A.transposed() * pl.n, pl.d - dot( pl.n, ixf.b ) };
}
 
template <typename T>
MR_REQUIRES_IF_SUPPORTED( VectorTraits<T>::size == 1 ) 
[[nodiscard]] inline Plane3<T> transformed( const Plane3<T> & plane, const AffineXf3<T> & xf )
{
    return invTransformed( plane, xf.inverse() );
}
 
template <typename T>
[[nodiscard]] inline bool operator == ( const Plane3<T> & a, const Plane3<T> & b )
{
    return a.n == b.n && a.d == b.d;
}
 
template <typename T>
[[nodiscard]] inline bool operator != ( const Plane3<T> & a, const Plane3<T> & b )
{
    return !( a == b );
}
 
 
}