#ifndef __CLevelSceneNode__
#define __CLevelSceneNode__

#include <irrlicht.h>

using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;

struct SNode
{
    f32 ix,iy,iz;
    aabbox3d<f32>* box;
    scene::SMeshBuffer* buffer;
};

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

      virtual ~CLevelSceneNode();

      virtual void render();

      virtual const core::aabbox3d<irr::f32>& getBoundingBox() const;
      /*
      //Type Return
      virtual ESCENE_NODE_TYPE getType() { return ESNT_CAMERA; }
      */
      private:
      SNode* nodes;
      scene::IAnimatedMesh* mesh;
	  core::aabbox3d<f32> Box;
	  video::SMaterial Material;

	  u16 totalNodes;


    /*  video::S3DVertex* getVertex(scene::IMeshBuffer* mb,u32 index)
			{
				if (mb->getVertexType()== video::EVT_STANDARD) return &Vertices_Standard[index];
				if (mb->getVertexType()== video::EVT_TANGENTS) return (video::S3DVertex*)&Vertices_Tangents[index];
				return (video::S3DVertex*)&Vertices_2TCoords[index];
			}

*/
};

#endif


//////////////////
#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(0)->getIndexCount();
	const void* pVertices =  mesh->getMesh(0)->getMeshBuffer(0)->getVertices();
	const u16* indices =  mesh->getMesh(0)->getMeshBuffer(0)->getIndices();
    video::E_VERTEX_TYPE vType = mesh->getMesh(0)->getMeshBuffer(0)->getVertexType();

     const S3DVertex* Vertices = (const S3DVertex*)pVertices;
    u16 x,y,z;
    u16 nodeID = 0;
    u16 vcounty;
    u16 vcountyy;
    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.0f,1.0f,1.0f))* 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;

                   u32 triangleCounter = 4;
                   u32 t;
                   u32 nv;
u16 IndexN;
                   for(t=0;t<verticesC;t++)
                   {
                        if(nodes[nodeID].box->isPointInside(Vertices[indices[t]].Pos))
                        {vcountyy+=1;  printf("%d\n",nodeID);IndexN++;
                        /*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[indices[t-2]]);
                                nodes[nodeID].buffer->Vertices.push_back(Vertices[indices[t-1]]);
                                nodes[nodeID].buffer->Vertices.push_back(Vertices[indices[t]]);
                                nodes[nodeID].buffer->Indices.push_back(IndexN);
                                nodes[nodeID].buffer->Indices.push_back(IndexN+1);
                                nodes[nodeID].buffer->Indices.push_back(IndexN+2);
                                t+=0;vcounty+=3;
                                triangleCounter+=0;
                                break;

                            case 1:
                                nodes[nodeID].buffer->Vertices.push_back(Vertices[indices[t]]);
                                nodes[nodeID].buffer->Vertices.push_back(Vertices[indices[t+1]]);
                                nodes[nodeID].buffer->Vertices.push_back(Vertices[indices[t+2]]);
                                nodes[nodeID].buffer->Indices.push_back(IndexN);
                                nodes[nodeID].buffer->Indices.push_back(IndexN+1);
                                nodes[nodeID].buffer->Indices.push_back(IndexN+2);
                                t+=2;vcounty+=3;
                                triangleCounter+=2;
                                break;

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

                      nodeID+=1;

               }
           }
    }

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

    printf("%d\n",verticesC);
    printf("%d\n",vcountyy);
}

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<(totalNodes);i++)
    {
    //printf("d");

    printf("%u \n",nodes[i].buffer->DisplayListId);
    driver->drawMeshBuffer(nodes[i].buffer);
    driver->draw3DBox(*nodes[i].box,video::SColor(5,5,5,5));
    //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
{

}