#include "COctTreeSceneNodeTriangleSelector.h"
#include "COctTreeSceneNode.h"
#include "OctTree.h"

using namespace irr;
using namespace scene;

COctTreeSceneNodeTriangleSelector::COctTreeSceneNodeTriangleSelector(COctTreeSceneNode* node)
: SceneNode(node)
{
}

COctTreeSceneNodeTriangleSelector::~COctTreeSceneNodeTriangleSelector()
{
}

s32 COctTreeSceneNodeTriangleSelector::getTriangleCount() const
{
    int triangleCount = 0;
    switch (SceneNode->vertexType)
    {
    case video::EVT_STANDARD:
        {
            for ( u32 i=0; i < SceneNode->StdMeshes.size(); ++i )
            {
                triangleCount += SceneNode->StdMeshes[i].Indices.size();
            }
            triangleCount /= 3;
            break;
        }
    case video::EVT_2TCOORDS:
        {
            for ( u32 i=0; i < SceneNode->LightMapMeshes.size(); ++i )
            {
                triangleCount += SceneNode->LightMapMeshes[i].Indices.size();
            }
            triangleCount /= 3;

            break;
        }
    }
    return triangleCount;
}

void COctTreeSceneNodeTriangleSelector::getTriangles(core::triangle3df* triangles, s32 arraySize,
		s32& outTriangleCount, const core::matrix4* transform)
{
    outTriangleCount = 0;
    if ( !arraySize )
        return;

	core::matrix4 mat;

	if (transform)
		mat = (*transform);

	if (SceneNode)
		mat *= SceneNode->getAbsoluteTransformation();

    switch (SceneNode->vertexType)
    {
    case video::EVT_STANDARD:
        {
            for ( u32 i=0; i < SceneNode->StdMeshes.size(); ++i )
            {
                OctTree<video::S3DVertex>::SMeshChunk &mesh = SceneNode->StdMeshes[i];
                for ( u32 t=0; t<mesh.Indices.size(); t+=3 )
                {
                    triangles[outTriangleCount].pointA = mesh.Vertices[ mesh.Indices[t] ].Pos;
                    triangles[outTriangleCount].pointB = mesh.Vertices[ mesh.Indices[t+1] ].Pos;
                    triangles[outTriangleCount].pointC = mesh.Vertices[ mesh.Indices[t+2] ].Pos;
                    mat.transformVect(triangles[outTriangleCount].pointA);
                    mat.transformVect(triangles[outTriangleCount].pointB);
                    mat.transformVect(triangles[outTriangleCount].pointC);

                    if ( ++outTriangleCount >= arraySize )
                        return;
                }
            }
            break;
        }
    case video::EVT_2TCOORDS:
        {
            for ( u32 i=0; i < SceneNode->LightMapMeshes.size(); ++i )
            {
                OctTree<video::S3DVertex2TCoords>::SMeshChunk &mesh = SceneNode->LightMapMeshes[i];
                for ( u32 t=0; t<mesh.Indices.size(); t+=3 )
                {
                    triangles[outTriangleCount].pointA = mesh.Vertices[ mesh.Indices[t] ].Pos;
                    triangles[outTriangleCount].pointB = mesh.Vertices[ mesh.Indices[t+1] ].Pos;
                    triangles[outTriangleCount].pointC = mesh.Vertices[ mesh.Indices[t+2] ].Pos;
                    mat.transformVect(triangles[outTriangleCount].pointA);
                    mat.transformVect(triangles[outTriangleCount].pointB);
                    mat.transformVect(triangles[outTriangleCount].pointC);

                    if ( ++outTriangleCount >= arraySize )
                        return;
                }
            }
            break;
        }
    }
}

void COctTreeSceneNodeTriangleSelector::getTriangles(core::triangle3df* triangles, s32 arraySize, s32& outTriangleCount,
		const core::aabbox3d<f32>& box, const core::matrix4* transform)
{
    outTriangleCount = 0;
    if ( !arraySize )
        return;
	core::matrix4 mat;

	if (SceneNode)
		mat = SceneNode->getAbsoluteTransformation();

	mat.makeInverse();
	core::aabbox3d<f32> invbox = box;
	mat.transformBox(invbox);

	mat.makeIdentity();

	if (transform)
		mat = (*transform);

	if (SceneNode)
		mat *= SceneNode->getAbsoluteTransformation();

    core::aabbox3d<f32> boxTriangle;

	switch(SceneNode->vertexType)
	{
	case video::EVT_STANDARD:
		{
		    SceneNode->StdOctTree->calculatePolys(invbox);
            OctTree<video::S3DVertex>::SIndexData* d =  SceneNode->StdOctTree->getIndexData();

            for ( u32 i=0; i < SceneNode->StdMeshes.size(); ++i )
            {
                OctTree<video::S3DVertex>::SMeshChunk &mesh = SceneNode->StdMeshes[i];

                for ( int t=0; t<d[i].CurrentSize; t+=3 )
                {
                    triangles[outTriangleCount].pointA = mesh.Vertices[ d[i].Indices[t] ].Pos;
                    triangles[outTriangleCount].pointB = mesh.Vertices[ d[i].Indices[t+1] ].Pos;
                    triangles[outTriangleCount].pointC = mesh.Vertices[ d[i].Indices[t+2] ].Pos;

                    boxTriangle.reset(triangles[outTriangleCount].pointA);
                    boxTriangle.addInternalPoint(triangles[outTriangleCount].pointB);
                    boxTriangle.addInternalPoint(triangles[outTriangleCount].pointC);
                    if ( boxTriangle.intersectsWithBox(invbox) )
                    {
                        mat.transformVect(triangles[outTriangleCount].pointA);
                        mat.transformVect(triangles[outTriangleCount].pointB);
                        mat.transformVect(triangles[outTriangleCount].pointC);

                        if ( ++outTriangleCount >= arraySize )
                            return;
                    }
                }
            }

		    break;
		}
    case video::EVT_2TCOORDS:
        {
            SceneNode->LightMapOctTree->calculatePolys(invbox);
            OctTree<video::S3DVertex2TCoords>::SIndexData* d = SceneNode->LightMapOctTree->getIndexData();

            for ( u32 i=0; i < SceneNode->LightMapMeshes.size(); ++i )
            {
                OctTree<video::S3DVertex2TCoords>::SMeshChunk &mesh = SceneNode->LightMapMeshes[i];

                for ( int t=0; t<d[i].CurrentSize; t+=3 )
                {
                    triangles[outTriangleCount].pointA = mesh.Vertices[ d[i].Indices[t] ].Pos;
                    triangles[outTriangleCount].pointB = mesh.Vertices[ d[i].Indices[t+1] ].Pos;
                    triangles[outTriangleCount].pointC = mesh.Vertices[ d[i].Indices[t+2] ].Pos;

                    boxTriangle.reset(triangles[outTriangleCount].pointA);
                    boxTriangle.addInternalPoint(triangles[outTriangleCount].pointB);
                    boxTriangle.addInternalPoint(triangles[outTriangleCount].pointC);
                    if ( boxTriangle.intersectsWithBox(invbox) )
                    {
                        mat.transformVect(triangles[outTriangleCount].pointA);
                        mat.transformVect(triangles[outTriangleCount].pointB);
                        mat.transformVect(triangles[outTriangleCount].pointC);

                        if ( ++outTriangleCount >= arraySize )
                            return;
                    }
                }
            }

            break;
        }
	}
}

void COctTreeSceneNodeTriangleSelector::getTriangles(core::triangle3df* triangles, s32 arraySize,
		s32& outTriangleCount, const core::line3d<f32>& line, const core::matrix4* transform)
{
	core::aabbox3d<f32> box(line.start);
	box.addInternalPoint(line.end);

	// TODO: Could be optimized for line a little bit more.
	COctTreeSceneNodeTriangleSelector::getTriangles(triangles, arraySize, outTriangleCount,	box, transform);
}