GLSL et gluSphere

Bonjour,

Accroché vous bien car je ne suis pas sur de pouvoir me faire comprendre. Donc si vous avez besoin d'éclaircissement, n'hésitez pas à demander.

Voilà, dans la base, je voudrais ( beaucoup de chose ) faire une sphère que je peux modifier facilement les couleurs de celle ci pixel par pixel.

Donc je me suis dis, que passé par la fonction gluSphere serai une bonne base pour la physique de l'objet et puis, par les shaders faire en sorte que les couleurs de ma sphère soit modifié.
J'espère déjà avoir juste dans le principe, sinon j'attends toutes les suggestions d'améliorations/rectifications.

Dans le vertice shader, je me passe la point du centre de la sphère, pour pouvoir modifier la couleur des pixels selon leurs distance du centre.
Dans le fragment shader, je me passe la taille de la sphère pour faire la normalisation de mes couleurs, et je me passe grace au vertex shader le centre de la sphère en coordonnée écran.

Voici le code:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

// Vertice shader uniform vec4 position; varying vec3 center;   void main(void) { gl_Position = ftransform(); center = (gl_ModelViewProjectionMatrix * position).xyz;   gl_FrontColor = gl_Color; }

---

Code:

---

1 2 3 4 5 6 7 8 9 10

// Fragment shader varying vec3 center; uniform float radius;   void main(void) { gl_FragColor = vec4((gl_FragCoord.x - center.x)/radius, 0, 0, 1); }

---

Ce code, pensais-je, aurais du me donner un dégradé sur ma sphère ... n'importe quel que soit l'angle de vue. Mais comme vous savez surement déjà cela me donne une sphère rouge pure.

Comment puis je faire pour atteindre ce que je veux?

Je pense que le probleme vient de la division par le radius... J'imagine que ton radius est la valeur de ton rayon en coordonnees monde... il te la faut en coordonnees ecran. Je suis persuade que ton calcul depasse 1 (car le radius est trop petit) et que le GPU te le clampes a 1.

Ensuite question perf : la position du centre de ta sphere est la meme pour tous les pixels donc au lieu de le recalculer a chaque vertex et de faire de linterpolation lineaire pour chaque pixel, tu pourrais faire le calcul cote CPU et envoyer l'abscisse du centre (donc un float au lieu d'un vecteur) par un uniform float directement au fragment shader.

J'ai compris ce que vous m'avez dit,
mais, si je fais le calcul du centre par le CPU, je ne sais pas trop comment le faire :s
( Récupération de la matrice, j'imagine ..., mais je ne sais pas comment on la récupère )
Et si je dois faire un calcul équivalent pour le rayon ( qui est de 1 actuellement ), dois je le multiplier par la même matrice et sa marchera? ( Surtout, que je ne crois pas possible de multiplier une matrice juste pas un float )
Car, tout comme le position de la sphere, le rayon, ne change qu'une fois, donc autant appliqué la même technique.

Je peux paraitre vraiment débile, mais je trouve que je peine beaucoup pour tout ce qui est 3D. C'est aussi pour ça que j'étais venu ici ...

[Edit]
Je sais comment on récupère les matrix ( glGet(GL_MODELVIEW_MATRIX) et glGet(GL_PROJECTION_MATRIX) )
Mais je ne sais toujours pas comment je modifie mon vecteur ( xyz ou xyzw ) pour le transformer en position ecran )
Je vais surement faire déjà la matrix de vue * la matrix de projection ... et après faut que j'applique )
Comment faire la multiplication facilement ?
[/Edit]

[Edit2]
Je récapitule ce que j'ai fais, pendant cette après midi.
Grace à glGetFloatv(GL_PROJECTION_MATRIX); je récupère la matrix de projection.
Après je fais un glPushMatrix() de façon à conserver ma matrice actuelle de tout modification. ( La matrice actuelle est celle de ModelVue ).
Je multiplie la matrice actuelle par celle de projection que j'avais récupéré avant.
Je glGetFloatv(GL_MODELVIEW_MATRIX) la matrice afin de récupéré le résultat de ma multiplication.
Je pop l'ancienne matrice.
On m'a conseillé d'inverser la matrice ? Est ce juste ? Le faut t'il vraiment ?
Maintenant je multiplie ma matrice par un vecteur. Suivant le code suivant:

Code:

---

1 2 3 4 5

result[0] = matrix[0] * vector[0] + matrix[1] * vector[1] + matrix[2] * vector[2] + matrix[3] * vector[3]; result[1] = matrix[4] * vector[0] + matrix[5] * vector[1] + matrix[6] * vector[2] + matrix[7] * vector[3]; result[2] = matrix[8] * vector[0] + matrix[9] * vector[1] + matrix[10] * vector[2] + matrix[11] * vector[3]; result[3] = matrix[12] * vector[0] + matrix[13] * vector[1] + matrix[14] * vector[2] + matrix[15] * vector[3];

---

Et puis normalement, après tout ça, j'ai mon vecteur en coordonnées ecran. Si je fais un cout dessus, je dois voir la position de ma sphère en pixels ou pas?
( Ça semble toujours pas marcher :p ) ( et surtout aucune changement niveau résultat )

Et je voudrais savoir, que pour la multiplication, j'utilise le vecteur suivant { position.x ; position.y ; position.z ; 1 } Est t'il juste de mettre w à 1 ?

Petite remarque, j'ai mon programme avec une camera satellite, et sous certains angle, ma boule apparait en noir... O_o
[/Edit2]

Oui tu peux aussi calculer le rayon mais c'est un peu plus complique...

OpenGL store les matrices en column major donc ta multiplication n'est pas bonne, il faut faire plutot :

Code:

---

1 2	result[0] = matrix[0] * vector[0] + matrix[4] * vector[1] + matrix[8] *vector[2] + matrix[12] * vector[3] etc.

---

En gros c'est le calcul transpose de ce que t'as fais. Tu peux utiliser une bibliotheque comme glm qui te permettra de faire ca de facon transparente :

http://glm.g-truc.net/

Mais ce n'est pas fini. Le resultat de ca est la position de ton point en coordonnees camera. Pour l'avoir en coordonnees ecran il faut deja que tu divises toutes les valeurs de ton vecteur par w (c'est la projection) et ensuite il faut que tu transformes de coordonnees normalisees en coordonnees ecran (ou viewport). Tu peux directement utiliser cette fonction :

http://www.opengl.org/documentation/...u/project.html

ou la recoder toi-meme (les formules de transformation sont donnees).

Ensuite pour le rayon je n'ai pas de methode tres simple. Le seul truc que j'ai c'est le suivant :

Calculer le centre de ton cercle en coordonnees camera (donc multiplier par la matrice de modelview seulement...). Ensuite prends ce point et rajoute lui radius en x pour creer un second point (il faut faire ca pour etre sur que les deux points sont sur un plan parallele au plan de l'ecran pour avoir une projection de la distance correcte). La tu calcules la projection de ces deux points en multipliant par la matrice de projection et en faisant les transformations pour avoir en coordonnees ecran (ou en appelant gluProject avec une matrice de modelview identite... car tu l'as deja appliquee). Et ensuite il te reste plus qu'a calculer la distance entre ces deux points et t'auras la valeur de ton radius en coordonnees ecran.

Le soucis c'est que ca ca marchera si ta matrice de projection et ton viewport font en sorte que ton cercle reste un cercle sur l'ecran... (ca peut etre une ellipse sinon... et la y'a pas un seul rayon xD)

Je m'excuse mais je suis complètement perdu.
Pourrais t'on résumé ce que j'ai à faire en partant de la cordonnée (xyz) de ma sphère.

Je demande ça, car finalement, j'ai la grande impression que la commande gluProject fais tout ce dont j'ai besoin en une fois ?

[EDIT]
Finalement, pour le centre ça semble marcher avec un simple gluProject.
Par contre pour le rayon c'est plus dur :s ( même problématique )
En plus je comprend pas ce que signifie le z resultat du gluPorject, car dans la théorie il me donnerai des coordonnées en 2D ...
[/EDIT]

gluProject te donne des coordonnees dites "viewport" (ecran est un abus). Dans les coordonnees viewport tu as le x et y en pixel qui sont la distance du point en pixel par rapport au point en bas a gauche du viewport sur l'ecran mais tu as aussi la valeur en z (de profondeur) qui va de 0 (sur le plan near) a 1 (sur le plan far) et qui sera stockee dans le z-buffer... Donc c'est pas vraiment des coordonnees 2d.

Sinon pour la distance du rayon ca ne se projette pas comme ca... Comme je t'ai dis je ne vois pas quelque chose de simple pour le faire. As-tu fais ce que j'ai dis pour la calculer ? Et encore ma methode ne prend pas en compte des scaling mais passons...

Grand merci TanEk. (ça marche!)
Il fallait juste que je me penche correctement sur ce que tu m'avais dit, que j'utilise ma petite tête et hop j'ai compris.

Donc la marche à suivre ( au cas ou que des gens passe après )
C'est une première multiplication du point, afin de l'avoir en coordonnée "camera".
Une fois que l'on a ça, si on ajoute le rayon de la sphère (qui restara bon, car les proportions ne sont pas modifié avec la matrice modelView) on trouvera le point à l'extrémité de la sphère. Celui ci sera toujours là quelque soit la caméra.

Après on fait un gluProject avec une modelView identité car nous avons déjà fait cette multiplication.
Ça donne les coordonnées ecran pour le centre et pour le point qui symbolise le rayon. Une petite soustraction et on trouve le rayon.

On passe le tout dans le shader, et on peut s'amuser avec.

Donc grand merci à TanEk :ccool:

[EDIT]
Pardon, j'avais oublié de le mettre en résolu, chose que j'allais faire de suite mais, *
Merci de l'avoir mis en résolu pour moi ;)
[/EDIT]