Sélection d'objets par méthode des couleurs, avec transparence.

[goperto]

Bonjour à tous,

je butte sur un problème depuis un petit moment.
Je souhaite déterminer l'objet sur lequel je clique, dans un contexte graphique GL. Après avoir essayé la méthode par picking, je me suis intéressé à la méthode des couleurs.
La raison principale c'est que j'affiche des QUADS texturés, lesquels peuvent présenter des zones transparentes. Et je souhaite que le click souris sélectionne l'objet le plus proche qui soit non-transparent à cet endroit.

J'ai galéré un moment avec les diverses fonctions de transparence, de textures d'environnement, etc.. en vain.

Ce que je souhaite c'est tracer mes QUADS en leur affectant une couleur distincte (ce qui me permet de déterminer l'objet sélectionné après le glReadPixels() ) tout en reproduisant les zones de transparence.

La solution évidente c'est de recréer des textures unicolores (une couleur distincte par objet) qui reproduise le canal alpha des textures originales.
L'ennui c'est que dans ce cas j'aurais à stocker d'un côté les textures originales des QUADS et de l'autre les textures unicolores qui ne servent qu'à la sélection.

Je cherchais un moyen pour éviter ça, par exemple en appliquant un facteur quelconque à la texture originale, de sorte que le canal alpha soit appliqué tel quel, mais que les canaux RGB ne montrent plus l'image originale mais juste une couleur particulière..

Je suis prêt à préciser ma pensée si je n'ai pas été clair.
Merci pour tout conseil !

GOperto

[goperto]

Je viens de mettre en oeuvre la "solution évidente" consistant à créer, à part, des textures unicolores reproduisant le canal alpha des textures originales.
Voici une capture du résultat que je souhaite obtenir :



à gauche, j'affiche des QUADS texturés normalement, dont certains présentent une zone transparente au milieu,
à droite, j'affiche les mêmes QUADS, présentant les mêmes zones transparentes, mais chaque texture ne montre qu'une seule couleur, ce qui me permet de savoir sur quel objet je clique.

Ce que je souhaitais donc, c'est une éventuelle façon de bidouiller le rendu des textures originales de sorte à obtenir le même résultat sans avoir à créer de textures supplémentaires.
Je me demandais si c'était possible en trafiquant avec les fonctions glTexEnv(), glBlendFunc(), glColor(), etc..

Voilà, merci d'avance pour toute aide !

[Suryavarman]

pour la passe du picking :

Code :

1
2
 
glDisable(GL_TEXTURE_2D);

ensuite tu dessinnes tes objets en mettant ça avant:

Code :

1
2
 
glColor3f (0.0f, 0.0f, ObjetCourant->GetRedColor() );

et tu réactives tes textures quand ta fini de dessinner tes objets
(quand tu dessinnes dans un buffer autre que le front
fait un

Code :

1
2
3
 
        glDrawBuffer(GL_RIGHT);
        glReadBuffer(GL_RIGHT);//(si tu dessinnes dans le right par exemple)

et nettoi le avant de dessinner

Code :

1
2
 
glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

si t'a plus de 255 objets regarde les formats des pixels que tu peus stocker sinon utilise les trois composantes ça te fera 65k d'objets pickables.

[goperto]

merci pour ta réponse mais ça ne m'aide pas beaucoup : c'est la transparence des textures qui m'intéresse.
Je peux m'éclaircir si besoin est.

[Suryavarman]

Code :

1
2
 
glColor4f(0.0f,0.0f,1.0f,ObjetCourant->GetAlphaColor() )

[goperto]

En fait, ce n'est pas la réponse que j'attends ou alors je n'ai pas compris.

Tu as l'air de me faire affecter une valeur discriminante à la transparence de chaque objet. Ce que j'explique dans mon post c'est que je souhaite donner une couleur discriminante à chaque objet mais en reproduisant le canal alpha de la texture originale appliquée.

C'est facilement réalisable si au départ je crée un ensemble de textures (autant qu'il y a d'objets), chaque texture étant unicolore (d'une couleur permettant de distinguer l'objet parmi les autres) mais reproduisant le canal alpha de la texture que j'applique à mon QUAD dans mon rendu.
Ma question c'est est-il possible de trafiquer, par exemple avec les fonctions de rendu de texture citées précédemment, pour éviter de créer ces textures, en gros j'aimerais un truc du genre :

Code :

1
2
3
4
5
6
7
8
9
 
glTexEnv(GL_MODULATE_QUI_NE_RETIENT_QUE_LE_CANAL_ALPHA_DE_LA_TEXTURE_ET_QUI_ZAPPE_LES_AUTRES_VALEURS_DE_COULEURS);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // fonction de transparence ordinaire
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBegin(GL_QUADS);
glColor4f(ma_couleur_discriminante,0.0,0.0,un_alpha_quelconque_le_but_etant_que_l_alpha_du_QUAD_soit_dicte_par_la_texture);
glEnd();
//etc...

Merci d'avance

[Laurent Gomila]

Y a un truc que je ne comprends pas. Pourquoi vouloir garder l'alpha si c'est pour faire du picking ? D'autant plus que du coup la couleur finale ne sera plus celle que tu auras affectée à l'objet.

[goperto]

Parce qu'en fait les textures de mes QUADS présentent des zones de transparence. Et par exemple si l'un de mes QUADS représente - admettons - un anneau (dont le centre serait donc transparent), je souhaite qu'en cliquant au centre de l'anneau ce soit non pas l'anneau qui soit sélectionné mais le premier objet non-transparent recouvrant cette zone. L'anneau quant à lui ne serait sélectionné qu'en cliquant sur ses zones non-transparentes (donc sur l'anneau "lui-même" et non pas sur tout son QUAD associé).
Voilà

[Laurent Gomila]

Ok. Dans ce cas utilise plutôt l'alpha-test, ce sera plus économique que l'alpha-blending.

Ensuite je pense qu'effectivement il faut bien paramétrer les unités de texture. Je saurais le faire avec DirectX, mais pas avec OpenGL... désolé

[raptor70]

http://www.developpez.net/forums/d60...color-picking/

[shenron666]

la transparence c'est bon pour l'affichage
pour du picking, on ne fait pas de rendu de transparence

[GoldenEye]

Raptor => j'ai bien réussi à faire le picking color mais pour reprendre l'exemple du topic que j'ai relancé, imaginons un anneau, si on clicke au centre de l'anneau, celui ci ne doit pas être sélectionné
Shenron => même en trafiquant les glTexEnv comme suggéré plus ?
Merci quand même !

[TanEk]

Il y a deux choses différentes avec la composante alpha : l'alpha test qui consiste à afficher un pixel en fonction de sa valeur en alpha et le blending. Tu peux donc très bien garder l'alpha test qui permet de faire des trous dans ton anneau (en désactivant le blending) pour faire du picking color.

Tu fais donc une génération de ton id sur les composantes rgb de ton objet (ou plutôt de la texture sur ton objet) et tu gardes les composantes alpha de ta texture originale...

Ceci oblige à générer une texture d'identifiant pour chaque objet utilisant l'alpha test pour son rendu. Ca prend donc deux fois plus de mémoire...

Je ne sais pas s'il y a des techniques moins coûteuses... C'est une proposition comme ça

[shenron666]

Tout d'abord, est-ce que tu as cherché un peu sur le forum les sujets sur le picking et ceux sur le color picking ?

concernant l'alpha, il n'a rien à faire dans un rendu de picking
ni alpha test ni alpha blending

la raison en est simple, tu veux détecter la sélection d'un élément par rapport à une couleur prédéterminée
comment veux tu connaitre la couleur de l'anneau si celui-ci est une texture ?
ou alors ta texture doit être un masque, et encore la phase de modulation de la texture avec la couleur de l'objet sera faussée

bref, pour un algorithme de picking tu dois dessiner chaque élément sélectionnable avec une couleur bien précise
de manière à ce que le pixel que tu récupères soit de la couleur que l'objet que tu es sensé détecter

si tu fais un

Code :

glColor3ub(200,0,0);

et que tu récupère un pixel de la couleur 201,0,0 tu fais comment ?
tu peux toujours prendre une marge mais ça limite tes possibilités

- désactiver les textures
- désactiver le dithering (qui fausse les couleurs)
- utiliser glColor3ub pour définir la couleur de l'objet
- désactiver le blending / alpha test
sont des conditions primordiales au bon fonctionnement d'un color picking

Tutorial en anglais sur le color picking

[TanEk]

En quoi l'alpha test fausse le picking shenron ? Je veux bien te croire lorsque tu dis qu'il faut le supprimer pour que tout fonctionne bien mais pourquoi ? Tu n'as toujours pas fourni d'arguments qui contredise la possibilité de son utilisation, enfin de ce que j'ai compris .

Il n'est pas possible d'appliquer une texture à un objet de telle sorte que lors du rendu la couleur de la texture ne soit pas modifiée par le "matériau" de l'objet ? Dans ce cas faire un alpha-test ne pose aucun problème non ? Il faut juste bien sûr donner une texture remplie de la couleur de l'id avec l'alpha de la texture d'origine comme je le dis dans mon précédent post.

[GoldenEye]

TanEK m'a précédé je me pose la même question, en quoi un alpha test ne fonctionne pas, je dois avouer que je n'ai pas bien compris ton explication
Autre idée avant d'abandonner la chose pourquoi ne pas faire en 2 passes :
- Dessin de la texture normale avec alpha test dans le stencil buffer
- Dessin du quad pour le color picking en tenant compte de ce qui a été mis dans le stencil
C'est peu être totalement déconnant, je lance l'idée (mais comme je suis une quiche avec le stencil, je ne suis pas prêt de la mettre en oeuvre)

[TanEk]

C'est une très bonne idée ! C'est beaucoup plus facile à implémenter, ça prend moins de mémoire mais c'est un peu plus lent (nécessite deux passes). Voire si tu n'as pas besoin du stencil pour le rendu ça prendrait un temps additionnel nul ! Tu l'actives par défaut et tu t'en sers qu'au picking. Essaye .

[GoldenEye]

Et hop aussitôt dit aussitôt fait j'ai testé le machin
Et force est de constater que cela ne marche pas...
Le qualité du color picking a diminué, sur certaines textures ça marche, sur d'autres non.

Code :

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
 
//------------------- STENCIL TEST----------------------------------
glClear (GL_STENCIL_BUFFER_BIT);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); // Afin de ne rien copier à l'écran
glEnable(GL_STENCIL_TEST); // Active le test stencil	
glEnable(GL_ALPHA_TEST); // Active le test alpha
glAlphaFunc(GL_GREATER,0.01); // Sachant que dans mes textures c'est alpha = 1. ou alpha = 0. pour chaque pixel
glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE); // Quoi qu'il arrive, on passe en mode "Write" du stencil buffer
glStencilFunc(GL_ALWAYS, 1, 0xffffffff); // Là où le quad est dessiné, le stencil prend la valeur 1
glEnable(GL_TEXTURE_2D); // Active les textures
glEnable(GL_BLEND); // Active la transparence (redondant avec le test alpha ?)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Mode de transparence
glColor4d(1.,1.,1,1.); // Rendu complet en toutes couleurs (ne seront pas dessinées de toute façon)
glBindTexture(GL_TEXTURE_2D,tex->GetId()); // Colle la texture
glBegin(GL_QUADS); // Fait le rendu du quad
glVertex2d(0,0);
glVertex2d(tex->GetWidth(),0);
glVertex2d(tex->GetWidth(),tex->GetHeight());
glVertex2d(0,tex->GetHeight());
glEnd();
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); // Repasse en mode "je dessine à l'écran"
glStencilFunc(GL_EQUAL, 1, 0xffffffff); // On ne dessine que si le stencil est égal à 1
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); // En mode lecture du stencil
glDisable(GL_BLEND); // Vire le blending
glDisable(GL_TEXTURE_2D); // Vire le texturing
//----------FIN DU STENCIL TEST---------------------------------//
 
glColor3ub(id%255,id/255,0); // Le dessin en couleur pour le picking. Marche très bien sauf sur les zones transparentes
glBegin(GL_QUADS);
glVertex2d(0,0);
glVertex2d(tex->GetWidth(),0);
glVertex2d(tex->GetWidth(),tex->GetHeight());
glVertex2d(0,tex->GetHeight());
glEnd();
glDisable(GL_STENCIL_TEST); // Désactive le stencil (on n'en a pas besoin par ailleurs)

Je précise que la chose est en 2D donc pas de depth test. Le stencil n'est pas utilisé par ailleurs...
Si l'un d'entre vous voit ce qui merde. Je suis super nul avec le stencil, j'ai ptêt raté un épisode

[TanEk]

Peut-être le fait de désactiver le glColorMask ça casse la chaîne de pipeline ? C'est pas grave tu sais si tu écris à l'écran, tu vas réécrire par dessus donc ça pose aucun pb. Au pire du erase le color buffer avant la deuxieme passe.

[GoldenEye]

Non malheureusement ça ne change rien...