Discussion :

[dams32]

J'ai fait une classe gérant le motion blur qui fonctionne de la manière suivante: je stocke un certain nombre de rendus (les 10 derniers par exemple) dans un tableau de textures, que j'affiche à chaque frame; bien sur, j'écrase la dernière texture par la nouvelle à chaque fois, je fais une rotation circulaire quoi.
Voici les étapes:
- je choisis un viewport de 512*512
- je dessine tous mes objets dans le front buffer
- je stocke le buffer dans une texture de 512*512 à l'aide de glCopyTexImage2D
- je reviens au viewport original
- je choisis une projection orthogonale
- je dessine toutes les textures de mon tableau sur des quads que je superpose en prenant bien soin de désactiver le depth_test et en mettant un alpha <1 pour chaque quad

Voici l'image obtenue avec 1 seule image, ca semble correct (enfin il n'y a aucun effet de motion blur puisqu'il n'y a qu'une image lol):
http://damien.rumiano.free.fr/opengl...le_texture.jpg

Mais si j'en met plus, et donc à partir du moment où je superpose au moins 2 quads, j'obtiens des bugs sur l'objet:
http://damien.rumiano.free.fr/opengl/trois_textures.jpg

Encore une avec plus de quads superposés:
http://damien.rumiano.free.fr/opengl...e_textures.jpg

D'une manière générale, dès que je superpose un quad texturé avec un autre, j'obtiens un effet bizarre, et des couleurs pas belles.

Si vous pensez que le code peut vous permettre de me répondre, je suis prêt à le poster, en tout cas la partie critique. Merci beaucoup

[Sixissor]

je dessine toutes les textures de mon tableau sur des quads que je superpose

- Tu les superposes de quelle façon ?

- Quelle est ta fonction de blending ?

[dams32]

Voici la partie du code qui superpose les quads:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
	glClearColor(0.0,0.0,0.0,1.0);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
	glViewport(offset_width,offset_height,width,height);
 
	ViewOrtho();
 
	// we render the previous pictures
	glEnable(GL_TEXTURE_2D);						// Enable 2D texture mapping
	glDisable(GL_DEPTH_TEST);						// Disable depth testing
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);				// Set blending mode
	//glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 
	for(int i=1; i<nb_pictures; i++){
		glBindTexture(GL_TEXTURE_2D,pictures[i]);		// Bind to the appropriate texture
		glBegin(GL_QUADS);
			GLfloat white[]={1.0,1.0,1.0,0.2/*2.0/nb_pictures*/};
			glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,white);
 
			glTexCoord2f(0,0);
			glVertex2f(0,0);
 
			glTexCoord2f(0,1);
			glVertex2f(0,512);
 
			glTexCoord2f(1,1);
			glVertex2f(512,512);
 
			glTexCoord2f(1,0);
			glVertex2f(512,0);
		glEnd();
	}
 
	ViewPerspective();
 
	glDisable(GL_TEXTURE_2D);
	glEnable(GL_DEPTH_TEST);
	glBindTexture(GL_TEXTURE_2D,0);		// Unbind the texture

J'ai essayé beaucoup de fonctions de blending, mais le problème est toujours le même.

[Sixissor]

Tes étapes sur le motion blur m'ont l'air correctes à priori, et je vais te donner ma "définition" de la chose pour voir si on est d'accord sur le principe déjà.
Rappel du principe du motion blur (grosso modo):

Capturer l'affichage du programme au moment T pour le binder comme texture en utilisant le blending au moment T+1 sur toute la surface.
La capture et l'affichage se font en mode ORTHO avec comme paramètres la largeur et la hauteur de la surface d'affichage.

On est d'accord là-dessus ou pas ?
Avoir une vision claire du problème permet de le résoudre à moitié...


Il y a quelques défauts dans ton code.

• J'ai pas compris pourquoi tu Bind plusieurs textures ? ... 1 seule suffit non ?
  En fait ton tableau de textures ne sert à rien, tu peux oublier.
  
  
• Vérifie lors du texturage de la surface que tu la crée avec cette propriété:
  

  Code :

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

  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

  Le paramètre GL_MODULATE est ici nécessaire au blending.
  
  
• Méfie-toi de ça:
  

  Code :

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

  1
  2
  3
  4
  glTexCoord2f(0,0);          glVertex2f(0,0);
  glTexCoord2f(0,1);          glVertex2f(0,512);
  glTexCoord2f(1,1);          glVertex2f(512,512);
  glTexCoord2f(1,0);          glVertex2f(512,0);

  Par défaut OpenGL spécifie les coordonnées de texture dans le sens trigonométrique, pas dans le sens horaire, donc à remplacer par ça:
  

  Code :

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

  1
  2
  3
  4
  glTexCoord2f(0,0);          glVertex2f(0,0);
  glTexCoord2f(1,0);          glVertex2f(512,0);
  glTexCoord2f(1,1);          glVertex2f(512,512);
  glTexCoord2f(0,1);          glVertex2f(0,512);

  Sinon tu risques d'avoir des résultats bizarres...
  
  
• Vérifie que si tu récupères la texture sur 'largeur' x 'hauteur' de la zone à "blurer" tu es bien en mode ORTHO avec

  Code :

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

  glOrtho( 0, largeur, hauteur, 0, 0, profondeur (=1 normalement));

• Si ça marche toujours pas essaye de remplacer
  

  Code :

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

  1
  2
  GLfloat white[]={1.0,1.0,1.0,0.2/*2.0/nb_pictures*/};
  glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,white);

  par
  

  Code :

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

  glColor4f(1.0,1.0,1.0,0.2/*2.0/nb_pictures*/);

Personnellement, j'aurais utilisé une méthode bien plus élégante pour faire du motion blur: j'aurais crée un shader qui s'occupe de ça en Cg.
Toutes ces manips "chiantes" niveau software tendent à disparaitre au profit des Shaders (le GPU est au chômage sinon ).

Bref, je ne te cache pas que j'ai passé pas mal de temps aussi à déboguer mon premier Motion Blur et je l'ai en travers de la gorge depuis...

Bonne chance en tout cas on est là pour essayer de t'aider

[dams32]

Tout d'abord, merci de ta réponse !

Pour ce qui est du motion blur, je pensais que l'effet serait bien meilleur en utilisant les images aux temps T-N+1, T-N, ..., T-1, T pour un affichage au temps T. En utilisant seulement les images aux temps T-1 et T pour un affichage au temps T, on obtient un motion blur quasi inexistant, non?

Sinon, j'ai essayé à peu près tout ce que tu m'as suggéré, mais je n'arrive pas à grand chose. En fait, j'ai réalisé un test encore plus simple: je n'affiche qu'un quad sur lequel j'applique l'image courante... on peut difficilement faire plus simple! Et pourtant, en mettant un alpha=0.5 sur le quad, j'obtiens quelque chose que je ne m'explique pas: sur un cube, il semble qu'on voit les faces de derrière, alors qu'au moment de la copie du buffer, mon cube est tout ce qu'il y a de plus opaque! Je n'ai surement pas saisi le fonctionnement des alphas et du blending.
Voila l'image:
http://damien.rumiano.free.fr/opengl/cube.jpg

Et le code:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
glEnable(GL_DEPTH_TEST);
glClearColor(0.0,0.0,0.0,1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
 
GLfloat white[]={1.0,1.0,1.0,1.0};
glMaterialf(GL_FRONT,GL_SHININESS,100);
glMaterialfv(GL_FRONT,GL_SPECULAR,white);
 
glViewport(0,0,512,512);
glutSolidCube(20.0);
 
glBindTexture(GL_TEXTURE_2D,pictures[0]);
glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 512, 512, 0);
 
glClearColor(0.0,0.0,0.0,1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
glViewport(offset_width,offset_height,width,height);
 
ViewOrtho();
 
glEnable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
glBegin(GL_QUADS);
	GLfloat white[]={1.0,1.0,1.0,0.5};
	glMaterialf(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,white);
 
	glTexCoord2f(0,0);
	glVertex2f(0,0);
 
	glTexCoord2f(1,0);
	glVertex2f(512,0);
 
	glTexCoord2f(1,1);
	glVertex2f(512,512);
 
	glTexCoord2f(0,1);
	glVertex2f(0,512);
glEnd();
 
ViewPerspective();
 
glDisable(GL_TEXTURE_2D);
glEnable(GL_DEPTH_TEST);
glBindTexture(GL_TEXTURE_2D,0);

Encore merci pour vos réponses!

[Sixissor]

Pour ce qui est du motion blur, je pensais que l'effet serait bien meilleur en utilisant les images aux temps T-N+1, T-N, ..., T-1, T pour un affichage au temps T. En utilisant seulement les images aux temps T-1 et T pour un affichage au temps T, on obtient un motion blur quasi inexistant, non?

Hum non.
Fait confiance a ta fonction de blending
Mais il est vrai que plus ton image "bouge", plus le motion blur sera accentue, et vice-versa.

je n'affiche qu'un quad sur lequel j'applique l'image courante... on peut difficilement faire plus simple! Et pourtant, en mettant un alpha=0.5 sur le quad, j'obtiens quelque chose que je ne m'explique pas: sur un cube, il semble qu'on voit les faces de derrière, alors qu'au moment de la copie du buffer, mon cube est tout ce qu'il y a de plus opaque!

C'est normal: ta composante alpha = 0.5, donc semi-transparent.
Si alpha = 0, ton cube est entierement transparent, et si alpha = 1, ton cube est completement opaque. Apres le blending s'effectuera selon la fonction que tu lui auras donne.

Le blending rentre en compte avant la rasterisation du pipeline OpenGL (http://neogamedev.chable.net/images/...ationsOGL.gif)

Donc quand tu ecris glutSolidCube(20.0) tu donnes des coordonees a OpenGL qu'il va traiter et ensuite afficher a l'ecran et "dessiner" le polygone selon la valeur du blending, etc.


Sinon, concernant le motion blur et vu comme c'est parti, ca ne donnera surement rien. Donc si tu es un peu patient je vais (re)faire un prog OpenGL qui implemente le motion blur "le plus facilement possible". Je ferai ca ce week-end, donc je donnerai la source avant Dimanche soir... Ou avant tout depend de mon temps libre.

++

PS: quand rien ne marche, restart from scratch

[dams32]

Oui mais au moment où j'écris glutSolidCube(20.0), mon objet a un matériau avec un alpha à 1. Donc lorsque je copie l'écran avec glCopyTexImage2D(), l'image copiée est un cube opaque! Et plus tard lorsque j'utilise cette texture pour mon quad, même si je prend un alpha<1 pour mon quad, ca ne devrait affecter que la transparence de celui-ci, et pas la transparence du cube, puisque désormais ce n'est plus qu'une texture. Je ne sais pas si je me fais bien comprendre...
Mais c'est peut-être moi qui ai mal saisi le fonctionnement d'opengl

[Sixissor]

OK j'ai compris ce que tu veux dire.
En effet tu as raison sur ce point.

Si tu veux vraiment savoir ce que j'en pense, je doute que l'on puisse résoudre ce problème ici comme ça.
Donc ce que je te propose: essaye de chercher sur le net des codes-sources et inspire-t-en pour résoudre ton problème. Dans tous les cas je diffuserai une source sur le motion blur avant Dimanche soir... Si ça peut t'aider...

Si tu as quand même encore des questions, n'hésites pas je ferai de mon mieux pour y répondre.

[dams32]

C'est vraiment pas évident de debugger un programme en opengl, surtout quand on utilise des astuces tordues

En tout cas merci Sixissor, et si jamais des personnes ont des idées sur mon problème, qu'ils n'hésitent pas !

[LeGreg]

Si tu ne désactives pas le blending quand tu traces ton cube, ton cube va etre semi-transparent.
Cela veut dire que certains polygones qui sont usuellement des faces cachées vont apparaitre suivant l'ordre dans lequel ils sont tracés.

Désactives le blending quand tu n'en as pas besoin.

LeGreg

[dams32]

LeGreg, je ne comprends pas bien pourquoi tu dis que mon cube sera semi-transparent si je ne désactive pas le blending, puisqu'au moment du dessin du cube, son matériau a un alpha=1. Peux-tu préciser ta pensée? lol

(tiens c'est marrant, il y a quelques mois je suis tombé sur ton site, et j'ai fait mon ptit raytracer grâce à toi, tes articles sur le sujet sont géniaux, merci !!)

[LeGreg]

déjà tu as deux variétés de la variable "white", l'une avec alpha = 1 et l'autre avec alpha = 0.5.
Celle avec alpha = 0.5 est utilisé pour modifier diffuse et ambiant, celle avec alpha = 1 est utilisé pour modifier specular.

A moins qu'il y ait quelque chose que tu n'as pas indiqué dans le code posté, ton cube va donc etre tracé avec un alpha de 0.5 (modulo tes calculs de texture et de shading bien entendu..).

De toute façon désactiver le blending quand tu ne l'utilises pas c'est la moindre des choses. 1 - ça évite des erreurs incongrues. 2 - c'est beaucoup demander au hardware de faire du blending quand il n'y en a pas, perf en pixels tracés/sec peut etre divisé par deux ou plus.

LeGreg

[dams32]

Parfait, tu viens de résoudre mon problème! En effet, j'utilisais white uniquement pour le specular lorsque je dessinais ma sphère! Ca marche beaucoup mieux maintenant

Merci à tous pour vos réponses!

[Sixissor]

gg LeGreg pour les propriétés Specular et Diffuse/Ambient
J'ai même pas été foutu de voir ça alors que c'était sous mes yeux, honte à moi !

Comme quoi c'est toujours mieux d'essayer de résoudre des problèmes à plusieurs
L'un arrive à voir ce que l'autre ne voit pas...


PS: Ca me rappel les mots flêchés étrangement... Tu passe 30 min à chercher des mots et une personne arrive et te les complètent cash...