[débutant] stencil buffer

**tchoco** · 06/08/2008, 12h49

Bonjour,

je cherche à appliqué le tuto de NEHE lesson27 et je suis bloqué depuis ........un bon moment maintenant!

Lorsque j'applique la première passe de l'algo j'ai une projection qui apparait, mais elle n'est pas transparente. Pourtant j'ai bien activé le blending.

Et si j'applique la deuxième passe, je n'est pas l'ombre sur mon sol.

remarque: j'ai bien initialisé le buffer avec

dans my_display:

Code :

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

glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT |GL_ACCUM_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

dans le main:

Code :

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

  glutInitDisplayMode (GLUT_RGBA | GLUT_DEPTH | GLUT_ACCUM | GLUT_DOUBLE | GLUT_STENCIL);

N'ayant pas une parfaite connaissance du stencil buffer, je pense que le problème vient de là.
Mais je reste tout ouie à vos avis!

**shenron666** · 06/08/2008, 14h59

le code que tu montres est inutile à la résolution de ton problème
il faudrait plutot nous montrer ce que tu fais dans ta boucle d'affichage

**tchoco** · 06/08/2008, 15h12

Alors désolé pour le premier post....

Je vous met les fonctions:

cette fonction va m'établir les voisins de chaque polygones, puis je récupère les points du couple de surface voisine éclairée / non-éclairée. Puis je prend ces points et je cherche quel est le coté qui est en commun afin de définir la frontière (l'edge proprement dit).

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
void Silhouette3DS( lib3ds_obj *obj, float *lp, GLuint * g_lst )
{   
     SetConnectivity3DS(obj);
 
 
    *g_lst = glGenLists (2);
     glNewList (*g_lst, GL_COMPILE);
 
     int i , j;
     vertex_type A, An, B, Bn, C, Cn, N;
 
 
     for (i=0; i<obj->polygons_qty; i++)
        {
 
            if(  obj->polygon[i].normal[0]* -lp[0]
                +obj->polygon[i].normal[1]* -lp[1]
                +obj->polygon[i].normal[2]* -lp[2] <0)
                              obj->polygon[i].visible = GL_TRUE ;
 
            else
                              obj->polygon[i].visible = GL_FALSE ;
 
	}
    glPushMatrix ();
    glRotatef (90, 1, 0, 0);
 
    for (i = 0; i < obj->polygons_qty; i++)
      {
 
        if ( (obj->polygon[i].visible ) )
         {
 
          for (j=0;j<3;j++)
           {
 
		int k = obj->polygon[i].neigh[j];
 
                if ( (obj->polygon[k].visible == GL_FALSE))
                  {
                    //si mon voisin n'est pas visible, c'est que j'ai un edge
                    // je doit le dessiner
 
                     // get the three vertices of the triangle
                    A = obj->vertex[obj->polygon[i].a];
                    B = obj->vertex[obj->polygon[i].b];
                    C = obj->vertex[obj->polygon[i].c];
 
                    An = obj->vertex[obj->polygon[k].a];
                    Bn = obj->vertex[obj->polygon[k].b];
                    Cn = obj->vertex[obj->polygon[k].c];
 
;
 
                    // Compute normal
                    N.x = (B.y - A.y) * (C.z - A.z) - (C.y - A.y) * (B.z - A.z);
                    N.y = -(B.x - A.x) * (C.z - A.z) + (C.x - A.x) * (B.z - A.z);
                    N.z = (B.x - A.x) * (C.y - A.y) - (C.x - A.x) * (B.y - A.y);
 
 
                    /*je test chaque point pour trouver la face commune aux 2 polygones*/
                    FaceCommune (A, B, C, An, Bn, Cn, N);
                    FaceCommune (B, A, C, An, Bn, Cn, N);
                    FaceCommune (C, A, B, An, Bn, Cn, N);
 
                  }
 
 
           }
          }
        }
 
 
  glPopMatrix (); 
  glEndList ();
}

Une fois fait, cette précédente fonction m'appelle FaceCommune qui me trace l'edge (je voulais vérifier le résultat) avec TracerSegment(). Puis j'appelle TracerOmbre()

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
void FaceCommune( vertex_type A, vertex_type B, vertex_type C, vertex_type An, vertex_type Bn, vertex_type Cn , vertex_type N)
{
                   if (((A.x == An.x) && (A.y == An.y) && (A.z == An.z))  ||  ((A.x == Bn.x) && (A.y == Bn.y) && (A.z == Bn.z))
                        ||  ((A.x == Cn.x) && (A.y == Cn.y) && (A.z == Cn.z)) )
 
                        {
                         if (pointSegment == 0)
                            {
                              pointSegment ++;
                              P1 = A;
                            }
 
                         if (pointSegment == 1)
                            {
                             P2 =A;
                             TracerSegment(P1,P2,N);
                             /*on peut commencer la projection du rayon lumière*/
                             TracerOmbre(P1,P2);
                             pointSegment = 0;
                            }
                        }
 
                    else
                    {
                      TracerSegment(B,C,N);
                      /*on peut commencer la projection du rayon lumière*/
                      TracerOmbre(B,C);
                    }
}

TracerOmbre est une fonction copié du tuto NEHE lesson 27. J'ai initialisé le stencil buffer comme je l'ai mis dans le premier post. Puis je commence la première passe en dessinant la scène en incrémentant le stencil buffer. Puis je décrémente le stencil lors de la deuxième passe.
Puis je trace un rectangle noir transparant couvrant la snène pour faire apparaitre l'ombre

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
void TracerOmbre(vertex_type A, vertex_type B)
{
 
        glPushAttrib( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_ENABLE_BIT | GL_POLYGON_BIT | GL_STENCIL_BUFFER_BIT );
	glDisable( GL_LIGHTING );					// Turn Off Lighting
	glDepthMask( GL_FALSE );					// Turn Off Writing To The Depth-Buffer
	glDepthFunc( GL_LEQUAL );
	glEnable( GL_STENCIL_TEST );					// Turn On Stencil Buffer Testing
	glColorMask( GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE );		// Don't Draw Into The Colour Buffer
	glStencilFunc( GL_ALWAYS, 1, 0xFFFFFFFFL );
 
 
 
	// First Pass. Increase Stencil Value In The Shadow
	glFrontFace( GL_CCW );
	glStencilOp( GL_KEEP, GL_KEEP, GL_INCR );
        TracerProjection( A, B);
 
 	// Second Pass. Decrease Stencil Value In The Shadow
	glFrontFace( GL_CW );
	glStencilOp( GL_KEEP, GL_KEEP, GL_DECR );
        TracerProjection( A, B);
 
 
 
 
	glFrontFace( GL_CCW );
	glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );	// Enable Rendering To Colour Buffer For All Components
 
	// Draw A Shadowing Rectangle Covering The Entire Screen
	glColor4f( 0.0f, 0.0f, 0.0f, 0.4f );
	glEnable( GL_BLEND );
	glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
	glStencilFunc( GL_NOTEQUAL, 0, 0xFFFFFFFFL );
	glStencilOp( GL_KEEP, GL_KEEP, GL_KEEP );
	glPushMatrix();
	glLoadIdentity();
	glBegin( GL_TRIANGLE_STRIP );
		glVertex3f(-0.1f, 0.1f,-0.10f);
		glVertex3f(-0.1f,-0.1f,-0.10f);
		glVertex3f( 0.1f, 0.1f,-0.10f);
		glVertex3f( 0.1f,-0.1f,-0.10f);
	glEnd();
	glPopMatrix();
	glPopAttrib();
        glEnable(GL_LIGHTING);
 
}

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
void TracerProjection(vertex_type A, vertex_type B)
{
        vertex_type v1, v2,  N1;  //v3, v4,  N2;
 
             v1.x = (A.x - light_sea1_position[0])*100;
         	v1.y = (A.y - light_sea1_position[1])*100;
	v1.z = (A.z - light_sea1_position[2])*100;
 
         	v2.x = (B.x - light_sea1_position[0])*100;
          	v2.y = (B.y - light_sea1_position[1])*100;
           	v2.z = (B.z - light_sea1_position[2])*100;
 
                // Compute normal
                N1.x = (B.y - A.y) * (v1.z - A.z) - (v1.y - A.y) * (B.z - A.z);
                N1.y = -(B.x - A.x) * (v1.z - A.z) + (v1.x - A.x) * (B.z - A.z);
                N1.z = (B.x - A.x) * (v1.y - A.y) - (v1.x - A.x) * (B.y - A.y);
 
                //draw the polygon
	   glBegin(GL_TRIANGLE_STRIP);
	   glNormal3f(N1.x, N1.y, N1.z);
	   glVertex3f(A.x, A.y, A.z);
	   glVertex3f(A.x + v1.x, A.y + v1.y, A.z + v1.z);
         	   glVertex3f(B.x, B.y, B.z);
          	   glVertex3f(B.x + v2.x, B.y + v2.y, B.z + v2.z);
                glEnd();
 
 
}

Merci de m'avoir lu!

**tchoco** · 06/08/2008, 15h23

Voilà les résultas obtenue à chaque étape.

Popur passer de la 2eme à la 3eme, je désactive la couleur et la transparence

**tchoco** · 07/08/2008, 09h24

Bon je galère toujours pour ma génération d'ombre.

Lorsque je fais ma première passe, j'ai un volume qui apparait. Mais mon, plan ne cache pas se qui se cache dessous....

Et lorsque je fais ma deuxième passe.....rien ne s'affiche!

Help SVP!

**tchoco** · 07/08/2008, 10h54

j'ai l'impression que le sol sur lequel l'ombre devrait apparaitre ....ne masque pas le volume d'ombre qui passe sous lui....

Problème de buffer? Depth? Stencil?

[débutant] stencil buffer

OpenGL

Vue hybride

Discussions similaires

Partager

Partager