#ifndef RAY_H
#define RAY_H RAY_H

#include "Vector.h"
#include <iostream>

class Ray
{
    public:
        Ray()
        {
        }

        Ray(const Vector & origin, const Vector & direction)
            : m_origin(origin), m_direction(direction)
        {
            m_direction.normalize();
        }

        /*
         * return a vector for the point at distance dist
         * from the ray's origin point, along its direction.
         */
        Vector getPositionAt(double dist) const
        {
            return Vector(
                    m_origin[0] + dist * m_direction[0],
                    m_origin[1] + dist * m_direction[1],
                    m_origin[2] + dist * m_direction[2]);
        }

        Ray shift(double amt)
        {
            return Ray(getPositionAt(amt), m_direction, false);
        }

        const Vector & getOrigin() const { return m_origin; }
        const Vector & getDirection() const { return m_direction; }

        static Ray randomRay();
        Vector operator[](double dist) const { return getPositionAt(dist); }

    protected:
        Ray(const Vector & origin, const Vector & direction, bool no_norm)
            : m_origin(origin), m_direction(direction)
        {
            /* no normalize version */
        }

        Vector  m_origin;
        Vector  m_direction;
};

std::ostream & operator<<(std::ostream & out, const Ray & r);

#endif