ray.H

Go to the documentation of this file.

#ifndef RAYH
#define RAYH

#include "std/support.H"
#include "mlib/points.H"
#include "disp/gel.H"

class APPEAR;
#define CRAYhit const RAYhit
class RAYhit {
  protected:
   int       _s;
   mlib::Wpt       _p;
   mlib::Wvec      _v;
   int       _is_surf;
   double    _d;
   double    _d_2d;
   mlib::Wpt       _nearpt;
   GELptr    _g;
   mlib::Wvec      _n;
   mlib::Wpt       _surfl;
   int       _uv_valid;
   int       _visibility;
   mlib::XYpt      _uv;
   APPEAR   *_appear;
   int       _tolerance;
   int       _from_camera;

  public:
   RAYhit(mlib::CWpt  &p, mlib::CWvec &v):_s(false), _p(p), _v(v.normalized()),
                              _is_surf(0),
                              _d(-1),_d_2d(-1), _uv_valid(0), _visibility(1),
                              _appear(0), _tolerance(12),_from_camera(0) {}
   RAYhit(mlib::CWpt  &a, mlib::CWpt  &b):_s(false), _p(a), _v((b-a).normalized()),
                              _is_surf(0),
                              _d(-1),_d_2d(-1), _uv_valid(0), _visibility(1),
                              _appear(0), _tolerance(12),_from_camera(0) {}
   RAYhit(mlib::CXYpt &p);
   virtual ~RAYhit() {}

   RAYhit    copy        () const         { return RAYhit(point(),vec()); }
   int       success     () const         { return _s; }
   mlib::Wpt       point       () const         { return _p; }
   mlib::Wvec      vec         () const         { return _v; }
   mlib::Wline     line        () const         { return mlib::Wline(_p, _v); }
   mlib::XYpt      screen_point() const;
   int       from_camera () const         { return _from_camera; }
   RAYhit    invert      (mlib::CWpt &) const;

   // These make sense iff _s is true
   double    dist        () const         { return _d; }
   mlib::Wplane    plane       () const         { return mlib::Wplane(surf(), norm()); }
   mlib::Wpt       surf        () const         { return _is_surf ? _p + _d*_v : _nearpt; } 
   mlib::Wpt       surfl       () const         { return _surfl; } 
   mlib::Wvec      norm        () const         { return _n; }
   CGELptr  &geom        () const         { return _g; }
   mlib::CXYpt    &uv          () const         { return _uv;}
   APPEAR   *appear      () const         { return _appear; }
   int       get_vis     () const         { return _visibility; }
   int       get_tol     () const         { return _tolerance; }

   void      set_vis     (int  vis)       { _visibility = vis; }
   void      set_tol     (int  pixels)    { _tolerance = pixels; }
   void      set_norm    (mlib::CWvec    &n)    { _n = n; }
   void      set_geom    (CGELptr  &g)    { _g = g;}
   void      set_uv      (mlib::CXYpt    &uv)   { _uv = uv;}

   static  STAT_STR_RET static_name()      { RET_STAT_STR("RAYhit"); }
   virtual STAT_STR_RET class_name () const{ return static_name(); }
   virtual int          is_of_type(Cstr_ptr &t)const { return IS(t); }
   static  int          isa       (CRAYhit &r)       { return ISA((&r)); }

   void      clear       (void);
   int       test        (double, int, double);
   virtual void check    (double, int, double, CGELptr &, mlib::CWvec &,
                          mlib::CWpt &, mlib::CWpt &, APPEAR *a, mlib::CXYpt &);
};

#define CRAYnear const RAYnear
class RAYnear {
  protected:
   int     _s;
   mlib::Wpt     _p;
   mlib::Wvec    _v;
   double  _d;
   double  _d_for_geom;
   GELptr  _g;

  public:
   RAYnear(mlib::CWpt &p, mlib::CWvec &v):_s(false), _p(p), _v(v.normalized()),
                                     _d_for_geom(-1) {}
   RAYnear(mlib::CWpt &a, mlib::CWpt &b):_s(false), _p(a), _v((b-a).normalized()),
                                     _d_for_geom(-1) {}
   RAYnear(mlib::CXYpt    &p);

   int     success     () const                  { return _s; }
   mlib::Wpt     point       () const                  { return _p; }
   mlib::Wvec    vec         () const                  { return _v; }
   double  dist        () const                  { return _d; }
   CGELptr&geom        () const                  { return _g; }

   void    set_geom    (CGELptr &g)              { _g = g; }

   void    clear       (void);
   void    check       (double d, CGELptr &g);
   void    check_geom  (double d, CGELptr &g);
};

inline int operator == (CRAYhit  &r, int b)  { return r.success() == b; }
inline int operator == (CRAYnear &r, int b)  { return r.success() == b; }

template <class T>
inline T* 
ray_geom(CRAYhit& ray, T* init) 
{
   return T::upcast(ray.geom());
}

template <class T>
inline T* 
ray_geom(CRAYnear& ray, T* init) 
{
   return T::upcast(ray.geom());
}

/*****************************************************************
 * GEL_list:
 *****************************************************************/
template <class T>
inline RAYhit& 
GEL_list<T>::intersect(RAYhit& r, mlib::CWtransf& m) const 
{
   for (int i=0; i<num(); i++)
      (*this)[i]->intersect(r, m);
   return r;
}

#endif

---