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

#include "Intersectable.h"
#include "SimpleRay.h"
//#include "ktbconf.h"

using namespace std;

#if _WIN32
#define ALIGN16 __declspec(align(16))
#else
ALIGN16 GALIGN16
#endif

namespace GtpVisibilityPreprocessor {


// This is the result of computing intersection
// static data member
  ALIGN16  IntersectionStr
  SimpleRay::IntersectionRes[32];

Intersectable::Intersectable(): 
mMailbox(0), 
mBvhLeaf(0), 
mVssRays(NULL),
mRenderedFrame(0)
#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";
        case TRANSFORMED_MESH_INSTANCE:
                return "transformed mesh instance";
        case SPHERE:
                return "sphere";
        case VIEW_CELL:
                return "view cell";
        case OGRE_MESH_INSTANCE:
                return "ogre_mesh_instance";
        case KD_INTERSECTABLE:
                return "kd";
        case TRIANGLE_INTERSECTABLE:
                return "triangle";
        case BVH_INTERSECTABLE:
                return "bvh";
        default:
                return "unknown";
        }
}

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


}