BOX.CPP - code.stephan-brumme.com

studies/grafik2/Computergrafik-Code6/Aufgabe17/BOX.CPP
⇒ download file

       1 #include "box.h"

       2 

       3 Box::Box(const Vector& llf,const Vector& urb) : llf_(llf), urb_(urb) {    

       4 }

       5 

       6 

       7 const Vector& Box::getLLF() const { return llf_; }

       8 

       9 void Box::setLLF(const Vector& v) { llf_ = v; }

      10 

      11 const Vector& Box::getURB() const { return urb_; }

      12 

      13 void Box::setURB(const Vector& n) { urb_ = n; }

      14 

      15 inline double max(double x, double y) {

      16     return (x<y) ? y : x;

      17 }

      18 inline double min(double x, double y) {

      19     return (x>y) ? y : x;

      20 }

      21 

      22 bool Box::intersect(const Ray& ray,Vector& point,Vector& normal, double& distance) const {

      23     const static Vector NormalRight(+1,0,0);

      24     const static Vector NormalLeft (-1,0,0);

      25     const static Vector NormalUp   (0,+1,0);

      26     const static Vector NormalDown (0,-1,0);

      27     const static Vector NormalFront(0,0,+1);

      28     const static Vector NormalBack (0,0,-1);

      29 

      30     // ray origin

      31     const Vector origin = ray.getOrigin();

      32     // ray direction

      33     const Vector direction = ray.getDirection();

      34 

      35 

      36     // ray enters box (-infinity)

      37     double tnear = -999999999999;

      38     // ray leaves box (+infinity)

      39     double tfar  = +999999999999;

      40 

      41 

      42     /////////////////////////////////////////////////////////

      43     // x

      44     const double& ox = origin[0];

      45     const double& rx = direction[0];

      46 

      47     // parallel to box ?

      48     if (rx == 0)

      49         if (ox < llf_[0] || ox > urb_[0])

      50             return false;

      51 

      52     // intersections

      53     const double tx1 = (llf_[0] - ox) / rx;

      54     const double tx2 = (urb_[0] - ox) / rx;

      55 

      56     // adjust tnear and tfar

      57     if (tx2 > tx1 && tx1 > tnear)

      58     {

      59         tnear  = tx1;

      60         normal = NormalLeft;

      61     }

      62     if (tx1 > tx2 && tx2 > tnear)

      63     {

      64         tnear = tx2;

      65         normal = NormalRight;

      66     }

      67 

      68     // ray doesn't hit box ?

      69     tfar = min(tfar, max(tx1, tx2));

      70     if (tnear > tfar || tfar < 0)

      71         return false;

      72     

      73 

      74     /////////////////////////////////////////////////////////

      75     // y

      76     const double& oy = origin[1];

      77     const double& ry = direction[1];

      78 

      79     // parallel to box ?

      80     if (ry == 0)

      81         if (oy < llf_[1] || oy > urb_[1])

      82             return false;

      83 

      84     // intersections

      85     const double ty1 = (llf_[1] - oy) / ry;

      86     const double ty2 = (urb_[1] - oy) / ry;

      87 

      88     // adjust tnear and tfar

      89     if (ty2 > ty1 && ty1 > tnear)

      90     {

      91         tnear  = ty1;

      92         normal = NormalDown;

      93     }

      94     if (ty1 > ty2 && ty2 > tnear)

      95     {

      96         tnear  = ty2;

      97         normal = NormalUp;

      98     }

      99 

     100     // ray doesn't hit box ?

     101     tfar = min(tfar, max(ty1, ty2));

     102     if (tnear > tfar || tfar < 0)

     103         return false;

     104 

     105 

     106     /////////////////////////////////////////////////////////

     107     // z

     108     const double& oz = origin[2];

     109     const double& rz = direction[2];

     110 

     111     // parallel to box ?

     112     if (rz == 0)

     113         if (oz < llf_[2] || oz > urb_[2])

     114             return false;

     115 

     116     // intersections

     117     const double tz1 = (llf_[2] - oz) / rz;

     118     const double tz2 = (urb_[2] - oz) / rz;

     119 

     120     // adjust tnear and tfar

     121     if (tz2 > tz1 && tz1 > tnear)

     122     {

     123         tnear  = tz1;

     124         normal = NormalBack;

     125     }

     126     if (tz1 > tz2 && tz2 > tnear)

     127     {

     128         tnear  = tz2;

     129         normal = NormalFront;

     130     }

     131 

     132     // ray doesn't hit box ?

     133     tfar = min(tfar, max(tz1, tz2));

     134     if (tnear > tfar || tfar < 0)

     135         return false;

     136 

     137 

     138     // intersection finally found !!!

     139     point  = ray.getOrigin() + tnear*ray.getDirection();

     140     distance = tnear;//abs(point-ray.getOrigin());

     141 

     142     // done !

     143     return true;

     144 }

     145