1

Cours de MII 2

GPGPU

2

GPGPU

Objectif du cours :Comprendre les architectures GPUComprendre la programmation parallèle sur GPUMaîtriser la programmation Cuda

Contenu :1 ou 2 cours magistraux2 ou 3 séances de TP

Notations :1 projet & TP notés

3

GPGPU

Plan1. Introduction2. Architecture3. GPGPU on the GPU4. GPGPU via Cuda5. Exemple et optimisation

4

GPGPU

1. Introduction

5

History of 3D

6

History of 3D

7

The way it uses to be...

Fixed Function Pipelines (DX7)Writing new rendering algorithms means

♦ Tricks with multitexture, stencil buffer, depth buffer, blending …

Examples♦ Stencil shadow volumes♦ Hidden line removal♦ ...

8

The way it uses to be...

The fixed function pipeline

9

The way it uses to be...

Programmable Shaders (DX8-10)Writing new rendering algorithms means

♦ Tricks with stencil buffer, depth buffer, blending♦ Plus: Writing shaders

Examples♦ User-defined materials♦ User-defined lights♦ User-defined data structures (built in texture memory)

10

The way it uses to be...

Programmable pipeline

11

The way it begins to be...

Software Graphics: Part I (DX11)Writing new rendering algorithms means

♦ Tricks with stencil buffer, depth buffer, blending…♦ Plus: Writing shaders♦ Plus: Writing data-and task-parallel algorithms

Analyze results of rendering pipeline Synthesize data structures

Examples♦ Dynamic summed area table♦ Dynamic quadtree adaptive shadow map♦ Dynamic histogram-analysis shadow map♦ Dynamic ambient occlusion

12

Examples (DX 11)

“Real-Time Approximate Sorting for Self Shadowing and Transparency in Hair Rendering,”

Sintornet al., I3D 2008

“Dynamic Ambient Occlusion and Indirect Lighting,” Bunnell, GPU Gems II, 2005

“Fast Summed- Area Table Generation and its Applications,” Hensley et al., Eurographics2005

13

The way it begins to be...

Software Graphics: Part II (DX11+)Writing new rendering algorithms means

♦ Tricks with stencil buffer, depth buffer, blending♦ Plus: Writing shaders♦ Plus: Writing data-and task-parallel algorithms♦ Plus: Creating new and extended rendering pipelines

Examples♦ Micropolygon rendering♦ Ray tracing pipelines

14

Examples

OptiX, NVIDIA 2008 “RenderAnts: Interactive Reyes Rendering on GPUs,” Zhou et al., ACM SIGGRAPH Asia

“Hardware-Accelerated Global Illuminationby Image Space Photon Mapping ,” McGuire and Luebke, HPG 09

“FreePipe: a Programmable Parallel Rendering Architecture for Efficient Multi-Fragment Effects ,” Liu et al.,

ACM SIGGRAPH 2010

CUDAinside

CUDAinside

15

The way it will be...

“Render to Data Structures”DX11 PixelShader5

♦ Atomics to global memory♦ Gather/scatter to memory (“unordered access views”

Order independent transparency♦ Capture all rendered fragments

Render directly to grid-of-lists data structure instead of FB No framebuffer bound while rendering Increment global counter to get unique address for fragment Result is grid of linked lists

♦ Sort and blend lists for final image (pixel shader or compute shader)

16

The way it will be...

17

GPU Programming ?

GPU stands for Graphics Processing UnitSimply – It is the processor that resides on your

graphics card.

GPUs allow us to achieve the unprecedented graphics capabilities now available in games

18

CPU vs GPU

Why use GPU ?

19

CPU vs GPU

A quiet revolution and potential build-upCalculation: 367 GFLOPS vs. 32 GFLOPSMemory Bandwidth: 86.4 GB/s vs. 8.4 GB/sUntil last couple years, programmed through

graphics API GPU in every PC and workstation – massive

volume and potential impact

20

GPU Programming ?

How has this comes about ? Game design has become ever more sophisticated. Fast GPUs are used to implement complex shader and

rendering operations for real-time effects. In turn, the demand for speed has led to ever-increasing

innovation in card design. The NV40 architecture has 225 million transistors, compared

to about 175 million for the Pentium 4 EE 3.2 Ghz chip. The gaming industry has overtaken the defense, finance, oil

and healthcare industries as the main driving factor for high performance processors.

21

GPU Programming ?

GPU speed increasing at cubed-Moore’s Law.This is a consequence of the data-parallel

streaming aspects of the GPU. GPUs are cheap ! Put a couple together, and

you can get a super-computer Warning ! Various granularities of parallelism

exist, but…programming model must not hinder parallel

implementationdata delivery needs careful management

Voronoi DiagramsData Analysis Motion Planning

Geometric Optimization

Physical Simulation

Matrix Multiplication

Conjugate Gradient Sorting and Searching

Force-field simulation

Particle Systems

Molecular Dynamics Graph Drawing

Signal Processing

Database queries

Range queries

… and graphics too !!

Image Processing

Radar, Sonar, Oil ExplorationFinance

PlanningOptimization

Wealth of applications

Wealth of applications

24

GPU Programming ?

A Unifying theme: StreamingAll the graphics language models share basic

properties:1. They view the frame buffer as an array of “pixel

computers”, with the same program running at each pixel (SIMD)

2. Fragments are streamed to each pixel computer3. The pixel programs have limited state.

All the GPGPU language works the same1. They view problem as an array of threads2. Data elements are streamed to each thread3. The threads have limited memory / computing power

25

Stream programming?

A stream is a sequence of datacould be numbers, colors, RGBA vectors,…

A kernel is a (fragment) program runs on each element of a streamgenerating an output stream (pixel buffer)

26

Stream programming?

Two main ways of doing stream programmingThe pure GPU way

♦ Using the graphic programmable pipeline♦ Language : Cg, HLSL, GLSL

The GPGPU way♦ Using high level abstraction library♦ Language : BrookGPU, CUDA, OpenCL

27

Stream program on GPU

Kernel vertex/fragment program

Input stream stream of fragments or vertices or texture data

Output stream frame buffer or pixel buffer or texture

Multiple kernels multi-pass rendering sequence on the GPU

28

Stream program on GPGPU

Kernel User defined function

Input stream Stream of any data (float mainly)

Output stream Stream of any data (float mainly)

Multiple kernels Multi-pass execution of kernel on the GPU with

synchronization

29

Stream programming

To program the GPU, one must think of it as a (parallel) stream

processor.

30

GPGPU

2. Architecture

31

GPU Architecture

Nomenclature :Kernel : treatment unitThread : a single processing unitHost : application hardware (CPU)Device : coprocessor hardware (GPU)

32

Architecture GeForce 7800 GTX

Triangle Setup/RasterTriangle Setup/Raster

Shader Instruction DispatchShader Instruction Dispatch

Fragment CrossbarFragment Crossbar

MemoryPartitionMemoryPartition

MemoryPartitionMemoryPartition

MemoryPartitionMemoryPartition

MemoryPartitionMemoryPartition

Z-CullZ-Cull

8 Vertex Engines

24 Pixel Shaders

16 Raster Operation Pipelines

33

Architecture G80 graphic mode

L2

FB

SP SP

L1

TF

Thre

ad P

roce

ssor

Vtx Thread Issue

Setup / Rstr / ZCull

Geom Thread Issue Pixel Thread Issue

Input Assembler

Host

SP SP

L1

TF

SP SP

L1

TF

SP SP

L1

TF

SP SP

L1

TF

SP SP

L1

TF

SP SP

L1

TF

SP SP

L1

TF

L2

FB

L2

FB

L2

FB

L2

FB

L2

FB

The future of GPU is programmable processing ?Build the architecture around the processor

34

Architecture G80 CUDA mode

Load/store

Global Memory

Thread Execution Manager

Input Assembler

Host

Texture Texture Texture Texture Texture Texture Texture TextureTexture

Parallel DataCache

Parallel DataCache

Parallel DataCache

Parallel DataCache

Parallel DataCache

Parallel DataCache

Parallel DataCache

Parallel DataCache

Load/store Load/store Load/store Load/store Load/store

Processors execute computing threadsNew operating mode/HW interface for computing

35

GPU Architecture

What is behind such an evolution ? GPU specialized for compute-intensive, highly data parallel

computation (exactly what graphics rendering is about) So, more transistors can be devoted to data processing

rather than data caching and flow control

36

GPU Architecture

Pipeline/Architecture of GPU (graphic mode)

37

GPGPU Architecture

Each « processor unit » can host a thread Kernel are launch on arrays of thread

Each thread runs the same code (SPMD)Each thread has an ID that it uses to compute

memory addresses and make control decisions

…float x = input[threadID];float y = func(x);output[threadID] = y;…

threadID 76543210

38

GPGPU Architecture

Kernel : grid of blocksAll thread share a single

memory space Blocks : batch of threads

Cooperates through♦ Execution synchronization♦ Shared memory

Thread in different blocks cannot cooperate

39

GPGPU Architecture

How can we distinct a thread from one other ?Each thread has an Id

♦ Can decide what data to work with

Each block has also an Id

Device

Grid 1

Block(0, 0)

Block(1, 0)

Block(2, 0)

Block(0, 1)

Block(1, 1)

Block(2, 1)

Block (1, 1)

Thread(0, 1)

Thread(1, 1)

Thread(2, 1)

Thread(3, 1)

Thread(4, 1)

Thread(0, 2)

Thread(1, 2)

Thread(2, 2)

Thread(3, 2)

Thread(4, 2)

Thread(0, 0)

Thread(1, 0)

Thread(2, 0)

Thread(3, 0)

Thread(4, 0)

40

GPGPU Architecture

Blocks can be 1D or 2DMeans Id are 1D or 2D

Threads can be 1, 2 or 3DMeans Id are the same

Simplifies memory addressing when processing multidimensional data Image processingSolving PDE on volumes...

Device

Grid 1

Block(0, 0)

Block(1, 0)

Block(2, 0)

Block(0, 1)

Block(1, 1)

Block(2, 1)

Block (1, 1)

Thread(0, 1)

Thread(1, 1)

Thread(2, 1)

Thread(3, 1)

Thread(4, 1)

Thread(0, 2)

Thread(1, 2)

Thread(2, 2)

Thread(3, 2)

Thread(4, 2)

Thread(0, 0)

Thread(1, 0)

Thread(2, 0)

Thread(3, 0)

Thread(4, 0)

41

Memory

Comparison CPU memory vs. GPU one CPU Memory : At any program point

Allocate/free local or global memory Random memory access Registers

♦ Read/write Local memory

♦ Read/write to stack Global memory

♦ Read/write to heap Disk

♦ Read/write to disk

42

GPU Memory

GPU Memory : restricted accesAllocate/free memory only before computationLimited memory access during computation (kernel)

♦ Registers Read/write

♦ Local memory Read/write

♦ Shared Memory Only available in GPGPU not Graphics pipeline

43

GPU Memory

♦ Global memory Read-only during computation Write-only at end of computation Read/write in GPGPU world only

♦ Virtual Memory Does not exist !

♦ Disk access Does not exist !

44

GPU Memory

Where is GPU data storedVertex bufferFrame bufferTexture

Vertex Buffer Vertex Processor RasterizerFragmentProcessor

Texture

Frame Buffer(s)

45

GPU Memory

Vertex buffer Store geometric and radiometric data

FramebufferStore image based data (color, depth, stencil...)

TextureStore any kind of information (color, normal,

radiometric data ...)

46

GPGPU Memory

Acces also restricted Each thread can:

R/W per-thread registersR/W per-thread local memoryR/W per-block shared

memoryR/W per-grid global memoryRead only per-grid

constant memoryRead only per-grid

texture memory

(Device) Grid

ConstantMemory

TextureMemory

GlobalMemory

Block (0, 0)

Shared Memory

LocalMemory

Thread (0, 0)

Registers

LocalMemory

Thread (1, 0)

Registers

Block (1, 0)

Shared Memory

LocalMemory

Thread (0, 0)

Registers

LocalMemory

Thread (1, 0)

Registers

Host

47

GPGPU Memory

The host can R/W global, constant, and texture memories

(Device) Grid

ConstantMemory

TextureMemory

GlobalMemory

Block (0, 0)

Shared Memory

LocalMemory

Thread (0, 0)

Registers

LocalMemory

Thread (1, 0)

Registers

Block (1, 0)

Shared Memory

LocalMemory

Thread (0, 0)

Registers

LocalMemory

Thread (1, 0)

Registers

Host

48

GPGPU Memory

Global memory : Long latency accesses !Main means of communicating R/W Data between

host and deviceContents visible to all threads

Constant and texture memoriesConstant initialized by hostContents visible to all threads

49

GPGPU Memory

Per thread local memoryRegister

Per block memoryShared memory

Global memory

50

GPGPU

3. GPGPU on the GPU

51

GPGPU

3. GPGPU on the GPU3.1 les shaders

52

Cartes graphiques programmable

Deux emplacements majeurs programmables

53

Les shaders

Deux types de programmes :Les vertex programLes fragment program

Intérêt :Adaptabilité du renduDe nouveaux rendus (rapides !) :

♦ Matériaux réalistes, Milieux participants, Éclairage par fragment, Ombre, Éclairage réaliste…

Autres calculs que le rendu♦ Calcul matriciel, Lancer de rayon, Silhouette,

Traitement d’images, Animation …

54

Les shaders

Intérêts ?

55

Les shaders

56

Les vertex program :InformationsInformations

SommetSommet

VERTEXVERTEXPROGRAMPROGRAMTexturesTextures

VariablesVariablesgénériquesgénériques

sommetsommet

dont position, taille des points, clipdont position, taille des points, clip

Information sommet à interpolerInformation sommet à interpoler

Les shaders

57

Les fragment program :InformationsInformations

fragmentfragment

FRAGMENTFRAGMENTPROGRAMPROGRAM

Couleur du fragmentCouleur du fragmentProfondeur du fragmentProfondeur du fragment

TexturesTexturesVariablesVariables

génériquesgénériquesfragmentfragment

dont position (image) etdont position (image) etfront_facingfront_facing

Les shaders

58

Les shaders

Langage particulier pour piloter les programmesAssembleur

♦ Dépendent de la carte (ATI / Nvidia)♦ Pénible à écrire à la main♦ Code optimisé

Langages haut niveau au dessus de ces assembleursAppelés les shading languages : langages de

shaders

59

Les shaders

Historique des langages de shaderShading language : indépendant des cartes

graphiquesSorte d'unité programmable atomiqueRenderman Shading Language (Renderman 88)

♦ Adapté au lancer de rayon & rendu photoréaliste♦ Adresse 5 shaders différents : light, displacement,

surface, volume et imagerISL : Interactive Shading Language (SGI 00)

♦ Encore plus haut niveau. Génère des passes de rendu en OpenGL

♦ S’adresse directement à des instructions OpenGL

60

Les shaders

Historique des langages de shaderHLSL : High-Level Shader Language (Microsoft 02)

♦ Très proche de OpenGLSL : syntaxe, vertex & fragment♦ Adresse DirectX♦ Le shader n’est pas compilé par le driver

Cg : C graphic (Nvidia 02)♦ Très très similaire à HLSL (développé conjointement

avec Microsoft)♦ Ajout d’une couche librairie (Cg runtime library)♦ Adresse OpenGL et Direct X

OpenGLSL (OpenGL 03)♦ Décrit par la suite

61

GPGPU

3. GPGPU on the GPU3.2 OpenGLSL

62

GLSL : introduction

OpenGLSL : un langage de shader librePropriétés

♦ Lien et intégration simple avec Open GL♦ Flexible aux futures évolutions des cartes graphiques♦ Indépendant du hardware♦ Conserve les performances des cartes graphiques♦ Langage simple à utiliser♦ Convient à la norme OpenGL ARB (Arch. Review Board)♦ Permet les futures parallélisations dans les cartes

graphiques♦ Simple à optimiser (donc langage simple)

63

GLSL : introduction

Caractéristiques :Syntaxe identique à celle du C / C++Nouveaux types de données :

♦ Vecteurs♦ Matrices♦ Fragment de texture

Existence de variables et fonctions prédéfiniesOpérateurs surchargésPas de pointeur ni de référencePas de promotion (cast) implicitePassage d’argument par valeur

64

GLSL : introduction

Architecture :ApplicationApplication

Code source shaderCode source shader

OpenGL DriverOpenGL Driver

ObjetObjetshadershader

CompilatCompilateureur

ObjetObjetprogrprogrammeamme

LinkLinkerer

Code compiléCode compilé

Code exécutableCode exécutable

Carte graphiqueCarte graphique

OpenGL APIOpenGL API

65

GLSL : introduction

Avantages :Colle à OpenGLCompilation à l’exécutionIndépendant du hardwareCompilation par le driver => Meilleures

performancesStandard open source Fonctionne pour tout processus graphiques

♦ Donc peut être dans le futur les dernières parties non programmable

Pas besoin de librairie supplémentaire

66

GLSL : Types

Types disponibles :Scalaires : int / float / bool

♦ int : de –65535 à 65535♦ bool : true ou false

Vecteurs♦ vec2, vec3, vec4 : vecteur en float à 2, 3 ou 4

composantes♦ ivec2, ivec3, ivec4 : idem mais avec des entiers♦ bvec2, bvec3, bvec4 : idem mais avec des booléens♦ Accès aux composantes 1, 2, 3 ou 4 du vecteur vec par

vec.x / vec.y / vec.z / vec.w vec.r / vec.g / vec.b / vec.a vec.s / vec.t / vec.p / vec.q Comme un tableau : vec[0] / vec[1] / vec[2] / vec[3]

Accès identique : Créé Accès identique : Créé pour des questions de lisibilitépour des questions de lisibilitéposition, couleur, textureposition, couleur, texture

67

GLSL : Types

Matrices♦ mat2, mat3, mat4 : Matrice 2x2, 3x3 et 4x4 de float♦ Organisé en colonne♦ Accès aux colonnes d’une matrice mat :

mat[0] / mat[1] / mat[2] / mat[3] : 1, 2, 3 et 4ème colonne♦ Accès à un élément de mat :

mat[0][2] : 3ème élément de la 1ère colonneSampler

♦ Type permettant un accès à une texture♦ Ne demande aucune connaissance de la façon dont est

définie la texture♦ Le shader ne peut définir de Sampler. Il les récupère

directement de l’application.

68

GLSL : Types

Sampler♦ Ne peut être modifié par le shader♦ Les différents types :

sampler1D : accès à une texture 1D sampler2D : accès à une texture 2D sampler3D : accès à une texture 3D samplerCube : accès à une texture cubique sampler1DShadow : accès à une texture 1D de profondeur avec

comparaison des profondeurs Sampler2DShadow : idem avec une texture 2D

69

GLSL : structures

TableauxDéclarés classiquement :La taille est optionnelle, peut être calculée à la

compilation :

Redimensionnement explicite ou implicite illégal :

typetype nomnom[[tailletaille]];;typetype nomnom[[tailletaille]];;

vec4 pts[];vec4 pts[];pts[0] = vec4(0,0,0,0);pts[0] = vec4(0,0,0,0);pts[6] = vec4(1,0,0,0);pts[6] = vec4(1,0,0,0);// pts est de taille 7// pts est de taille 7

vec4 pts[];vec4 pts[];pts[0] = vec4(0,0,0,0);pts[0] = vec4(0,0,0,0);pts[6] = vec4(1,0,0,0);pts[6] = vec4(1,0,0,0);// pts est de taille 7// pts est de taille 7

vec4 pts[];vec4 pts[];vec4 pts[10];vec4 pts[10];vec4 pts[20]; // Illégalvec4 pts[20]; // Illégalpts[20] = vec4(0,0,0,0); // Illégalpts[20] = vec4(0,0,0,0); // Illégal

vec4 pts[];vec4 pts[];vec4 pts[10];vec4 pts[10];vec4 pts[20]; // Illégalvec4 pts[20]; // Illégalpts[20] = vec4(0,0,0,0); // Illégalpts[20] = vec4(0,0,0,0); // Illégal

70

GLSL : structures

StructureSyntaxe :

Exemple :

Peuvent être emboîtées et encapsuléesPeuvent contenir tous les types précédentsS’utilisent directement sans le mot clé structstruct

structstruct nom_structurenom_structure {{ type champstype champs;;}}structstruct nom_structurenom_structure {{ type champstype champs;;}}

structstruct kernel3x3 kernel3x3 {{ sizesize ponderation; ponderation; floatfloat coef[9]; coef[9];}}

structstruct kernel3x3 kernel3x3 {{ sizesize ponderation; ponderation; floatfloat coef[9]; coef[9];}}

kernel3x3 blur;kernel3x3 blur;kernel3x3 blur;kernel3x3 blur;

71

GLSL : constructeurs

« Constructeurs » (initialisation)Scalaire : comme en C :Autres types : utilisation de constructeur

♦ Similaire à un appel de fonction♦ Autant d’argument que de valeur à initialiser♦ Exemple :

♦ Cas particulier : Constructeur vecteur avec 1 float : remplissage Constructeur matrice avec 1 float : matrice diagonale

float a,b=3.0,c;float a,b=3.0,c;float a,b=3.0,c;float a,b=3.0,c;

vec4 v = vec4(1.0,2.0,0.0,1.0);vec4 v = vec4(1.0,2.0,0.0,1.0);kernel3x3 blur = blur(1./9.,{0.0f});kernel3x3 blur = blur(1./9.,{0.0f});vec4 v = vec4(1.0,2.0,0.0,1.0);vec4 v = vec4(1.0,2.0,0.0,1.0);kernel3x3 blur = blur(1./9.,{0.0f});kernel3x3 blur = blur(1./9.,{0.0f});

72

GLSL : conversions

Conversions :vers bool : 0 ou 0.0 => false sinon truede bool : false => 0 / true => 1Vecteur à Vecteur :

♦ La source doit avoir un nombre de composante > destination

♦ Affectation dans l’ordre. Les termes restants ne sont pas utilisés

Vecteur à Matrice :♦ Remplissage dans l’ordre de la matrice (colonne major)

Matrice à Matrice :♦ Lecture, remplissage en colonne major

73

GLSL : qualifiers

Qualificatifs de variables (qualifiers) : attribute :

♦ Variables correspondant à ce qui est injecté fréquemment dans le pipe line : sommets, normales …

♦ Accessible en lecture uniquement♦ Réservé au vertex program♦ Sont forcément des flottants : float, vecteur ou matrice♦ Certaines variables prédéfinies

uniform :♦ Variables correspondant à des données ne changeant pas fréquemment (au

maximum 1 fois par primitive)♦ Accessible en lecture uniquement♦ Certaines variables prédéfinies♦ Commun aux vertex et fragment program

74

GLSL : qualifiers

Qualificatifs de variables (qualifiers) :varying :

♦ Interface entre le vertex program et le fragment program♦ Accessible en écriture dans le vertex shader♦ Accessible en lecture dans le fragment shader♦ Interpolation entre le vertex et le fragment sur la

primitiveconst :

♦ Constante : initialisation obligatoire et accessible en lecture

sans qualificateur :♦ Variable temporaire : accessible en lecture et écriture♦ Défini pour un program donné (vertex ou fragment)

75

GLSL : flux de données

Les vertex program :prédéfinies prédéfinies

gl_Vertex, gl_Normal …gl_Vertex, gl_Normal …

VERTEXVERTEXPROGRAMPROGRAM

prédéfiniesprédéfiniesgl_ModelViewMatrixgl_ModelViewMatrixgl_LightSource[0..n]gl_LightSource[0..n]

prédéfiniesprédéfiniesgl_FrontColorgl_FrontColor

gl_FogFragColorgl_FogFragColor

définies pardéfinies parutilisateurutilisateur AttributeAttribute

définiesdéfiniespar l’utilisateurpar l’utilisateur

UniformUniform

spéciales :spéciales :gl_Position, gl_PointSizegl_Position, gl_PointSize

gl_ClipVertexgl_ClipVertex

définiesdéfiniespar par

l’utilisateurl’utilisateurVaryingVarying

TexturesTextures

76

GLSL : flux de données

Fragment program

FRAGMENTFRAGMENTPROGRAMPROGRAM

SpécialesSpécialesgl_FragColor, gl_FragDepthgl_FragColor, gl_FragDepth

prédéfiniesprédéfiniesgl_Colorgl_Color

gl_TexCoord[0..n]gl_TexCoord[0..n]

spéciales :spéciales :gl_FragCoordgl_FragCoord

gl_FrontFacinggl_FrontFacing

définiesdéfiniespar par

l’utilisateurl’utilisateurVaryingVarying

prédéfiniesprédéfiniesgl_ModelViewMatrixgl_ModelViewMatrixgl_LightSource[0..n]gl_LightSource[0..n]

définiesdéfiniespar l’utilisateurpar l’utilisateur

UniformUniform

TexturesTextures

77

GLSL : flux d'instructions

Chaque programme possède un main Quasiment strictement identique au C

if…else / while / do … while / forbreak / continuePas de switch, pas de goto

Fonctions : identique au C saufPassage par valeur et référence : qualificateurs

♦ in : passage par valeur♦ out : accessible en écriture seulement (copié à la fin)♦ inout : passage par référence (copié au début et à la fin)♦ const : ne peut être écrit, utilisable uniquement avec in

78

GLSL : opérations

Similaires à celles du CArithmétiques : +, -, *, /Logiques : &&, ||, ^^, !, , =, ==, !=Affectation : =, +=, -=, *=, /=, ++, --Sélection : ., [], ?:

Opérations sur les vecteurs & matricesPas d’opérateur logique (fonctions prédéfinies)Opérations composant par composant SAUF :

♦ vecteur * matrice : transposée du vecteur fois la matrice♦ matrice * vecteur : l’opération classique matrice vecteur

79

GLSL : opérations

Sélection composantes d’un vecteur : swizlingTrois groupes de sélection : xyzw, rgba ou stpqOn peut les composer / ordonner / restreindre à

loisir

vec4 v = vec4(1.0,2.0,0.0,3.0);vec4 v = vec4(1.0,2.0,0.0,3.0);v4.rgba; // vecteur à 4 composantes identique à v4v4.rgba; // vecteur à 4 composantes identique à v4v4.xy; // vecteur à 2 composantes (1.0,2.0)v4.xy; // vecteur à 2 composantes (1.0,2.0)v4.psq; // vecteur à 3 composantes (0.0,1.0,3.0)v4.psq; // vecteur à 3 composantes (0.0,1.0,3.0)v4.g; // C’est un floatv4.g; // C’est un floatv4.xyba; // Illégalv4.xyba; // Illégalvec4 dup=v4.rraa; // dup = vec4(1.0,1.0,3.0,3.0)vec4 dup=v4.rraa; // dup = vec4(1.0,1.0,3.0,3.0)dup.xzyw = v4.xxzz;// dup = vec4(1.0,0.0,1.0,0.0)dup.xzyw = v4.xxzz;// dup = vec4(1.0,0.0,1.0,0.0)dup.xxzz = v4; // Illégaldup.xxzz = v4; // Illégal

vec4 v = vec4(1.0,2.0,0.0,3.0);vec4 v = vec4(1.0,2.0,0.0,3.0);v4.rgba; // vecteur à 4 composantes identique à v4v4.rgba; // vecteur à 4 composantes identique à v4v4.xy; // vecteur à 2 composantes (1.0,2.0)v4.xy; // vecteur à 2 composantes (1.0,2.0)v4.psq; // vecteur à 3 composantes (0.0,1.0,3.0)v4.psq; // vecteur à 3 composantes (0.0,1.0,3.0)v4.g; // C’est un floatv4.g; // C’est un floatv4.xyba; // Illégalv4.xyba; // Illégalvec4 dup=v4.rraa; // dup = vec4(1.0,1.0,3.0,3.0)vec4 dup=v4.rraa; // dup = vec4(1.0,1.0,3.0,3.0)dup.xzyw = v4.xxzz;// dup = vec4(1.0,0.0,1.0,0.0)dup.xzyw = v4.xxzz;// dup = vec4(1.0,0.0,1.0,0.0)dup.xxzz = v4; // Illégaldup.xxzz = v4; // Illégal

80

GPGPU

3. GPGPU on the GPU3.3 Lien avec l'application

81

Shader & pipeline

Le lien se fait par les variables ! L’application envoie dans le pipe line :

Des primitives : constituées de vertex ou données♦ Ce seront les variables attribute

L’état de la machine OpenGL :♦ Variables prédéfinies comme les lumières ou la couleur

du brouillard♦ Variables définies par l’application♦ Ce sont les variables uniform

82

Shader & pipeline

Vertex ShaderRemplace complètement le pipe line classiqueVariables attribute prédéfinies :

♦ Reçue par des appels standard à des fonctions OpenGL♦ Prédéfinies :

gl_Position : correspond à glVertex3f(…) gl_Normal : correspond à glNormal3f(…) gl_Color : correspond à glColor3f(…) gl_SecondaryColor : correspond à glSecondaryColor3f(…) gl_MultiTexCoord0 :

correspond à glTexCoord2f(…) / glMultiTexCoord(…) …

83

Shader & pipeline

Vertex ShaderVariables attribute définies par l’utilisateur :

♦ Utilisation de glVertexAttribARB♦ Voir dans la partie suivante

Variables uniform prédéfinies♦ Cf. ci-après

Variable uniform définies par l’utilisateur♦ Utilisation de glUniformARB♦ Voir dans la partie suivante

84

Shader & pipeline

Vertex ShaderVariables varying spéciales :

♦ Variable gl_Position Doit impérativement être écrite C’est un vec4

♦ Variable gl_PointSize Taille du point : optionnel C’est un float

♦ Variable gl_ClipVertex Coordonnées du point pour le clipping : optionnel C’est un vec4

85

Shader & pipeline

Vertex ShaderVariables varying prédéfinies :

♦ vec4 gl_FrontColor♦ vec4 gl_BackColor♦ vec4 gl_FrontSecondaryColor♦ vec4 gl_BackSecondaryColor♦ vec4 gl_TexCoord[0..n]♦ float gl_FogFragCoord

Variables varying définies par l’utilisateur♦ Rien à faire coté application. Tout est géré dans le driver

86

Shader & pipeline

Fragment ShaderLes varying arrivent après interpolation

perspectiveVariables varying spéciales :

♦ vec4 gl_FragCoord : Position du fragment

♦ bool gl_FrontFacing : La primitive du fragment est elle face à la caméra

Variables varying prédéfinies : ♦ vec4 gl_SecondaryColor♦ vec4 gl_Color♦ vec4 gl_TexCoord[0..n]♦ float gl_FogFragCoord

87

Shader & pipeline

Fragment ShaderVariables uniform : comme pour le vertex shaderVariables de sorties :

♦ vec4 gl_FragColor : Couleur du fragment à ajouter dans l’image

♦ float gl_FragDepth : Permet de fixer la profondeur du fragment Si non fixé, on conserve la valeur de base

88

Shader & pipeline

Variables uniformes prédéfiniesIl y en a énormément :

♦ Pour les lumières♦ Pour le brouillard♦ Pour les matrices de transformation♦ Pour les paramètres de la caméra♦ Pour les matériaux utilisés par les objets♦ Pour les propriétés de point ♦ …

Correspondent à des « états » du pipeline graphique

Liste complète :

89

// VERTEX PROGRAM (tiré du ‘Orange Book’)// VERTEX PROGRAM (tiré du ‘Orange Book’)uniformuniform float CoolestTemp; float CoolestTemp;uniformuniform float tempRange; float tempRange;

attributeattribute float vertexTemp; float vertexTemp;

varyingvarying float Temperature; float Temperature;

void main() {void main() { // Calcule le degre de temperature entre 0 et 1// Calcule le degre de temperature entre 0 et 1 TemperatureTemperature = ( = (vertexTempvertexTemp - - CoolestTempCoolestTemp)/)/tempRangetempRange;; gl_Positiongl_Position = = gl_ModelViewProjectionMatrixgl_ModelViewProjectionMatrix * * gl_Vertexgl_Vertex;;}}

// VERTEX PROGRAM (tiré du ‘Orange Book’)// VERTEX PROGRAM (tiré du ‘Orange Book’)uniformuniform float CoolestTemp; float CoolestTemp;uniformuniform float tempRange; float tempRange;

attributeattribute float vertexTemp; float vertexTemp;

varyingvarying float Temperature; float Temperature;

void main() {void main() { // Calcule le degre de temperature entre 0 et 1// Calcule le degre de temperature entre 0 et 1 TemperatureTemperature = ( = (vertexTempvertexTemp - - CoolestTempCoolestTemp)/)/tempRangetempRange;; gl_Positiongl_Position = = gl_ModelViewProjectionMatrixgl_ModelViewProjectionMatrix * * gl_Vertexgl_Vertex;;}}

// FRAGMENT PROGRAM (tiré du ‘Orange Book’)// FRAGMENT PROGRAM (tiré du ‘Orange Book’)uniformuniform vec3 CoolestColor; vec3 CoolestColor;uniformuniform vec3 HottestColor; vec3 HottestColor;

varyingvarying float Temperature; float Temperature;

void main() {void main() { // Utilisation d’une fonction prédéfinie : mix// Utilisation d’une fonction prédéfinie : mix // afin de trouver une couleur mélangée// afin de trouver une couleur mélangée vec3 color = vec3 color = mixmix((CoolestColorCoolestColor,,HottestColorHottestColor,,TemperatureTemperature);); gl_FragColorgl_FragColor = = vec4vec4(color,1.0); (color,1.0); }}

// FRAGMENT PROGRAM (tiré du ‘Orange Book’)// FRAGMENT PROGRAM (tiré du ‘Orange Book’)uniformuniform vec3 CoolestColor; vec3 CoolestColor;uniformuniform vec3 HottestColor; vec3 HottestColor;

varyingvarying float Temperature; float Temperature;

void main() {void main() { // Utilisation d’une fonction prédéfinie : mix// Utilisation d’une fonction prédéfinie : mix // afin de trouver une couleur mélangée// afin de trouver une couleur mélangée vec3 color = vec3 color = mixmix((CoolestColorCoolestColor,,HottestColorHottestColor,,TemperatureTemperature);); gl_FragColorgl_FragColor = = vec4vec4(color,1.0); (color,1.0); }}

Exemple de shader

90

Utilisation des shaders

Comment utiliser les shader dans une application OpenGL ?Utilisation des API :

♦ GLSL_vertex_program♦ GLSL_fragment_program

Collection de fonction en C (fourni par les drivers de votre carte) permettant de :

♦ Créer les vertex / fragment shader (vide)♦ Les remplir avec du code en provenance d’un fichier♦ Compiler (à l’utilisation donc !), attacher, lier ces

programmes♦ Envoyer des données aux shaders

91

Utilisation des shaders

Méthode :1. Créer un ou plusieurs shaders

♦ glCreateShaderObject2. Leur donner du code source

♦ glShaderSource3. Les compiler

♦ glCompileShader4. Créer un objet programme

♦ glCreateProgramObject5. Attacher les shaders à cet objet

♦ glAttachObject

92

Utilisation des shaders

Méthode :6. Lier le programme

♦ Permet par exemple de relier les variables varying …♦ Similaire à la phase de lien d’une phase de compilation♦ glLinkProgram

7. Intégrer le programme dans le pipeline graphique

♦ glUseProgramObject8. Fournir les variables définies par l’utilisateur

♦ glGetUniformLocation, glUniform♦ glBindAttribLocation, glGetAttribLocation, glVertexAttrib♦ glEnableVertexAttribArray, glVertexAttribPointer

93

GLhandleARB loadShaders(const char *vertexFile,const char *fragmentFile) {GLhandleARB loadShaders(const char *vertexFile,const char *fragmentFile) {

GLhandleARB programObject;GLhandleARB programObject; // CREATION DU PROGRAMME// CREATION DU PROGRAMME programObject = programObject = glCreateProgramObjectglCreateProgramObject();(); if(!programObject) return 0;if(!programObject) return 0;

// CHARGEMENT DU VERTEX SHADER :// CHARGEMENT DU VERTEX SHADER : char *vertexSource;char *vertexSource; // Récupération de la chaine de caractère du fichier d’entree// Récupération de la chaine de caractère du fichier d’entree if (!if (!loadSourceloadSource(vertexFile, &vertexSource)) return 0;(vertexFile, &vertexSource)) return 0; // Creation d'un objet qui va contenir des sources// Creation d'un objet qui va contenir des sources GLhandleARB shaderObject = GLhandleARB shaderObject = glCreateShaderObjectglCreateShaderObject(GL_VERTEX_SHADER_ARB);(GL_VERTEX_SHADER_ARB); // Association des sources// Association des sources glShaderSourceglShaderSource(shaderObject, 1, & vertexSource, NULL);(shaderObject, 1, & vertexSource, NULL); // Compilation des sources// Compilation des sources glCompileShaderglCompileShader(shaderObject);(shaderObject); // Attachement au programme// Attachement au programme glAttachObjectglAttachObject(programObject, shaderObject);(programObject, shaderObject); // Destruction de l’objet shader (inutile maintenant)// Destruction de l’objet shader (inutile maintenant) glDeleteObjectglDeleteObject(shaderObject);(shaderObject);

......

GLhandleARB loadShaders(const char *vertexFile,const char *fragmentFile) {GLhandleARB loadShaders(const char *vertexFile,const char *fragmentFile) {

GLhandleARB programObject;GLhandleARB programObject; // CREATION DU PROGRAMME// CREATION DU PROGRAMME programObject = programObject = glCreateProgramObjectglCreateProgramObject();(); if(!programObject) return 0;if(!programObject) return 0;

// CHARGEMENT DU VERTEX SHADER :// CHARGEMENT DU VERTEX SHADER : char *vertexSource;char *vertexSource; // Récupération de la chaine de caractère du fichier d’entree// Récupération de la chaine de caractère du fichier d’entree if (!if (!loadSourceloadSource(vertexFile, &vertexSource)) return 0;(vertexFile, &vertexSource)) return 0; // Creation d'un objet qui va contenir des sources// Creation d'un objet qui va contenir des sources GLhandleARB shaderObject = GLhandleARB shaderObject = glCreateShaderObjectglCreateShaderObject(GL_VERTEX_SHADER_ARB);(GL_VERTEX_SHADER_ARB); // Association des sources// Association des sources glShaderSourceglShaderSource(shaderObject, 1, & vertexSource, NULL);(shaderObject, 1, & vertexSource, NULL); // Compilation des sources// Compilation des sources glCompileShaderglCompileShader(shaderObject);(shaderObject); // Attachement au programme// Attachement au programme glAttachObjectglAttachObject(programObject, shaderObject);(programObject, shaderObject); // Destruction de l’objet shader (inutile maintenant)// Destruction de l’objet shader (inutile maintenant) glDeleteObjectglDeleteObject(shaderObject);(shaderObject);

......

Utilisation des shaders

94

...... // CHARGEMENT DU FRAGMENT SHADER :// CHARGEMENT DU FRAGMENT SHADER : char *fragmentSource;char *fragmentSource; // Récupération de la chaine de caractère du fichier d’entree// Récupération de la chaine de caractère du fichier d’entree if (!if (!loadSourceloadSource(fragmentFile, &fragmentSource)) return 0;(fragmentFile, &fragmentSource)) return 0; // Creation d'un objet qui va contenir des sources// Creation d'un objet qui va contenir des sources shaderObject = shaderObject = glCreateShaderObjectglCreateShaderObject(GL_FRAGMENT_SHADER_ARB);(GL_FRAGMENT_SHADER_ARB); // Association des sources// Association des sources glShaderSourceglShaderSource(shaderObject, 1, & fragmentSource, NULL);(shaderObject, 1, & fragmentSource, NULL); // Compilation des sources// Compilation des sources glCompileShaderglCompileShader(shaderObject);(shaderObject); // Attachement au programme// Attachement au programme glAttachObjectglAttachObject(programObject, shaderObject);(programObject, shaderObject); // Destruction de l’objet shader (inutile maintenant)// Destruction de l’objet shader (inutile maintenant) glDeleteObjectglDeleteObject(shaderObject);(shaderObject);

// Linkage du programme// Linkage du programme glLinkProgramglLinkProgram(programObject);(programObject);}}// PLUS TARD DANS L'INITIALISATION// PLUS TARD DANS L'INITIALISATIONsProg = loadShaders(sProg = loadShaders("vert.vert","fragtxt.frag");"vert.vert","fragtxt.frag");// PLUS TARD DANS LA FONCTION DE DESSIN ...// PLUS TARD DANS LA FONCTION DE DESSIN ...glUseProgramglUseProgram(sProg); (sProg); // si =0 on garde le pipeline classique// si =0 on garde le pipeline classique

...... // CHARGEMENT DU FRAGMENT SHADER :// CHARGEMENT DU FRAGMENT SHADER : char *fragmentSource;char *fragmentSource; // Récupération de la chaine de caractère du fichier d’entree// Récupération de la chaine de caractère du fichier d’entree if (!if (!loadSourceloadSource(fragmentFile, &fragmentSource)) return 0;(fragmentFile, &fragmentSource)) return 0; // Creation d'un objet qui va contenir des sources// Creation d'un objet qui va contenir des sources shaderObject = shaderObject = glCreateShaderObjectglCreateShaderObject(GL_FRAGMENT_SHADER_ARB);(GL_FRAGMENT_SHADER_ARB); // Association des sources// Association des sources glShaderSourceglShaderSource(shaderObject, 1, & fragmentSource, NULL);(shaderObject, 1, & fragmentSource, NULL); // Compilation des sources// Compilation des sources glCompileShaderglCompileShader(shaderObject);(shaderObject); // Attachement au programme// Attachement au programme glAttachObjectglAttachObject(programObject, shaderObject);(programObject, shaderObject); // Destruction de l’objet shader (inutile maintenant)// Destruction de l’objet shader (inutile maintenant) glDeleteObjectglDeleteObject(shaderObject);(shaderObject);

// Linkage du programme// Linkage du programme glLinkProgramglLinkProgram(programObject);(programObject);}}// PLUS TARD DANS L'INITIALISATION// PLUS TARD DANS L'INITIALISATIONsProg = loadShaders(sProg = loadShaders("vert.vert","fragtxt.frag");"vert.vert","fragtxt.frag");// PLUS TARD DANS LA FONCTION DE DESSIN ...// PLUS TARD DANS LA FONCTION DE DESSIN ...glUseProgramglUseProgram(sProg); (sProg); // si =0 on garde le pipeline classique// si =0 on garde le pipeline classique

Utilisation des shaders

95

Utilisation des shaders

Transmission des variables uniform :Variables prédéfinies :

♦ Utiliser les instructions classiques OpenGLVariables définies par l’utilisateur

♦ Récupération de l’indice de stockage du driver : glGetUniformLocation(program, "nom_variable")

♦ Envoi des valeurs à cette variable : glUniform{1|2|3|4}{s|f|v}{v} (indice,{nb,} valeur)

Transmission des variables attribute :Variables prédéfinies :

♦ Utilisation glVertex pour gl_Vertex♦ Utilisation glNormal pour gl_Normal …

96

Utilisation des shaders

Variables définies par l’utilisateur :♦ Récupérer l’indice de stockage de la variable :

ind = glGetAttribLocation(program, "nom_variable" ); ind = glBindAttribLocation(program,1, "nom_variable" );

♦ Envoyer les valeurs : Une valeur : glVertexAttrib{1234}{s|f|d}{v}(indice,valeur);

D’autres combinaisons existent (avec 4) Par vertex array :

glEnableVertexAttribArray(indice)glVertexAttribPointer(indice, size, type, normalized,

stride, pointeur);

97

GPGPU

3. GPGPU on the GPU3.4 Conseils & optimisations

98

Conseils

Avoir une idée claire de ce que l’on veutOù le shader intervient-il dans cela ?

Ajouter la complexité progressivementCommencer par les choses simplesTester et complexifierMettre des commentaires sur les choses qui

marchent Faire au plus simple Faire au plus modulaire

Utiliser des fonctionsIl est préférable de faire une bibliothèque de

shaders simples qu’un grand shader gérant tout !

99

Conseils

Faire une bonne répartition des calculs entreCPU

♦ Précalcul dans des textures♦ Si le CPU est dispo : l’utiliser !

Vertex shader♦ Pour toute donnée variant peu dans l’image

Fragment shader♦ Seulement pour des données variant beaucoup et non

linéairement ! Enlever toutes les opérations non nécessaires

100

Optimisations

Utilisez les fonctions prédéfiniesListe accessible sur :

Utiliser les vecteursType native des processeurs électroniques

Utiliser des texturesPour encoder des fonctions complexes de 1,2 ou 3

variables

http://developer.3dlabs.com/documents/index.htmhttp://developer.3dlabs.com/documents/index.htm

101

GPGPU

3. GPGPU on the GPU3.4 Exemples simples

102

Exemples simples Application d’une texture

// [Vertex_Shader] // [Vertex_Shader] void main() { void main() {

gl_TexCoord[0] = gl_MultiTexCoord0; gl_TexCoord[0] = gl_MultiTexCoord0; gl_Position = ftransform(); gl_Position = ftransform();

} }

// [Vertex_Shader] // [Vertex_Shader] void main() { void main() {

gl_TexCoord[0] = gl_MultiTexCoord0; gl_TexCoord[0] = gl_MultiTexCoord0; gl_Position = ftransform(); gl_Position = ftransform();

} }

// [Fragment_Shader] // [Fragment_Shader] uniform sampler2D colorMap; uniform sampler2D colorMap; void main (void) { void main (void) {

gl_FragColor = texture2D( colorMap, gl_TexCoord[0].st); gl_FragColor = texture2D( colorMap, gl_TexCoord[0].st); }}

// [Fragment_Shader] // [Fragment_Shader] uniform sampler2D colorMap; uniform sampler2D colorMap; void main (void) { void main (void) {

gl_FragColor = texture2D( colorMap, gl_TexCoord[0].st); gl_FragColor = texture2D( colorMap, gl_TexCoord[0].st); }}

// Dans le code source : initialisation// Dans le code source : initialisationglActiveTextureARB(GL_TEXTURE0_ARB) ;glActiveTextureARB(GL_TEXTURE0_ARB) ;glEnable(GL_TEXTURE_2D);glEnable(GL_TEXTURE_2D);glBindTexture(GL_TEXTURE_2D,tex_id );glBindTexture(GL_TEXTURE_2D,tex_id );glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height, 0, GL_RGB,glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height, 0, GL_RGB,GL_UNSIGNED_BYTE, (const GLvoid *)texData) ;GL_UNSIGNED_BYTE, (const GLvoid *)texData) ;glBindTexture(GL_TEXTURE_2D,0);glBindTexture(GL_TEXTURE_2D,0);

// Dans la fonction display// Dans la fonction displayglUniform1i(glGetUniformLocation(shadprg,"colorMap"),0) ;glUniform1i(glGetUniformLocation(shadprg,"colorMap"),0) ;glBindTexture(GL_TEXTURE_2D, tex_id);glBindTexture(GL_TEXTURE_2D, tex_id);

// Dans le code source : initialisation// Dans le code source : initialisationglActiveTextureARB(GL_TEXTURE0_ARB) ;glActiveTextureARB(GL_TEXTURE0_ARB) ;glEnable(GL_TEXTURE_2D);glEnable(GL_TEXTURE_2D);glBindTexture(GL_TEXTURE_2D,tex_id );glBindTexture(GL_TEXTURE_2D,tex_id );glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height, 0, GL_RGB,glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height, 0, GL_RGB,GL_UNSIGNED_BYTE, (const GLvoid *)texData) ;GL_UNSIGNED_BYTE, (const GLvoid *)texData) ;glBindTexture(GL_TEXTURE_2D,0);glBindTexture(GL_TEXTURE_2D,0);

// Dans la fonction display// Dans la fonction displayglUniform1i(glGetUniformLocation(shadprg,"colorMap"),0) ;glUniform1i(glGetUniformLocation(shadprg,"colorMap"),0) ;glBindTexture(GL_TEXTURE_2D, tex_id);glBindTexture(GL_TEXTURE_2D, tex_id);

103

Exemples simples

Phong lighting// [Vertex_Shader]// [Vertex_Shader]

varying vec3 normal, lightDir, eyeVec;varying vec3 normal, lightDir, eyeVec;void main()void main(){{

normal = gl_NormalMatrix * gl_Normal;normal = gl_NormalMatrix * gl_Normal;vec3 vVertex = vec3(gl_ModelViewMatrix * gl_Vertex);vec3 vVertex = vec3(gl_ModelViewMatrix * gl_Vertex);lightDir = vec3(gl_LightSource[0].position.xyz - vVertex);lightDir = vec3(gl_LightSource[0].position.xyz - vVertex);eyeVec = -vVertex;eyeVec = -vVertex;gl_Position = ftransform();gl_Position = ftransform();

}}

// [Vertex_Shader]// [Vertex_Shader]

varying vec3 normal, lightDir, eyeVec;varying vec3 normal, lightDir, eyeVec;void main()void main(){{

normal = gl_NormalMatrix * gl_Normal;normal = gl_NormalMatrix * gl_Normal;vec3 vVertex = vec3(gl_ModelViewMatrix * gl_Vertex);vec3 vVertex = vec3(gl_ModelViewMatrix * gl_Vertex);lightDir = vec3(gl_LightSource[0].position.xyz - vVertex);lightDir = vec3(gl_LightSource[0].position.xyz - vVertex);eyeVec = -vVertex;eyeVec = -vVertex;gl_Position = ftransform();gl_Position = ftransform();

}}

104

Exemples simples

// [Fragment_Shader]// [Fragment_Shader]varying vec3 normal, lightDir, eyeVec;varying vec3 normal, lightDir, eyeVec;void main (void) {void main (void) {

vec4 final_color = vec4 final_color = (gl_FrontLightModelProduct.sceneColor * gl_FrontMaterial.ambient) + (gl_FrontLightModelProduct.sceneColor * gl_FrontMaterial.ambient) + (gl_LightSource[0].ambient * gl_FrontMaterial.ambient);(gl_LightSource[0].ambient * gl_FrontMaterial.ambient);vec3 N = normalize(normal);vec3 N = normalize(normal);vec3 L = normalize(lightDir);vec3 L = normalize(lightDir);float lambertTerm = dot(N,L);float lambertTerm = dot(N,L);if(lambertTerm > 0.0) {if(lambertTerm > 0.0) {

final_color += gl_LightSource[0].diffuse * final_color += gl_LightSource[0].diffuse * gl_FrontMaterial.diffuse * gl_FrontMaterial.diffuse *

lambertTerm;lambertTerm;vec3 E = normalize(eyeVec);vec3 E = normalize(eyeVec);vec3 R = reflect(-L, N);vec3 R = reflect(-L, N);float specular = pow( max(dot(R, E), 0.0), float specular = pow( max(dot(R, E), 0.0), gl_FrontMaterial.shininess );gl_FrontMaterial.shininess );final_color += gl_LightSource[0].specular * final_color += gl_LightSource[0].specular * gl_FrontMaterial.specular * gl_FrontMaterial.specular *

specular;specular;}}gl_FragColor = final_color;gl_FragColor = final_color;

}}

// [Fragment_Shader]// [Fragment_Shader]varying vec3 normal, lightDir, eyeVec;varying vec3 normal, lightDir, eyeVec;void main (void) {void main (void) {

vec4 final_color = vec4 final_color = (gl_FrontLightModelProduct.sceneColor * gl_FrontMaterial.ambient) + (gl_FrontLightModelProduct.sceneColor * gl_FrontMaterial.ambient) + (gl_LightSource[0].ambient * gl_FrontMaterial.ambient);(gl_LightSource[0].ambient * gl_FrontMaterial.ambient);vec3 N = normalize(normal);vec3 N = normalize(normal);vec3 L = normalize(lightDir);vec3 L = normalize(lightDir);float lambertTerm = dot(N,L);float lambertTerm = dot(N,L);if(lambertTerm > 0.0) {if(lambertTerm > 0.0) {

final_color += gl_LightSource[0].diffuse * final_color += gl_LightSource[0].diffuse * gl_FrontMaterial.diffuse * gl_FrontMaterial.diffuse *

lambertTerm;lambertTerm;vec3 E = normalize(eyeVec);vec3 E = normalize(eyeVec);vec3 R = reflect(-L, N);vec3 R = reflect(-L, N);float specular = pow( max(dot(R, E), 0.0), float specular = pow( max(dot(R, E), 0.0), gl_FrontMaterial.shininess );gl_FrontMaterial.shininess );final_color += gl_LightSource[0].specular * final_color += gl_LightSource[0].specular * gl_FrontMaterial.specular * gl_FrontMaterial.specular *

specular;specular;}}gl_FragColor = final_color;gl_FragColor = final_color;

}}

105

Exemples simples : érosion 2D// [Vertex_Shader]// [Vertex_Shader]varying vec4 owncoordinates;varying vec4 owncoordinates;varying vec4 gl_TexCoord[4]; // Inutile (variables prédéfinies)varying vec4 gl_TexCoord[4]; // Inutile (variables prédéfinies)uniform vec4 coeff_image;uniform vec4 coeff_image;/* Renvoie les 8-connexites suivantes .../* Renvoie les 8-connexites suivantes ...[1].zw[1].zw || [1].xy[1].xy || [0].zw[0].zw[2].xy[2].xy || XX || [0].xy[0].xy[2].zw[2].zw || [3].xy[3].xy || [3].zw[3].zw*/*/void main()void main(){{

// Recuperation de la position de la camera// Recuperation de la position de la cameraowncoordinates = gl_MultiTexCoord0;owncoordinates = gl_MultiTexCoord0;gl_TexCoord[0] = vec4(gl_MultiTexCoord0.x+coeff_image.x,gl_MultiTexCoord0.y,gl_TexCoord[0] = vec4(gl_MultiTexCoord0.x+coeff_image.x,gl_MultiTexCoord0.y,

gl_MultiTexCoord0.x+coeff_image.x,gl_MultiTexCoord0.ygl_MultiTexCoord0.x+coeff_image.x,gl_MultiTexCoord0.y +coeff_image.y);+coeff_image.y);

gl_TexCoord[1] = vec4(gl_MultiTexCoord0.x,gl_MultiTexCoord0.y+coeff_image.y,gl_TexCoord[1] = vec4(gl_MultiTexCoord0.x,gl_MultiTexCoord0.y+coeff_image.y, gl_MultiTexCoord0.x-coeff_image.x,gl_MultiTexCoord0.ygl_MultiTexCoord0.x-coeff_image.x,gl_MultiTexCoord0.y

+coeff_image.y);+coeff_image.y);gl_TexCoord[2] = vec4(gl_MultiTexCoord0.x-coeff_image.x,gl_MultiTexCoord0.y,gl_TexCoord[2] = vec4(gl_MultiTexCoord0.x-coeff_image.x,gl_MultiTexCoord0.y,

gl_MultiTexCoord0.x-coeff_image.x,gl_MultiTexCoord0.ygl_MultiTexCoord0.x-coeff_image.x,gl_MultiTexCoord0.y-coeff_image.y);-coeff_image.y);

gl_TexCoord[3] = vec4(gl_MultiTexCoord0.x,gl_TexCoord[3] = vec4(gl_MultiTexCoord0.x,gl_MultiTexCoord0.y-coeff_image.y,gl_MultiTexCoord0.y-coeff_image.y, gl_MultiTexCoord0.x+coeff_image.x,gl_MultiTexCoord0.ygl_MultiTexCoord0.x+coeff_image.x,gl_MultiTexCoord0.y

-coeff_image.y);-coeff_image.y);gl_Position = ftransform();gl_Position = ftransform();

}}

// [Vertex_Shader]// [Vertex_Shader]varying vec4 owncoordinates;varying vec4 owncoordinates;varying vec4 gl_TexCoord[4]; // Inutile (variables prédéfinies)varying vec4 gl_TexCoord[4]; // Inutile (variables prédéfinies)uniform vec4 coeff_image;uniform vec4 coeff_image;/* Renvoie les 8-connexites suivantes .../* Renvoie les 8-connexites suivantes ...[1].zw[1].zw || [1].xy[1].xy || [0].zw[0].zw[2].xy[2].xy || XX || [0].xy[0].xy[2].zw[2].zw || [3].xy[3].xy || [3].zw[3].zw*/*/void main()void main(){{

// Recuperation de la position de la camera// Recuperation de la position de la cameraowncoordinates = gl_MultiTexCoord0;owncoordinates = gl_MultiTexCoord0;gl_TexCoord[0] = vec4(gl_MultiTexCoord0.x+coeff_image.x,gl_MultiTexCoord0.y,gl_TexCoord[0] = vec4(gl_MultiTexCoord0.x+coeff_image.x,gl_MultiTexCoord0.y,

gl_MultiTexCoord0.x+coeff_image.x,gl_MultiTexCoord0.ygl_MultiTexCoord0.x+coeff_image.x,gl_MultiTexCoord0.y +coeff_image.y);+coeff_image.y);

gl_TexCoord[1] = vec4(gl_MultiTexCoord0.x,gl_MultiTexCoord0.y+coeff_image.y,gl_TexCoord[1] = vec4(gl_MultiTexCoord0.x,gl_MultiTexCoord0.y+coeff_image.y, gl_MultiTexCoord0.x-coeff_image.x,gl_MultiTexCoord0.ygl_MultiTexCoord0.x-coeff_image.x,gl_MultiTexCoord0.y

+coeff_image.y);+coeff_image.y);gl_TexCoord[2] = vec4(gl_MultiTexCoord0.x-coeff_image.x,gl_MultiTexCoord0.y,gl_TexCoord[2] = vec4(gl_MultiTexCoord0.x-coeff_image.x,gl_MultiTexCoord0.y,

gl_MultiTexCoord0.x-coeff_image.x,gl_MultiTexCoord0.ygl_MultiTexCoord0.x-coeff_image.x,gl_MultiTexCoord0.y-coeff_image.y);-coeff_image.y);

gl_TexCoord[3] = vec4(gl_MultiTexCoord0.x,gl_TexCoord[3] = vec4(gl_MultiTexCoord0.x,gl_MultiTexCoord0.y-coeff_image.y,gl_MultiTexCoord0.y-coeff_image.y, gl_MultiTexCoord0.x+coeff_image.x,gl_MultiTexCoord0.ygl_MultiTexCoord0.x+coeff_image.x,gl_MultiTexCoord0.y

-coeff_image.y);-coeff_image.y);gl_Position = ftransform();gl_Position = ftransform();

}}

106

Exemples simples// [Vertex_Shader]// [Vertex_Shader]uniform sampler2D basetex;uniform sampler2D basetex;varying vec2 owncoordinates ;varying vec2 owncoordinates ;varying vec4 gl_TexCoord[4]; // Inutile (variables prédéfinies)varying vec4 gl_TexCoord[4]; // Inutile (variables prédéfinies)

void main()void main(){{

float cpt = 0.0;float cpt = 0.0;

gl_FragColor = vec4(0.0,0.0,0.0,1.0);gl_FragColor = vec4(0.0,0.0,0.0,1.0);

if (texture2D(basetex,owncoordinates.xy).r > 0.0) {if (texture2D(basetex,owncoordinates.xy).r > 0.0) {//CALCUL DES TEXTURES ...//CALCUL DES TEXTURES ...cpt += texture2D(basetex,gl_TexCoord[0].xy).r;cpt += texture2D(basetex,gl_TexCoord[0].xy).r;cpt += texture2D(basetex,gl_TexCoord[0].zw).r;cpt += texture2D(basetex,gl_TexCoord[0].zw).r;cpt += texture2D(basetex,gl_TexCoord[1].xy).r;cpt += texture2D(basetex,gl_TexCoord[1].xy).r;cpt += texture2D(basetex,gl_TexCoord[1].zw).r;cpt += texture2D(basetex,gl_TexCoord[1].zw).r;if (cpt == 4.0) gl_FragColor.r = 1.0;if (cpt == 4.0) gl_FragColor.r = 1.0;

}}}}

// [Vertex_Shader]// [Vertex_Shader]uniform sampler2D basetex;uniform sampler2D basetex;varying vec2 owncoordinates ;varying vec2 owncoordinates ;varying vec4 gl_TexCoord[4]; // Inutile (variables prédéfinies)varying vec4 gl_TexCoord[4]; // Inutile (variables prédéfinies)

void main()void main(){{

float cpt = 0.0;float cpt = 0.0;

gl_FragColor = vec4(0.0,0.0,0.0,1.0);gl_FragColor = vec4(0.0,0.0,0.0,1.0);

if (texture2D(basetex,owncoordinates.xy).r > 0.0) {if (texture2D(basetex,owncoordinates.xy).r > 0.0) {//CALCUL DES TEXTURES ...//CALCUL DES TEXTURES ...cpt += texture2D(basetex,gl_TexCoord[0].xy).r;cpt += texture2D(basetex,gl_TexCoord[0].xy).r;cpt += texture2D(basetex,gl_TexCoord[0].zw).r;cpt += texture2D(basetex,gl_TexCoord[0].zw).r;cpt += texture2D(basetex,gl_TexCoord[1].xy).r;cpt += texture2D(basetex,gl_TexCoord[1].xy).r;cpt += texture2D(basetex,gl_TexCoord[1].zw).r;cpt += texture2D(basetex,gl_TexCoord[1].zw).r;if (cpt == 4.0) gl_FragColor.r = 1.0;if (cpt == 4.0) gl_FragColor.r = 1.0;

}}}}

107

GPGPU

4. GPGPU via Cuda

108

Let the specialists talk...

A view on Cuda Tutorial of Nvidia...

Diapo 1Diapo 2Diapo 3Diapo 4Diapo 5Diapo 6Diapo 7Diapo 8Diapo 9Diapo 10Diapo 11Diapo 12Diapo 13Diapo 14Diapo 15Diapo 16Diapo 17Diapo 18Diapo 19Diapo 20Diapo 21Yes ! Wealth of applicationsDiapo 23Diapo 24Diapo 25Diapo 26Diapo 27Diapo 28Diapo 29Diapo 30Diapo 31Diapo 32Diapo 33Diapo 34Diapo 35Diapo 36Diapo 37Diapo 38Diapo 39Diapo 40Diapo 41Diapo 42Diapo 43Diapo 44Diapo 45Diapo 46Diapo 47Diapo 48Diapo 49Diapo 50Diapo 51Diapo 52Diapo 53Diapo 54Diapo 55Diapo 56Diapo 57Diapo 58Diapo 59Diapo 60Diapo 61Diapo 62Diapo 63Diapo 64Diapo 65Diapo 66Diapo 67Diapo 68Diapo 69Diapo 70Diapo 71Diapo 72Diapo 73Diapo 74Diapo 75Diapo 76Diapo 77Diapo 78Diapo 79Diapo 80Diapo 81Diapo 82Diapo 83Diapo 84Diapo 85Diapo 86Diapo 87Diapo 88Diapo 89Diapo 90Diapo 91Diapo 92Diapo 93Diapo 94Diapo 95Diapo 96Diapo 97Diapo 98Diapo 99Diapo 100Diapo 101Diapo 102Diapo 103Diapo 104Diapo 105Diapo 106Diapo 107Diapo 108