source: GTP/trunk/Lib/Vis/Preprocessing/src/KdIntersectable.h @ 1314

#ifndef __KDINTERSECTABLE_H
#define __KDINTERSECTABLE_H

#include "AxisAlignedBox3.h"
#include "Intersectable.h"


namespace GtpVisibilityPreprocessor {

struct VssRayContainer;
class KdNode;
class BvhNode;
struct Face;


/**
        Wrapper used for creating a PVS compliant intersectable.
*/
template<typename T>
class IntersectableWrapper: public Intersectable
{
public:
        IntersectableWrapper(T *item);

        /** Returns node associated with this instance. 
        */
        T *GetItem() const;

        /** See get.
        */
        void SetItem(T *item);

        //-- inherited functions from Intersectable

        AxisAlignedBox3 GetBox() const;
        
        int CastRay(Ray &ray);
        
        bool IsConvex() const;
        bool IsWatertight() const;
        float IntersectionComplexity();
  
        int NumberOfFaces() const;
        //int Type() const;

        int GetRandomSurfacePoint(GtpVisibilityPreprocessor::Vector3 &point, 
                                                          GtpVisibilityPreprocessor::Vector3 &normal);

        int GetRandomVisibleSurfacePoint(GtpVisibilityPreprocessor::Vector3 &point,
                                                                         GtpVisibilityPreprocessor::Vector3 &normal,
                                                                         const GtpVisibilityPreprocessor::Vector3 &viewpoint,
                                                                         const int maxTries);
  
        ostream &Describe(ostream &s);
        

protected:
        
        T *mItem;
};


template<typename T>
IntersectableWrapper<T>::IntersectableWrapper(T *item):
Intersectable(), mItem(item)
{
}

template<typename T>
void IntersectableWrapper<T>::SetItem(T *item)
{
        mItem = item;
}

template<typename T>
T *IntersectableWrapper<T>::GetItem() const
{ 
        return mItem; 
}
        
template<typename T>
AxisAlignedBox3 IntersectableWrapper<T>::GetBox() const
{       // TODO matt
        return AxisAlignedBox3();
}

template<typename T>
int IntersectableWrapper<T>::CastRay(Ray &ray)
{       // TODO matt
        return 0;
}
        
template<typename T>
bool IntersectableWrapper<T>::IsConvex() const
{
        return true;
}

template<typename T>
bool IntersectableWrapper<T>::IsWatertight() const
{
        return true;
}

template<typename T>
float IntersectableWrapper<T>::IntersectionComplexity()
{
        return 1.0f;
}

template<typename T>
int IntersectableWrapper<T>::NumberOfFaces() const
{
        return 0;
}

template<typename T>
int IntersectableWrapper<T>::GetRandomSurfacePoint(Vector3 &point,
                                                                                                Vector3 &normal)
{
        return 0;
}

template<typename T>
int IntersectableWrapper<T>::GetRandomVisibleSurfacePoint(Vector3 &point,
                                                                                                           Vector3 &normal,
                                                                                                           const Vector3 &viewpoint,
                                                                                                           const int maxTries)
{
        return 0;
}
  
template<typename T>
ostream &IntersectableWrapper<T>::Describe(ostream &s)
{
        s << mItem;
        return s;
}


class KdIntersectable: public IntersectableWrapper<KdNode>
{
public:
        KdIntersectable(KdNode *item):
        IntersectableWrapper<KdNode>(item) {}

        int Type() const
        {
                return Intersectable::KD_INTERSECTABLE;
        }
};


class BvhIntersectable: public IntersectableWrapper<BvhNode>
{
public:
        BvhIntersectable(BvhNode *item):
        IntersectableWrapper<BvhNode>(item) {}

        int Type() const
        {
                return Intersectable::BVH_INTERSECTABLE;
        }
};

class FaceIntersectable: public IntersectableWrapper<Face>
{
public:
        FaceIntersectable(Face *item):
        IntersectableWrapper<Face>(item) {}

        int Type() const
        {
                return Intersectable::FACE_INTERSECTABLE;
        }
};


}

#endif