Sphere.h

//  trax track library
//  AD 2013 
//
//  "And the arms of the ocean are carrying me"
//
//              Florence + the Machine
//
// Copyright (c) 2025 Trend Redaktions- und Verlagsgesellschaft mbH
// Copyright (c) 2019 Marc-Michael Horstmann
//
// Permission is hereby granted to any person obtaining a copy of this software 
// and associated source code (the "Software"), to use, view, and study the 
// Software for personal or internal business purposes, subject to the following 
// conditions:
//
// 1. Redistribution, modification, sublicensing, or commercial use of the 
// Software is NOT permitted without prior written consent from the copyright 
// holder.
//
// 2. The Software is provided "AS IS", without warranty of any kind, express 
// or implied.
//
// 3. All copies of the Software must retain this license notice.
//
// For further information, please contact: horstmann.marc@trendverlag.de
 
#pragma once
 
#include "Position.h"
 
namespace spat{
 
    template<typename> struct Box;
    template<typename,typename> struct VectorBundle;
    
    template<typename Valtype>
    struct Sphere
    {
        typedef Valtype value_type;
 
        Position<Valtype>   c;  
        Valtype             r;  
 

        Sphere() noexcept = default;            
        Sphere( const Position<Valtype>& center, Valtype radius ) noexcept;
 

        void Init() noexcept;
 

        Position<Valtype> Center() const noexcept;
 

        Valtype Radius() const noexcept;
 

        bool Includes( Valtype x, Valtype y, Valtype z ) const noexcept;
 

        bool Includes( const Position<Valtype>& pt ) const noexcept;
 

        Box<Valtype> ExBox() const noexcept;
 

        Box<Valtype> InBox() const noexcept;
    };

    template<typename Valtype>
    bool    operator==( const Sphere<Valtype> a, const Sphere<Valtype> b ) noexcept;
    template<typename Valtype>
    bool    operator!=( const Sphere<Valtype> a, const Sphere<Valtype> b ) noexcept;

    template<typename Valtype>
    bool Intersecting( const Sphere<Valtype>& sphereA, const Sphere<Valtype>& sphereB ) noexcept;
 
    template<typename Valtype,typename ValtypeT>
    bool Intersecting( const Sphere<Valtype>& sphere, const VectorBundle<Valtype,ValtypeT>& ray ) noexcept;

template<typename Valtype> inline 
Sphere<Valtype>::Sphere( const Position<Valtype>& center, Valtype radius ) noexcept
    :   c{center},
        r{radius}
{}
 
template<typename Valtype> inline 
void Sphere<Valtype>::Init() noexcept{
    c.Init();
    r = static_cast<Valtype>(1);
}
 
template<typename Valtype> inline 
Position<Valtype> Sphere<Valtype>::Center() const noexcept{
    return c;
}
 
template<typename Valtype> inline 
Valtype Sphere<Valtype>::Radius() const noexcept{
    return r;
}
 
template<typename Valtype> inline 
bool Sphere<Valtype>::Includes( Valtype x, Valtype y, Valtype z ) const noexcept{
    return Includes( { x, y, z } );
}
 
template<typename Valtype> inline 
bool Sphere<Valtype>::Includes( const Position<Valtype>& pt ) const noexcept{
    return (pt - c).Length() < r;
}
 
template<typename Valtype> inline 
Box<Valtype> Sphere<Valtype>::ExBox() const noexcept{
    return Box<Valtype>( 
        c.x - r, c.y - r, c.z - r,
        c.x + r, c.y + r, c.z + r );
}
 
template<typename Valtype> inline 
Box<Valtype> Sphere<Valtype>::InBox() const noexcept{
    Valtype a = r / std::sqrt(3);
    return Box<Valtype>( 
        c.x - a, c.y - a, c.z - a,
        c.x + a, c.y + a, c.z + a );
}
 
template<typename Valtype> inline 
bool operator==( const Sphere<Valtype> a, const Sphere<Valtype> b ) noexcept{
    return a.Center() == b.Center() && a.Radius() == b.Radius();
}
 
template<typename Valtype> inline 
bool operator!=( const Sphere<Valtype> a, const Sphere<Valtype> b ) noexcept{
    return !(a == b);
}
 
template<typename Valtype>
bool Intersecting( const Sphere<Valtype>& sphereA, const Sphere<Valtype>& sphereB ) noexcept{
    return (sphereA.Center() - sphereB.Center()).Length() < sphereA.Radius() + sphereB.Radius();
}
 
template<typename Valtype,typename ValtypeT>
bool Intersecting( const Sphere<Valtype>& sphere, const VectorBundle<Valtype,ValtypeT>& ray ) noexcept{
    const Vector<Valtype> D = sphere.Center() - ray.P;
    return (D - (D*ray.T) * ray.T).Length() < sphere.Radius();
}
 
} // namespace spat