#include "Intersectable.h"
#include "SimpleRay.h"

using namespace std;

#if _WIN32
#define ALIGN16 __declspec(align(16))
#else
#ifdef USE_HAVRAN_RAYCASTER 
#include "ktbconf.h"
#define ALIGN16 GALIGN16
#else
#define ALIGN16
#endif
#endif

namespace GtpVisibilityPreprocessor 
{


int Intersectable::sMailId = 10000;//2147483647;
int Intersectable::sReservedMailboxes = 1;

int Intersectable::sMailId2 = 10000;//2147483647;
int Intersectable::sReservedMailboxes2 = 1;


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


}