sphere.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_MATH_SPHERE_1310040710_HPP
#define OGLPLUS_MATH_SPHERE_1310040710_HPP

#include <oglplus/math/vector.hpp>

#include <cassert>
#include <type_traits>

namespace oglplus {


template <typename T>
class Sphere
{
private:
    Vector<T, 3> _center;
    T _radius;
public:
    Sphere(void)
     : _center(T(0))
     , _radius(T(1))
    { }


    Sphere(T x, T y, T z, T r)
     : _center(x, y, z)
     , _radius(r)
    {
        assert(_radius >= T(0));
    }


    Sphere(const Vector<T, 3>& position, T radius)
     : _center(position)
     , _radius(radius)
    {
        assert(_radius >= T(0));
    }

    template <typename U>
    Sphere(const Sphere<U>& that)
     : _center(that.Center())
     , _radius(that.Radius())
    {
        assert(_radius >= T(0));
    }

    const Vector<T, 3>& Center(void) const
    {
        return _center;
    }

    void Center(const Vector<T, 3>& position)
    {
        _center = position;
    }

    void Translate(const Vector<T, 3>& offset)
    {
        _center += offset;
    }

    void Transform(const Matrix<T, 4, 4>& matrix)
    {
        _center = (matrix * Vector<T, 4>(_center, 1)).xyz();
    }

    bool Degenerate(void) const
    {
        return _radius == T(0);
    }


    T Radius(void) const
    {
        return _radius;
    }


    void Radius(T radius)
    {
        assert(_radius >= T(0));
        _radius = radius;
    }


    void Grow(T amount)
    {
        assert(amount >= T(0));
        _radius += amount;
    }


    void Shrink(T amount)
    {
        assert(amount >= T(0));
        assert(amount <= Radius());
        _radius -= amount;
    }


    void Scale(T amount)
    {
        assert(amount >= T(0));
        _radius *= amount;
    }


    T Diameter(void) const
    {
        return 2*Radius();
    }

#if OGLPLUS_DOCUMENTATION_ONLY
    friend bool Intersecting(const Sphere& a, const Sphere& b);
#endif

    bool IntersectsWith(const Sphere& that) const
    {
        T d = this->_radius + that._radius;
        return Distance(this->_center, that._center) < d;
    }
};

#if OGLPLUS_DOCUMENTATION_ONLY || defined(GL_FLOAT)
typedef Sphere<GLfloat> Spheref;
#endif

template <typename T>
bool Intersecting(const Sphere<T>& a, const Sphere<T>& b)
{
    return a.IntersectsWith(b);
}

} // namespace oglplus

#endif // include guard