Tableaux dynamiques GLuint [sous windows]

int main(int argc, char *argv[]) 
{ 
  
  
  
  
  
    SDL_Event event; 
  
    const Uint32 time_per_frame = 1000/FPS; 
    unsigned int width = LARGEUR_FENETRE; 
    unsigned int height = HAUTEUR_FENETRE; 
  
  
    Uint32 last_time,current_time,elapsed_time; //for time animation 
    Uint32 start_time,stop_time; //for frame limit 
  
    SDL_Init(SDL_INIT_VIDEO); 
    atexit(stop); 
  
    SDL_WM_SetCaption("SDL GL Application", NULL); 
  
  
  
  
    SDL_SetVideoMode(width, height, 32, SDL_OPENGL); 
  
  
initFullScreen(&width,&height); 
  
 glMatrixMode( GL_PROJECTION ); 
 glLoadIdentity(); 
 gluPerspective(70,(double)width/height,0.001,1000); 
glEnable (GL_DEPTH_TEST); 
glEnable (GL_TEXTURE_2D); 
load();

void load() 
{ 
ofstream fichier8("doco.txt", ios::out | ios::trunc); 
  
    int j, teka=0, pointagep, pointaget; 
    int nbrPoints=0, nbrTex=0; 
    ifstream fichier2("doc/liste1.jaj", ios::in); 
    ifstream fichier3("doc/liste2.jaj", ios::in); 
  
  fichier2>>nbobjets; 
glGenTextures(nbobjets,&identifiant); 
  
  
  
  nbrfacesp  = new int [nbobjets]; 
  
    for(j=0;j<nbobjets;j++) 
    { 
        pointagep=nbrPoints; 
        pointaget=nbrTex; 
  
  
        nomsobjets.push_back(""); 
        nomstextures.push_back(""); 
  
  
     fichier2>>nomsobjets[j]; 
         fichier3>>nomstextures[j]; 
  
  
  
 loadTexture(nomstextures[j].c_str(),identifiant+j); 
  
    texture.push_back(identifiant + j); 
  
  
  
    nbrfacesp[j]=0; 
  
  
  ifstream fichier(nomsobjets[j].c_str(), ios::in); 
  
    if(fichier) 
    { 
  
  
        char caractere; 
  
  
        while( !fichier.eof() ) 
        { 
  
  
            fichier.get(caractere); 
            fichier8<<caractere<<endl; 
            switch(caractere) 
            { 
  
                case 'v' : 
                    fichier.get(caractere); 
                    if(caractere==' ') 
                    { 
                        point1.push_back(1); 
                        point2.push_back(1); 
                        point3.push_back(1); 
                        fichier >> point1[nbrPoints]>> point2[nbrPoints]>> point3[nbrPoints]; 
                         fichier8 << point1[nbrPoints]<< point2[nbrPoints]<< point3[nbrPoints]<<endl; 
  
                        nbrPoints++; 
  
                    } 
                    else if(caractere=='t') 
                    { 
                        tex1.push_back(1); 
                        tex2.push_back(1); 
  
                        fichier >> tex1[nbrTex]>> tex2[nbrTex]; 
                        fichier8 << tex1[nbrTex]<< tex2[nbrTex]<<endl; 
                        nbrTex++; 
                    } 
                    break; 
                case 'f' : 
  
                        texFace1.push_back(1); // (*) 
                        texFace2.push_back(1); 
                        texFace3.push_back(1); 
  
  
                        face1.push_back(1); 
  
                        face2.push_back(1); 
                        face3.push_back(1); 
  
  
                     teka=0; 
                    fichier>>teka; 
                        fichier8<<teka<<endl; 
                    face1[nbrFaces]= teka + pointagep; 
                    fichier.get(caractere); 
                    fichier >> teka; 
                    fichier8<<teka<<endl; 
                    texFace1[nbrFaces] = teka + pointaget; 
                     fichier>>teka; 
                     fichier8<<teka<<endl; 
                    face2[nbrFaces] = teka + pointagep; 
                    fichier.get(caractere); 
                    fichier >> teka; 
                    fichier8<<teka<<endl; 
                    texFace2[nbrFaces] = teka + pointaget; 
                    fichier>>teka; 
                    fichier8<<teka<<endl; 
                    face3[nbrFaces] = teka + pointagep; 
                    fichier.get(caractere); 
                    fichier >> teka; 
                    fichier8<<teka<<endl; 
                    texFace3[nbrFaces] = teka + pointaget; 
                    nbrFaces++; 
                     nbrfacesp[j]++; 
  
                    break; 
  
                    default: 
                    while(caractere!='n' && !fichier.eof() ) 
                        fichier.get(caractere); 
                    break; 
  
  
            } 
  
        } 
  
  
    } 
    else 
        cerr << "Impossible d'ouvrir le fichier !" << endl; 
  
 fichier.close(); 
  
    } 
  
  
  
fichier2.close(); 
fichier3.close(); 
}

void loadTexture(const char * filename,GLuint k) 
{ 
    GLuint glID; 
    SDL_Surface * picture_surface = NULL; 
    SDL_Surface *gl_surface = NULL; 
    SDL_Surface * gl_fliped_surface = NULL; 
    Uint32 rmask, gmask, bmask, amask; 
  
    picture_surface = IMG_Load(filename); 
    if (picture_surface == NULL) 
  
  
#if SDL_BYTEORDER == SDL_BIG_ENDIAN 
  
    rmask = 0xff000000; 
    gmask = 0x00ff0000; 
    bmask = 0x0000ff00; 
    amask = 0x000000ff; 
#else 
  
    rmask = 0x000000ff; 
    gmask = 0x0000ff00; 
    bmask = 0x00ff0000; 
    amask = 0xff000000; 
#endif 
  
    SDL_PixelFormat format = *(picture_surface->format); 
    format.BitsPerPixel = 32; 
    format.BytesPerPixel = 4; 
    format.Rmask = rmask; 
    format.Gmask = gmask; 
    format.Bmask = bmask; 
    format.Amask = amask; 
  
    gl_surface = SDL_ConvertSurface(picture_surface,&format,SDL_SWSURFACE); 
  
    gl_fliped_surface = flipSurface(gl_surface); 
  
  
      glBindTexture(GL_TEXTURE_2D, k); 
  
  
  
        gluBuild2DMipmaps(GL_TEXTURE_2D, 4, gl_fliped_surface->w, 
                          gl_fliped_surface->h, GL_RGBA,GL_UNSIGNED_BYTE, 
                          gl_fliped_surface->pixels); 
  
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, 
                        GL_LINEAR_MIPMAP_LINEAR); 
  
  
  
        glTexImage2D(GL_TEXTURE_2D, 0, 4, gl_fliped_surface->w, 
                     gl_fliped_surface->h, 0, GL_RGBA,GL_UNSIGNED_BYTE, 
                     gl_fliped_surface->pixels); 
  
  
  
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); 
  
  
    SDL_FreeSurface(gl_fliped_surface); 
    SDL_FreeSurface(gl_surface); 
    SDL_FreeSurface(picture_surface); 
  
  
}

  
  
int i = 0,k=0, bim; 
  
  
  
  
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
  
  
  
  
    glMatrixMode(GL_MODELVIEW); //Crée une matrice 
  
    glLoadIdentity(); //Iniatlise la matriceGLuint texture; 
  
camera->look(); 
  
glBindTexture(GL_TEXTURE_2D, texture[0]); 
  
            glEnd(); 
  
  
          for(int j=0; j<nbrFaces; j++) 
        { 
  
           if(k==nbrfacesp[i]) 
              { 
                      i++; 
  
                       glBindTexture(GL_TEXTURE_2D, texture[i]); 
  
  
                            glEnd(); 
                   k=0; 
                  } 
  
  
k++; 
  
  
  
  
  
  
            glBegin(GL_TRIANGLES); 
            glTexCoord2f(tex1[ texFace1[j]-1],tex2[ texFace1[j]-1]);  glVertex3f(point1[ face1[j]-1], point2[ face1[j]-1], point3[ face1[j]-1]); 
            glTexCoord2f(tex1[ texFace2[j]-1],tex2[ texFace2[j]-1]);  glVertex3f(point1[ face2[j]-1], point2[ face2[j]-1], point3[ face2[j]-1]); 
            glTexCoord2f(tex1[ texFace3[j]-1],tex2[ texFace3[j]-1]);  glVertex3f(point1[ face3[j]-1], point2[ face3[j]-1], point3[ face3[j]-1]); 
           glEnd(); 
  
  
  
  
  
  
        } 
  
        glFlush(); 
        SDL_GL_SwapBuffers(); 
}