ImathPlane.h

//
// SPDX-License-Identifier: BSD-3-Clause
// Copyright Contributors to the OpenEXR Project.
//
 
//
// A 3D plane class template
//
 
#ifndef INCLUDED_ATOMSMATHPLANE_H
#define INCLUDED_ATOMSMATHPLANE_H
 
#include <AtomsMath/ImathLine.h>
#include <AtomsMath/ImathNamespace.h>
#include <AtomsMath/ImathVec.h>
 
ATOMSMATH_INTERNAL_NAMESPACE_HEADER_ENTER
 
 
template <class T> class Plane3
{
  public:
 
    
    Vec3<T> normal;
    
    T distance;
 
 
 
    ATOMSMATH_HOSTDEVICE Plane3() noexcept {}
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Plane3 (const Vec3<T>& normal, T distance) noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Plane3 (const Vec3<T>& point, const Vec3<T>& normal) noexcept;
    
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Plane3 (const Vec3<T>& point1,
                                               const Vec3<T>& point2,
                                               const Vec3<T>& point3) noexcept;
 
    
    
    ATOMSMATH_HOSTDEVICE void set (const Vec3<T>& normal, T distance) noexcept;
 
    ATOMSMATH_HOSTDEVICE void set (const Vec3<T>& point, const Vec3<T>& normal) noexcept;
 
    ATOMSMATH_HOSTDEVICE void set (const Vec3<T>& point1, const Vec3<T>& point2, const Vec3<T>& point3) noexcept;
 
    
    
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool
    intersect (const Line3<T>& line, Vec3<T>& intersection) const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool intersectT (const Line3<T>& line, T& parameter) const noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr T distanceTo (const Vec3<T>& point) const noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Vec3<T> reflectPoint (const Vec3<T>& point) const noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Vec3<T> reflectVector (const Vec3<T>& vec) const noexcept;
 
};
 
typedef Plane3<float> Plane3f;
 
typedef Plane3<double> Plane3d;
 
//---------------
// Implementation
//---------------
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline Plane3<T>::Plane3 (const Vec3<T>& p0, const Vec3<T>& p1, const Vec3<T>& p2) noexcept
{
    set (p0, p1, p2);
}
 
template <class T> ATOMSMATH_CONSTEXPR14 inline Plane3<T>::Plane3 (const Vec3<T>& n, T d) noexcept
{
    set (n, d);
}
 
template <class T> ATOMSMATH_CONSTEXPR14 inline Plane3<T>::Plane3 (const Vec3<T>& p, const Vec3<T>& n) noexcept
{
    set (p, n);
}
 
template <class T>
inline void
Plane3<T>::set (const Vec3<T>& point1, const Vec3<T>& point2, const Vec3<T>& point3) noexcept
{
    normal = (point2 - point1) % (point3 - point1);
    normal.normalize();
    distance = normal ^ point1;
}
 
template <class T>
inline void
Plane3<T>::set (const Vec3<T>& point, const Vec3<T>& n) noexcept
{
    normal = n;
    normal.normalize();
    distance = normal ^ point;
}
 
template <class T>
inline void
Plane3<T>::set (const Vec3<T>& n, T d) noexcept
{
    normal = n;
    normal.normalize();
    distance = d;
}
 
template <class T>
constexpr inline T
Plane3<T>::distanceTo (const Vec3<T>& point) const noexcept
{
    return (point ^ normal) - distance;
}
 
template <class T>
constexpr inline Vec3<T>
Plane3<T>::reflectPoint (const Vec3<T>& point) const noexcept
{
    return normal * distanceTo (point) * -2.0 + point;
}
 
template <class T>
constexpr inline Vec3<T>
Plane3<T>::reflectVector (const Vec3<T>& v) const noexcept
{
    return normal * (normal ^ v) * 2.0 - v;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Plane3<T>::intersect (const Line3<T>& line, Vec3<T>& point) const noexcept
{
    T d = normal ^ line.dir;
    if (d == 0.0)
        return false;
    T t   = -((normal ^ line.pos) - distance) / d;
    point = line (t);
    return true;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Plane3<T>::intersectT (const Line3<T>& line, T& t) const noexcept
{
    T d = normal ^ line.dir;
    if (d == 0.0)
        return false;
    t = -((normal ^ line.pos) - distance) / d;
    return true;
}
 
template <class T>
std::ostream&
operator<< (std::ostream& o, const Plane3<T>& plane)
{
    return o << "(" << plane.normal << ", " << plane.distance << ")";
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 Plane3<T>
operator* (const Plane3<T>& plane, const Matrix44<T>& M) noexcept
{
    //                        T
    //                      -1
    //  Could also compute M    but that would suck.
    //
 
    Vec3<T> dir1 = Vec3<T> (1, 0, 0) % plane.normal;
    T dir1Len    = dir1 ^ dir1;
 
    Vec3<T> tmp = Vec3<T> (0, 1, 0) % plane.normal;
    T tmpLen    = tmp ^ tmp;
 
    if (tmpLen > dir1Len)
    {
        dir1    = tmp;
        dir1Len = tmpLen;
    }
 
    tmp    = Vec3<T> (0, 0, 1) % plane.normal;
    tmpLen = tmp ^ tmp;
 
    if (tmpLen > dir1Len)
    {
        dir1 = tmp;
    }
 
    Vec3<T> dir2  = dir1 % plane.normal;
    Vec3<T> point = plane.distance * plane.normal;
 
    return Plane3<T> (point * M, (point + dir2) * M, (point + dir1) * M);
}
 
template <class T>
constexpr inline Plane3<T>
operator- (const Plane3<T>& plane) noexcept
{
    return Plane3<T> (-plane.normal, -plane.distance);
}
 
ATOMSMATH_INTERNAL_NAMESPACE_HEADER_EXIT
 
#endif // INCLUDED_ATOMSMATHPLANE_H