Bonjour,

J´ai une question qui paraitra sans doute à deux balles pour ceux habitués à opengl mais moi je ne m´y suis sérieusement que depuis hier

Donc je suis en train de regarder ce que donne le couple opengl/sdl par rapport à du sdl tout seul pour faire de la simili 2d, et dans tout les tutos que j´ai croisé jusqu´ici toute la scène est redessinée à chaque fois entièrement. Hors moi avec les trois quarts de l´écran qui ne changent jamais cà me parait servir à rien de redessiner à chaque frame tout le fond plus une trentaine de quads pour le texte plus encore tout les quads des sprites qui ne bougent pas. Ma question est donc la suivante: est ce que c´est obligé de tout redessiner à chaque frame, ou est ce qu´on peut se contenter de changer que les parties qui changent à l´écran? Si j´arrête d´appeller glclear à chaque affichage j´ai le apparemment le restant de la frame d´avant qui reste en mémoire, mais je ne sais pas si c´est très propre de procéder comme cà.

voila un début de réponse (ou au moin de précision) concernant l´affichage avec opengl:
la fonction de raffraichissement est appelé automatiquement lorsqu´il y en a besoin (quand tu depalce la fenetre, quand quelquechose passe devant la fenetre, quand tu l´appelle...) avec SDL l´affichage est raffraichis uniquement quand TOI tu le décides. Donc je ne pense pas qu´il soit possible de redessiner juste un morceau de ton image. Le programme ne peut pas savoir quels objets se sont déplacés et quels autres sont réstés statiques sans tout recalculer. De plus opengl fonctionne avec le Z-buffer == il n´affiche que les elements qui sont devants (un quad derriere un autre ne sera pas afficher). Donc en admettant que tu deffinisses des objets qui ne bougent pas,comment savoir sans recalculer si un element n´est pas passé devant ton objet fixe ?

je sais pas si c´est tres clair, ni tres juste donc je suis aussi interessé par une réponse.

le programmeut peut tres bien maintenir une "dirty list" des elements qui ne sont plus a jour. Tu peux ne pas clear ton backbuffer, bcp de jeux le font d´ailleurs, sachant qu´ils vont redessiner la frame suivante par dessus.
tu peux aussi decomposer ta scene en layers (ie. le HUD dans une render target, le fond dans un autre , etc.) et les composer pour creer l´image finale.
En general, on ne prend pas la peine de clearer son backbuffer, mais on redessine tout dans la mesure ou quasiment tout change ; si tu es dans un cas special ou peu de choses changent, tu peux ne traiter que ce que tu uptades. Mais fais attention pour cela a ne pas mettre en place de mecanismes qui soit des perfs killers (mieux vaut dessiner 1000 triangles rapidemment, que 100 treees lentement)

Ok, merci bien des réponses, j´y vois un peu plus clair mais (hélas) toujours pas suffisamment. En fait je suppose que j´ai besoin de comprendre comment opengl garde en mémoire et gère ce qu´on lui donne à dessiner.

Je vais prendre un exemple concret, par exemple ceci: http://perso.wanadoo.fr/pyxsoftware/images_exterieures/ogl.gif

C´est un agrandissement du coin bas gauche de ma fenêtre opengl.

Donc quand j´ouvre ma fenêtre j´appelle une première fonction draw qui dessine un quad rose à une profondeur z donnée. Par la suite j´appelle une deuxième fonction qui ne s´occupe plus du quad rose ou d´effacer quoi que soit mais qui affichera à chaque fois la lettre A, la première fois elle est affichée en bas à gauche et à chaque fois je la décale un peu sur la droite. Les 10 premières fois je règle la profondeur de A un peu en dessous du quad rose, puis ensuite un peu au-dessus.

Puisque A n´apparait pas les dix premières fois et apparait les suivantes, je suppose donc qu´opengl garde en mémoire les positions de tout les quads et gère ce qui devient visible via le Z-buffer quand je lui demande d´afficher autre chose? Donc en fait sur mon image j´ai une vingtaine de quads en mémoire? Supposons que je veuille virer le quad rose pour voir ce qu´il y a derrière, comment puis je procéder?

Sinon SDL fournie une fonction SDL_UpdateRect() pour ne pas avoir à toujours tout remettre à jour l´écran par contre avec OpenGl je sais pas si ça marche.

Pour les théories appuis toi sur la doc.
http://opengl.org

j´ai également une petite page qui explique un peu la théorie sur mon site : (cf ma carte) rubrique info / culture / theorie prog image.

Sinon, pour répondre a la question :
OpenGL NE GARDE PAS les polygones en mémoire.

Quand tu balances un polygones dans le buffer, il l´affiche immédiatement sur l´écran. tu le vois si tu désactives le Z-buffer : les derniers triangles affichés sont ceux qui sont devant.

Mais tu dois te dire "et avec le Z-buffer ?"
En fait, c´est simple : a chaque affichage, l´ordi garde en mémoire dans un buffer, pour chaque pixel, la prodondeur maximale atteinte pour le moment.
Autrement dit, si tu dessines un triangle devant, alors ce buffer (qui, tu t´en doute, est le Z-buffer) contiendra la valeur de la profondeur atteinte a ce pixel.
Quand tu mets un autre triangle, ses pixels ne s´afficheront QUE si ils sont "devant". Si la coordonnée Z du pixel du nouveau triangle a rendre est inférieure a celle déja enregistré dans le Z-buffer a la meme place, alors ça veut dire qu´un objet se trouve déja devant : donc le pixel n´est pas affiché...
Donc pas de mise en mémoire et de classement de tous les triangles

Pour répondre a ton autre question sur le fait d´effacer l´écran ou non : sache que si tu utilises le Z-buffer, autant effacer tout l´écran.
En effet, tu as du remarquer que tu "clear" le Z-buffer a chaque frame, de toute façon. Si tu ne le fais pas, alors ça fera n´importe quoi, car e Z-buffer interdira l´affichage complet ou partiel de certains triangles, alors qu´il ne doit pas...
C´est pour ça qu´on clear toujours le Z-buffer a chaque frame si on s´en sert...
Et en général, pour répondre a la question, on clear EN MEME TEMPS le buffer d´image :

glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

Cette fonction est faite pour appeler les 2 en meme temps, et les cartes graphiques actuelles font le clear "en parallele" des 2 buffers.
Donc, tant qu´a perdre du temps a nettoyer le Z, si le buf color peut se nettoyer en meme temps, pourquoi s´en priver

Sinon, je ne donne pas tort a LGV quand il dit que parfois ce n´est pas utile : en effet, des fois les jeux utilisent le BSP et pas vraiment le Z-buffer, et des fois, si vraiment uniquement une partie de l´écran doit bouger, autant ne gérer que celle la, a coup de viewport... Et surement d´autres cas que je ne connais pas sinon

Merci beaucoup de cette explication complète et très claire , là je crois que j´ai vraiment compris comment cà marche.

D´ailleurs je m´en retourne faire mumuse avec mon code de ce pas, cà paraitra beaucoup plus facile maintenant que j´ai une bonne vision de comment cà fonctionne