ImathSphere.h

//
// SPDX-License-Identifier: BSD-3-Clause
// Copyright Contributors to the OpenEXR Project.
//
 
//
// A 3D sphere class template
//
 
#ifndef INCLUDED_ATOMSMATHSPHERE_H
#define INCLUDED_ATOMSMATHSPHERE_H
 
#include <AtomsMath/ImathBox.h>
#include <AtomsMath/ImathLine.h>
#include <AtomsMath/ImathNamespace.h>
#include <AtomsMath/ImathVec.h>
 
ATOMSMATH_INTERNAL_NAMESPACE_HEADER_ENTER
 
 
template <class T> class Sphere3
{
  public:
 
    
    Vec3<T> center;
 
    T radius;
 
 
 
    ATOMSMATH_HOSTDEVICE constexpr Sphere3() : center (0, 0, 0), radius (0) {}
 
    ATOMSMATH_HOSTDEVICE constexpr Sphere3 (const Vec3<T>& c, T r) : center (c), radius (r) {}
 
    
    
    ATOMSMATH_HOSTDEVICE void circumscribe (const Box<Vec3<T>>& box);
 
    
    
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool
    intersect (const Line3<T>& l, Vec3<T>& intersection) const;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool intersectT (const Line3<T>& l, T& t) const;
 
};
 
typedef Sphere3<float> Sphere3f;
 
typedef Sphere3<double> Sphere3d;
 
//---------------
// Implementation
//---------------
 
template <class T>
inline void
Sphere3<T>::circumscribe (const Box<Vec3<T>>& box)
{
    center = T (0.5) * (box.min + box.max);
    radius = (box.max - center).length();
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 bool
Sphere3<T>::intersectT (const Line3<T>& line, T& t) const
{
    bool doesIntersect = true;
 
    Vec3<T> v = line.pos - center;
    T B       = T (2.0) * (line.dir ^ v);
    T C       = (v ^ v) - (radius * radius);
 
    // compute discriminant
    // if negative, there is no intersection
 
    T discr = B * B - T (4.0) * C;
 
    if (discr < 0.0)
    {
        // line and Sphere3 do not intersect
 
        doesIntersect = false;
    }
    else
    {
        // t0: (-B - sqrt(B^2 - 4AC)) / 2A  (A = 1)
 
        T sqroot = std::sqrt (discr);
        t        = (-B - sqroot) * T (0.5);
 
        if (t < 0.0)
        {
            // no intersection, try t1: (-B + sqrt(B^2 - 4AC)) / 2A  (A = 1)
 
            t = (-B + sqroot) * T (0.5);
        }
 
        if (t < 0.0)
            doesIntersect = false;
    }
 
    return doesIntersect;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 bool
Sphere3<T>::intersect (const Line3<T>& line, Vec3<T>& intersection) const
{
    T t (0);
 
    if (intersectT (line, t))
    {
        intersection = line (t);
        return true;
    }
    else
    {
        return false;
    }
}
 
ATOMSMATH_INTERNAL_NAMESPACE_HEADER_EXIT
 
#endif // INCLUDED_ATOMSMATHSPHERE_H