MIKE56 => Aucun intérêt à ce qu'il soit en français.

C'est quoi toutes ces variables globales définies un peu partout ? Ok pour l'exemple, mais le   code est sale à mon gout.

Record 565.

C'est un peu chiant la fermeture du programme dès qu'on perd. Sinon ça tourne bien.

"SDL impose d'avoir une DLL en externe or mon moteur est aussi compilé sous la forme d'une bibliothèque dynamique"
=> Avoir deux dlls, ne posent un pb particulier ?

"si ce n'est pour comparer les rendus"
=> Les rendus sont censés être rigoureusement équivalent: la somme et le produit de deux nombres fera tjs le meme résultat sous DirectX ou OpenGL (heureusement) et comme la 3D, ca ne se résume qu'a ca...

"la bonne méthode permettant d'afficher un triangle (VertexBuffers ?)"
=> Oui, il s'agit simplement d'utiliser le meme principe que DirectX.
http://www.g-truc.net/article/vbo-fr.pdf

Une question et une remarque.

La question: Je me demandais quel est l'intérêt de gérer openGL et directX:
- Si on faire un soft uniquement pour windows, alors autant faire que du DirectX.
- Si on veut faire du portable, alors autant tout faire en OpenGL.
Non ?

La remarque: Ta méthode pour afficher un triangle est openGL est un peu dépassée.

J'ai fais une petite erreur: "glGenBuffersARB(1, &frames[0].vboVertices);" bien sur et non:
"glGenBuffersARB(1, frames[0].vboVertices);"

De meme après, c'est des pointeurs que prend la fonction glDeleteBuffers:
if (frames[i].vboVertices != 0)
    glDeleteBuffersARB(1, &frames[i].vboVertices);
if (frames[i].vboNormales != 0)
    glDeleteBuffersARB(1, &frames[i].vboNormales);
if (frames[i].vboTexCoords != 0)
    glDeleteBuffersARB(1, &frames[i].vboTexCoords);

Oulala, j'avais pas vu en effet.
Tu fais ca: "glGenBuffersARB(1, &frames->vboVertices);"
Tu devrais faire ca: "glGenBuffersARB(1, frames[0].vboVertices);" (bien que ce soit rigoureusement équivalement)

Mais il faut initialiser tous les membres de la structure quand tu la créés et pas laisser des champs indéterminés. Si tu utilises pas frames[1].vboVertices, mets lui la valeur 0:
frames[1].vboVertices = 0;
frames[1].vboNormales = 0;
frames[1].vboTexCoords = 0;

Et lors de la destruction, tu ne détruits que les vbos qui ont été créé.
if (frames[i].vboVertices != 0)
    glDeleteBuffersARB(1, frames[i].vboVertices);
if (frames[i].vboNormales != 0)
    glDeleteBuffersARB(1, frames[i].vboNormales);
if (frames[i].vboTexCoords != 0)
    glDeleteBuffersARB(1, frames[i].vboTexCoords);

Peut etre que la fonction glDeleteBuffers ne fait rien si l'id du buffer vaut 0 mais on sait jamais. On voit ici l'intéret d'initialiser les ids de tes vbos a 0 si tu les utilises pas.

Pour les vbos en général, tu peux utiliser soit glLock/UnlockBuffer ou glBufferData. En première approche, c'est pareil. (glBufferData parfois un poil plus rapide).

"glLockArraysEXT, glUnlockArraysEXT"
=> Il me semble que ces fonctions ne concernent que les vertex arrays, donc pas les vbos.

"je trouve trop de solution differente je suis un peu perdu"
=> Oui c'est le bordel. Et on peut donc te reprocher de poster une source sur les vbos sans les maitriser totalement puisque ca peut induire en erreur des personnes qui regarderaient ton code.

Bon alors, tu peux nous expliquer ce qu'il fait de spécial ton code. Je vois juste des vbos on ne peut plus standard non ?

Sinon pour ton problème:
#  delete [] frames;
# frames = NULL;
# }
# //==========================================
# // !!! Probléme:
# glDeleteBuffersARB(1, &frames->vboVertices);
# glDeleteBuffersARB(1, &frames->vboNormales);
# glDeleteBuffersARB(1, &frames->vboTexCoords);

Tu détruits tes vbos après avoir "delete" frames. De plus frames est un tableau, donc, tu devrais plutot avoir:
  if (frames)
{
for (int i = 0; i < numFrames; i++)
{
....
glDeleteBuffersARB(1, frames[i].vboVertices);
glDeleteBuffersARB(1, frames[i].vboNormales);
glDeleteBuffersARB(1, frames[i].vboTexCoords);
}
delete [] frames;
frames = NULL;
}

Remplacé par rien. A jeter ces fonctions. Pour afficher, c'est:
glDrawElements
glDrawRangeElements

et rien d'autre.

CChargy : Je parle de la dernière version d'openGL : "Opengl 3"
Mais il y aurait encore un support des fonctions à la con (ex: glVertex) pendant quelques temps je crois.

"vu que c'est du matériel normalement et pas du logiciel"
=> Manque de bol, la carte graphique ne fait que du FLOAT, donc tous tes appels "glVertex2d" sont d'abord convertis en FLOAT par le CPU ! Donc tu auras des perfs horribles avec ton programme. Des que tu vas atteindre quelques dizaines de milliers de poly, ca va commencer à ramer.

De deux, les glVertex* c'est plus a utilisé. Tout facon, ca disparait dans la nouvelle version d'opengl. Ces fonctions sont catastrophiques pour les performances. Donc en conclusion, faire du pure hardware en opengl, c'est délicat...

Autrement remarque, un short = -+ 65000. Un int, c'est en milliards...