source: GTP/trunk/Lib/Vis/Preprocessing/src/InternalRayCaster.cpp @ 1876

#include "InternalRayCaster.h"
#include "VssRay.h"
#include "KdTree.h"
#include "Preprocessor.h"

#define DEBUG_RAYCAST 0


namespace GtpVisibilityPreprocessor {


InternalRayCaster::InternalRayCaster(const Preprocessor &preprocessor, KdTree *kdTree):
RayCaster(preprocessor), mKdTree(kdTree)
{
}


InternalRayCaster::~InternalRayCaster()
{
}


int InternalRayCaster::CastRay(const SimpleRay &simpleRay,
                                                           VssRayContainer &vssRays,
                                                           const AxisAlignedBox3 &box,
                                                           const bool castDoubleRay,
                                                           const bool pruneInvalidRays
                                                           )
{
  if (simpleRay.mType == Ray::GLOBAL_RAY)
        return CastGlobalRay(simpleRay, vssRays, box, pruneInvalidRays);
  
  //cout << "internal ray" << endl;
  static Ray ray;
  int hits = 0;
  Intersection hitA(simpleRay.mOrigin), hitB(simpleRay.mOrigin);
  
  // inside test for bounding box
  // enlarge box slightly so the view point fits for sure
  //  AxisAlignedBox3 sbox = box;
  //  sbox.Enlarge(Vector3(-Limits::Small));
  // $$ JB moved here from Validate routine

//   if (!box.IsInside(simpleRay.mOrigin)) {
//      cout<<"out of box "<<simpleRay.mOrigin<<" "<<box<<endl;
//      return 0;
//   }
  
  mPreprocessor.SetupRay(ray, simpleRay.mOrigin, simpleRay.mDirection);
  ray.mFlags &= ~Ray::CULL_BACKFACES;
  
  if (mKdTree->CastRay(ray)) 
        {
          hitA.mObject = ray.intersections[0].mObject;
          hitA.mPoint = ray.Extrap(ray.intersections[0].mT);
          hitA.mNormal = ray.intersections[0].mNormal; 
          //    cout << "hita: " << hitA.mPoint << " !obj: " << hitA.mObject << endl;
        }
  
        mPreprocessor.SetupRay(ray, simpleRay.mOrigin, -simpleRay.mDirection);
        ray.mFlags &= ~Ray::CULL_BACKFACES;
  
  if (castDoubleRay && mKdTree->CastRay(ray)) 
                {
                        hitB.mObject = ray.intersections[0].mObject;
                        hitB.mPoint = ray.Extrap(ray.intersections[0].mT);
                        hitB.mNormal = ray.intersections[0].mNormal;
                }
  
  return ProcessRay(
                                                                                simpleRay,
                                                                                hitA,
                                                                                hitB,
                                                                                vssRays,
                                                                                box,
                                                                                castDoubleRay,
                                                                                pruneInvalidRays
                                                                                );
}


int
InternalRayCaster::CastGlobalRay(const SimpleRay &simpleRay,
                                                                                                                                 VssRayContainer &vssRays,
                                                                                                                                 const AxisAlignedBox3 &box,
                                                                                                                                 const bool pruneInvalidRays
                                                                                                                                 )
{
  static Ray ray;
  int hits = 0;
  mPreprocessor.SetupRay(ray, simpleRay.mOrigin, simpleRay.mDirection);
  
  float tmin, tmax;
  if (!(box.ComputeMinMaxT(ray, &tmin, &tmax) && (tmin < tmax)))
        return 0;
  
  // shift the ray origin to tmin
  //    Vector3 origin = ray.Extrap(tmin);
  //    mPreprocessor.SetupRay(ray, origin, simpleRay.mDirection);
  ray.SetType(Ray::GLOBAL_RAY);
  ray.mFlags &= ~Ray::CULL_BACKFACES;
  

  VssRay *vssRay;
  
  if (mKdTree->CastRay(ray)) {
        // sort intersections
        ray.SortIntersections();
        //      cout<<"I="<<ray.intersections.size()<<endl;
        
        
        Ray::Intersection &hit = ray.intersections[0];
        
        if (DotProd(hit.mNormal, ray.GetDir()) < 0) {
          //      cout<<"F:"<<tmin<<" "<<hit.mT<<endl;
          // insert intial segment
          vssRay = new VssRay(
                                                  ray.Extrap(tmin),
                                                  ray.Extrap(hit.mT),
                                                  NULL,
                                                  hit.mObject,
                                                  mPreprocessor.mPass,
                                                  simpleRay.mPdf
                                                  );

          vssRay->mFlags |= VssRay::Valid;
          vssRays.push_back(vssRay);
          ++hits;
        }
                                
        hit = ray.intersections[ray.intersections.size()-1];
        if (DotProd(hit.mNormal, ray.GetDir()) > 0) {
          //      cout<<"L:"<<tmax<<" "<<hit.mT<<endl;
          
          // insert termination segment
          vssRay = new VssRay(
                                                  ray.Extrap(tmax),
                                                  ray.Extrap(hit.mT),
                                                  NULL,
                                                  hit.mObject,
                                                  mPreprocessor.mPass,
                                                  simpleRay.mPdf
                                                  );
          vssRay->mFlags |= VssRay::Valid;
          vssRays.push_back(vssRay);
          ++hits;
        }
        
        // insert the rest of segments
        for (int i=0; i < ray.intersections.size() - 1; i++) {
          Ray::Intersection &hitA = ray.intersections[i];
          Ray::Intersection &hitB = ray.intersections[i + 1];
          if (hitB.mT - hitA.mT > Limits::Small) {
                if (DotProd(hitA.mNormal, ray.GetDir()) > 0 &&
                        DotProd(hitB.mNormal, ray.GetDir()) < 0
                        ) {
                  
                  vssRay = new VssRay(
                                                          ray.Extrap(hitA.mT),
                                                          ray.Extrap(hitB.mT),
                                                          hitA.mObject,
                                                        hitB.mObject,
                                                          mPreprocessor.mPass,
                                                          simpleRay.mPdf
                                                          );
                  vssRay->mFlags |= VssRay::Valid;
                  vssRays.push_back(vssRay);
                  ++hits;
                  
                  vssRay = new VssRay(
                                                          ray.Extrap(hitB.mT),
                                                          ray.Extrap(hitA.mT),
                                                          hitB.mObject,
                                                          hitA.mObject,
                                                          mPreprocessor.mPass,
                                                          simpleRay.mPdf
                                                          );
                  
                  vssRay->mFlags |= VssRay::Valid;
                  vssRays.push_back(vssRay);
                  ++hits;
                }
          }
        }
  }
  
  return hits;
}

void InternalRayCaster::CastRays16(const int index,
                                                                   SimpleRayContainer &rays, 
                                                                   VssRayContainer &vssRays,
                                                                   const AxisAlignedBox3 &sbox,
                                                                   const bool castDoubleRays,
                                                                   const bool pruneInvalidRays)
{
        const int num = 16;

#if DEBUG_RAYCAST
        Debug << "C16 " << flush;
#endif

        // no acceleration for ray bundles implemented right now
        for (int i = index; i < index + num; i++) 
        {
                CastRay(rays[i], vssRays, sbox, castDoubleRays, pruneInvalidRays);
        }

#if DEBUG_RAYCAST
        Debug<<"C16F\n"<<flush;
#endif
}

}