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

#ifndef _RayCaster_H__
#define _RayCaster_H__

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

//


namespace GtpVisibilityPreprocessor {


class Intersectable;
class VssRay;
class SimpleRayContainer;
class AxisAlignedBox3;
//class Vector3;
struct VssRayContainer;
class Preprocessor;
struct SimpleRay;


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

public:
        
        enum {
          INTERNAL_RAYCASTER = 0,
          INTEL_RAYCASTER
        };

        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);

  /*virtual void CastRaysEye4(SimpleRayContainer &rays,
                                                          VssRayContainer &vssRays,
                                                          const AxisAlignedBox3 &sbox,
                                                          const bool castDoubleRay,
                                                          const bool pruneInvalidRays = true) = 0;
*/
        virtual void
        SortRays(SimpleRayContainer &rays);


  // pool of vss rays to be used in one pass of the sampling
  struct VssRayPool {
        VssRayPool(): mRays(NULL), mIndex(0), mNumber(0) 
        {}

        ~VssRayPool() 
        {
                DEL_PTR(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;
};


}

#endif