Unnamed

#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)->getVertexCount();
	const void* pVertices =  mesh->getMesh(0)->getMeshBuffer(0)->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);
    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
{

}