class HexagonalField;

/*
 * ta premier class Hexagone
 * qui represente l'hexagone x,y de ton terrain
 */
class Hexagone
{
    public:
        Hexagone(Hexagonnal *_root, int x, int y) : root(_root)
        {
            /*
             * position des vertices de ton hexagone (exemple tu adaptera)
             * tu peut également utiliser des irr::video::S3DVertex2TCoord si tu nécéssite deux uvmap
             */
            vertices.push_back(irr::video::S3DVertex(x,0,y+0.5 , 0,1,0, irr::video::SColor(255,255,255), u, v));
            vertices.push_back(irr::video::S3DVertex(x,0,y-0.5 , 0,1,0, irr::video::SColor(255,255,255), u, v));
            vertices.push_back(irr::video::S3DVertex(x+0.3,0,y+0.3, 0,1,0, irr::video::SColor(255,255,255), u, v));
            vertices.push_back(irr::video::S3DVertex(x-0.3,0,y+0.3, 0,1,0, irr::video::SColor(255,255,255), u, v));
            vertices.push_back(irr::video::S3DVertex(x-0.3,0,y-0.3, 0,1,0, irr::video::SColor(255,255,255), u, v));
            vertices.push_back(irr::video::S3DVertex(x+0.3,0,y-0.3, 0,1,0, irr::video::SColor(255,255,255), u, v));
            
            boundingbox.reset(vertices[i].Pos);
            for(unsigned char i = 1; i<vertices.size(); ++i)
                boundingbox.addInternalPoint(vertices[i].Pos);
        }
        bool isHit(irr::video::line3df a)
        {
            if(boundingbox.intersectsWithLine(a))
            {
                /**
                 * tu fait deux 'plane' avec les vertices {{0,1,2,3} et {2,3,4,5}}
                 * tu fait un test :
                 * 
                 * if(plance[0].intersetWithLine(a) || plance[1].intersetWithLine(a)) return true;
                 * return false;
                 */
                return false;
            }
            return false;
        }
        void setTextureCoord(irr::core::vector2d<irr::f32> i)
        {
            /*
             * calculate texture coordination by given vector to vertex coord
             * 
             * il te faudras définir un type de texture approprier,
             * une texture qui contiendras dans la même image plusieur texture sous forme de tableau
             * pour que cela reste simple au niveaux du calcule tu represente chaque image de la même taille
             * 
             */
            
            vertices[0].TCoords.X = 0;  vertices[0].TCoords.Y = 0;
            vertices[1].TCoords.X = 0;  vertices[1].TCoords.Y = 0;
            vertices[2].TCoords.X = 0;  vertices[2].TCoords.Y = 0;
            vertices[3].TCoords.X = 0;  vertices[3].TCoords.Y = 0;
            vertices[4].TCoords.X = 0;  vertices[4].TCoords.Y = 0;
            vertices[5].TCoords.X = 0;  vertices[5].TCoords.Y = 0;
            
            root->updateMesh();
        }
    public:
        irr::core::array<irr::video::S3DVertex> vertices;
        irr::core::aabbox3df boundingbox;
        HexagonalField *root;
};
/*
 * c'est un exemple après il te faudras, pour bien faire
 * dérivé ta class HexagonalField de irr::scene::ISceneNode
 */
class HexagonalField // public : irr::scene::ISceneNode
{
    public:
        HexagonalField(int _x, _y) : height(_y), width(_x)
        {
            mesh = new irr::scene::SMeshBuffer();
            field = new Hexagone[height*width+1];
            for(int y = 0; y<height; ++y)
            {
                for(int x = 0; x<width; ++x)
                {
                    field[y*width+x] = new Hexagone(x,y);
                }
            }
            updateMesh();
        }
        Hexagone *select(int x, int y)
        {
            return field[y*width+x};
        }
        Hexagone *select(irr::core::line3df a)
        {
            for(int y = 0; y<height; ++y)
            {
                for(int x = 0; x<width; ++x)
                {
                    if(field[y*width+x]->isHit(a))
                      return field[y*width+x];
                }
            }
            return 0;
        }
        void updateMesh()
        {
            mesh->Vertices.clear();
            mesh->Indices.clear();
            unsigned long index = 0;
            for(int y = 0; y<height; ++y)
            {
                for(int x = 0; x<width; ++x)
                {
                    for(unsigned char i =0; i<field[y*width+x]; ++i)
                        mesh->Vertices.push_back(field[y*width+x].vertices[i]);
                    
                    //if you use quad
                    mesh->Indices.push_back(index);
                    mesh->Indices.push_back(index++);
                    mesh->Indices.push_back(index++);
                    mesh->Indices.push_back(index++);
                    mesh->Indices.push_back(index--);
                    mesh->Indices.push_back(index++);
                    mesh->Indices.push_back(index++);
                    mesh->Indices.push_back(index++);
                    index++;
                }
            }
            mesh->setDirty();
        }
    protected:
        Hexagone *field;
        irr::scene::SMeshBuffer *mesh;
        int width, height;
};