[débutant] stencil buffer

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

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, 15h59

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, 16h12

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, 16h23

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, 10h24

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, 11h54

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?

**shenron666** · 07/08/2008, 11h59

tu devrais essayer d'afficher en polygones pleins ton volume d'ombre
afin de t'assurer que c'est bien un volume que tu crées
et que ton volume est suffisamment étiré pour passer à travers le sol
parceque l'ombre générée par cette technique est en fait l'intersection entre le sol et le volume d'ombre

**tchoco** · 07/08/2008, 12h08

je viens de vérifier, le volume créer passe bien en dessous de mon sol.

mais mon sol ne cache pas ce qui passe dessous, le volume est entiérement visible

**shenron666** · 07/08/2008, 13h10

s'il n'y a pas intersection, ça ne marchera pas
ton volume doit passer au travers de ton sol
si tu affiches le volume comme si c'était un objet 3D normal (surfaces pleines, test de profondeur activé) tu devrais voir le volume de ton objet projeté jusque ton sol et le sol qui cache ce qu'il y a dessous

**tchoco** · 07/08/2008, 13h18

ok, je viens de trouver ...j'avais un depth test qui ne se faisait pas!

désolé....

Donc maintenant, j'en reviens à mon stencil buffer......

Lorsque je fais la première passe (cf photo) j'obtiens un volume noir (pas transparent du tout).
Lorsque je fais la deuxième phase, plus rien......

**tchoco** · 07/08/2008, 17h47

j'ai beau cherché...je tourne en rond!

le volume d'ombre crée, est plein, il ne prend pas la transparence, et la deuxième passe ne fait rien apparaitre (du moins rien n'est visible).

Alors je me pose la question, je fais toute cette opération de génération d'ombre dans une liste, peut etre que comme certains appels sont imposibles depuis une liste (cf. red book: glIsEnabled()), je ne puisse pas jouer avec la couche alpha.......mais j'y crois pas vraiment !

Alors si qqun à un avis, même une toute toute petite idée....ca serait bien venu!

**shenron666** · 07/08/2008, 18h03

bah ça devrait pas être compliqué de tester sans la liste non ?
le fait que tu n'arrives pas à activer la transparence c'est que tu dois faire une erreur quelque part

dans ton programme normal, après avoir fait les 2 passes du volume d'ombre, tu affiches un triangle strip, il couvre bien TOUT l'écran ?
il m'a l'air petit, tu devrais essayer de l'afficher sans le test stencil afin de t'assurer qu'il couvre bien ton champ de vision et surtout toute l'intersection entre le volume d'ombre et le sol

**tchoco** · 07/08/2008, 18h18

je vérifie ca demain, je te tiens au courant!
encore merci!!

**tchoco** · 07/08/2008, 20h43

en fait, j'ai pas arrêté de penser à ce que tu m'as dit, j'ai donc vite fait tracer le rectangle...Et surprise (ou pas) il était tout petit, donc j'ai décidé d'en refaire un plus grand...mais comment est ce que je règle la coordonnée Z de ce plan?!

J'ai cherché dans les tutos...et pas vu ...

Pour être plus précis maintenant sur mon problème de transparence. J'ai fait le test suivant :
Au lieu de faire les 2 passes qui appelle la méthode pour tracer les shadow-quads (la projection des edges depuis l'objet), je réduit ma fonction à juste un appel à la fonction de tracé des shadow-quads (juste ca!).
Dans cette fonction de tracé, je rajoute une couleur, et j'autorise le GL_BLEND et GL_COLOR_MATERIAL, puis je trace, et je désactive tout.
Et j'obtiens bien les shadow-quads, qui intersectent le sol, en transparence.

Donc j'en déduit que je peux faire du blending si je veux.

Alors je reviens maintenant sur ma fonction au 2 passes avec le stencil buffer qui ne marche pô!

Pour le moment, je dois comprendre cette histoire de plan et qui sait, ca pourrait me décoincer...

**shenron666** · 08/08/2008, 12h06

normalement le plan, tu le place juste après ton "near plan"
voir ce que tu as mis comme valeur dans gluPerspective

[débutant] stencil buffer

OpenGL

Discussions similaires

Partager

Partager