Discussion :

[Yno]

Bonjour,

Ayant eu un peu de mal avec le titre, je vais essayer de détailler plus clairement mon problème.

Pour commencer, il me semble savoir que les shaders ASM ne s'utilisent pas de la même façon que les shaders GLSL (appels de fonctions différents), déjà là, corrigez-moi immédiatement si j'ai tors, car toute la suite du problème repose là dessus.

Avec les objets de shaders ASM, il est possible de faire :

glBindProgramARB(VERTEX/FRAGMENT, ...);

Et le type du shader a utiliser est specifié explicitement lors du binding.

Avec les fonctions de manipulation des shaders GLSL, il faut regrouper deux shaders dans un program (glAttachShader) puis utiliser ensuite ce program.

L'avantage des shaders ASM (côté API) est que l'on peut changer de fragment program sans avoir à "débinder" le vertex program, comme cela :

Code :

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

1
2
3
4
5
6
7
8
9
glBindProgram(GL_VERTEX, a);
glBindProgram(GL_FRAGMENT, b);
 
/* utilisation ... */
 
/* changement du fragment program */
glBindProgram(GL_FRAGMENT, c);
 
/* utilisation ... */

(toujours pareil, si j'ai tors dîtes-le moi)

C'est plutôt pratique.
Avec des shaders GLSL, je ne connais aucune méthode pour faire cela aussi "facilement", à part celle-ci :

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
/* creation */
p = glCreateProgram();
 
/* 'attachement' */
glAttachShader(p, vs);
glAttachShader(p, ps);
 
/* liaison */
glLinkProgram(p);
 
glUseProgram(p);
 
/* utilisation ... */
 
/* glDetach ps ? ... */
glAttachShader(p, ps2);
glLinkProgram(p);
 
glUseProgram(p);
 
/* utilisation ... */

Et dans ce cas, je me demandais si les appels à glAttach* et glLink* n'étaient pas un peu trop "gourmands" par rapport au simple glBind pour les shaders ASM ?
De plus, glLink peut retourner une erreur, et il faut donc prendre en compte la gestion de la valeur de retour.

Merci bien

[shenron666]

si j'ai bien compris, tu n'as pas de problème, juste des interrogations au sujet des shaders asm et glsl

perso je te déconseille les shaders asm, toutes les instructions ne sont pas compatibles, il faut une version pour ati, une pour nvidia et voire même pour les différentes générations de puces

si ta carte supporte le glsl, fonce, éventuellement il y a cg
mais l'asm n'a que peu d'intérêt

au sujet des fonctions GLSL, sauf erreur de ma part :
- tu utilises glAttachShader et glLinkProgram au début de ton programme pour compiler tes shaders (équivalent à la création d'une texture)
- glUseProgram pendant le traitement d'image pour sélectionner ton shader (équivalent au bind d'une texture)
- glDetachShader en fin de programme pour déchargement le shader (équivalent à la destruction d'une texture)

tu peux lire le tutorial sur lighthouse (en anglais) :
http://www.lighthouse3d.com/opengl/glsl/index.php
la page suivante parle justement de ce que je t'explique :
http://www.lighthouse3d.com/opengl/g...php?oglprogram

[Laurent Gomila]

Le "problème" avec GLSL c'est que tu peux déclarer des variables globales au vertex shader et au pixel shader. C'est pour ça qu'il faut une phase d'édition de liens.

C'est vrai que c'est emmerdant si tu veux juste changer l'un des deux, je sais pas trop si c'est possible sans refaire l'édition de liens (et je ne sais pas si cette dernière est coûteuse -- enfin je pense que oui).

[shenron666]

en fait en GLSL tu utilises glAttachShader pour attacher un "vertex shader" et un "fragment shader" à un "program shader" que tu link
tu peux attacher le même "vertex shader" avec un autre "fragment shader" à un autre "program shader" et refaire un link pour obtenir donc un second "program shader"
tout ça c'est dans l'initialisation (faut juste faire gaffe à la limite de "program shader" qui peuvent être linkés dans les drivers)

après dans la boucle de rendu, il n'y a "que" des appels à glUseProgram
?que? sauf si tu veux utiliser plus de "program shaders" que la carte n'autorise en mémoire en même temps
d'ailleurs je me demande quelles sont les limites des cartes genre radeon 9500 assez courantes aujourd'hui et qui supportent le GLSL

[Yno]

Merci à vous deux pour vos réponses

Le "problème" avec GLSL c'est que tu peux déclarer des variables globales au vertex shader et au pixel shader. C'est pour ça qu'il faut une phase d'édition de liens.

C'est vrai que c'est emmerdant si tu veux juste changer l'un des deux, je sais pas trop si c'est possible sans refaire l'édition de liens (et je ne sais pas si cette dernière est coûteuse -- enfin je pense que oui).

C'est la réponse que j'attendais (enfin plus ou moins, mais au moins on me confirme que pour changer juste un type de shader GLSL je suis effectivement dans le caca )

J'ai un livre sur OpenGL, et l'utilisation des shaders GLSL n'est pas un problème pour moi (je les utilise couramment sans aucun problème), mais merci quand même pour tes liens shenron666

En revanche les incompatibilités dont tu me fait part à propos des shaders ASM, je n'en étais pas au courant, voilà qui a de quoi diminuer mes intentions de les utiliser.

En fait, pour expliquer pour clairement mon véritable problème, j'essaie de programmer une interface de gestion de shaders quelconques.
Disons qu'il suffira de specifier le type du shader, et ensuite les fonctions d'utilisation seraient les mêmes, quelque soit le type.
Avez-vous des suggestions et/ou des conseils à ce sujet ?

J'ai également une autre question, au sujet des attributs de vertex.
Pour GLSL, c'est simple, on récupère l'ID d'un attribut, puis on le donne à manger à glVertexAttribPointer().
Mais pour les shaders ASM ?
Même question pour Cg, car je compte l'intégrer également.

J'ai d'ailleurs vu sur la doc de ce dernier que Cg proposait à l'utilisateur d'envoyer des tableaux aux shaders, mais son utilisation est différente de celle des glVertexAttribPointer (utilisation de fonctions Cg pour envoyer les donnees), je me demandais donc si on était obligé de passer par les fonctions de Cg pour envoyer des attributs de vertex ? Et si c'est le cas, peut-on bénéficier des VBOs ? (comme c'est le cas avec glVertexAttribPointer())

Encore merci

Bonne soirée.

[Laurent Gomila]

Pourquoi faire un truc générique qui gère Cg, alors que Cg est déjà générique ? C'est juste pour gérer aussi GLSL ?

En tout cas si tu veux tu peux t'inspirer du code de Ogre, il me semblent qu'ils gèrent aussi tout type de shaders.

[Yno]

Bonsoir,

Pourquoi faire un truc générique qui gère Cg, alors que Cg est déjà générique ? C'est juste pour gérer aussi GLSL ?

Disons que je ne sais pas avec exactitude comment fonctionne Cg
Mais si il ne gère pas GLSL, ce que tu laisses sous-entendre et ce que j'ai toujours pensé, alors oui, c'est juste pour gérer GLSL.

En tout cas si tu veux tu peux t'inspirer du code de Ogre, il me semblent qu'ils gèrent aussi tout type de shaders.

J'irai jeter un coup d'oeil

Merci.