Discussion :

[Jorjor]

Bonjour,

J'ai développé une application iPad (en objective-C) qui me permet de charger et de visualiser des objets 3D (*.obj). Et je souhaite maintenant pouvoir réaliser des coupes sur ces objets, à partir d'autres objets 3D qui me serviront de boite de coupe.
J'ai effectué quelques recherches concernant les différentes méthodes pouvant me permettre de couper mes objets. Et je suis souvent tombé sur la CSG (Constructive solid geometry) et la soustraction d'objets 3D, or je n'ai pas trouvé d'exemple concret pouvant me servir de modèle (je débute en openGL).
J'ai également vu que l'on pouvait utiliser des shaders, mais j'avoue que je n'en ai jamais utilisé.

Est-ce quelqu'un à une idée, un exemple, ou une remarque pouvant m'aider à avancer ?

Merci.

[p3ga5e]

J'ai également vu que l'on pouvait utiliser des shaders, mais j'avoue que je n'en ai jamais utilisé.

Impossible ! En OpenGL ES 2.X tu es obligé d’utiliser le pipeline programmable donc au minium de 2 shaders (Vertex et Pixel)

Les techniques CSG et soustraction sont des techniques de modélisation 3D n’ayant rien avoir avec le temps réel et OpenGL. Si tu souhaites réaliser tes coupes lors de la rastérisation de tes éléments 3D, alors regarde donc plus en détails le fonctionnement du Stencil Buffer. Ce que tu souhaites réaliser me semble être un bon cas d’école pour la manipulation du stencil.

[ShevchenKik]

Bonjour,

Impossible ! En OpenGL ES 2.X tu es obligé d’utiliser le pipeline programmable donc au minium de 2 shaders (Vertex et Pixel)

Si, possible: bien qu'OpenGL ES 2.0 soit supporté dès l'iPad 1, l'iOS permet de créer un contexte OpenGL ES 1.1 (Dans ce cas le pipeline fixe est recréé par des shaders en fait, mais c'est invisible pour le dévelopeur, donc c'est parfaitement possible que Jorjor n'ait jamais touché à un shader).

Bref, en ce qui concerne la vue en coupe je suis du même avis que toi par contre, ca se fait avec le stencil buffer.

le principe c'est d'utiliser un clip plane pour découper ton objet, puis le stencil buffer pour "remplir" la tranche coupée (sinon tu observes l'intérieur de ton objet).

un lien là dessus:
ftp://ftp.sgi.com/opengl/contrib/bly...es/node21.html

Et un extrait de mon code OpenGL 1.x (ca tombe bien qui affiche une coupe en 3d:

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
 
// 1. Configure clip plane and turn-it ON
// -------------------------------------------------------------------------------
double[] eqn = new double[4] { 0.0, 0.0, -1.0, this.clipPlaneDepth };
Gl.glClipPlane(Gl.GL_CLIP_PLANE0, eqn);
 
Gl.glPushAttrib(Gl.GL_ENABLE_BIT);
    Gl.glEnable(Gl.GL_CLIP_PLANE0);
 
    Gl.glPushMatrix();
        Gl.glRotatef(-90.0f, .0f, 1.0f, .0f);
        Gl.glCullFace(Gl.GL_BACK);  
        Gl.glEnable(GL_CULL_FACE);     
        //>>>>>>> Draw object's outside (we are culling back faces)<<<<<<<<<<<<<
 
        // 2. Cull front face and turn Stencil-Test ON
        //              Stencil func: set to always pass and set reference value to 1
        //              Stencil op: set the low stencil if z-compare is successful
        // -------------------------------------------------------------------------------       
        Gl.glCullFace(Gl.GL_FRONT);           
        Gl.glStencilFunc(Gl.GL_ALWAYS, 1, 1);
        Gl.glStencilOp(Gl.GL_KEEP, Gl.GL_KEEP, Gl.GL_REPLACE);
        Gl.glEnable(Gl.GL_STENCIL_TEST);
        Gl.glPolygonOffset(-.1f, .1f);
        Gl.glEnable(Gl.GL_POLYGON_OFFSET_FILL);
 
        //>>>>>>>>>>>>> Draw object's inside (we are culling front faces) <<<<<<<<<
    Gl.glPopMatrix();
 
        // 3. Turn off culling and clipping plane
        // -------------------------------------------------------------------------------
       Gl.glDisable(Gl.GL_CLIP_PLANE0);
       Gl.glStencilFunc(Gl.GL_EQUAL, 1, 1);
       Gl.glStencilOp(Gl.GL_KEEP, Gl.GL_KEEP, Gl.GL_KEEP);                Gl.glPopAttrib();

NOTE: le glPolygonOffset c'est optionel, rajouté plus tard pour éviter les problèmes de Z-fighting, tu peux essayer sans pour commencer.

Voilà pour commencer, j'espère que ca t'aidera!
Bonne chance!

[Jorjor]

Bonjour,

Merci pour ta réponse !
En effet, j'ai pu remarquer la présence des shaders car ils ont étés générés automatiquement, mais je ne m'y suis pas interessé jusqu'à présent (j'ai repris l'exemple de base).
J'ai pu me renseigner et j'ai cru comprendre que le Stencil Buffer filtrait les pixels.
Sachant que pour générer et charger mes objets 3D, j'utilise une bibliothèque (ninevehGL). J'aimerai savoir si le Stencil Buffer peut s'appliquer directement sur ces objets 3D ? Ou alors, dois-je générer/parser manuellement mes fichiers *.obj afin de disposer de toutes les coordonnées dans un tableau, afin que le Stencil Buffer puisse avoir accès à toutes ces données ?

Merci.

[Jorjor]

Bonjour ShevchenKik,

Merci beaucoup pour ton aide !
Je vais tout de suite me pencher sur ton exemple.

Bonne journée.

[p3ga5e]

J’ai du mal à comprendre ce que tu souhaites obtenir, l’utilisation du stencil te permettra d’obtenir une coupe "visuelle", donc lors de la rastérisation uniquement, cela ne touche en rien la géométrie de tes objets

Un exemple WebGL d’intersection et de soustraction utilisant le stencil a été posté sur une discution similaire ici. WebGL est en réalité une API OpenGL ES 2.0 , le code source de l’exemple est clean, tu auras pas trop de souci pour l’adapter

[ShevchenKik]

Re,

Sachant que pour générer et charger mes objets 3D, j'utilise une bibliothèque (ninevehGL). J'aimerai savoir si le Stencil Buffer peut s'appliquer directement sur ces objets 3D ? Ou alors, dois-je générer/parser manuellement mes fichiers *.obj afin de disposer de toutes les coordonnées dans un tableau, afin que le Stencil Buffer puisse avoir accès à toutes ces données ?

Je dirais: qu'importe!

=> charger un .obj dans OpenGL, que tu le fasses toi-même ou à l'aide d'une lib, ca veut dire convertir les coordonées de tes sommets, normales etc en commandes comprehensibles par OpenGL. Ca veut dire stocker tes sommets dans un vertex Array, Vertex Buffer Object ou Vertex Array object, en fonction de ce qui est supporté par ta carte graphique (sur l'iPad tu peux utiliser directement les VAOs, mais je te conseille de commencer par les VAs puis les VBOs si tu ne connais pas encore).

Apres le stencil se débrouille: tant que tu utilises des commandes OpenGL pour envoyer des sommets à dessiner, il pourra les récupérer.

[Jorjor]

Bonjour p3ga5e,

Merci pour ton exemple, c'est très proche de ce que je souhaite réaliser. Sauf que je souhaite que l'objet permettant la coupe ne soit pas visible. Pour être plus clair, en reprenant ton exemple je souhaite que juste le cube et la coupe soit visible et que la sphère soit "cachée".

Merci beaucoup pour vos réponses.

[Jorjor]

Re ShevchenKik,

Merci pour ta réponse, ca me paraît plus clair à présent.

[Jorjor]

Bonjour,

Désolé de relancer le topic. Je suis désespérément à la recherche d'un tutoriel ou d'un exemple d'utilisation afin de retranscrire vos exemples en openGL ES 2.0. En effet, la syntaxe est assez différente que celle dans les exemples qui m'ont été donné.
J'ai effectué des recherches sur internet et j'ai pu dégoter des exemples normalement fonctionnels comme par exemple :

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
    glBindRenderbufferOES(GL_RENDERBUFFER_OES,depthStencilRenderbuffer);
    glRenderbufferStorageOES(GL_RENDERBUFFER_OES,
                             GL_DEPTH24_STENCIL8_OES,
                             backingWidth,
                             backingHeight);
    glGenRenderbuffers(1, &depthStencilRenderbuffer);
    glBindRenderbuffer(GL_RENDERBUFFER, depthStencilRenderbuffer);
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthStencilRenderbuffer);
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, depthStencilRenderbuffer);
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
    /*glVertexPointer(2, GL_FLOAT, 0, vertices);
    glTexCoordPointer(2, GL_FLOAT, 0, texcoords);*/
 
    glClearStencil(0);
    glClearColor (0.0,0.0,0.0,1);
    glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 
 
    // mask rendering
    glColorMask( GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE );
    glEnable(GL_STENCIL_TEST);
    glEnable(GL_ALPHA_TEST);
    glBlendFunc( GL_ONE, GL_ONE );
    glAlphaFunc( GL_NOTEQUAL, 0.0 );
    glStencilFunc(GL_ALWAYS, 1, 1);
    glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
 
    glDrawArrays(GL_TRIANGLE_STRIP, 4, 4);
 
    // scene rendering
    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
    glStencilFunc(GL_EQUAL, 1, 1);
    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);

Sans résultats. Il m'est impossible de créer le stencil.

Est-ce que quelqu'un aurait connaissance d'un tutoriel sur l'utilisation des stencils buffer avec opengl es 2.0 ?

[Jorjor]

Bonjour,

Résolu, je poste la méthode permettant cette opération pour les interessés :

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
 
-(void) drawSubtraction:(NGLMesh*)objet1 with:(NGLMesh*)objet2
{
 
	// write back of A in depth and stencil
	// Spécifie, pour Gl.ColorMaski, l'indice du tampon de tracé auquel
	// appliquer le masque de couleur. STATIC SUB ColorMask ( Red AS Boolean,
	// impact sur la couleur de la partie coupé :
	glColorMask(false, false, false, false);
 
	glCullFace(GL_FRONT);
 
	glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
 
	[self drawMeshCoupe:objet1];
	// draw back of B where it hides backside of A
 
	// modifie la couleur de l'objet coupé vue a travers l'objet coupant
	glColorMask(true, true, true, true);
 
	// test du pochoir.
	glStencilFunc(GL_EQUAL, 1, 1);
 
        [self drawMeshCoupant:objet2];
	// draw front of A where it is falsely hidden by back of B
 
	glCullFace(GL_BACK);
	//glUniform1f(shader.normalDirectionUniform, 1.0);
 
	glStencilFunc(GL_EQUAL, 2, 2);
	// if our fragment has a Z value that is greater than the one that is
	// currently there, use our new one rather than the old one
	glDepthFunc(GL_GREATER);
 
        [self drawMeshCoupe:objet1];
	glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 
	// write front of B in depth
	glStencilFunc(GL_ALWAYS, 0, 0);
	glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
	// if our fragment has a Z value that is less than the one that is currently
	// there, use our new one rather than the old one
	glDepthFunc(GL_LESS);
 
	glColorMask(false, false, false, false);
 
        [self drawMeshCoupant:objet2];
	// draw front of A
 
	glColorMask(true, true, true, true);
 
        [self drawMeshCoupe:objet1];
}

Rappel : pour l'affiche de mes objets j'utilise la libraire ninevehgl d'ou les objets NGLMesh.