class MC_World {
public:
    MC_World() : vram(ML_vram_adress())
    {
        unsigned int debug0[6]={0,0,0,0,0,0};
        nbPoints=0;
        nbFaces=0;
        nbCubeModels=1;
        nbBlockModels=1;
        nbLoadded=0;
        cubeModels=new MC_CubeModel[nbCubeModels];
        blockModels=new MC_BlockModel[nbBlockModels];
        blockModels[0]=MC_BlockModel(0,debug0,cubeModels);
        loaddedBlocks=0;
        points=0;
        points2D=0;
        faces=0;
    }

    ~MC_World() {delete points;delete faces;delete blockModels;delete cubeModels;}

    void testLoaddChunk(MC_Chunk chunk,Point3D c)
    {
        //faudra faire le test de visibilité l'hors du parcours
        for(int x=0;x<16;++x)
            for(int z=0;z<16;++z)
                for(int y=0;y<16;++y)
                    if(chunk.getBlock(x,y,z)>0) generateBlock(chunk.getBlock(x,y,z)-1,c/*.move(x<<1,y<<1,z<<1)*/,chunk.getOcclusion(x,y,z));
    }

    void generateBlock(unsigned int ID,Point3D pos,unsigned char occ)
    {
        MC_LoaddedBlock *tmp0=new MC_LoaddedBlock[nbLoadded+1];
        for(unsigned int i=0;i<nbLoadded;++i) tmp0[i]=loaddedBlocks[i];
        delete(loaddedBlocks);
        loaddedBlocks=tmp0;

        loaddedBlocks[nbLoadded].IDBlockModel=ID;
        unsigned int nbP=cubeModels[blockModels[ID].getCubeModelID()].getNbPoints();
        unsigned int nbF=cubeModels[blockModels[ID].getCubeModelID()].getNbFaces();
        loaddedBlocks[nbLoadded].refPoints=new unsigned int[nbP];
        loaddedBlocks[nbLoadded].refFaces=new unsigned int[nbF];
        //resize(points,nbPoints,nbPoints+nbP);
        //points=new Point3D[8];
        //points2D=new Point2D[8];
        //points=(Point3D*)realloc(points,(nbPoints+nbP)*sizeof(Point3D));
        //points2D=(Point2D*)realloc(points2D,(nbPoints+nbP)*sizeof(Point2D));

        Point3D *tmp1=new Point3D[nbPoints+nbP];
        for(unsigned int i=0;i<nbPoints;++i) tmp1[i]=points[i];
        [red]delete(points);[/red]
        points=tmp1;

        Point2D *tmp2=new Point2D[nbPoints+nbP];
        for(unsigned int i=0;i<nbPoints;++i) tmp2[i]=points2D[i];
        [red]delete(points2D);[/red]
        points2D=tmp2;

        //resize(faces,nbFaces,nbFaces+nbF);
        //faces=new MC_Lface[6];
        //faces=(MC_Lface*)realloc(faces,(nbFaces+nbF)*sizeof(MC_Lface));

        MC_Lface *tmp3=new MC_Lface[nbFaces+nbF];
        for(unsigned int i=0;i<nbFaces;++i) tmp3[i]=faces[i];
        [red]delete(faces);[/red]
        faces=tmp3;

        for(unsigned int i=0;i<nbP;++i)
        {
            //a optimiser (calcul des points commun aux objets)
            points[nbPoints+i]=(cubeModels[blockModels[ID].getCubeModelID()].getPoint(i))+pos;
            loaddedBlocks[nbLoadded].refPoints[i]=nbPoints+i;
        }
        for(unsigned int i=0;i<nbF;++i)
    if(occ&(1<<i))
        {
            //éventuellement optimiser directement a la création des blocs la gestion des points des faces inutiles par proximité
            MC_Cface tmp=cubeModels[blockModels[ID].getCubeModelID()].getFace(i);
            faces[nbFaces+i].A=tmp.A+nbPoints;
            faces[nbFaces+i].B=tmp.B+nbPoints;
            faces[nbFaces+i].C=tmp.C+nbPoints;
            faces[nbFaces+i].D=tmp.D+nbPoints;
            faces[nbFaces+i].IDT=blockModels[ID].getFaceID(i);
            faces[nbFaces+i].Z=0;
            loaddedBlocks[nbLoadded].refFaces[i]=nbFaces+i;
        }
        nbPoints+=nbP;
        nbFaces+=nbF;
        ++nbLoadded;
    }

    void brutRenderWorld(unsigned char rx,unsigned char ry,unsigned char rz) //rendu de débuggage
    {
        Matrix<float> rot(matrix3D(rx,ry,rz));
        for(unsigned int i=0;i<nbPoints;++i) points2D[i]=to2D(rot.multiply(points[i]));
        vram.fillBuffer(0);
        for(unsigned int j=0;j<nbFaces;++j)
        {
            if(((points2D[faces[j].A].x-points2D[faces[j].B].x)*(points2D[faces[j].C].y-points2D[faces[j].B].y)-(points2D[faces[j].A].y-points2D[faces[j].B].y)*(points2D[faces[j].C].x-points2D[faces[j].B].x))>0)
            {
                //faces[i].Z=
                //test direct vers le buffer
                vram.line(points2D[faces[j].A],points2D[faces[j].B],1);
                vram.line(points2D[faces[j].B],points2D[faces[j].C],1);
                vram.line(points2D[faces[j].C],points2D[faces[j].D],1);
                vram.line(points2D[faces[j].D],points2D[faces[j].A],1);
            }
        }
//        delete(points2D);
    }

protected:
    Point3D *points;
    Point2D *points2D;
    unsigned int nbPoints;
    MC_Lface *faces;
    unsigned int nbFaces;
    MC_BlockModel *blockModels;
    unsigned int nbBlockModels;
    MC_CubeModel *cubeModels;
    unsigned int nbCubeModels;
    MC_LoaddedBlock *loaddedBlocks;
    unsigned int nbLoadded;
    Buffer vram;
};