Discussion :

[jcs2]

Débutant en OpenGL, je me demande si la méthode que j'ai choisie pour réaliser un 'slideshow' avec des fondus enchainés
entre chaque photo est la bonne.

- un quad occupant tout l'écran,
- j'applique une première texture (1ère photo),
- j'applique une deuxième texture (2ème photo) avec d'abord une transparence totale,
- avec un timer je fais progressivement monter l'opacité de la 2ème texture
- ... et je recommence

Est-ce correct, vais-je tomber sur un PB, ou une autre méthode serait-elle peut-être plus adaptée?

Ce genre d'application peut s'effectuer totalement avec le CPU, mais on atteint très vite des problèmes de performances alors que le GPU peut faire cela naturellement et très rapidement

[badamboum]

Je suis loin d'être un spécialiste en la matière, mais en tout cas je pense que j'aurais fais a peu près la même chose..
Par contre je me demande si sa va bien rendre de monter la transparence de toute l'image d'un coup, peut être se serait mieux de le faire progressivement de la gauche vers la droite par exemple, enfin c'est une idée.

Ce genre d'application peut s'effectuer totalement avec le CPU, mais on atteint très vite des problèmes de performances alors que le GPU peut faire cela naturellement et très rapidement

Ca ne poserais a priori pas de problème de faire sa avec des shaders, même si je ne vois pas trop ce qui vas poser géner les performances, enfin je peux me tromper...

[shenron666]

Un effet qui rend plutot pas mal est de "découper" l'image et de considérer chaque pixel comme un quad, on a la possibilité de :
- faire exploser l'image
- la faire onduler
- faire un effet de page qu'on tourne
- faire un effet de page qu'on déchire
- faire venir les pixels vers nous comme un effet de starfield
- et pleins d'autres effets très facilement

[jcs2]

Merci pour vos réponses, Badamboum et Shenron66. A priori ma méthode n'a pas l'air de vous choquer.
En potassant un peu plus le bouquin OPENGL1.4 je m'aperçois qu'il y a aussi la primitive glDrawPixels qui serait peut-être plus adapté que des textures.
Qu'en pensez-vous?

[Laurent Gomila]

Tout ce qui est à base d'affichage direct sur le backbuffer sera non seulement beaucoup plus lent, mais aussi plus limité en fonctionnalités. Le mieux est bien d'utiliser un rendu sur quads texturés.

... ou un pixel shader si on peut se le permettre.

[shenron666]

glDrawPixels est vraiment très lent
tu peux toujous faire des tests mais à ta place j'éviterai

[jcs2]

Meric à tous pour vos réponses.
Donc textures au lieu de glDrawPixel.

Je me permets de poser une autre question concernant le Blending:

Naivement je pensais que OPenGL permettait de modifier globalement, avec une seule primitive, le facteur Alpha de tous les pixels d'une texture entière (ou d'une image). et que cela se réalisait avec le GPU qui opère sur des vecteurs
Mais je ne trouve rien. Faut-il alors balayer un à un tous les pixels d'un bitmap afin de leur attribuer un coefficient Alpha commun?
Ce qui veut dire que dans le cas où je veuille réaliser un fondu enchainé entre deux images je doit boucler 1 million de fois pour chaque frame, et donc me retrouver à occuper outrageusement le CPU?

[shenron666]

Tu peux attribuer une transparence alpha par vertex en utilisant par exemple glVertex4f et ainsi rendre un polygone plus ou moins transparent

[jcs2]

...en utilisant par exemple glVertex4f et ainsi rendre un polygone plus ou moins transparent

Excuse-moi, mais je ne vois pas comment affecter une transparence avec cette primitive. C'est sans doute glColor4f que tu voulais citer.
Mais cela ne résoud pas mon problème concernant des textures que je veux rendre progressivement transparentes dynamiquement.

[Laurent Gomila]

Si les vertices sont transparents et que tu paramètres ton unité de texture pour moduler la couleur du vertex et de la texture, ça fera le boulot.

[shenron666]

Excuse-moi, mais je ne vois pas comment affecter une transparence avec cette primitive. C'est sans doute glColor4f que tu voulais citer.

Oui c'est ce que j'aurai dû taper, glColor4f, merci d'avoir compris et désolé pour l'erreur

pour la suite, Loulou a répondu

[jcs2]

OK, merci à vous deux.

[zax-tfh]

Salut,

y'a un effet sympa aussi : en gros tu as ton image1 sur tout l'écran, puis tu la vois s'eloigner et en fait tu te rend compte que c'est la face d'un cube qui pivote puis vient se recoller sur l'ecran en full avec l'image numero2 ^^
Merci apple j'ai cet effet là pour changer de desktop ca pete

[jcs2]

Loulou24 me demande dans un autre fil de décrire plus précisément mon projet. Je le fais volontiers ici
_______________
Merci Loulou24 de t'intéresser à ma problématique.

En fait mon projet je l'ai déjà un peu évoqué. C'est en fait un 'slideshow' classique. En quelques mots:

- un moteur de 'projection' d'images, plein écran, synchronisée avec une bande sonore(MP3, WAV ou OGG).

- L'image est issue soit d'un fichier (Jpeg, Png ...) soit générée si c'est un texte.
- Chaque image est associée essentiellement à 3+1 paramètres:
. durée de présence à l'écran,
. un type de transition (fondu, cut, glissement latéral etc...) qui l'introduit,
. durée de la transition,
. éventuellement une des images texte en surimpression (avec transition et durée)
- le nom des fichiers et les paramètres des images sont lus à partir d'un fichier texte (je ne m'intéresse ici qu'au moteur de projection)

La projection est donc conditionnée par un 'time code' déduit des durées de présence et en supposant que le morceau musical ne dérive pas dans le temps, on devrait pouvoir sauvegarder la synchronisation (ce dont je ne suis pas sûr d'ailleurs).

Pour l'instant j'en reste à une application 2D, bien que cela pourrait être intéressant de réaliser des effets de transition en 3D. Cela sera pour plus tard. A chaque jour sa peine.

Suite aux conseils donnés ici, je me suis donc orienté vers la technique des textures.

- Dans un buffer FIFO j'accumule les images lues que je transforme aussitôt en liste de pixels. (ce traitement devra être réalisé en tant que thread secondaire et réveillé de temps en temps pour alimenter régulièrement ce buffer). Actuellement j'ai un buffer de 10 images. Une image demande avec sa lecture 160 ms de traitement. En le réveillant toutes les 3-4 secondes cela devrait être suffisant pour éviter que le buffer ne se vide complètement.

- dans le thread principal, un timer conduit par la liste des time codes permet de provoquer l'apparition d'une image. Cela consiste d'abord à éventuellement réalimenter, à partir du buffer des pixels, les textures si toutes ont déjà été exploitées, puis à effectuer la transition (la création d'une texture demande environ 8 ms ce qui est très bon). Si je les alimente 5 par 5 (40 ms ) cela devrait être bon.

- les transitions:

. cut (immédiat,sans effet): aucun souci, simple changement de texture. Très rapide.

. fondu: utilisation du blending. Je fais monter progressivement grâce à un timer (40ms soit 25 images:/sec.) le coefficient alpha de 0 à 1. Le résultat est excellent (très fluide) sauf que je constate une progression
non linéaire du fondu à l'écran: Pour un fondu de 5 secondes, la 2ème image est quasiment visible à 95% au bout d'une seconde. Les 'restes' de la 1ère image, à peine visibles, ne disparaissent qu'à la 5ème seconde. Est-ce du aux paramètres que j'utilise?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 
      glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
 
      {Accumuler les textures 2D}
      glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, Width, Height
                  , 0, GL_RGB , GL_UNSIGNED_BYTE, pPixelBuffer);
 
      {et pour le blending }
      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

. transitions 'spatiales' en 2D:
Pour l'instant je n'ai réalisé que le glissement latéral de la 2ème image en modifiant progressivement les coordonnées de sa texture. Le résultat est bon sauf pour les glissements lents (plus de 4-5 secondes) où il apparaît saccadé.

Voilà l'essentiel. J'ai été un peu long sans doute. Merci pour votre écoute et vos conseils.

Les questions qui subsistent pour l'instant avec certainement d'autres à venir plus tard:
1. suis-je dans la bonne direction avec les textures?
2. ai-je intérêt à générer les textures 5 par 5 ou à l'unité?
3. est-ce que mes suppositions sur les données temporelles semblent correctes?
4. peut-on régler la question du fondu non-linéaire?
5. est-ce que je peux supprimer cet effet de saccade dans les mouvements lents de texture?
6. existe t-il un moyen d'asservir le timer principal (changement d'image) à la bande son?
Ce serait préférable à une synchronisation non dirigée.
__________________

- réalisation en Delphi sans librairie auxiliaire
- essais sur portable SONY VAIO, CPU Intel M740 1.73 ghz, GPU NVidia GeForce Go 6200 128 MO
- photos Jpeg 2048x1536, réduites en textures 1024x768
- plan de projection 1024x768