Encore une question ( avec un peu de chance, elles sont pas trop ennuyantes) !

Depuis de plus en plus longtemps, je cherche à faire un petit moteur 2D ( on parle ici de vraiment très très petit, du genre mauvais demo-making, je fais ça pour les connaissances, pas pour l´esthétique ) . Depuis quelques temps, je m´amuse avec OpenGL et, après avoir fait le tour des trucs les plus importants pour pouvoir faire le rendu d´une image 2D ( faire un quad, texture mapping, lighting, blending, alpha blending et même une technique de masking pas très efficace quand le lighting est enablé) j´en viens à me poser une petite question en ce qui concerne l´animation.

Qu´est-ce qui semble plus efficace en ce qui concerne les sprites ? Sachant qu´il s´agit des multiples frames d´une animation toutes dans une seule image ( j´ai toujours mon super homemade DLL pour charger des . tga ) , est-ce que je devrais faire le " saut" de frame à frame par le texture mapping ( à vrai dire, j´ignore si c´est vraiment faisable, le mapping en OGL est normalisé) ou est-ce que je programme une procédure de loading qui " split" l´image en plusieurs textures différentes et, une fois au rendu, je change simplement le binding ?

Je cherche à faire ce qu´il y a de plus propre...

Bonne question !
Selon ce que j´ai entendu, il est legerement plus rapide de faire toutes tes frames dans une seule image, et de jouer sur glTexCoord pour afficher le bon sprite : ça t´évite de faire des glBind trop souvent, et il parait que ça va plus vite ( mais légerement, faire autant de sprites que de frames n´est pas lent non plus)

Conseil pour tes grandes images :
fait en sorte que leur résolution x ou y soit une puissance de 2, ou alors presque :
en effet, OpenGL n´aime que les images en résolution x et y puissances de 2. si tu ne fait pas cela, il passe a la puissance supérieure en distrordant ton image en mémoire :

genre si ton image fait 64*32, c´est parfait
si elle fait 60*30, il passe a 64*32 c´est pas bien grave, mais si elle fait 66*34, tu passes a 128*64 --> pan la mémoire ! !

Tu verras également que si tu colles trop tes frames les unes des autres ( et surtout si ton image n´était a l´origine pas une puissance de 2) il risque d´y avoir un léger flou, et tu risques de voir un petit peu la frame précédente sur une frame donnée

Sinon, si tu veux de la 2D, untilise glOrtho et pas gluPerspective

Parfait ! Merci beaucoup !

aussi, pour la couleur transparente, y´a plusieurs façons : soit tu utilises un masque, mais bon, c´est long et chiant,
soit tu te sers du canal alpha, tu définis les pixels transparents avec un alpha de 255

puis tu actives :

glEnable(GL_ALPHA_TEST);
et tu parametres : glAlphaFunc

c´est un tout-ou-rien
ce n´est pas la meme chose que GL_BLEND

En fait, j´envisage de permettre de changer l´éclairage dans mon moteur ( je veux dire, ouais, il est petit présentement mais je veux faire un jeu un jour avec tout ça). Conséquemment, le mask, ça fonctionne pas ( la superposition obtenue n´est pas la même selon l´éclairage).

Mais j´ai suivi l´exemple de NeHe pour faire du alpha blending, ça fonctionne très bien. Photoshop permet de faire un alpha channel très facilement. Cela dit, j´ai choisi

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);

plutôt que

glEnable(GL_ALPHA_TEST);

car, selon NeHe, le alpha test ne permet pas la semi-transparence. Et j´ai pensé que mettre les edges de mes sprites en transparence 50% ( c´est plutôt facile à faire avec photoshop comme j´ai dit précédemment) donnerait peut-être quelque chose proche d´un antialiasing ( j´ignore si ce terme s´applique en 2D mais, quoiqu´il en soit, le fait de faire du color keying amène immanquablement un effet d´escalier plutôt laid sur les edges).

Des suggestions à ce sujet ?

Hum ! En effet, le keyframe color risque de te faire des effets d´antialiasging, mais bon, peut etre pas non plus trop grave ? quoique !

L´inconvénient de ta méthode, c´est que si tu actives le blending, tu es obligé de désactiver le Z-buffer.

Tu vas me dire " je m´en tape du Z-buffer pour la 2D", mais dans des cas, c´est tres pratique :

Imagine que tu fasses une jeu comme Final Fight :
https://www.jeuxvideo.com/affpic.htm?images/ga/f/f/ffonga003.jpg

Comme tu vois, faut afficher les bonhommes au bon endroit, certains devant d´autres.
Dans ce cas, l´ordre d´affichage dépend de la position y du mec, mais pas toujours : si le mec saute : il a un y plus petit mais doit etre affiché devant la tete du gars qui est derriere, et pourtant plus bas
Donc en 2D pure : il faut trier les bonhommes avant leur affichage.
Avec le Z-buffer actif, tu assignes a tes bonhommes une position z fictive ( qui ne se verra pas si tu bosses en glOrtho(), et tu les affiches brutalement dans n´importe quel ordre, le Z-buffer se charge de te faire ça tout beau tout seul
C´est une des astuces pour utiliser les accelerateurs 3d pour de la 2d

C´est certain ! Mais je pensais faire une structure pour wrapper mes quads de façon à pouvoir les traiter un peu comme des surfaces. Tout ce qu´il resterait à faire pour empêcher le blending de merder avec un Z-Buffer actif c´est de faire un tri ( faire le rendu des surfaces les plus loins en premier).

Mais je dois admettre que ne pas avoir à me soucier d´un quelconque sorting est particulièrement tentant. Je vais jeter un oeil à l´alpha testing .

D´ailleurs, j´ai remarqué un petit problème avec tout ça ( je reviens ici sur le thème général du blending, le problème ne vient pas de l´alpha testing). Si je traite mes textures en GL_LINEAR plutôt qu´en GL_NEAREST, je perds la transparence à certains endroits ( dans le cas présent, j´ai une ligne verte dans le haut de l´image). Est-ce qu´il y aurait une solution simple au phénomène ?

Je commence à prolonger le topic beaucoup, je vais essayer d´éviter d´avoir une question après celle-ci .

Merci !

en fait, GL_LINEAR te fait un fondu avec les couleurs du dessus et du dessous.
Et il faut savoir que le graphisme se repete :
c´est a dire que si tu as une image qui va de 0 à 63, la 63e ligne va faire un fondu avec la 62 ( normal) MAIS AUSSI AVEC LA 0
et si tu as une ligne verte en haut, c´est surement que tu alignes la ligne 0 de ton sprite et qu´elle se fond avec la derniere ligne de ta texture, tu vois ?

pour desactiver ça :
glTexParameteri( GL_TEXTURE_2D , GL_TEXTURE_WRAP_S,GL_CLAMP ) ;
glTexParameteri( GL_TEXTURE_2D , GL_TEXTURE_WRAP_T,GL_CLAMP ) ;

Ça fonctionne ! Il faut que je me trouve une référence pour tous les paramètres qui peuvent passer dans des fonctionnes comme celle-là . Espérons qu´MSDN est plus à jour à propos d´OGL que l´aide de VS.

Merci beaucoup !
C´est tout pour ce soir ( je suis Canadien, il est tard hehe) !

j´ai ton bonheur :

http://pyopengl.sourcefororge.net/documentation/manual/

And if you are canadian, you speack english, so no problem for you this page

Tut tut tut, faut pas faire de généralisation mais I speak english, so no problem for me this page .

Merci encore !