Chapitre VIII : Vertex et Fragment Shaders - Programmation 3Daubert/p3d/Cours08.pdfChapitre VIII : Vertex et Fragment Shaders Programmation 3D Fabrice Aubert [email protected] Licence/Master

Chapitre VIII : Vertex et Fragment ShadersProgrammation 3D

Fabrice [email protected]

Licence/MasterUSTL - IEEA

2008-2009

F. Aubert (LS6/MS2) P3D/ VIII Shaders 2008-2009 1 / 28

Introduction


Pipeline

Les shaders sont des programmes qui se substituent a des phases dupipeline de rendu.

Vertex shader : programme se substituant a la phase detransformation des sommets et au calcul d’eclairement/coordonneesde texture aux sommets.

Pixel shader : programme qui se substitue a la phase d’attribution dela couleur et des coordonnees de texture aux fragments (lors de larasterization).

But : donner une grande liberte a la manipulation des sommets et desfragments... par ailleurs, les shaders sont executes par la cartegraphique.


Langage

Langage de haut niveau : Cg (nVidia, interfacable avec Direct 3D etOpenGL), HLSL (direct3D), GLSL (OpenGL).

Choix : GLSL (OpenGL 2.1/GLSL 1.2).

Syntaxe tres similaire au C.

Manuel de reference :http://www.opengl.org/sdk/libs/OpenSceneGraph/glsl_quickref.pdf

IDE pour shaders : OpenGL shader designer(http://www.opengl.org/sdk/tools/ShaderDesigner/),RenderMonkey (http://developer.amd.com/gpu/rendermonkey).


Vertex shader

Un vertex shader possede en entree des attributs de sommets (i.e. tout ce qui concerne unsommet : position, couleur, coordonnee de texture, etc). L’utilisateur peut specifier desattributs et/ou utiliser ceux predefinis par OpenGL (« built-in attributes » : gl_Vertex,gl_Normal, ...)

Exemple : le code suivant affecte la position gl_Vertex et la couleur gl_Color du vertexshader :

g l B e g i n (GL POLYGON ) ;g l C o l o r 3 f ( 0 . 2 , 0 . 4 , 0 . 6 ) ;g l V e r t e x 3 f ( −1 . 0 , 1 . 0 , 2 . 0 ) ;

. . .g lEnd ( ) ;

Pour parametrer le shader, on peut egalement utiliser et definir des variables qui serontconstantes lors du trace d’une primitive donnee : ce sont les variables dites uniform. Lesetats OpenGL sont par exemple accessibles grace a des uniforms predefinis :gl_ModelViewMatrix, gl_Light, ...

Les sorties d’un vertex shader (i.e. mise a jour de variables) sont qualifiees de varying :leurs valeurs vont etre interpolees (moyenne ponderee entre les sommets) et passees aufragment shader.


Vertex Shader : exemple simple

Fichier exemple_vertex.vert :

vo id main ( ) {g l P o s i t i o n = g l P r o j e c t i o n M a t r i x ∗ g l M o d e l V i e w M a t r i x ∗ g l V e r t e x ;}

On se contente ici de faire ce qui est fait par defaut par le pipelineOpenGL : Pproj = PROJECTION ∗MODELVIEW ∗ Plocal .

Les gl_ sont des « variables »GLSL predefinies.

gl_Position doit obligatoirement etre affecte lors d’un vertexshader (sortie speciale).

Types et qualifications de ces variables predefinies (donc inutile de lesdeclarer) :

uniform mat4 gl_ModelViewMatrix;uniform mat4 gl_ProjectionMatrix;attribute vec4 gl_Vertex;vec4 gl_Position; // variable speciale


Pipeline

Probleme : toutes les operations par defaut ne sont plus faites(substitution totale). Par exemple, si vous voulez simplement changerla generation des coordonnees de texture, il vous faut programmer lestransformations, le calcul d’eclairement, ...

Pas de connaissance des autres sommets dans un vertex shader.

Cependant : acces a tous les etats d’OpenGL (material, texture, ...)grace aux uniform.


Fragment Shader

Un fragment shader possede en entree les valeurs interpolees dessommets : position, couleur, coordonnee de texture, depth. Cesvariables sont qualifiees de varying.

Les sorties du fragment shader consiste principalement a ecrire sacouleur gl_FragColor.

Pas de connaissance des autres fragments (pixels voisins par exemple).

Acces aux etats d’OpenGL (variables uniforms predefinies).

Remarque : on manipule bien un fragment et non un pixel (parexemple, un fragment shader qui deplacerait un pixel sur l’ecran n’aaucun sens).

Pas de blending (operation faite apres l’execution du pixel shader).


Fragment Shader : exemple

Exemple fichier : exemple_pixel.frag

vo id main ( ) {g l F r a g C o l o r = vec4 ( 0 . 4 , 0 . 4 , 0 . 8 , 1 . 0 ) ;}

La variable gl_FragColor doit etre obligatoirement affectee dans unfragment shader.


Integration des shaders en OpenGL

Dans ce cours : specification OpenGL 2.1 (version actuelle 3.1 : pasde modification pour l’integration).

Etapes pour la definition des shaders :


Exemple

vo id myShader ( ) {GLchar ∗v s o u r c e ,∗ f s o u r c e ;GLuint v , f , p ;

// c r e a t i o n h a n d l e :v = g l C r e a t e S h a d e r (GL VERTEX SHADER ) ;f = g l C r e a t e S h a d e r (GL FRAGMENT SHADER ) ;

// un programme = ( au moins ) un f ragment e t un v e r t e x s h a d e rp = g l C r e a t e P r o g r a m ( ) ;g l A t t a c h S h a d e r ( p , v ) ;g l A t t a c h S h a d e r ( p , f ) ;

// l e c t u r e du GLSL s o u r c e :v s o u r c e = t e x t F i l e R e a d ( ”e x e m p l e v e r t e x . v e r t ” ) ;f s o u r c e = t e x t F i l e R e a d ( ”e x e m p l e p i x e l . f r a g ” ) ;

// a f f e c t a t i o n des s o u r c e s aux h a n d l e sg l S h a d e r S o u r c e ( v , 1 , ( const char ∗∗)& v s o u r c e , NULL ) ;g l S h a d e r S o u r c e ( f , 1 , ( const char ∗∗)& f s o u r c e , NULL ) ;// c o m p i l a t i o n des s o u r c e sg l C o m p i l e S h a d e r ( v ) ;g l C o m p i l e S h a d e r ( f ) ;

// mise en p l a c e dans l e p i p e l i n e :g l L i n k Pr o g r a m ( p ) ;

g lUseProgram ( p ) ; // s i p=0, p i p e l i n e par d e f a u t}


1 GLSL (GL Shading Language)


Types et qualifications

mat4 type matrice (16 floats) ; vec4 type vecteur (4 floats) ; etc

Exemples :

vo id main ( ) {vec4 a=vec4 ( 0 . 1 , 0 . 2 , 0 . 3 , 0 . 4 ) ;f l o a t b=a . x ;vec2 c=a . xy ;f l o a t d=a . w;mat2 e = mat2 ( 1 . 0 , 0 . 0 , 1 . 0 , 0 . 0 ) ;f l o a t f=e [ 1 ] [ 1 ] ;vec2 g=e [ 1 ] ; // 2 ieme c o l o n n e .. . .

}

uniform : constant lors d’une primitive (glBegin(...) ... glEnd()) ;uniquement en lecture seule par le shader.

attribute : peut changer entre chaque sommet. En lecture seule(sauf special).

varying : valeur qui sera interpolee (generalement en ecriture dansun vertex, et en lecture dans un pixel).


Communiquer avec un shader

Les shaders peuvent lire (et non ecrire) des variables globales passeespar OpenGL : utilisation des uniform.vertex shader GLSL :u n i f o r m f l o a t t ime ; // v a r i a b l e g l o b a l e au s h a d e r

vo id main ( vo id ) {vec4 v = vec4 ( g l V e r t e x ) ;

v . z = v . z+s i n ( 5 . 0∗ s q r t ( v . x∗v . x+v . y∗v . y ) + t ime ∗0 . 5 )∗0 . 2 5 ;g l P o s i t i o n = g l M o d e l V i e w P r o j e c t i o n M a t r i x ∗ v ;

}

⇒ Faire varier time ?


Modification de time

programme OpenGL :

i n t l o c a t i o n t i m e ; // h a n d l e pour l a v a r i a b l e t ime// du s h a d e r

f l o a t mon temps ; // v a r i e e n t r e chaque image. . .vo id myShader ( ) {

. . .g l L in k Pr o g r a m ( p ) ;

l o c a t i o n t i m e = g l G e t U n i f o r m L o c a t i o n ( p , ”t ime ” ) ; // d e t e r m i n a t i o n du h a n d l e// l e programme p d o i t a v o i r e t e l i n k e

}. . .vo id myDisp lay ( vo id ) {

g l C l e a r ( GL COLOR BUFFER BIT | GL DEPTH BUFFER BIT ) ;

g lUseProgram ( p ) ;// a f f e c t a t i o n de l ’ u n i f o r m ”t ime ” du s h a d e r a l a v a l e u r mon temps :g l U n i f o r m 1 f ( l o c a t i o n t i m e , mon temps ) ;// g l U n i f o r m f o n c t i o n n e uniquement s u r l e programme c o u r a n t ( donne par g lUseProgram )g l u t S o l i d T e a p o t ( 1 ) ;

g l u t S w a p B u f f e r s ( ) ;

mon temps +=0.01;}


2 Un exemple : eclairement par pixel


Rendre le speculaire

Eclairement par defaut d’OpenGL : calcul d’eclairement en chacundes sommets puis interpolation des couleurs pour chacun des pixels.Interet avec le fragment shader : provoquer un eclairement pourchaque pixel trace pour nuancer le mauvais rendu du speculaired’OpenGL.


Rappel

Calcul du speculaire :

Cs = Is ∗ Ks(V · R)s

avec R = 2(N · L)N − L


Principe

Dans le vertex shader : pour chaque sommet on determine les valeursN, L et V (dans le repere de l’observateur).

En chacun des pixels on pourra alors recuperer ces valeurs interpolees(moyennees).

(L, N et V seront donc qualifies de varying).

Dans le fragment shader : on calcul le vecteur R puis le speculaireresultant.


Vertex shader

v a r y i n g vec3 N, L , V ;

vo id main ( ) {L=g l L i g h t S o u r c e [ 0 ] . p o s i t i o n . xyz ;N=g l N o r m a l M a t r i x∗g l N o r m a l ;

vec4 v e r t e x=g l V e r t e x ;v e r t e x=g l M o d e l V i e w M a t r i x∗ g l V e r t e x ;

V=n o r m a l i z e(−v e r t e x . xyz ) ;N=n o r m a l i z e (N ) ;L=n o r m a l i z e ( L ) ;

g l P o s i t i o n = g l P r o j e c t i o n M a t r i x∗ v e r t e x ;}

normalize est fournie par GLSL pour normer un vecteur.

gl_LightSource[0] correspond a la LIGHT0. On a acces a tous lesparametres de LIGHT0.


Fragment Shader

v a r y i n g vec3 N, L , V ;

vo id main ( ) {vec3 N2 , L2 , V2 ;vec3 R ;

N2=n o r m a l i z e (N ) ;V2=n o r m a l i z e (V ) ;L2=n o r m a l i z e ( L ) ;

R=2.0∗ dot (N2 , L2 )∗N2−L2 ;n o r m a l i z e (R ) ;

// i n t e n s i t e s p e c u l a i r ef l o a t i s p e c ;i s p e c=pow ( max ( dot (V2 , R ) , 0 . 0 ) , g l F r o n t M a t e r i a l . s h i n i n e s s ) ;vec4 s p e c u l a i r e ;s p e c u l a i r e=g l L i g h t S o u r c e [ 0 ] . s p e c u l a r∗ g l F r o n t M a t e r i a l . s p e c u l a r∗ i s p e c ;

g l F r a g C o l o r = s p e c u l a i r e ;}

Il faut normer N, L et V.

dot est la fonction produit scalaire.

On accede au Ks par gl_FrontMaterial.specular, au Is pargl_LightSource[0].specular, et a la brillance s par gl_FrontMaterial.shininess(uniforms pre definis).


Remarques

Attention : il n’y a que le speculaire ici. Il faut ajouter le diffus etl’ambiant dans le vertex et le pixel shader.

Remarque : pour ces 2 derniers, il suffit de calculer la couleur auxsommets, puis d’interpoler cette couleur (on ajoute directement acouleur les 2 varying provenant du diffus et de l’ambiant).


3 Acces aux textures


Exemple : multi-texturing simple

Vertex :

v a r y i n g vec2 coord0 , coord1 ;

vo id main ( ) {

coord0=g l M u l t i T e x C o o r d 0 . s t ;coord1=g l M u l t i T e x C o o r d 1 . s t ;

g l P o s i t i o n = g l P r o j e c t i o n M a t r i x∗g l M o d e l V i e w M a t r i x∗ g l V e r t e x ;}

Fragment :

v a r y i n g vec2 coord0 , coord1 ;u n i f o r m sampler2D tex1 , t e x 0 ;

vo id main ( ) {vec4 c o l o r 0 , c o l o r 1 ;c o l o r 0=t e x t u r e 2 D ( tex0 , coord0 ) ;c o l o r 1=t e x t u r e 2 D ( tex1 , coord1 ) ;g l F r a g C o l o r = c o l o r 0∗ c o l o r 1 ;

}


Le type sampler2D

Doit etre declare en uniform pour associer la variable du shader a uneunite de texture.

Exemple :

. . .g l A c t i v e T e x t u r e (GL TEXTURE2 ) ;g l B i n d T e x t u r e (GL TEXTURE 2D , t e x i d ) ;. . .l o c a t i o n=g l G e t U n i f o r m L o c a t i o n ( p , ”t e x 0 ” ) ;g lUseProgram ( p ) ;g l U n i f o r m 1 i ( l o c a t i o n , 2 ) ;// => t e x 0 f e r a r e f e r e n c e a l a t e x t u r e c o u r a n t e de l ’ u n i t e 2 ( i c i t e x i d ) .


Exemple


Exemple

Vertex :

u n i f o r m vec3 p o s S o u rc e ;

v a r y i n g vec2 coord0 , coord1 ;v a r y i n g vec3 normal ;v a r y i n g vec3 L ;

vo id main ( ) {

vec3 v e r t e x E y e ;

coord0=g l M u l t i T e x C o o r d 0 . s t ;coord1=g l M u l t i T e x C o o r d 1 . s t ;

v e r t e x E y e =( g l M o d e l V i e w M a t r i x∗ g l V e r t e x ) . xyz ;L=posSource−v e r t e x E y e ;normal=( g l M o d e l V i e w M a t r i x∗vec4 ( g l Normal , 0 ) ) . xyz ;

g l P o s i t i o n = g l P r o j e c t i o n M a t r i x∗g l M o d e l V i e w M a t r i x∗ g l V e r t e x ;}


Exemple

Fragment :

v a r y i n g vec2 coord0 , coord1 ;u n i f o r m sampler2D tex0 , t e x 1 ;v a r y i n g vec3 normal ;v a r y i n g vec3 L ;

vo id main ( ) {vec4 c o l o r 0 , c o l o r 1 ;vec3 normal2 , L2 ;normal2=n o r m a l i z e ( normal ) ;L2=n o r m a l i z e ( L ) ;f l o a t d i f f u s=dot ( L2 , normal2 ) ;

i f ( d i f f u s <0.0) {c o l o r 0=t e x t u r e 2 D ( tex0 , coord0 ) ;d i f f u s=−d i f f u s ;

}e l s e {

c o l o r 0=t e x t u r e 2 D ( tex1 , coord0 ) ;}

g l F r a g C o l o r = c o l o r 0∗ d i f f u s ∗2 . 0 ;}


Documents

Chapitre VIII : Vertex et Fragment Shaders - Programmation 3Daubert/p3d/Cours08.pdfChapitre VIII : Vertex et Fragment Shaders Programmation 3D Fabrice Aubert [email protected] Licence/Master