source: GTP/trunk/Lib/Vis/Preprocessing/src/Intersectable.cpp @ 2231

#include "Intersectable.h"

using namespace std;


namespace GtpVisibilityPreprocessor {


Intersectable::Intersectable(): 
mMailbox(0), 
mBvhLeaf(0), 
mVssRays(NULL) 
#if STORE_VIEWCELLS_WITH_BVH
, mViewCells(NULL)
#endif
{}


Intersectable::~Intersectable() 
{
        DEL_PTR(mVssRays);
}


string Intersectable::GetTypeName(Intersectable *obj)
{
        switch(obj->Type())
        {
        case MESH_INSTANCE:
                return "mesh_instance\n";

        case TRANSFORMED_MESH_INSTANCE:
                return "transformed_mesh_instance\n";

        case SPHERE:
                return "sphere\n";

        case VIEW_CELL:
                return "view cell\n";

        case OGRE_MESH_INSTANCE:
                return "ogre_mesh_instance\n";

        case KD_INTERSECTABLE:
                return "kd_intersectable\n";

        default:
                return "unknown\n";
        }
}

  
Vector3 Intersectable::GetNormal(const int idx) const 
{ 
        return Vector3(0, 0, 0); 
}


VssRayContainer *Intersectable::GetOrCreateRays() 
{ 
        if (!mVssRays)
                mVssRays = new VssRayContainer();

        return mVssRays;
}

#if STORE_VIEWCELLS_WITH_BVH

ViewCellContainer *Intersectable::GetOrCreateViewCells() 
{ 
        if (!mViewCells)
                mViewCells = new ViewCellContainer();

        return mViewCells;
}


void Intersectable::DelViewCells()
{
        DEL_PTR(mViewCells);
}

#endif


void Intersectable::DelRayRefs()
{
        DEL_PTR(mVssRays);
}


int Intersectable::GenerateSilhouetteRays(const int nrays,
                                                                                  const AxisAlignedBox3 &originBox,
                                                                                  const AxisAlignedBox3 &directionBox, 
                                                                                  VssRayContainer &rays) 
{
        return 0;
}


int Intersectable::GetRandomSurfacePoint(const float u,
                                                                                 const float v,
                                                                                 Vector3 &point,
                                                                                 Vector3 &normal) 
{
        cerr << "GetRandomSurfacePoint(u,v...) not yet implemented for type " << Type() << endl;
        return 1;
}


bool Intersectable::GreaterCounter(const Intersectable *a,
                                                                   const Intersectable *b) 
{
        return a->mCounter > b->mCounter;
}


float Intersectable::GetArea() const 
{
        cerr << "GetArea not implemented yet for this type" << endl;
        return 0; 
}


}