source: GTP/trunk/Lib/Vis/Preprocessing/src/RayCaster.h @ 2621

#ifndef _RayCaster_H__
#define _RayCaster_H__


#include "Containers.h"
#include <string>
#include <iostream>
#include "Vector3.h"
#include "VssRay.h"

using namespace std;

//


namespace GtpVisibilityPreprocessor {


class Intersectable;
class VssRay;
class SimpleRayContainer;
class AxisAlignedBox3;
struct VssRayContainer;
class Preprocessor;
struct SimpleRay;
class RayPacket2x2;
class Matrix4x4;

/** This class provides an interface for ray casting.
*/
class RayCaster
{

public:
        
  enum {
    INTERNAL_RAYCASTER = 0,
    INTEL_RAYCASTER = 1,
    HAVRAN_RAYCASTER = 2
  };

  RayCaster(const Preprocessor &preprocessor);

  virtual ~RayCaster();
  
  virtual int Type() const = 0;

  /** Wrapper for casting single ray.
      @returns ray or NULL if invalid
  */
  VssRay *CastRay(const SimpleRay &simpleRay,
                  const AxisAlignedBox3 &box,
                  const bool castDoubleRay);

  virtual int CastRay(const SimpleRay &simpleRay,
                      VssRayContainer &vssRays,
                      const AxisAlignedBox3 &box,
                      const bool castDoubleRay,
                      const bool pruneInvalidRays = true) = 0;

  virtual void CastRays16(SimpleRayContainer &rays,
                          VssRayContainer &vssRays,
                          const AxisAlignedBox3 &sbox,
                          const bool castDoubleRay,
                          const bool pruneInvalidRays = true) = 0;
  
  virtual void CastRays(
                        SimpleRayContainer &rays,
                        VssRayContainer &vssRays,
                        const AxisAlignedBox3 &sbox,
                        const bool castDoubleRay,
                        const bool pruneInvalidRays = true);

  // Using packet of 4 rays supposing that these are coherent
  virtual void CastRaysPacket4(Vector3 origin4[],
                               Vector3 direction4[],
                               int     result4[],
                               float   dist4[]) {  }

  // Using packet of 4 rays supposing that these are coherent
  // We give a box to which each ray is clipped to before the
  // ray shooting is computed !
  virtual void CastRaysPacket4(const Vector3 &minBox,
                                                           const Vector3 &maxBox,
                                                           const Vector3 origin4[],
                                                           const Vector3 direction4[],
                                                           int result4[],
                                                           float dist4[]) {  }
  
  // Just for testing concept
  virtual void CastRaysPacket2x2(RayPacket2x2 &raysPack,
                                 bool castDoubleRay,
                                 const bool pruneInvalidRays = true)
  { }
  
  /*virtual void CastRaysEye4(SimpleRayContainer &rays,
    VssRayContainer &vssRays,
    const AxisAlignedBox3 &sbox,
    const bool castDoubleRay,
    const bool pruneInvalidRays = true) = 0;
  */

  virtual void
  SortRays(SimpleRayContainer &rays);


  virtual void AddDynamicObjecs(const ObjectContainer &objects, const Matrix4x4 &m) = 0;
  virtual void UpdateDynamicObjects(const Matrix4x4 &m) = 0;
  virtual void DeleteDynamicObjects() = 0;

  // pool of vss rays to be used in one pass of the sampling
  struct VssRayPool 
  {
    VssRayPool(): mRays(NULL), mIndex(0), mNumber(0) 
    {}
    
    ~VssRayPool() 
    {
      delete []mRays;
    }
    
    void Reserve(const int number) 
    {
      DEL_PTR(mRays);
      mRays = new VssRay[number];
      mNumber = number;
    }
    
    void Clear() 
    {
      mIndex = 0;
    }
    
    VssRay *Alloc() 
    {
      // reset pool
      if (mIndex == mNumber)
        mIndex = 0;
      return mRays + mIndex ++;
    }
  protected:
    VssRay *mRays;
    int mIndex;
    int mNumber;
  };


  VssRayPool mVssRayPool;
  
  void ReserveVssRayPool(const int n) 
  {
    mVssRayPool.Reserve(n);
  }
  
  void InitPass() 
  {
    mVssRayPool.Clear();
  }
  
  
protected:
  
  VssRay *RequestRay(const Vector3 &origin, 
                     const Vector3 &termination, 
                     Intersectable *originObject, 
                     Intersectable *terminationObject, 
                     const int pass, 
                     const float pdf);
  
  void _SortRays(SimpleRayContainer &rays,
                 const int l,
                 const int r,
                 const int depth,
                 float box[12]);
  
  struct Intersection
  {
    Intersection(): mObject(NULL), mFaceId(0)
    {}
    
    Intersection(const Vector3 &p, const Vector3 &n, Intersectable *o, const int f):
      mPoint(p), mNormal(n), mObject(o), mFaceId(f)
    {}
    
    Intersection(const Vector3 &p): mPoint(p), mObject(NULL), mFaceId(0)
    {}
    
    
    ////////////
    
    Vector3 mPoint;
    Vector3 mNormal;
    Intersectable *mObject;
    int mFaceId;
  };


  int ProcessRay(const SimpleRay &ray,
                 Intersection &hitA,
                 Intersection &hitB,
                 VssRayContainer &vssRays,
                 const AxisAlignedBox3 &box,
                 const bool castDoubleRay,
                 const bool pruneInvalidRays = true);
  
  /** Checks if ray is valid.
      I.e., the ray is in valid view space.
      @note: clamps the ray to valid view space.
  */
  bool ValidateRay(const Vector3 &origin,
                   const Vector3 &direction,
                   const AxisAlignedBox3 &box,
                   Intersection &hit);
  
  bool ClipToViewSpaceBox(const Vector3 &origin,
                          const Vector3 &termination,
                          Vector3 &clippedOrigin,
                          Vector3 &clippedTermination);
  
  const Preprocessor &mPreprocessor;
#if 1
public:
  // Added by VH for debugging
  Intersection intersect;
#endif  
};


}

#endif