ray.hh

#ifndef VTESTBED_GEOMETRY_RAY_HH
#define VTESTBED_GEOMETRY_RAY_HH

#include <ostream>

#include <vtestbed/geometry/types.hh>

namespace vtb {

    namespace geometry {

        template <class T, int N>
        class Ray {

        public:
            static constexpr const int dimensions = N;
            using scalar_type = T;
            using value_type = Vertex<T,N>;
            using reference = value_type&;
            using const_reference = const value_type&;

        private:
            value_type _origin{T{}};
            value_type _direction{T{}};

        public:

            Ray() = default;
            Ray(const Ray&) = default;
            Ray& operator=(const Ray&) = default;
            Ray(Ray&&) = default;
            Ray& operator=(Ray&&) = default;
            ~Ray() = default;

            inline explicit
            Ray(const_reference origin, const_reference direction):
            _origin(origin),
            _direction(direction) {}

            inline const_reference
            origin() const noexcept {
                return this->_origin;
            }

            inline const_reference
            direction() const noexcept {
                return this->_direction;
            }

            inline void
            invert() {
                this->_direction = -this->_direction;
            }

            inline bool
            contains(const value_type& c, T eps) const {
                value_type ca = c-origin();
                return !any(abs(cross(ca,direction())) > eps);
            }

            inline friend std::ostream&
            operator<<(std::ostream& out, const Ray& rhs) {
                return out << rhs.origin() << ' ' << rhs.direction();
            }

        };

    }

}

#endif // vim:filetype=cpp