Ray.h

#ifndef RAY_H
#define RAY_H


/*
** ---------------------------------------------------------------
** Includes:
*/
#include "Polygon.h"
#include "Vector3.h"
#include "Vector4.h"

/*
** ---------------------------------------------------------------
** Definitions:
*/


class Ray {

private :

        Vector3 o, d;
public:
        Ray(void);
        Ray(const Vector3 &o,const Vector3 &d);

        //Vector3 & origin();
        Vector3 origin() const;

        //Vector3 & direction();
        Vector3 direction() const;

        Ray unit(void);

        virtual void transform(const AffineTransform &r);

        virtual Real intersect(const Vector4 &h);

        virtual Real intersect(const Triangle &p,const Vector4 &plane)

        
        virtual Inode *intersect(const Triangle &p,const Vector4 &plane);

        static Vector3 ray_point(const Vector3 &r, Real t);

};



inline
Ray::Ray(void)
{
}

inline
Ray::Ray(const Vector3 &o_, const Vector3 &d_)
        : o(o_),
          d(d_)
{
}

/*inline Vector3 &
Ray::origin()
{
        return o;
}
*/

inline Vector3
Ray::origin() const
{
        Vector3 o_(o);
        return o_;
}

/*inline Vector3 &
Ray::direction()
{
        return d;
}
*/

inline Vector3
Ray::direction() const
{
        Vector3 d_(d);
        return d_;
}

inline Ray
Ray::unit(void)
{
  d.unit();
  return *this;
}

inline Vector3
Ray::ray_point(const Ray &r,Real t)
{
  return Vector3(r.origin() + (t*r.direction()));
}

template <typename T>
inline int max3_index(T const& d1,T const& d2,T const& d3)
{
        if (d1 > d2)
                return (d1 > d3)? 1 : 3;
        else
                return (d2 > d3)? 2 : 3;
}       

#endif //RAY_H

---