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

#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