#include "irrlicht.h"
#include "CLevelSceneNode.h"

using namespace scene;

CLevelSceneNode::CLevelSceneNode(scene::ISceneNode* parent, scene::ISceneManager* mgr,scene::IAnimatedMesh *mesh,u8 slices)
                         : ISceneNode( parent, mgr)
{

    totalNodes = slices * slices * slices;

    nodes = new SNode[totalNodes];

    core::vector3df minExtent = mesh->getMesh(0)->getBoundingBox().MinEdge;
    core::vector3df maxExtent = mesh->getMesh(0)->getBoundingBox().MaxEdge;
    core::vector3df size = maxExtent - minExtent;
    core::vector3df singleUnit = size/slices;

     u32 verticesC =  mesh->getMesh(0)->getMeshBuffer(1)->getVertexCount();
	const void* pVertices =  mesh->getMesh(0)->getMeshBuffer(1)->getVertices();
     video::E_VERTEX_TYPE vType = mesh->getMesh(0)->getMeshBuffer(0)->getVertexType();

     const S3DVertex* Vertices = (const S3DVertex*)pVertices;
    u16 x,y,z;
    u16 nodeID = 0;
    for(z=0;z<slices;z++)
    {
           for(y=0;y<slices;y++)
           {
               for(x=0;x<slices;x++)
               {
                   core::vector3df currentPt = core::vector3df(x,y,z);
                   core::vector3df minNodeBounds = minExtent + (currentPt* singleUnit);
                   core::vector3df maxNodeBounds = minExtent + ((currentPt+core::vector3df(1,1,1))* singleUnit);

                   core::aabbox3d<f32> currentBB = core::aabbox3d<f32>(minNodeBounds,maxNodeBounds);

                   nodes[nodeID].box = new core::aabbox3d<f32>(minNodeBounds,maxNodeBounds);
                   nodes[nodeID].buffer = new scene::SMeshBuffer();
                   nodes[nodeID].buffer->DisplayList = true;

                   u16 m;

                   u16 triangleCounter = 4;
                   u16 t;
                   u16 nv;

                   for(t=0;t<verticesC;t++)
                   {
                        if(currentBB.isPointTotalInside(Vertices[t].Pos))
                        {
                        /*const S3DVertex* nodeVerts = (const S3DVertex*)nodes[nodeID].buffer->getVertices();
                        nodeVerts = new S3DVertex[verticesC];*/
                        switch(triangleCounter%3)
                        {
                            case 0:
                                nodes[nodeID].buffer->Vertices.push_back(Vertices[t-2]);
                                nodes[nodeID].buffer->Vertices.push_back(Vertices[t-1]);
                                nodes[nodeID].buffer->Vertices.push_back(Vertices[t]);
                                t+=2;
                                triangleCounter+=2;
                                break;

                            case 1:

                                nodes[nodeID].buffer->Vertices.push_back(Vertices[t]);
                                nodes[nodeID].buffer->Vertices.push_back(Vertices[t+1]);
                                nodes[nodeID].buffer->Vertices.push_back(Vertices[t+2]);
                                t+=2;
                                triangleCounter+=2;
                                break;

                            case 2:
                                nodes[nodeID].buffer->Vertices.push_back(Vertices[t-1]);
                                nodes[nodeID].buffer->Vertices.push_back(Vertices[t]);
                                nodes[nodeID].buffer->Vertices.push_back(Vertices[t+1]);
                                t+=2;
                                triangleCounter+=2;
                                break;
                        }
                        }
                        triangleCounter+=1;
                    }


                   nodeID++;
               }
           }
    }

    Material.Wireframe = true;
    Material.Lighting = false;
    Material.MaterialType = video::EMT_SOLID;


}

CLevelSceneNode::~CLevelSceneNode()
{
}


void CLevelSceneNode::render()
{

	video::IVideoDriver* driver = SceneManager->getVideoDriver();
    ICameraSceneNode* camera = SceneManager->getActiveCamera();
    driver->setMaterial(Material);
    driver->setTransform(video::ETS_WORLD, AbsoluteTransformation);



    for(int i=0;i<4*4*4;i++)
    {
    //printf("d");
    printf("%d \n",nodes[i].buffer->getVertexCount());
    driver->drawMeshBuffer(nodes[i].buffer);
    //for(int k=0;k<nodes[i].buffer->getVertexCount();k++)
    //printf("%f \n",nodes[i].buffer->Vertices[k].Pos.X);
    }


}

const core::aabbox3d<irr::f32>& CLevelSceneNode::getBoundingBox() const
{

}