Discussion :

[acx01b]

Bonjour,

j'ai renommé mon sujet il s'intitule Y-fighting

c'est à dire: j'ai un petit problème avec un code de shadowmap en opengl et glsl

ce code fonctionne bien pour les objets de base (glVertex)
avec une lumière en (0,80,0) mais pas sur des objets un peu plus complexes (des gluSphere par exemple)
on dirait que la lumière vient alors de (80,0,0)

la solution (provisoire je l'espère) que j'ai trouvé est de remplacer
le glTranslatef(0.5,0.5,0.5); du bias de la projection dans la coordonnée lumière par glTranslatef(0.5,0.4915,0.49995);
et là j'obtiens quelque chose d'à peu près correct sur toute ma scène

pour le translate de 0.49995 en Z ok c'est compréhensible (Z-fighting), mais en Y ?????????
c'est vraiment bizarre

voici le code incriminé:


création du fbo

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
 
    GLuint fbo;
    GLuint depth_texture;
 
    glGenFramebuffersEXT(1, &fbo);
    glGenTextures(1, &depth_texture);
    glBindTexture(GL_TEXTURE_2D, depth_texture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_INTENSITY);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
 
    glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, w, h, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, depth_texture, 0);
    glDrawBuffer(GL_NONE);
    glReadBuffer(GL_NONE);
    CHECK_FRAMEBUFFER_STATUS();
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

la boucle d'affichage

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
53
54
55
56
57
 
        /* dessin de la shadow map (render depth buffer to texture) */
 
       glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
 
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective(50,(float)w/h,1,100);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        gluLookAt(0,80,0,0,0,0,1,0,0);
 
        glClear(GL_DEPTH_BUFFER_BIT);
        glEnable(GL_POLYGON_OFFSET_FILL);
        glPolygonOffset (1.1,4);
        afficher_scene();
        glDisable(GL_POLYGON_OFFSET_FILL);
 
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
 
        /* dessin de la scène ombrée */
 
        glUseProgram(shad);
 
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
        glActiveTextureARB(GL_TEXTURE0_ARB);
        glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D,depth_texture);
 
        glMatrixMode(GL_TEXTURE);
        glLoadIdentity();
        //glTranslatef(0.5,0.5,0.5);
		glTranslatef(0.5,0.4915,0.49995);
        glScalef(0.5,0.5,0.5);
        gluPerspective(50,(float)w/h,1,100);
        gluLookAt(0,80,0,0,0,0,1,0,0);
 
        glActiveTextureARB(GL_TEXTURE1_ARB);
        glEnable(GL_TEXTURE_2D);
        glMatrixMode(GL_TEXTURE);
        glLoadIdentity();
        gluLookAt(0,80,0,0,0,0,1,0,0);
 
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective(50,(float)w/h,1,100);
 
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        gluLookAt(0,80,0,0,0,0,1,0,0);
 
        afficher_scene();
 
        glUseProgram(0);
 
        SDL_GL_SwapBuffers();

le vertex shader

Code :

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

1
2
3
4
5
6
7
8
varying vec4 proj_shadow;
 
void main(void)
{
	gl_Position = ftransform();
	gl_FrontColor = gl_Color;
	proj_shadow = gl_TextureMatrix[0] * gl_TextureMatrixInverse[1]  * gl_ModelViewMatrix * gl_Vertex;
}

le pixel shader

Code :

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

1
2
3
4
5
6
7
8
9
uniform sampler2DShadow shadow_map;
 
varying vec4 proj_shadow;
 
void main()
{
	gl_FragColor = shadow2DProj(shadow_map, proj_shadow) * gl_Color;
 
}

en même temps ce code fonctionne pour les objets de base donc il peut aussi servir à quelqu'un qui veut essayer les shadow map

merci d'avance pour votre aide,
Renaud

[Bakura]

Ça va peut-être rien changé, mais en ajoutant glEnable (GL_DEPTH_TEST), le problème est toujours présent ?

[acx01b]

oui les 2 premières lignes de mon programme après initialisation de SDL étaient bien glClearColor(0,0,0,0); glEnable(GL_DEPTH_TEST);

par contre j'ai trouvé un truc qui supprime ce Y-fighting, mais qui laisse inchangé le Z-fighting !!!
(on a plus besoin de la ligne horrible glTranslatef(0.5,0.4991,0.491); ...)

la texture shadow map (qui stocke le depth buffer): doit être de taille une puissance de 2 (par exemple 512x512 ou 1024x512 ou 1024x1024)

au moment de faire la matrice de projection pour le rendu vu de la lumière:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
 
      /* Affichage vu de la lumière */
       glMatrixMode(GL_PROJECTION);
       glLoadIdentity();
        glPushAttrib(GL_VIEWPORT_BIT);  // <--- rajouté
        glViewport(0,0,1024,512);     // adapter le viewport
        gluPerspective(120,(float)1024/512,1,100);
        ...
        afficher_scene();
        glPopAttrib(); // <---- remetre le viewport pour l'écran

grâce au pushattrib et au viewport on peut avoir une depth texture 1024x512 avec et un écran 1200x800 par exemple

Pourquoi ça change quelque chose d'avoir une texture de taille puissance de 2 ?

sûrement un problème d'approximation par le GPU et de flottants (sur le GPU) de précision faible

en gros: il reste le Z-fighting et apparement chacun y va de sa méthode pour le diminuer / supprimer

donc ce sujet est pour ainsi dire résolu (si personne ne vient me contredire): trop d'approximations sur les GPU pour faire sérieusement des shadow map ?

[F-fisher]

Salut,
Je crois que je sais d'où vient ton problème, c'est au niveau de la création de ta depth map, tu spécifie GL_DEPTH_COMPONENT24, alors qu'il se peut que ton depth buffer soit à 32 bits !
Le meilleur moyen est d'utiliser GL_DEPTH_COMPONENT tout court, ainsi, openGL va choisir le nombre de bits selon la profondeur actuelle de ton depthBuffer.
Merci pour les sources