Vous êtes sur la page 1sur 40

Tutoriels Direct3D 10 : Bases

Par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
Date de publication : 19 janvier 2009
Dernire mise jour : 19 janvier 2009
Traduction d'un article original de la Library MSDN US
Les tutoriels suivant ont t crs afin d'apprendre un programmeur les bases de la
programmation de l'API Direct3D 10.
Ils couvrent la mise en place et les procdures basiques afin d'accomplir les taches
fondamentales, comme dessiner et transformer.
Le public vis est un public familier avec la programmation, mais relativement nouveau dans
la programmation 3D graphique. Les tutoriels de bases seront un premier pas sur Direct3D,
servant expliquer des concepts simple derrire le rendu 3D, comme les sommets, les
transformations et les animations.
Les utilisateurs plus expriments migrant vers Direct3D 10 peuvent passer ces explications
et aller voir les changements effectus dans cette itration de l'API.
Le SDK DirectX est tlchargeable Ici
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 2 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
I - Tutoriels de base.................................................................................................................................................... 4
I-0 - Tutoriel 0 : Les bases de Win32.................................................................................................................... 4
I-0-a - Rsum.................................................................................................................................................. 4
I-0-b - Source.................................................................................................................................................... 4
I-0-c - Prparation de la fentre....................................................................................................................... 4
I-1 - Tutoriel 1 : L'essentiel de Direct3D 10........................................................................................................... 6
I-1-a - Sommaire............................................................................................................................................... 6
I-1-b - Source.................................................................................................................................................... 6
I-1-c - Cration d'un device Direct3D 10.......................................................................................................... 6
I-1-d - En modifiant la boucle de messages.................................................................................................... 8
I-1-e - Le code de l'affichage............................................................................................................................8
I-2 - Tutoriel 2 : Dessiner un Triangle.................................................................................................................... 9
I-2-a - Rsum.................................................................................................................................................. 9
I-2-b - Source.................................................................................................................................................... 9
I-2-c - Elments d'un Triangle.......................................................................................................................... 9
I-2-d - Composition d'entre........................................................................................................................... 10
I-2-e - Composition de sommets.................................................................................................................... 12
I-2-f - Cration du vertex buffer...................................................................................................................... 12
I-2-g - Topologie des primitives...................................................................................................................... 13
I-2-h - Le dessin du triangle........................................................................................................................... 15
I-3 - Tutoriel 3 : Shaders et systme d'effets.......................................................................................................15
I-3-a - Rsum................................................................................................................................................ 16
I-3-b - Source.................................................................................................................................................. 16
I-3-c - Le pipeline graphique...........................................................................................................................16
I-3-d - Les shaders......................................................................................................................................... 16
I-3-e - Les vertex shaders.............................................................................................................................. 16
I-3-f - Les pixel shaders..................................................................................................................................17
I-3-g - Systme d'effets...................................................................................................................................18
I-3-h - Crer l'effet et la technique d'effet.......................................................................................................18
I-3-i - Rassembler tout cela............................................................................................................................ 18
I-4 - Tutoriel 4 : Espaces 3D................................................................................................................................19
I-4-a - Rsum................................................................................................................................................ 19
I-4-b - Source.................................................................................................................................................. 19
I-4-c - Espaces 3D..........................................................................................................................................19
I-4-d - L'espace objet...................................................................................................................................... 21
I-4-e - L'espace monde...................................................................................................................................21
I-4-f - L'espace vue......................................................................................................................................... 22
I-4-g - L'espace projection.............................................................................................................................. 22
I-4-h - L'espace cran.....................................................................................................................................22
I-4-i - Transformation d'espace espace....................................................................................................... 22
I-4-j - Transformation monde.......................................................................................................................... 23
I-4-k - Transformation vue.............................................................................................................................. 23
I-4-l - Transformation de projection................................................................................................................ 23
I-4-m - Utilisation des Transformations...........................................................................................................25
I-4-n - Modifier le Vertex Buffer...................................................................................................................... 25
I-4-o - Modifier le Vertex Shader.................................................................................................................... 26
I-4-p - Configurer les Matrices........................................................................................................................27
I-4-q - Mettre jour les Buffers Constant.......................................................................................................28
I-5 - Tutoriel 5 : Transformation 3D......................................................................................................................28
I-5-a - Rsum................................................................................................................................................ 28
I-5-b - Source.................................................................................................................................................. 28
I-5-c - Transformation......................................................................................................................................28
I-5-d - Translation............................................................................................................................................29
I-5-e - Rotation................................................................................................................................................ 30
I-5-f - Scaling...................................................................................................................................................31
I-5-g - Transformations multiples.................................................................................................................... 31
I-5-h - Crer l'orbit...........................................................................................................................................32
I-5-i - Le buffer de profondeur........................................................................................................................ 33
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 3 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
I-6 - Tutoriel 6 : La lumire.................................................................................................................................. 34
I-6-a - Rsum................................................................................................................................................ 34
I-6-b - Source.................................................................................................................................................. 34
I-6-c - L'clairage............................................................................................................................................ 34
I-6-d - initialiser les lumires...........................................................................................................................35
I-6-e - Rendu des lumires dans le Pixel Shader.......................................................................................... 36
I-7 - Tutoriel 7 : Mapping de texture et Constant Buffers.................................................................................... 36
I-7-a - Rsum................................................................................................................................................ 37
I-7-b - Source.................................................................................................................................................. 37
I-7-c - Mapping de texture.............................................................................................................................. 37
I-7-d - Creation d'un Shader Resource depuis une Texture...........................................................................37
I-7-e - Dfinir les coordonnes....................................................................................................................... 37
I-7-f - Attribuer une texture en tant que Shader Resource............................................................................ 38
I-7-g - Appliquer la Texture (fx)...................................................................................................................... 39
I-7-h - Constant Buffers.................................................................................................................................. 39
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 4 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
I - Tutoriels de base
I-0 - Tutoriel 0 : Les bases de Win32
I-0-a - Rsum
Dans ce tutoriel prliminaire, nous allons passer en revue les lments ncessaires pour crer une application Win32.
Nous allons prparer une fentre vide pour l'utilisation de Direct3D 10.
I-0-b - Source
(SDK root)\Samples\C++\Direct3D10\Tutorials\Tutorial00
I-0-c - Prparation de la fentre
Chaque application Windows requiert au moins un objet fentre. Avant mme de voir les spcificits de Direct3D 10,
notre application doit avoir un objet fentre fonctionnel. 3 choses sont ncessaires :
1. Enregistrer la classe de la fentre
//
// Enregistrement de la classe de la fentre
//
WNDCLASSEX wcex;
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon(hInstance, (LPCTSTR)IDI_TUTORIAL1);
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wcex.lpszMenuName = NULL;
wcex.lpszClassName = szWindowClass;
wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_TUTORIAL1);
if( !RegisterClassEx(&wcex) )
return FALSE;
2. Crer un objet fentre
//
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 5 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
// Cration de la fentre
//
g_hInst = hInstance; // Stock l'identifiant de l'instance de notre variable globale
RECT rc = { 0, 0, 640, 480 };
AdjustWindowRect( &rc, WS_OVERLAPPEDWINDOW, FALSE );
g_hWnd = CreateWindow( szWindowClass, L"Direct3D 10 Tutoriel 0 : Preparation de la fenetre",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT, rc.right - rc.left, rc.bottom - rc.top, NULL, NULL,
hInstance, NULL);

if( !g_hWnd )
return FALSE;

ShowWindow( g_hWnd, nCmdShow );
3. Rcuprer et distribuer les messages de cette fentre
//
// Boucle principale des messages
//
MSG msg = {0};
while( GetMessage( &msg, NULL, 0, 0 ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}

LRESULT CALLBACK WndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
{
PAINTSTRUCT ps;
HDC hdc;

switch (message)
{
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
EndPaint(hWnd, &ps);
break;

case WM_DESTROY:
PostQuitMessage(0);
break;

default:
return DefWindowProc(hWnd, message, wParam, lParam);
}

return 0;
}
Celles-ci sont les tapes ncessaires pour configurer un objet fentre qui est ncessaire pour chaque application
Windows. Si nous compilons et dmarrons ce code, nous verrons une fentre avec un fond blanc.
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 6 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
I-1 - Tutoriel 1 : L'essentiel de Direct3D 10
I-1-a - Sommaire
Dans ce premier tutoriel, nous allons examiner les lments ncessaires pour crer une application minimale Direct3D
10. Toute application Direct3D 10 doit avoir ces lments pour fonctionner correctement. Les lments incluent la
cration d'une fentre et d'un objet device direct3D 10 puis l'affichage d'une couleur sur la fentre.
I-1-b - Source
(SDKracine)\Samples\C++\Direct3D10\Tutorials\Tutorial01
I-1-c - Cration d'un device Direct3D 10
Maintenant que nous avons une fentre qui est affiche, nous pouvons continuer tablir un objet device Direct3D
10, lequel est ncessaire si nous voulons afficher des scnes 3D. La premire chose faire est de crer deux objets :
un device et une chane d'changes.
L'objet device est utilis par l'application pour amliorer l'affichage sur un tampon. L'objet device Direct3D 10 contient
aussi des mthodes pour crer des ressources
La chane d'changes est alors charge de lire le tampon dans lequel le device Direct3D 10 effectue le rendu et en
affiche le contenu sur l'cran du moniteur. La chane d'changes contient deux ou plusieurs tampons, principalement
celui du devant et du fond. Ce sont des textures que le device Direct3D 10 dessine aussi pour l'affichage sur le
moniteur. Le tampon du devant est celui que l'utilisateur regarde actuellement. Ce tampon est en lecture seule et ne
peut tre modifi. Le tampon du fond est la cible d'affichage sur laquelle le device va dessiner. Une fois que le dessin
est termin, la chane d'change prsentera le tampon du fond, en changeant les deux tampons c'est--dire que le
tampon du fond va devenir le tampon du devant et vice versa.
Pour crer la chane d'changes, nous remplissons une structure DXGI_SWAPCHAIN_DESC qui dcrit la chane
d'changes que nous sommes en train de crer. Quelques champs mritent d'tre cits : BacktamponUsage est un
drapeau qui dit l'application comment le tampon du fond doit tre utilis. Dans ce cas, nous voulons afficher le
tampon du fond, donc nous allons configurer la BackBufferUsage DXGI_USAGE_RENDER_TARGET_OUTPUT.
Le champ OutputWindow reprsente la fentre que la chane d'changes va utiliser pour prsenter des images sur
l'cran. SampleDesc est utilis pour permettre le multi-chantillonnage. Puisque ce tutoriel n'utilise pas de multi-
chantillonnage, le compte de SampleDesc est configur 1 pour fonctionner et 0 pour dsactiver le multi-
chantillonnage.
Une fois que la description a t remplie, nous pouvons appeler la fonction pour crer l'ensemble du device et de la
chane d'changes pour nous. Le code pour crer un device et une chane d'change est list ci-dessous :
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 7 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
DXGI_SWAP_CHAIN_DESC sd;
ZeroMemory( &sd, sizeof(sd) );
sd.tamponCount = 1;
sd.tamponDesc.Width = 640;
sd.tamponDesc.Height = 480;
sd.tamponDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.tamponDesc.RefreshRate.Numerator = 60;
sd.tamponDesc.RefreshRate.Denominator = 1;
sd.tamponUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.OutputWindow = g_hWnd;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.Windowed = TRUE;

if( FAILED( D3D10CreateDeviceAndSwapChain( NULL, D3D10_DRIVER_TYPE_REFERENCE, NULL,
0, D3D10_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice ) ) )
{
return FALSE;
}
La prochaine chose que nous avons besoin de faire est de crer une vue cible d'affichage. Une vue cible d'affichage
est un type de ressources au niveau vue dans Direct3D 10. Une ressource au niveau vue permet une ressource
d'tre relie la pipeline graphique lors d'une phase particulire. Pensez que la ressource au niveau vue* est
comme un type cast en langage C. Un bout de mmoire brute en C peut tre cast en n'importe quel type de donnes.
Nous pouvons caster ce bout de mmoire en un tableau d'entiers, un tableau de flottants, une structure, un tableau
de structures etc. La mmoire brute elle-mme n'est pas trop utile pour nous si nous ne connaissons pas ce type.
Les ressources au niveau vue de Direct3D 10 fonctionnent d'une manire similaire. Par exemple une texture 2D,
analogue un bout de mmoire brute est une ressource brute sous-jacente. Une fois que nous avons cette ressource
nous pouvons crer diffrentes ressources au niveau vue pour relier cette texture aux diffrentes phases dans le
pipeline graphique avec diffrents formats : une cible d'affichage qui doit dessiner, un tampon de gabarit tendu qui
recevra une information tendue ou une ressource de texture. Les types cast en C permett un bout de mmoire
d'tre utilis de diffrentes faons, les ressources au niveau vue de Direct3D 10 font de mme.
Nous avons besoin de crer une vue de cible d'affichage car nous aimerions lier le tampon du fond de notre chane
d'change comme tant une cible d'affichage, de telle faon que Direct3D 10 puisse l'afficher dedans. Nous appelons
d'abord GetBuffer() pour obtenir l'objet du tampon du fond. Facultativement, nous pouvons remplir la structure
D3D10_RENDERTARGETVIEW_DESC qui dcrit la vue cible d'affichage qui va tre cre. Cette description est
normalement le second paramtre de CreateRenderTarget. Cependant, pour ces tutoriels, la vue cible d'affichage
par dfaut suffira. La vue cible d'affichage par dfaut peut tre obtenue en passant NULL comme second paramtre.
Une fois que nous avons cr la vue cible d'affichage, nous pouvons appeler OMSetRenderTargets() pour la lier au
pipeline de faon ce qu' la sortie, cette dernire affiche ce qu'elle va crire dans le tampon du fond. Le code pour
crer et configurer la vue cible d'affichage est crit ci-dessous :
// creation d'une vue de cible d'affichage
ID3D10Texture2D *pBacktampon;
if( FAILED( g_pSwapChain->Gettampon( 0, __uuidof( ID3D10Texture2D ), (LPVOID*)&pBacktampon ) ) )
return FALSE;
hr = g_pd3dDevice->CreateRenderTargetView( pBacktampon, NULL, &g_pRenderTargetView );
pBacktampon->Release();
if( FAILED( hr ) )
return FALSE;
g_pd3dDevice->OMSetRenderTargets( 1, &g_pRenderTargetView, NULL );
La dernire chose que nous avons besoin de faire avant que Direct3D 10 puisse afficher est d'initialiser la zone
d'affichage. Les coordonnes de l'espace cadr du plan de la zone d'affichage, qui va de -1 1 pour x et y, et de 0
1 pour z, affiche l'espace cible. Ce dernier est aussi connu sous le nom de "l'espace pixel". Dans Direct3D 9, une
zone d'affichage par dfaut est cre pour tre de la mme taille que la cible d'affichage si l'application n'en cre pas
d'autres. Dans Direct3D 10, il n'y a pas de zone d'affichage cre par dfaut. Par consquent, nous devons en crer
une avant que nous puissions voir quelque chose sur l'cran. Puisque nous aimerions utiliser la cible d'affichage
entire pour la sortie, nous allons situer le point du sommet gauche (0, 0) et la largeur et la hauteur sera identique
la taille de la cible d'affichage. Le code qui illustre ceci est prsent ci-dessous :
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 8 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
D3D10_VIEWPORT vp;
vp.Width = 640;
vp.Height = 480;
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
g_pd3dDevice->RSSetViewports( 1, &vp );
I-1-d - En modifiant la boucle de messages
Nous avons cre la fentre et le device Direct3D 10, et nous sommes prts afficher. Cependant, il y a toujours
un problme avec notre boucle de messages : cette dernire utilise GetMessage() pour obtenir des messages. Le
problme avec GetMessage() est que s'il n'y a pas de message dans la file pour la fentre applicatrice, GetMessage()
bloque et ne retourne pas son rsultat jusqu' ce qu'un message soit libre. Par consquent, au lieu d'afficher, notre
application bloque l'intrieur de GetMessage() quand la file de message est vide. Nous pouvons rsoudre ce
problme en utilisant PeekMessage() la place de GetMessage(). PeekMessage() peut rcuprer un message
comme GetMessage() le fait, mais quand il n'y a pas de message qui attend, PeekMessage() retourne immdiatement
son rsultat au lieu de bloquer. Nous pouvons alors afficher quelque chose. La boucle de messages modifie, qui
utilise PeekMessage(), ressemble a ceci :
MSG msg = {0};
while( WM_QUIT != msg.message )
{
if( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
else
{
Render(); // fait l'affichage
}
}
I-1-e - Le code de l'affichage
L'affichage est fait dans la fonction Render(). Dans ce tutoriel, nous afficherons la scne la plus simple possible, qui
est de remplir l'cran avec une seule couleur. Dans Direct3D 10, une faon simple de remplir la cible d'affichage
avec une seule couleur est d'utiliser la mthode ClearRenderTargetView() du device. Nous dfinissons d'abord une
structure D3D10_COLOR qui dcrit la couleur avec laquelle nous voudrions remplir l'cran, puis on transmet cette
structure ClearRenderTargetView(). Dans cet exemple, un shader de bleu est choisi. Une fois que nous avons
rempli notre tampon du fond, nous appelons la mthode Present() de la chane d'changes pour complter l'affichage.
Present() est responsable de l'affichage du contenu du tampon de la chane d'changes sur l'cran de sorte que
l'utilisateur puisse le voir. La fonction Render() ressemble ceci :
void Render()
{
//
// nettoie le tampon du fond
//
float ClearColor[4] = { 0.0f, 0.125f, 0.6f, 1.0f }; // RGBA
g_pd3dDevice->ClearRenderTargetView( g_pRenderTargetView, ClearColor );

g_pSwapChain->Present( 0, 0 );
}
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 9 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
I-2 - Tutoriel 2 : Dessiner un Triangle
I-2-a - Rsum
Dans le tutoriel prcdent, nous avons construit l'armature minimale d'une application Direct3D 10 qui produit une
seule couleur dans la fentre. Dans ce tutoriel, nous allons tendre l'application pour dessiner un triangle l'cran.
Nous allons parcourir le processus pour dfinir les structures de donnes associes un triangle.
Le produit de ce tutoriel est une fentre avec un triangle dessin en son centre.
I-2-b - Source
(SDK root)\Samples\C++\Direct3D10\Tutorials\Tutorial02
I-2-c - Elments d'un Triangle
Un triangle est dfini par ses trois points, aussi appels sommets. Un ensemble de 3 sommets avec des positions
uniques dfinie un triangle unique. Afin que le GPU dessine un triangle, nous devons lui donner la position de 3
sommets. Pour un exemple 2D, disons que nous souhaitons dessiner un triangle comme sur l'image 1. Nous passons
les 3 sommets avec les positions (0, 0) (0, 1) et (1, 0) au GPU, alors le GPU a assez d'informations pour dessiner
le triangle que nous voulons.
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 10 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
Donc maintenant, nous savons que nous devons passer 3 positions au GPU afin de dessiner un triangle. Comment
passe-t-on ces informations au GPU ? Avec Direct3D 10, les informations des sommets, comme la position, sont
stockes dans un tampon de ressources. Un tampon qui est utilis pour stocker les informations des sommets est
appel le "vertex buffer". Nous devons crer un vertex buffer suffisamment grand pour 3 sommets et le remplir avec
les positions des sommets. Dans Direct3D 10, l'application doit spcifier une taille de tampon en octets lorsque l'on
cre un tampon de ressources. Nous savons que le buffer doit tre assez grand pour 3 sommets, mais de combien
d'octets a besoin chaque sommet ? Pour rpondre cette question, il est ncessaire de comprendre la composition
des sommets.
I-2-d - Composition d'entre
Un sommet a une position. Plus souvent que jamais, il a aussi d'autres attributs, comme une normale, une ou plusieurs
couleurs, des coordonnes de textures (utilises pour le placement de textures), et ainsi de suite. La composition de
sommets dfini comment ces attributs se situent en mmoire : quel type de donnes utilise chaque attribut, quelle
taille chaque attribut, et l'ordre des attributs en mmoire. Parce que les attributs ont habituellement diffrents types,
similaires aux champs dans une structure C, un sommet est habituellement reprsent par une structure. La taille du
sommet est facilement obtenue partir de la taille de la structure.
Dans ce tutoriel, nous travaillons seulement avec la position des sommets. Donc, nous dfinissons notre structure de
sommets avec un seul champ de type D3DXVECTOR3. Ce type est un vecteur de 3 composants virgules flottantes,
qui est typiquement le type de donnes utilis pour une position en 3D.
struct SimpleVertex
{
D3DXVECTOR3 Pos; // Position
};
Nous avons maintenant une structure qui reprsente notre sommet. Celle-ci prend soin de stocker les informations
de sommets dans la mmoire systme de notre application. Cependant, quand nous fournissons au GPU le vertex
buffer contenant nos sommets, nous lui fournissons juste un morceau de mmoire. Le GPU doit aussi connatre
la composition de sommet afin d'extraire les attributs corrects du tampon. Pour accomplir ceci, l'utilisation de la
composition d'entre sera requise.
Dans Direct3D 10, une composition d'entre est un objet Direct3D qui dcrit la structure des sommets d'une
faon qui peut tre comprise par le GPU. Chaque attribut de sommet peut tre dcrit avec la structure
D3D10_INPUT_ELEMENT_DESC. Une application dfinie une ou plusieurs D3D10_INPUT_ELEMENT_DESC,
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 11 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
ensuite utilise ce tableau pour crer l'objet de composition d'entre qui dcrit compltement les sommets. Nous allons
maintenant regarder en dtails les champs de D3D10_INPUT_ELEMENT_DESC.
SemanticName SemanticName est une chane de caractres
contenant un mot qui dcrit la nature ou le
but (ou smantiques) de cet lment. Le
mot peut tre dans une des formes qu'un
identifieur C peut avoir, et peut tre tout
ce que nous choisissons. Par exemple,
un bon nom smantique pour la position
des sommets est POSITION. Les noms
smantiques ne sont pas sensibles la
casse.
SemanticIndex Les SemanticIndex compltent les noms
smantiques. Un sommet peut avoir
de multiples attributs de mme nature.
Par exemple, il peut avoir 2 sries de
coordonnes de texture ou 2 sries de
couleurs. Au lieu d'utiliser des noms
smantiques qui possdent des nombres,
tels que "COLOR0" et "COLOR1", les deux
lments peuvent partager un seul nom
smantique, "COLOR", avec des indices
diffrents 0 et 1.
Format Le format dfinie le type de donnes qui sera
utilis pour cet lment. Par exemple, un
format DXGI_FORMAT_R32G32B32_FLOAT
a trois nombres virgules flottantes
de 32 bits, ce qui fait que l'lment
utilise 12 octets. Un format
DXGI_FORMAT_R16G16B16A16_UINT a
quatre entiers non signs de 16 bits, ce qui
fait que l'lment utilise 8 octets.
InputSlot Comme mentionn prcdemment, une
application Direct3D 10 passe les donnes
de sommet au GPU par l'utilisation de
vertex buffer. Dans Direct3D 10, plusieurs
vertex buffer peuvent tre fournis au GPU
simultanment, 16 pour tre exact. Chaque
vertex buffer est assign un numro
d'emplacement d'entre compris entre 0
et 15. Le champ InputSlot dit au GPU quel
vertex buffer il doit aller chercher pour cet
lment.
AlignedByteOffset Un sommet est stock dans un vertex buffer,
qui est simplement un morceau de mmoire.
Le champ AlignedByteOffset dit au GPU
l'emplacement mmoire pour commencer
aller chercher les donnes pour cet lment.
InputSlotClass Ce champ a habituellement la valeur
D3D10_INPUT_PER_VERTEX_DATA.
Quand une application utilise
l'instanciation, elle peut dfinir un
InputSlotClass de la composition d'entre
D3D10_INPUT_PER_INSTANCE_DATA
pour travailler avec le vertex buffer
contenant les donnes d'instance.
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 12 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
L'instanciation est un sujet avanc de
Direct3D et ne sera pas discute ici. Pour
ce tutoriel, nous utiliserons exclusivement
D3D10_INPUT_PER_VERTEX_DATA.
InstanceDataStepRate Ce champ est utilis pour l'instanciation.
Comme nous n'utilisons pas l'instanciation,
ce champ n'est pas utilis et doit tre dfini
0.
Maintenant, nous pouvons dfinir notre tableau D3D10_INPUT_ELEMENT_DESC et crer la
composition d'entre :
// Dfini la composition d'entre
D3D10_INPUT_ELEMENT_DESC layout[] =
{
{ L"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
};
UINT numElements = sizeof(layout)/sizeof(layout[0]);
I-2-e - Composition de sommets
Dans le prochain tutoriel, nous expliquerons l'objet "technique" et les shaders associs. Pour l'instant, nous nous
concentrerons juste sur la cration de l'objet de composition de sommets Direct3D 10 pour la technique. Cependant,
nous apprendrons que la technique et les shaders sont troitement coupls avec cette composition de sommets. La
raison est que la cration d'un objet de composition de sommet requiert la signature d'entre du shader de sommets.
Nous appelons tout d'abord la mthode de la technique GetPassByIndex() pour obtenir un objet d'effet de passage qui
rprsente le premier passage de la technique. Ensuite, nous appellons la mthode de l'objet de passage GetDesc()
pour obtenir une structure de description du passage. Dans cette structure, il y a un champ nomm pIAInputSignature
qui renvoie vers la donne binaire que reprsente la signature d'entre du vertex shader utilis dans ce passage. Une
fois que nous avons cette donne, nous pouvons appeler ID3D10Device::CreateInputLayout() pour crer un objet de
composition de sommets, et ID3D10Device::IASetInputLayout() pour le dfinir en tant que composition de sommets
active. Le code pour effectuer tout cela est montr ci-dessous :
// Cre la composition d'entre
D3D10_PASS_DESC PassDesc;
g_pTechnique->GetPassByIndex( 0 )->GetDesc( &PassDesc );
if( FAILED( g_pd3dDevice->CreateInputLayout( layout, numElements, PassDesc.pIAInputSignature,
PassDesc.IAInputSignatureSize, &g_pVertexLayout ) ) )
return FALSE;
// Dfini la composition d'entre
g_pd3dDevice->IASetInputLayout( g_pVertexLayout );
I-2-f - Cration du vertex buffer
Une chose que nous aurons aussi besoin de faire durant l'initialisation est de crer le vertex buffer
qui contiendra les donnes des sommets. Pour crer un vertex buffer dans Direct3D 10, nous
remplissons deux structures, D3D10_BUFFER_DESC et D3D10_SUBRESOURCE_DATA, et ensuite, nous
appelons ID3D10Device::CreateBuffer(). D3D10_BUFFER_DESC dcrit l'objet vertex buffer qui sera cr, et
D3D10_SUBRESOURCE_DATA dcrit les donnes actuelles qui seront copies dans le vertex buffer durant la
cration. La cration et l'initialisation du vertex buffer sont effectues en une seule fois de sorte que nous n'ayons
pas besoin d'initialiser le buffer plus tard. Les donnes qui seront copies dans le vertex buffer sont les sommets,
un tableau de 3 SimpleVertex. Les coordonnes dans le tableau de sommets sont choisies afin que nous puissions
voir un triangle au milieu de la fentre de notre application lors de l'affichage avec nos shaders. Aprs que le vertex
buffer soit cr, nous pouvons appeler ID3D10Device::IASetVertexBuffers() pour l'attribuer vers le device. Le code
complet est montr ici :
// Cre le vertex buffer
SimpleVertex vertices[] =
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 13 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
{
D3DXVECTOR3( 0.0f, 0.5f, 0.5f ),
D3DXVECTOR3( 0.5f, -0.5f, 0.5f ),
D3DXVECTOR3( -0.5f, -0.5f, 0.5f ),
};
D3D10_BUFFER_DESC bd;
bd.Usage = D3D10_USAGE_DEFAULT;
bd.ByteWidth = sizeof( SimpleVertex ) * 3;
bd.BindFlags = D3D10_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
D3D10_SUBRESOURCE_DATA InitData;
InitData.pSysMem = vertices;
if( FAILED( g_pd3dDevice->CreateBuffer( &bd, &InitData, &g_pVertexBuffer ) ) )
return FALSE;

// Dfini le vertex buffer
UINT stride = sizeof( SimpleVertex );
UINT offset = 0;
g_pd3dDevice->IASetVertexBuffers( 0, 1, &g_pVertexBuffer, &stride, &offset );
I-2-g - Topologie des primitives
La topologie des primitives identifie comment le GPU obtient les trois sommets dont il a besoin pour dessiner le
triangle. Nous avons discut ci-dessus qu'afin d'afficher un seul triangle, l'application a besoin d'envoyer 3 sommets
au GPU. Ainsi, le vertex buffer comporte 3 sommets. Que se passe t-il si nous voulons dessiner deux triangles ? Une
solution est d'envoyer 6 sommets au GPU. Les 3 premiers sommets dfinissent le premier triangle et les 3 autres
sommets dfinissent le second triangle. Cette topologie est appele une liste de triangles. Les listes de triangles
ont l'avantage d'tre facile comprendre, mais dans certains cas, ils sont trs inefficaces. De tels cas se produisent
quand vous affichez successivement des triangles qui partagent des sommets. Par exemple, l'image 3a nous montre
un carr compos de 2 triangles : A B C et C B D. (Par convention, les triangles sont typiquement dfinis en listant
leurs sommets dans le sens des aiguilles d'une montre.) Si nous envoyons ces deux triangles vers le GPU en utilisant
une liste de triangles, notre vertex buffer ressemblerait ceci :
A B C C B D
Notez que B et C apparaissent deux fois dans le vertex buffer car ils sont partags par les deux triangles.
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 14 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
L'image 3a contient un carr compos de 2 triangles; l'image 3b contient une forme pentagonale compose de 3
triangles.
Nous pouvons faire un vertex buffer plus petit si nous pouvons dire au GPU que lors de l'affichage du second triangle,
au lieu d'aller chercher les 3 sommets depuis le vertex buffer, d'utiliser 2 des sommets du triangle prcdent et d'aller
chercher seulement 1 sommet depuis le vertex buffer. Il s'avre que cela est support par Direct3D, et la topologie est
appele "bande de triangles". Lors du dessin d'une bande de triangles, le tout premier triangle est dfini par les trois
premiers sommets du vertex buffer. Le triangle suivant est dfini par les deux derniers sommets du triangle prcdent
plus le sommet suivant dans le vertex buffer. En prenant le carr sur l'image 3a comme exemple, en utilisant une
bande de triangle, le vertex buffer ressemblerait ceci :
A B C D
Les trois premiers sommets, A B C, dfinissent le premier triangle. Le second triangle est dfini par B et C, les deux
derniers sommets du premier triangle, plus D. Donc, en utilisant la topologie de bande de triangles, la taille vertex
buffer est passe de 6 sommets 4 sommets. Similairement, pour trois triangles comme sur l'image 3b, l'utilisation
d'une liste de triangles ncessiterait un vertex buffer comme ceci :
A B C C B D C D E
En utilisant une bande de triangles, la taille du vertex buffer est dramatiquement rduite :
A B C D E
Vous avez pu noter que dans l'exemple de la bande de triangles, le second triangle est dfini par B C D. Ces 3
sommets ne forment pas un ordre dans le sens des aiguilles d'une montre. C'est un phnomne naturel de l'utilisation
des bandes de triangles. Pour contourner ceci, le GPU change automatiquement l'ordre des 2 vertices provenant
du triangle prcdent. Il effectue seulement ceci pour le second triangle, le quatrime triangle, le sixime triangle, le
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 15 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
huitime triangle, et ainsi de suite. Cela assure que tous les triangles sont dfinis par des sommets dans un ordre
correct (sens des aiguilles d'une montre, dans ce cas). A ct des listes de triangles et des bandes de triangles,
Direct3D 10 supporte plusieurs autres types de topologies de primitives. Nous ne discuterons pas de ceux-ci dans
ce tutoriel.
Dans notre code, nous avons un triangle, donc ce que nous spcifions importe peu. Cependant, nous devons spcifier
quelque chose, donc nous optons pour une liste de triangle.
// Dfini la topologie de primitive
g_pd3dDevice->IASetPrimitiveTopology( D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
I-2-h - Le dessin du triangle
L'lment final manquant est le code qui effectue l'affichage actuel du triangle. Comme mentionn prcdemment,
ce tutoriel utilisera le systme d'effets. Nous commenons en appelant ID3D10EffectTechnique::GetDesc() sur l'objet
technique obtenu plus tt pour recevoir une structure D3D10FX_TECHNIQUE_DESC qui dcrit la technique. Un
des membres de D3D10FX_TECHNIQUE_DESC, Passes, indique le nombre de passage que la technique contient.
Pour dessiner correctement en utilisant cette technique, l'application doit boucler le mme nombre de fois qu'il y
a de passages. Dans la boucle, nous devons d'abord appeler la mthode GetPassByIndex() de la technique pour
obtenir l'objet de passage, ensuite appeler sa mthode Apply() pour avoir le systme d'effet attribu aux shaders
associs et les tats d'affichages vers le pipeline graphique. La chose suivante que nous faisons est d'appeler
ID3D10Device::Draw(), laquelle commande au GPU de dessiner en utilisant le vertex buffer courant, la composition
de sommets, et la topologie de primitives. Le premier paramtre de Draw() est le nombre de sommets envoyer au
GPU, et le second paramtre est l'indice du premier sommet pour commencer envoyer. Comme nous dessinons
un triangle et que nous dessinons depuis le dbut du vertex buffer, nous utilisons 3 et 0, respectivement, pour les
deux paramtres. Le code entier d'affichage du triangle ressemble ceci :
// Affichage d'un triangle
D3D10_TECHNIQUE_DESC techDesc;
g_pTechnique->GetDesc( &techDesc );
for( UINT p = 0; p < techDesc.Passes; ++p )
{
g_pTechnique->GetPassByIndex( p )->Apply(0);
g_pd3dDevice->Draw( 3, 0 );
}
I-3 - Tutoriel 3 : Shaders et systme d'effets
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 16 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
I-3-a - Rsum
Dans le tutoriel prcdent, nous avons configur un vertex buffer et envoy un triangle au GPU. Maintenant, nous
allons en fait passer par tapes au travers du pipeline graphique et regarder comment chaque niveau fonctionne. Le
concept de shaders et du systme d'effets sera expliqu.
Notez que ce tutoriel partage le mme code source que le prcdent, mais correspondera diffrentes sections.
I-3-b - Source
(SDK root)\Samples\C++\Direct3D10\Tutorials\Tutorial03
I-3-c - Le pipeline graphique
Dans le tutoriel prcdent, nous avons configur le vertex buffer, et ensuite, nous avons associ une composition de
sommets avec un objet technique. Maintenant, nous allons expliquer l'objet technique et les shaders qui le composent.
Pour comprendre pleinement chacun des shaders, nous allons faire un pas en arrire et regarder l'intgralit du
pipeline graphique.
Dans le tutoriel 2, quand nous avons appel Apply depuis la technique, nous avons en fait limit notre shader
un niveau du pipeline. Ensuite, quand nous avons appel Draw, nous avons commenc traiter les donnes des
sommets passes dans le pipeline graphique. Les sections suivantes dcrivent en dtail ce qu'il se produit aprs
la commande Draw.
I-3-d - Les shaders
Dans Direct3D 10, les shaders rsident dans diffrents niveaux du pipeline graphique. Ce sont de courts programmes
qui, excuts par le GPU, prennent certaines donnes d'entres, traitent ces donnes, et ensuite, produisent le
rsultat vers le niveau suivant du pipeline. Direct3D 10 supporte 3 types de shaders : le vertex shader, le geometry
shader, et le pixel shader. Un vertex shader prend un sommet comme entre. Il est utilis une seule fois pour tous les
sommets passs au GPU via des vertex buffers. Un geometry shader prend une primitive comme entre, et est utilis
une seule fois pour toutes les primitives passes au GPU. Une primitive est un point, une ligne, ou un triangle. Un
pixel shader prend un pixel (ou parfois appel un fragment) comme entre, et est utilis une seule fois pour chaque
pixel d'une primitive que nous souhaitons afficher. Ensemble, les vertex, geometry, et pixel shaders se situent o
l'essentiel de l'action se produit. Lors de l'affichage avec Direct3D 10, le GPU doit avoir un vertex shader et un pixel
shader valide. Le geometry shader est une fonctionnalit avance dans Direct3D 10 et est optionnel, donc nous ne
discuterons pas des geometry shaders dans ce tutoriel.
I-3-e - Les vertex shaders
Les vertex shaders sont de courts programmes qui sont executs par le GPU sur des sommets. Pensez aux vertex
shaders comme des fonctions C qui prennent chaque sommet comme entre, traitent l'entre, et ensuite produisent
le sommet modifi. Aprs que l'application ait pass les donnes des sommets au GPU sous la forme d'un vertex
buffer, le GPU itre au travers les sommets du vertex buffer, et excute le vertex shader actif une fois pour chaque
sommet, en passant les donnes des sommets au vertex shader en tant que paramtres d'entres.
Tant qu'un vertex shader peut tre utilis pour effectuer plusieurs tches, le travail le plus important d'un vertex shader
est la transformation. La transformation est le procd de conversion des vecteurs d'un systme de coordonne vers
un autre. Par exemple, un triangle dans une scne 3D peut avoir ses sommets aux positions (0, 0, 0) (1, 0, 0) (0, 1,
0). Quand le triangle est dessin sur un buffer de texture 2D, le GPU doit connatre les coordonnes 2D des points du
buffer o les sommets doivent tre dessins. C'est la transformation qui nous aide accomplir cel. La transformation
sera traite en dtails dans le tutoriel suivant. Pour ce tutoriel, nous utiliserons un vertex shader simple, qui ne fait
rien except passer les donnes d'entre en tant que sortie.
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 17 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
Dans les tutoriels Direct3D 10, nous crirons nos shaders en High-Level Shading Language (HLSL), et les
applications utiliseront ces shaders avec le systme d'effets. Rappelez vous que nos donnes sommets ont une
position 3D, et le vertex shader ne traitera pas du tout l'entre. Le vertex shader rsultant ressemblera ceci :
float4 VS( float4 Pos : POSITION ) : SV_POSITION
{
return Pos;
}
Ce vertex shader ressemble fortement une fonction C. HLSL utilise une syntaxe ressemblant au C pour rendre
l'apprentissage plus simple pour les programmeurs C/C++. Nous pouvons voir que ce vertex shader, nomm VS,
prend un paramtre de type float4 et retourne une valeur float4. Dans HLSL, un float4 est un vecteur 4 composants,
o chaque composant est un nombre virgule flottante. Les deux points dfinissent les smantiques du paramtre
ainsi que la valeur retourne. Comme mentionn plus haut, les smantiques dans HLSL dcrivent la nature des
donnes. Dans notre shader prcdent, nous choisissons POSITION comme smantique du paramtre d'entre Pos
car ce paramtre contiendra la position du sommet. Les smantiques de la valeur retourne, SV_POSITION, sont
des smantiques prdfines avec des significations spciales. Ces smantiques disent au pipeline graphique que
les donnes associes aux smantiques dfinissent la position dans l'espace cadr. Cette position est requise par
le GPU afin de dessiner les pixels l'cran. (On discutera de l'espace cadr dans le tutoriel suivant.) Dans notre
shader, on rend la donne de position d'input et d'output de la mme manire dans le pipeline.
I-3-f - Les pixel shaders
Les moniteurs d'ordinateurs modernes sont habituellement des affichages matriciels, ce qui signifie que l'cran est
en fait une grille deux dimensions de petits points appels pixels. Chaque pixel contient une couleur indpendante
des autres pixels. Quand nous affichons un triangle l'cran, nous n'affichont pas rellement un triangle en tant
qu'une seule entit. Mais plutt, nous allumons un groupe de pixels qui sont couverts par la zone du triangle. L'image
2 montre une illustration de ceci.
A Gauche : ce que nous souhaitons dessiner. A Droite : ce qui se trouve rellement sur l'cran.
Le procd de conversion d'un triangle dfini par 3 sommets vers un ensemble de pixels couverts par le triangle est
appel "rasterisation". Le GPU dtermine d'abord quels pixels sont couverts par le triangle qui est dessin. Ensuite,
il invoque le pixel shader actif pour chacun de ces pixels. Le but premier d'un pixel shader est de calculer la couleur
que chaque pixel doit avoir. Le shader prend certaines entres du pixel qui va tre colori, calcule la couleur du pixel,
ensuite retourne cette couleur vers le pipeline. Les entres qu'il prend proviennent du geometry shader actif, ou, si
un geometry shader n'est pas prsent, comme dans ce tutoriel, l'input provident directement du vertex shader.
Le vertex shader que nous avons cr prcdemment produit un float4 avec les smantiques SV_POSITION. Cela
sera l'entre de notre pixel shader. Comme les pixel shaders produisent des valeurs de couleur, la sortie de notre
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 18 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
pixel shader sera un float4. On donne la sortie les smantiques SV_TARGET pour signifier la sortie vers le format
de l'affichage cibl. Le pixel shader ressemble ceci :
float4 PS( float4 Pos : SV_POSITION ) : SV_Target
{
return float4( 1.0f, 1.0f, 0.0f, 1.0f ); // Jaune, avec Alpha = 1
}
I-3-g - Systme d'effets
Notre fichier d'effet se compose de deux shaders, un vertex shader et un pixel shader, et la dfinition de la technique.
La dfinition de la technique dfinira les shaders correspondants pour chaque section. En plus, il y a aussi la
semantique pour compiler le shader. Notez que le geometry shader est laiss NULL car il n'est pas ncessaire
et sera trait plus tard.
// Dfinition de la technique
technique10 Render
{
pass P0
{
SetVertexShader( CompileShader( vs_4_0, VS() ) );
SetGeometryShader( NULL );
SetPixelShader( CompileShader( ps_4_0, PS() ) );
}
}
I-3-h - Crer l'effet et la technique d'effet
Dans le code de l'application, nous devrons crer un objet effet. Cet objet effet reprsente notre fichier d'effet, et est
cr en appelant D3D10CreateEffectFromFile(). Une fois que nous avons cr l'objet d'effet, nous pouvons appeler la
mthode ID3D10Effect::GetTechniqueByName(), en passant "Render" en tant que nom, pour obtenir l'objet technique
qui sera utilis pour faire l'affichage actuel. Le code est dmontr ci-dessous :
// Cre l'effet
if( FAILED( D3DX10CreateEffectFromFile( L"Tutorial03.fx", NULL, NULL,
D3D10_SHADER_ENABLE_STRICTNESS, 0, g_pd3dDevice, NULL, NULL, &g_pEffect, NULL ) ) )
return FALSE;

// Obtient la technique
g_pTechnique = g_pEffect->GetTechniqueByName( "Render" );
I-3-i - Rassembler tout cela
Aprs avoir parcouru le pipeline graphique, nous pouvons commencer comprendre le procd d'affichage du
triangle que nous avons cr au dbut du tutoriel 2. La cration des applications Direct3D requiert deux tapes
distinctes. La premire serait de crer la source des donnes dans les donnes de sommets, comme nous avons
fait dans le tutoriel 2; le second niveau sera de crer les shaders qui transformeront ces donnes pour l'affichage,
qui a t montr dans ce tutoriel.
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 19 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
I-4 - Tutoriel 4 : Espaces 3D
I-4-a - Rsum
Dans le tutoriel prcdent, nous avons russi afficher un triangle au centre de la fentre de notre application. Nous
n'avons pas prt beaucoup d'attention aux positions des sommets que nous avons pris dans notre vertex buffer.
Dans ce tutoriel, nous allons rentrer dans le dtail des positions 3D et des transformations.
L'objectif de ce tutoriel sera d'avoir un objet 3D affich l'cran. L o le prcdent tutoriel se concentrait sur
l'affichage d'objet 2D dans un monde 3D, ici nous afficherons un objet 3D.
I-4-b - Source
(SDK root)\Samples\C++\Direct3D10\Tutorials\Tutorial04
I-4-c - Espaces 3D
Dans le tutoriel prcdent, les sommets du triangle taient placs stratgiquement pour s'aligner parfaitement sur
l'cran. Cependant, ce ne sera pas toujours le cas, et donc, nous avons besoin d'un systme pour dcrire les objets
dans l'espace 3D et un systme pour les afficher.
Dans le monde rel, les objets existent dans un espace 3D. Cela signifie que pour placer un objet dans une position
particulire dans le monde, nous aurons besoin d'utiliser un systme de coordonnes et de dfinir 3 coordonnes qui
correspondent la position. Dans le graphisme par ordinateur, les espaces 3D sont communment dans un systme
de coordonnes Cartsien. Dans ce systme de coordonnes, 3 axes, X, Y, et Z, perpendiculaires les uns envers
les autres, dictant les coordonnes que chaque point dans l'espace possde. Ce systme de coordonnes est de
plus divis en un systme main gauche et main droite. Dans un systme main gauche, lorsque l'axe X pointe vers la
droite et l'axe Y pointe vers le haut, et l'axe Z pointe vers l'avant. Dans un systme en main droite, avec les mmes
axes X et Y, l'axe Z pointe vers l'arrire.
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 20 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
Figure 1 : Systme de coordonnes main gauche contre main droite
Maintenant que nous avons abord le systme de coordonnes, considrons des espaces 3D. Un point a diffrentes
coordonnes dans diffrents espaces. Dans un exemple en 1D, supposons que nous ayons une rgle et que nous
notons le point P, la marque 5 cm de la rgle. Maintenant, si nous dplaons la rgle d'1 cm vers la droite, le mme
point se trouve la marque 4 cm. En dplaant la rgle, l'image de rfrence a chang, et ainsi, bien que le point
n'ait pas boug, il possde une nouvelle coordonne.
Figure 2 : Illustration de l'espace 1D
En 3D, un espace est typiquement dfini par une origine et trois axes uniques depuis l'origine : X, Y et Z. Il y a
plusieurs espaces habituellement utiliss dans le graphisme par ordinateur : l'espace objet, l'espace monde, l'espace
vue, l'espace de projection et l'espace cran.
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 21 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
Figure 3 : Un cube dfini dans l'espace objet
I-4-d - L'espace objet
Remarquez que le cube est centr sur l'origine. L'espace objet, galement appel l'espace du modle, correspond
l'espace utilis par les artistes quand ils crent les modles 3D. Habituellement, les artistes crent des modles
qui sont centrs autour de l'origine afin qu'il soit plus facile d'effectuer des transformations, telles que la rotation
des modles, comme nous le verrons quand nous nous interresserons aux transformations. Les 8 sommets ont les
coordonnes suivantes :
(-1, 1, -1)
( 1, 1, -1)
(-1, -1, -1)
( 1, -1, -1)
(-1, 1, 1)
( 1, 1, 1)
(-1, -1, 1)
( 1, -1, 1)
Parce que l'espace objet est ce que les artistes utilisent habituellement quand ils dessinent et crent des modles,
les modles qui sont stocks sur le disque sont galement dans l'espace objet. Une application peut crer un vertex
buffer pour reprsenter un tel modle et initialiser le buffer avec les donnes du modle. Ainsi, les sommets dans
le vertex buffer seront habituellement aussi dans l'espace objet. Cela signifie aussi que le vertex shader reoit en
entre les donnes des sommets dans l'espace objet.
I-4-e - L'espace monde
L'espace Monde (World space) est un espace partag par chaque objet dans la scne. Il est utilis pour dfinir
la relation spatiale entre les objets que l'on souhaite afficher (render). Pour visualiser l'espace Monde, on pourrait
imaginer que nous nous trouvons dans le coin sudouest d'une pice rectangulaire qui fait face au nord. On dfinit le
coin o nos pieds se trouvent comme tant l'origine (0, 0, 0). L'axe X se trouve notre droite; l'axe Y vers le haut;
et l'axe Z vers l'avant, la mme direction que celle dont nous faisons face. Quand on effectue ceci, chaque position
dans la pice peut tre identifie avec une srie de coordonnes XYZ. Par exemple, il pourrait y avoir une chaise
5 pieds en face et 2 pieds notre droite. Il pourrait y avoir une lampe de 8 pieds de haut sur le plafond directement
haut-dessus de la chaise. On peut se rfrer la position de la chaise qui est (2, 0, 5) et la position de la lampe
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 22 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
qui est (2, 8, 5). Comme nous pouvons le voir, l'espace monde est appel ainsi car il nous dit o les objets sont en
relation les uns les autres dans le monde.
I-4-f - L'espace vue
L'espace vue, parfois appel espace camra, est similaire l'espace monde en cela qu'il est typiquement utilis pour
la scne entire. Cependant, dans l'espace vue, l'origine se trouve sur le spectateur ou la camra. La direction de
la vue (o le spectateur regarde) dfini l'axe Z positif. Une direction "haut" dfinie par l'application devient l'axe Y
positif comme expliqu ci-dessous.
Figure 4 : Le mme objet en espace monde (gauche) et en espace vue (droite)
L'image de gauche montre une scne qui se compose d'un objet ressemblant un humain et un spectateur (camra)
regardant l'objet. L'origine et les axes qui sont utiliss par l'espace monde sont indiqus en rouge. L'image de droite
montre l'espace vue en relation avec l'espace monde. Les axes de l'espace vue sont indiqus en bleu. Pour claircir
l'illustration, l'espace vue ne possde pas la mme orientation que l'espace monde sur l'image de gauche pour les
lecteurs. Notez que dans l'espace vue, le spectateur regarde dans la direction Z.
I-4-g - L'espace projection
L'espace projection rfre lespace aprs l'application de la transformation de projection depuis l'espace vue. Dans
cet espace, le contenu visible a les coordonnes X et Y compris entre -1 et 1, et la coordonne Z allant de 0 1.
I-4-h - L'espace cran
L'espace cran est parfois utilis pour se rfrer aux localisations dans le frame buffer. Comme le frame buffer est
habituellement une texture 2D, l'espace cran est un espace 2D. Le coin suprieur gauche est l'origine avec les
coordonnes (0, 0). Le X positif va vers la droite et le Y positif pointe vers le bas. Pour un tampon qui est de w pixels
de large et h pixels de haut, le pixel le plus bas sur la droite a les coordonnes (w - 1, h - 1).
I-4-i - Transformation d'espace espace
Les transformations sont les plus habituellement utilises pour convertir les sommets d'un espace vers un autre. En
graphisme 3D par ordinateur, il y a logiquement 3 telles transformations dans le pipeline : transformation monde,
vue, et projection. Les oprations de transformations individuelles telles que la translation, la rotation, et la mise
l'chelle sont tudies dans le tutoriel suivant.
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 23 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
I-4-j - Transformation monde
La transformation monde, comme son nom le suggre, convertit les sommets depuis l'espace objet vers l'espace
monde. Il se compose habituellement d'une ou plusieurs mise l'chelle, rotations et translations, bases sur la taille,
l'orientation et la position que nous voulons donner l'objet. Chaque objet dans la scne possde sa propre matrice
de transformation monde. C'est parce que chaque objet a sa propre taille, orientation, et position.
I-4-k - Transformation vue
Aprs que les sommets soient convertis dans l'espace monde, la transformation vue convertit ces sommets depuis
l'espace monde vers l'espace vue. En se souvenant de la conversation plus haut, disant que l'espace vue est ce que
le monde parat depuis la vue du spectateur (ou la camra). En espace vue, le spectateur est localis l'origine,
regardant le long de l'axe Z positif.
Il faut noter que bien que l'espace vue soit le monde depuis l'image de rfrence du spectateur, la matrice
de transformation vue est applique aux sommets, pas au spectateur. D'o, la matrice de vue doit effectuer la
transformation inverse que nous appliquons notre spectateur ou camra. Par exemple, si nous voulons dplacer la
camra de 5 units vers la direction -Z, nous aurions besoin de calculer une matrice de vue qui dplace les sommets
de 5 units le long de la direction +Z. Bien que la camra ait recul, les sommets, depuis le point de vue de la camra,
ont avanc. Dans Direct3D, une API appele D3DXMatrixLookAtLH() est souvent utilise pour calculer une matrice de
vue. Nous aurons simplement besoin de lui dire o le spectateur se trouve, o il regarde, et la direction reprsentant
le haut du spectateur, galement appele le vecteur haut, pour obtenir une matrice de vue correspondante.
I-4-l - Transformation de projection
La transformation de projection convertit les sommets depuis les espaces 3D comme les espaces monde et vue vers
l'espace projection. Dans l'espace projection, les coordonnes X et Y d'un sommet sont obtenues depuis les ratios
X/Z et Y/Z de ce sommet dans l'espace 3D.
Figure 5 : Projection
Dans l'espace 3D, les choses apparaissent en perspective. Ainsi, plus un objet est proche, plus grand il apparat.
Comme il est montr que le somemt d'un arbre h units de haut et d units de l'oeil du spectateur, apparatra au
mme point que le sommet d'un autre arbre de 2h d'units de haut et 2d units de distance. De cela, o un sommet
apparat sur un cran 2D est directement affect vers ses ratios X/Z et Y/Z.
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 24 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
Un des paramtres qui dfinit un espace 3D est appel champ de vision (field-of-view en anglais - FOV). Le FOV
dnote quels objets sont visibles depuis une position particulire, pendant que l'on regarde dans une direction
particulire. Les humains ont un champ de vision qui est vers l'avant (on ne peut pas voir ce qui se passe derrire
nous) et on ne peut pas voir les objets qui sont trop proches ou trop loin. En graphisme par ordinateur, le champ de
vision est contenu dans un frustum de vue. Le frustum de vue est dfini par 6 plans en 3D. Deux de ces plans sont
parallles au plan XY. Ceux-ci sont appels le plans Z proche et le plan Z loign. Les 4 autres plans sont dfinis
par le champ de vision horizontal du spectateur et le champ de vision vertical. Le FOV le plus large est o le volume
frustrum est le plus large et o le spectateur voit le plus d'objets.
Le GPU filtre les objets qui sont en dehors du frustum de vue afin qu'il n'ait pas dpenser du temps dessiner
quelque chose qui ne sera pas affich. Ce procd est appel clipping. Le frustum de vue est une pyramide 4 cts
avec un toit dcoup. Le clipping de ce volume est compliqu car pour clipper par rapport un plan du frustrum de
vue, le GPU doit comparer chaque sommet l'quation du plan. A la place, le GPU effectue gnralement d'abord la
transformation de projection, et ensuite clippe sur le volume du frustrum de vue. L'effet de transformation de projection
sur le frustum de vue est que la forme du frustrum de vue pyramidale devient une bote dans l'espace projection.
C'est parce que, comme mentionn plus haut, dans l'espace projection, les coordonnes X et Y sont bases sur
les X/Z et Y/Z dans l'espace 3D. Donc, le point a et le point b auront la mme coordonne X et Y dans l'espace de
projection, c'est pourquoi le frustum de vue devient une bote.
Figure 6 : Cne de vue
Supposez que le sommet de deux arbres se trouve exactement sur le haut une arrte du frustum de vue. De plus,
supposons que d = 2h. La coordonne Y le long de l'arrte suprieure dans l'espace projection sera ensuite 0.5
(car h/d = 0.5). Donc, les valeurs Y aprs projection qui sont plus grandes que 0.5 seront clippes par le GPU. Le
problme ici est que 0.5 est dtermin par le champ de vision vertical choisi par le programme, et diffrentes valeurs
de FOV produisent diffrentes valeurs que le GPU doit clipper nouveau. Pour rendre le procd plus convenable,
les programmes 3D mettent gnralement l'chelle les valeurs projetes de X et Y des sommets afin que les valeurs
X et Y visibles aient une porte de -1 1. En d'autres mots, tout ce qui a des coordonnes X et Y qui se trouvent
en dehors de la porte [-1 1] sera clipp. Pour que ce schma de clipping fonctionne, la matrice de projection doit
mettre l'chelle les coordonnes X et Y des sommets projets par l'inverse de h/d, ou d/h. d/h est galement la co-
tangeante de la moiti du FOV. Avec la mise l'chelle, le haut du view frustum devient h/d * d/h = 1. Tout ce qui est
plus grand que 1 sera clipp par le GPU. C'est ce que nous voulons.
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 25 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
Un ajustement similaire est gnralement effectu pour la coordonne Z dans l'espace projection. On souhaiterait
que le plan Z proche et le plan Z loign soit respectivement 0 et 1 dans l'espace projection. Quand Z = la valeur
Z proche dans l'espace 3D, Z doit tre 0 dans l'espace projection; quand Z = la valeur Z loign dans l'espace 3D,
Z doit tre 1 dans l'espace projection. Aprs que ceci soit effectu, les valeurs Z en dehors de [0 1] seront clippes
par le GPU.
Dans Direct3D 10, la manire la plus simple d'obtenir une matrice de projection est d'appeler la mthode
D3DXMatrixPerspectiveFovLH(). On fournit simplement 4 paramtres-- FOVy, Aspect, Zn, et Zf -- et elle retourne une
matrice qui effectue tout ce qui est ncessaire comme mentionn ci-dessus. FOVy est le FOV dans la direction Y.
Aspect est le ratio d'aspect, qui est le ratio de l'espace vue de la largeur sur la hauteur. A partir de FOVy et Aspect,
FOVx peut tre calcul. Ce ratio d'aspect est habituellement obtenu depuis le ratio de la largeur sur la hauteur de
l'affichage cibl. Zn et Zf sont respectivement les valeurs Z proche et Z loign dans l'espace vue.
I-4-m - Utilisation des Transformations
Dans le tutoriel prcdent, nous avons crit un programme qui affiche un seul triangle l'cran. Quand on cre le
vertex buffer, les positions des sommets que nous utilisons, sont directement dans l'espace projection afin que nous
n'ayons pas effectuer de transformation. Maintenant que nous avons une comprhension de l'espace 3D et des
transformations, nous allons modifier le programme afin que le vertex buffer soit dfini dans l'espace objet, comme
il doit l'tre. Ensuite, nous modifierons notre vertex shader pour transformer les sommets depuis l'espace objet vers
l'espace projection.
I-4-n - Modifier le Vertex Buffer
Comme nous avons commenc reprsenter les choses en 3 dimensions, nous avons chang le triangle plat du
tutoriel prcdent en un cube. Cela nous permettra de dmontrer ces concepts plus clairement.
SimpleVertex vertices[] =
{
{ D3DXVECTOR3( -1.0f, 1.0f, -1.0f ), D3DXVECTOR4( 0.0f, 0.0f, 1.0f, 0.0f ) },
{ D3DXVECTOR3( 1.0f, 1.0f, -1.0f ), D3DXVECTOR4( 0.0f, 1.0f, 0.0f, 0.0f ) },
{ D3DXVECTOR3( 1.0f, 1.0f, 1.0f ), D3DXVECTOR4( 0.0f, 1.0f, 1.0f, 0.0f ) },
{ D3DXVECTOR3( -1.0f, 1.0f, 1.0f ), D3DXVECTOR4( 1.0f, 0.0f, 0.0f, 0.0f ) },
{ D3DXVECTOR3( -1.0f, -1.0f, -1.0f ), D3DXVECTOR4( 1.0f, 0.0f, 1.0f, 0.0f ) },
{ D3DXVECTOR3( 1.0f, -1.0f, -1.0f ), D3DXVECTOR4( 1.0f, 1.0f, 0.0f, 0.0f ) },
{ D3DXVECTOR3( 1.0f, -1.0f, 1.0f ), D3DXVECTOR4( 1.0f, 1.0f, 1.0f, 0.0f ) },
{ D3DXVECTOR3( -1.0f, -1.0f, 1.0f ), D3DXVECTOR4( 0.0f, 0.0f, 0.0f, 0.0f ) },
};
Si vous le remarquez, tout ce que nous avons fait est de spcifier les huit points du cube, mais nous n'avons
actuellement pas dcrit individuellement les triangles. Si nous avions pass ceci tel quel, la sortie ne serait pas ce
que l'on attend. Nous devons spcifier les triangles qui forment le cube au travers de ces huit points.
Pour un cube, beaucoup de triangles partageront le mme sommet et ce serait une perte de mmoire de les redfinir
encore et encore. Ainsi, il y a une mthode pour spcifier juste les huit points et ensuite laisser Direct3D savoir quels
points prendre pour un triangle. Cela est effectu au travers d'un index buffer. Un index buffer contiendra une liste,
qui rfrera l'indice des sommets dans le buffer, pour spcifier quels points utiliser dans chaque triangle. Le code
ci-dessous montre quels points compose chacun de nos triangles.
// Cr un index buffer
DWORD indices[] =
{
3,1,0,
2,1,3,
0,5,4,
1,5,0,
3,4,7,
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 26 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
0,4,3,
1,6,5,
2,6,1,
2,7,6,
3,7,2,
6,4,5,
7,4,6,
};
Comme vous pouvez le voir, le premier triangle est dfini par les points 3, 1, et 0. Cela signifie que le premier triangle
a ses sommets respectivement : ( -1.0f, 1.0f, 1.0f ),( 1.0f, 1.0f, -1.0f ), et ( -1.0f, 1.0f, -1.0f ). Il y a six faces pour le
cube, et chaque face est compose de deux triangles, donc, vous voyez 12 triangles au total ici dfini.
Comme chaque sommet est explicitement list, et qu'aucun des deux triangles ne partage des arrtes (au moins, de
la faon dont ils ont t dfinis), ceci est considr comme une liste de triangles. Au total, pour les 12 triangles dans
la liste de triangle, nous devrons avoir au total 36 sommets.
La cration de l'index buffer est trs similaire au vertex buffer, o nous spcifions les paramtres tels que la taille et
le type dans une structure, et on a appel CreateBuffer. Le type est D3D10_BIND_INDEX_BUFFER, et comme nous
avons declar notre tableau en utilisant des DWORD, on utilisera sizeof(DWORD).
bd.Usage = D3D10_USAGE_DEFAULT;
bd.ByteWidth = sizeof( DWORD ) * 36; // 36 sommets ncessaires pour 12 triangles dans une triangle list
bd.BindFlags = D3D10_BIND_INDEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
InitData.pSysMem = indices;
if( FAILED( g_pd3dDevice->CreateBuffer( &bd, &InitData, &g_pIndexBuffer ) ) )
return FALSE;
Une fois que l'on a cr ce buffer, nous devrons le dfinir afin que Direct3D sache se rfrer cet index buffer lors
de la gnration des triangles. On spcifie le pointeur vers le buffer, le format, et le dcalage dans le buffer pour
commencer le rfrencement.
// Dfini l'index buffer
g_pd3dDevice->IASetIndexBuffer( g_pIndexBuffer, DXGI_FORMAT_R32_UINT, 0 );
I-4-o - Modifier le Vertex Shader
Dans notre vertex shader du tutoriel prcdent, on a pris la mme position d'entre et de sortie de sommet sans
aucune modification. On peut faire cela car la position d'entre du sommet est dj dfinie dans l'espace projection.
Maintenant, comme la position d'entre du sommet est dfinie dans l'espace objet, nous devons la transformer avant
de la sortir du vertex shader. On effectue ceci en 3 tapes : on transforme depuis l'espace objet vers l'espace monde,
on transforme de l'espace monde vers l'espace vue, et on transforme de l'espace vue vers l'espace projection. La
premire chose que nous devons faire est de dclarer 3 variables de buffer constants. Les buffers constants sont
utiliss pour stocker des donnes que l'application a besoin de passer aux shaders. Avant l'affichage, l'application
crit habituellement des donnes importantes dans les buffers constants, et ensuite durant l'affichage, les donnes
peuvent tre lues depuis l'intrieur des shaders. Dans un fichier FX, des variables de buffer constants sont dclares
comme des variables globales en C++. Les 3 variables que nous utiliserons sont les matrices de transformation
monde, vue et projection de type HLSL "matrix".
Une fois que nous avons dclar les matrices dont nous aurons besoin, on met jour notre vertex shader pour
transformer la position d'entre en utilisant les matrices. Un vecteur est transform en multipliant le vecteur par une
matrice. Dans HLSL, ceci est effectu en utilisant la fonction intrinsque mul(). Notre dclaration de variable et le
nouveau vertex shader sont montrs ci-dessous :
matrix World;
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 27 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
matrix View;
matrix Projection;
//
// Vertex Shader
//
VS_OUTPUT VS( float4 Pos : POSITION, float4 Color : COLOR )
{
VS_OUTPUT output = (VS_OUTPUT)0;
output.Pos = mul( Pos, World );
output.Pos = mul( output.Pos, View );
output.Pos = mul( output.Pos, Projection );
output.Color = Color;
return output;
}
Dans le vertex shader, chaque mul() applique une transformation la position d'entre. Les transformations monde,
vue, projection sont appliques dans cet ordre squentiellement. Ceci est ncessaire car la multiplication de vecteurs
et de matrices n'est pas commutative.
I-4-p - Configurer les Matrices
Nous avons mis jour notre vertex shader pour transformer en utilisant les matrices, mais nous avons aussi besoin
de dfinir 3 matrices dans notre programme. Ces trois matrices stockeront la transformation pour tre utilises
lors de l'affichage. Avant l'affichage, on copie les valeurs de ces matrices dans le buffer constant de shader.
Ensuite, quand on dbute l'affichage en appelant Draw(), notre vertex shader lit les matrices stockes dans le
buffer constant. En plus des matrices, nous avons aussi besoin de dfinir 3 pointeurs ID3D10EffectMatrixVariable.
ID3D10EffectMatrixVariable est un objet qui reprsente une matrice dans le buffer constant. Nous pouvons utiliser
ces 3 objets pour copier les matrices vers le buffer constant. Ainsi, nos variables globales possdent ceci en plus :
ID3D10EffectMatrixVariable* g_pWorldVariable = NULL;
ID3D10EffectMatrixVariable* g_pViewVariable = NULL;
ID3D10EffectMatrixVariable* g_pProjectionVariable = NULL;
D3DXMATRIX g_World;
D3DXMATRIX g_View;
D3DXMATRIX g_Projection;
Pour initialiser les 3 objets ID3D10EffectMatrixVariable, on appelle ID3D10Effect::GetVariableByName() aprs la
cration de l'effet, en passant le nom de la variable qui nous intresse. GetVariableByName() retourne une
interface ID3D10EffectVariable, mme si l'objet sous-jacent est spcifique au type de variable dfinie dans le
fichier FX. Dans ce cas, les objets sous jacents sont ID3D10EffectMatrixVariable. Pour obtenir une interface
ID3D10EffectMatrixVariable depuis un ID3D10EffectVariable, on peut appeler sa mthode AsMatrix() :
g_pWorldVariable = g_pEffect->GetVariableByName( "World" )->AsMatrix();
g_pViewVariable = g_pEffect->GetVariableByName( "View" )->AsMatrix();
g_pProjectionVariable = g_pEffect->GetVariableByName( "Projection" )->AsMatrix();
La chose suivante que nous avons besoin de faire est de pointer avec les 3 matrices que nous utiliserons pour faire la
transformation. Nous voulons que le triangle soit l'origine, parallle au plan XY. Voici exactement comment cela est
stock dans le vertex buffer dans l'espace objet. Ainsi, la transformation monde ne doit rien faire, et nous initialisons
la matrice monde avec une matrice identit. Nous souhaitons configurer notre camra afin qu'elle soit situe [0 1
-5], regardant au point [0 1 0]. On peut appeler D3DXMatrixLookAtLH() pour calculer correctement une matrice de
vue pour nous en utilisant le vecteur haut [0 1 0] car nous souhaitons toujours que la direction Y+ reste toujours vers
le haut. Finalement, pour avoir une matrice de projection, on appelle D3DXMatrixPerspectiveFovLH(), avec un FOV
vertical de 90 degrs (pi/2), un ratio d'aspect de 640/480 qui apporte la taille de notre back buffer, et les Z proche et
loign respectivement 0.1 et 100. Cela signifie que tout ce qui est plus proche que 0.1 ou plus loin que 100 ne sera
pas visible l'cran. Ces trois matrices sont stockes dans les variables globales g_World, g_View, et g_Projection.
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 28 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
I-4-q - Mettre jour les Buffers Constant
Nous avons les matrices, et maintenant nous devons les crire dans le buffer constant quand nous dessinons afin
que le GPU puisse les lire. Les buffers constants sont tudis en profondeur dans le prochain tutoriel. Pour l'instant,
considrez-les comme les conteneurs pour les constantes passes aux shaders. Car nous crivons les matrices dans
le buffer constant, on appelle la mthode de SetMatrix() de ID3D10EffectMatrixVariable, en lui passant la matrice
crire dans le buffer. Ceci doit tre effectu avant que l'on fasse l'appel Draw().
//
// Met jour les variables
//
g_pWorldVariable->SetMatrix( (float*)&g_World );
g_pViewVariable->SetMatrix( (float*)&g_View );
g_pProjectionVariable->SetMatrix( (float*)&g_Projection );
I-5 - Tutoriel 5 : Transformation 3D
I-5-a - Rsum
Dans le tutoriel prcdent, on a dessin un cube depuis l'espace modle l'cran. Dans ce tutoriel, nous allons
tendre le concept de transformation et montrer une simple animation qui peut tre faite avec ces transformations.
Au final de ce tutoriel, nous aurons un objet qui tourne autour d'un autre. Il sera utile de dcrire les transformations
et comment elles peuvent tre combines pour obtenir l'effet dsir. Les tutoriaux futurs seront construits sur cette
fondation quand nous introduirons de nouveaux concepts.
I-5-b - Source
(SDK root)\Samples\C++\Direct3D10\Tutorials\Tutorial05
I-5-c - Transformation
En graphisme 3D, la transformation est souvent utilise pour oprer sur des sommets et des vecteurs. C'est aussi
utilis pour les convertir d'un espace vers un autre. La transformation est effectue via multiplication avec une
matrice. Il y a typiquement 3 types de transformation primitive qui peuvent tre effectues sur des sommets : la
translation, la rotation , et le scaling (sa distance depuis l'origine). En plus de celles-ci, la transformation de projection
est utilise pour passer de l'espace vue l'espace projection. La bibliothque D3DX contient des API qui peuvent
construire commodment une matrice pour beaucoup de buts tels que la translation, la rotation, le scaling, la
transformation monde vers vue, la transformation vue vers projection, etc. Une application peut ensuite utiliser ces
matrices pour transformer les sommets dans sa scne. Une comprhension basique des transformations de matrices
est ncessaire. On va brivement examiner ci-dessous quelques exemples.
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 29 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
I-5-d - Translation
La translation se rfre au mouvement ou dplacement d'une certaine distance dans l'espace. En 3D, la matrice
utilise pour la translation a la forme :
1 0 0 0
0 1 0 0
0 0 1 0
a b c 1
O (a, b, c) est le vecteur qui dfinit la direction et la distance de dplacement. Par exemple, pour dplacer un sommet
de -5 units le long de l'axe X (direction X ngative), on peut la multiplier avec cette matrice :
1 0 0 0
0 1 0 0
0 0 1 0
-5 0 0 1
Si nous appliquons ceci un objet cube centr l'origine, le rsultat est que la bote est dplace de 5 units vers
l'avant sur l'axe X ngatif, comme indiqu sur la figure 1, aprs que la translation soit applique.
Figure 1 : effet de la translation
En 3D, un espace est typiquement dfini par un point d'origine et trois axes uniques depuis l'origine : X, Y et Z. Il y
a plusieurs espaces habituellement utiliss en graphisme sur ordinateur : l'espace objet, l'espace monde, l'espace
vue, l'espace projection et l'espace cran.
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 30 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
Figure 2 : un cube dfini dans l'espace objet
I-5-e - Rotation
La rotation se rfre la rotation des sommets sur un axe en partant de l'origine. Ces 3 axes sont les axes X, Y, et
Z dans l'espace. Un exemple en 2D ferait pivoter le vecteur [1 0] de 90 degrs dans le sens contraire des aiguilles
d'une montre. Le rsultat de la rotation est le vecteur [0 1]. La matrice utilise pour la rotation ? dans le sens des
aiguilles d'une montre sur l'axe Y ressemble ceci :
cos? 0 -sin? 0
0 1 0 0
sin? 0 cos? 0
0 0 0 1
La figure 3 montre l'effet de rotation d'un cube, centre l'origine, de 45 degrs sur l'axe Y.
Figure 3 : l'effet d'une rotation sur l'axe Y
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 31 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
I-5-f - Scaling
Le scaling se rfre l'agrandissement ou la diminution de la taille de vecteurs composants le long des axes. Par
exemple, un vecteur peut tre agrandi dans toutes les directions ou rduit seulement sur l'axe X. Pour faire le scaling,
on applique habituellement la matrice ci-dessous :
p 0 0 0
0 q 0 0
0 0 r 0
0 0 0 1
O p, q, et r sont les facteurs de scaling le long des directions X, Y et Z, respectivement. La figure 4 montre l'effet
de scaling par 2 le long de l'axe X et le scaling par 0.5 le long de l'axe Y.
Figure 4 : l'effet du scaling
I-5-g - Transformations multiples
Pour appliquer de multiples transformations un vecteur, on peut simplement multiplier le vecteur par la premire
matrice de transformation et, ensuite, multiplier le vecteur rsultant par la seconde matrice de transformation, et ainsi
de suite. La multiplication des vecteurs et des matrices tant associative, on peut aussi multiplier toutes les matrices
d'abord et ensuite multiplier les vecteurs par la matrice du produit et obtenir un rsultat identique. La figure 5 montre
comment le cube serait si nous combinions ensemble une rotation et une translation.
Figure 5 : l'effet d'une translation et d'une rotation
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 32 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
I-5-h - Crer l'orbit
Dans ce tutoriel, on va transformer deux cubes. Le premier tournera sur place, pendant que le second tournera autour
du premier, et tournera sur son propre axe. Les deux cubes auront leur propre matrice de transformation de monde
qui leur est associe, et cette matrice leur sera rapplique chaque frame dessine.
Il y a des fonctions dans D3DX qui nous assisterons dans la cration de la matrice de rotation, de translation et de
scaling.
Les rotations effectues autour des axes X, Y et Z sont accomplies avec les fonctions
D3DXMatrixRotationX, D3DXMatrixRotationY, et D3DXMatrixRotationZ respectivement. Elles crent
des matrices de rotations basiques qui tournent autour des axes primaires. Les rotations complexes autour
d'autres axes peuvent tre effectues en multipliant ensemble plusieurs d'entre elles.
Les translations peuvent tre effectues en invoquant la fonction D3DXMatrixTranslation. Cette fonction
crera une matrice qui va translater les points spcifis par les paramtres.
Le scaling est effectu avec D3DXMatrixScaling. Elle fait le scaling seulement le long des axes primaires.
Si le scaling le long d'axes arbitraires est souhait, alors la matrice de scaling peut tre multiplie avec une
matrice de rotation approprie pour accomplir l'effet.
Le premier cube tournera sur place et agira comme le centre de l'orbite. Le cube a une rotation le long de l'axe
Y applique la matrice monde associe. C'est effectu en appelant la fonction D3DXMatrixRotationY montre
ci-dessous. Le cube est pivot par un certain montant chaque frame. Comme les cubes sont supposs tourner
continuellement, la valeur par laquelle la matrice de rotation est base est incrmente avec chaque frame.
// 1er Cube : tourne autour de l'origine
D3DXMatrixRotationY( &g_World1, t );
Le second cube orbitera autour du premier. Pour montrer de multiples transformations, un facteur de scaling, et son
propre axe de rotation seront ajouts. La formule utilise est montre juste en dessous du code (en commentaire).
D'abord le cube sera rduit l'chelle d'une taille de 30%, et ensuite sera pivot autour de son propre axe de rotation
(l'axe Z dans ce cas). Pour simuler l'orbite, il sera translat depuis l'origine, et ensuite, pivot autour de l'axe Y.
L'effet dsir peut tre obtenu en utilisant 4 matrices spares avec leur transformation individuelle (mScale, mSpin,
mTranslate, mOrbit), puis, multiplies ensemble.
// 2me Cube : tourne autour de l'origine
D3DXMATRIX mTranslate;
D3DXMATRIX mOrbit;
D3DXMATRIX mSpin;
D3DXMATRIX mScale;
D3DXMatrixRotationZ( &mSpin, -t );
D3DXMatrixRotationY( &mOrbit, -t*2.0f );
D3DXMatrixTranslation( &mTranslate, -4.0f, 0.0f, 0.0f );
D3DXMatrixScaling( &mScale, 0.3f, 0.3f, 0.3f );
D3DXMatrixMultiply( &g_World2, &mScale, &mSpin );
D3DXMatrixMultiply( &g_World2, &g_World2, &mTranslate );
D3DXMatrixMultiply( &g_World2, &g_World2, &mOrbit );
//g_World2 = mScale * mSpin * mTranslate * mOrbit;
Un point important noter est que ces oprations ne sont pas commutatives. L'ordre dans lequel les transformations
sont appliques est important. Exprimentez avec l'ordre de transformation et observez les rsultats.
Comme toutes les fonctions de transformation vont crer une nouvelle matrice depuis les paramtres, le montant
avec lequel elles pivotent doit tre incrment. Ceci est effectu en mettant jour la variable "time".
// Met jour le temps (time)
t += D3DX_PI * 0.0125f;
Avant que les appels d'affichage ne soient effectus, la technique doit collecter les variables pour les shaders. Ici,
la matrice monde, la matrice vue et la matrice de projection sont attribues vers la technique. Notez que la matrice
monde est propre chaque cube, et donc, change pour chaque objet qui passe par elle/lui.
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 33 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
//
// Affiche le 1er cube
//
D3D10_TECHNIQUE_DESC techDesc;
g_pTechnique->GetDesc( &techDesc );
for( UINT p = 0; p < techDesc.Passes; ++p )
{
g_pTechnique->GetPassByIndex( p )->Apply(0);
g_pd3dDevice->DrawIndexed( 36, 0, 0 );
}
//
// Met jour les variables pour le second cube
//
g_pWorldVariable->SetMatrix( (float*)&g_World2 );
g_pViewVariable->SetMatrix( (float*)&g_View );
g_pProjectionVariable->SetMatrix( (float*)&g_Projection );
//
// Affiche le second cube
//
for( UINT p = 0; p < techDesc.Passes; ++p )
{
g_pTechnique->GetPassByIndex( p )->Apply(0);
g_pd3dDevice->DrawIndexed( 36, 0, 0 );
}
I-5-i - Le buffer de profondeur
Il y a un ajout important dans ce tutoriel, qui est le buffer de profondeur (depth buffer). Sans lui, le cube le plus petit en
orbite serait toujours dessin au dessus du cube plus grand au centre quand il se trouverait l'arrire du dernier. Le
buffer de profondeur permet Direct3D de garder des traces de la profondeur de chaque pixel dessin l'cran. Le
comportement par dfaut du buffer de profondeur dans Direct3D 10 est de vrifier chaque pixel dessin l'cran par
rapport la valeur stocke dans le buffer de profondeur pour ce pixel dans l'espace cran. Si la profondeur du pixel
affich est moindre ou gale la valeur dj dans le buffer de profondeur, le pixel est dessin et la valeur dans le
buffer de profondeur est mise jour par la profondeur du pixel nouvellement dessin. D'autre part, si le pixel dessin
a une profondeur plus grande que la valeur dj dans le buffer de profondeur, le pixel est ignor et la valeur de
profondeur dans le buffer de profondeur reste inchange.
Le code suivant dans l'exemple cre un buffer de profondeur (une texture DepthStencil). Il cre aussi une
DepthStencilView du buffer de profondeur afin que Direct3D 10 sache l'utiliser en tant que texture Depth Stencil.
// Cre une texture depth stencil
D3D10_TEXTURE2D_DESC descDepth;
descDepth.Width = width;
descDepth.Height = height;
descDepth.MipLevels = 1;
descDepth.ArraySize = 1;
descDepth.Format = DXGI_FORMAT_D32_FLOAT;
descDepth.SampleDesc.Count = 1;
descDepth.SampleDesc.Quality = 0;
descDepth.Usage = D3D10_USAGE_DEFAULT;
descDepth.BindFlags = D3D10_BIND_DEPTH_STENCIL;
descDepth.CPUAccessFlags = 0;
descDepth.MiscFlags = 0;
hr = g_pd3dDevice->CreateTexture2D( &descDepth, NULL, &g_pDepthStencil );
if( FAILED(hr) )
return hr;
// Cre la depth stencil view
D3D10_DEPTH_STENCIL_VIEW_DESC descDSV;
descDSV.Format = descDepth.Format;
descDSV.ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2D;
descDSV.Texture2D.MipSlice = 0;
hr = g_pd3dDevice->CreateDepthStencilView( g_pDepthStencil, &descDSV, &g_pDepthStencilView );
if( FAILED(hr) )
return hr;
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 34 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
Afin d'utiliser ce buffer depth stencil nouvellement cr, le tutoriel doit l'attribuer au device. C'est effectu en passant
la vue depth stencil au troisime paramtre de la fonction OMSetRenderTargets.
g_pd3dDevice->OMSetRenderTargets( 1, &g_pRenderTargetView, g_pDepthStencilView );
Comme avec la cible affiche, nous devons aussi vider le buffer de profondeur avant l'affichage. Cela assure que les
valeurs de profondeur des frames prcdentes n'ignorent pas incorrectement les pixels dans la frame actuelle. Dans
ces tutoriaux le buffer de profondeur est configur pour avoir un nombre maximum de (1.0).
//
// Vide le depth buffer 1.0 (profondeur max)
//
g_pd3dDevice->ClearDepthStencilView( g_pDepthStencilView, D3D10_CLEAR_DEPTH, 1.0f, 0 );
I-6 - Tutoriel 6 : La lumire
I-6-a - Rsum
Dans les tutoriaux prcdents, le monde semblait ennuyant car tous les objets t clairs de la mme faon.
Ce tutoriel va introduire le concept d'clairage simple et comment il peut tre appliqu. La technique utilise sera
l'clairage lambertien.
Le rsultat de ce tutoriel modifiera l'exemple prcdent pour inclure une source de lumire. Cette source de lumire
sera attache au cube en orbite. Les effets de lumire pourront tre vu sur le cube centr.
I-6-b - Source
(SDK root)\Samples\C++\Direct3D10\Tutorials\Tutorial06
I-6-c - L'clairage
Dans ce tutoriel, le type le plus basique d'clairage sera introduit : l'clairage lambertien. L'clairage lambertien a
une intensit uniforme irrespectueuse de la distance par rapport la lumire. Quand la lumire touche la surface, le
montant de lumire rflchie est calcul par l'angle d'incidence que la lumire a sur la surface. Quand une lumire
brille directement sur une surface, elle est montre pour refletter toute la lumire, avec une intensit maximum.
Cependant, comme l'angle de la lumire augmente, l'intensit de la lumire s'estompera.
Pour calculer l'intensit qu'une lumire a sur une surface, l'angle entre la direction de la lumire et la normale de la
surface doit tre calcul. La normale pour une surface est dfinie en tant qu'un vecteur qui est perpendiculaire la
surface. Le calcul de l'angle peut tre effectu avec un simple produit en croix, lequel retournera la projection de la
direction du vecteur de la lumire sur la normale. Plus large est l'angle, plus petite sera la projection. Donc, cela nous
donne la fonction correcte pour moduler la lumire diffuse.
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 35 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
La source de lumire utilise dans ce tutoriel est une approximation de l'clairage directionnel. Le vecteur qui dcrit
la source de lumire dtermine la direction de la lumire. Comme c'est une approximation, peu importe o se trouve
un objet, la direction dans laquelle la lumire brille est la mme. Un exemple de cette source de lumire est le soleil;
le soleil est toujours vu comme brillant dans la mme direction pour tous les objets dans la scne. En plus, l'intensit
de la lumire sur des objets individuels n'est pas prise en considration.
Les autres types de lumires incluent les points lumineux (point lights), qui rayonnent uniformment la lumire depuis
son centre, et les spots lumineux (spot lights), qui sont directionnels mais pas uniformes au travers de tous les objets.
I-6-d - initialiser les lumires
Dans ce tutoriel, il y aura deux sources de lumires. Une sera place statiquement au dessus et derrire le cube, et
une autre sera en orbite autour du cube centr. Notez que le cube en orbite dans le tutoriel prcdent a t remplac
avec cette source de lumire.
Comme l'clairage est calcul par les shaders, les variables devront tre dclares et ensuite attribues dans les
variables l'intrieur de la technique. Dans cet exemple, nous avons juste besoin de la direction de la source de
lumire, ainsi que de sa couleur. La premire lumire est grise et immobile, et la seconde est une lumire rouge
en orbite.
// Configure nos paramtres d'clairage
D3DXVECTOR4 vLightDirs[2] =
{
D3DXVECTOR4( -0.577f, 0.577f, -0.577f, 1.0f ),
D3DXVECTOR4( 0.0f, 0.0f, -1.0f, 1.0f ),
};
D3DXVECTOR4 vLightColors[2] =
{
D3DXVECTOR4( 0.5f, 0.5f, 0.5f, 0.0f ),
D3DXVECTOR4( 0.5f, 0.0f, 0.0f, 0.0f )
};
La lumire en orbite tourne juste comme le cube dans le dernier tutoriel. La matrice de rotation applique
changera la direction de la lumire, pour afficher l'effet qui brille toujours face au centre. Notez que la fonction
D3DXVec3Transform est utilise pour multiplier une matrice avec un vecteur. Dans le tutoriel prcdent, nous avons
juste multipli les matrices de transformation dans la matrice monde, nous sommes passe ensuite dans le shader
pour transformation; mais dans ce cas, nous allons faire la transformation monde de la lumire par le CPU, pour
une question de simplicit.
//fait tourner la seconde lumire autour de l'origine
D3DXMATRIX mRotate;
D3DXVECTOR4 vOutDir;
D3DXMatrixRotationY( &mRotate, -2.0f*t );
D3DXVec3Transform( &vLightDirs[1], (D3DXVECTOR3*)&vLightDirs[1], &mRotate );
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 36 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
La direction de la lumire et la couleur sont toutes les deux passes dans le shader juste comme des matrices. La
variable associe est appele pour affecter, et le paramtre y est pass.
//
// Met jour les variables d'clairage
//
g_pLightDirVariable->SetFloatVectorArray( (float*)vLightDirs, 0, 2 );
g_pLightColorVariable->SetFloatVectorArray( (float*)vLightColors, 0, 2 );
I-6-e - Rendu des lumires dans le Pixel Shader
Une fois que nous avons toutes les donnes configures et le shader correctement fourni avec les donnes, on peut
calculer le terme de l'clairage lambertien sur chaque pixel depuis les sources de lumire. Nous utiliserons la rgle
du produit en croix discute plus haut.
Une fois que l'on a pris le produit en croix de la lumire par rapport la normale, celui-ci peut tre multipli avec la
couleur de la lumire pour calculer l'effet de cette lumire. Cette valeur est passe au travers de la fonction saturate,
qui converti la porte vers [0, 1]. Finalement, le rsultat depuis les deux clairages spars sont additionns ensemble
pour crer la couleur pixel finale.
Considrez que le matriau de la surface n'est pas factoris dans le calcul de la lumire; la couleur finale sur la
surface est le rsultat des couleurs des lumires.
//
// Pixel Shader
//
float4 PS( PS_INPUT input) : SV_Target
{
float4 finalColor = 0;

//do NdotL lighting for 2 lights
for(int i=0; i<2; i++)
{
finalColor += saturate( dot( (float3)vLightDir[i],input.Norm) * vLightColor[i] );
}
return finalColor;
}
Une fois au travers du pixel shader, les pixels auront t moduls par les lumires et vous pouvez voir l'effet de
chaque lumire sur la surface du cube. Notez que la lumire dans ce cas semble plate car les pixels sur la mme
surface auront la mme normale. La lumire diffuse est un modle d'clairage trs simple et trs facile calculer. Des
modles d'clairage plus complexes peuvent tre utiliss pour accomplir des matriaux plus riches et plus ralistes.
I-7 - Tutoriel 7 : Mapping de texture et Constant Buffers
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 37 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
I-7-a - Rsum
Dans le tutoriel prcdent nous avons introduit l'clairage notre projet; maintenant nous allons construire sur tout
cela en ajoutant des textures notre cube. En plus, nous allons introduire le concept des constant buffers et comment
ils peuvent tre utiliss pour acclrer le traitement en minimisant l'usage de la bande passante.
Le rsultat de ce tutoriel modifiera le cube central pour qu'il y ait une texture mappe sur lui.
Ce tutoriel conclut l'introduction des concepts basiques dans Direct3D 10. Les tutoriaux suivants seront construits
partir de ces concepts en introduisant DXUT, le chargement de mesh, ainsi qu'un exemple de chaque shader.
I-7-b - Source
(SDK root)\Samples\C++\Direct3D10\Tutorials\Tutorial07
I-7-c - Mapping de texture
Le mapping de texture se rfere la projection d'une image 2D sur une gomtrie 3D. On peut penser ceci comme
un emballage cadeau, en plaant un papier dcoratif par-dessus une bote fade. Pour faire ceci, nous devons spcifier
comment les points sur la surface de la gomtrie correspondent avec l'image 2D.
Le soucis est de correctement aligner les coordonnes du modle avec la texture. Pour des modles complexes, il
est difficile de dterminer les coordonnes pour les textures la main. Donc, les programmes de modlisation 3D
vont gnralement exporter les modles avec les coordonnes de textures correspondantes. Comme notre exemple
est un cube, il est facile de dterminer les coordonnes ncessaires pour correspondre la texture. Les coordonnes
de texture sont dfinies aux vertices et interpoles pour les pixels individuels sur la surface.
I-7-d - Creation d'un Shader Resource depuis une Texture
La texture est une image 2D qui est obtenue depuis un fichier et utilise pour crer une vue shader-resource, afin
qu'elle puisse tre lue depuis un shader.
hr = D3DX10CreateShaderResourceViewFromFile( g_pd3dDevice, L"seafloor.dds", NULL, NULL,
&g_pTextureRV, NULL );
I-7-e - Dfinir les coordonnes
Avant que l'on puisse mapper l'image sur notre cube, nous devons d'abord dfinir les coordonnes de textures sur
chacun des vertices du cube. Comme les images peuvent tre de plusieurs tailles, le systme de coordonnes utilis
a t normalis [0, 1]. Le coin suprieur gauche de la texture correspond (0,0) et le coin infrieur droit mappe
(1,1).
Dans cet exemple, nous avons l'entiret de la texture qui s'tend sur chaque ct du cube. Cela simplifie la dfinition
des coordonnes, sans confusion. Cependant, il est entirement possible de spcifier la texture pour s'tendre sur
toutes les 6 faces, bien qu'il soit plus difficile de dfinir les points, et cela apparatra tir et distorsionn.
D'abord, on met jour la structure utilise pour dfinir nos vertices pour inclure les coordonnes de texture.
struct SimpleVertex
{
D3DXVECTOR3 Pos; // Position
D3DXVECTOR2 Tex; // Texture Coordinate
};
Ensuite, on met jour l'input layout des shaders pour galement inclure ces coordonnes.
// Dfini l'input layout
D3D10_INPUT_ELEMENT_DESC layout[] =
{
{ L"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0,
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 38 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
D3D10_INPUT_PER_VERTEX_DATA, 0 },
{ L"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12,
D3D10_INPUT_PER_VERTEX_DATA, 0 },
};
Comme l'input layout a chang, l'input vertex shader correspondant doit aussi tre modifi pour correspondre l'ajout.
struct VS_INPUT
{
float4 Pos : POSITION;
float2 Tex : TEXCOORD;
};
Finalement, nous sommes prts inclure les coordonnes de texture dans nos sommets que nous avons definies
dans le tutoriel 4. Notez que le second paramtre d'input est un D3DXVECTOR2 contenant les coordonnes de
texture. Chaque sommet du cube correspondra un coin de la texture. Ceci cre un mapping simple o chaque
sommet reoit (0,0) (0,1) (1,0) ou (1,1) comme coordonne.
// Cre le vertex buffer
SimpleVertex vertices[] =
{
{ D3DXVECTOR3( -1.0f, 1.0f, -1.0f ), D3DXVECTOR2( 0.0f, 0.0f ) },
{ D3DXVECTOR3( 1.0f, 1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 0.0f ) },
{ D3DXVECTOR3( 1.0f, 1.0f, 1.0f ), D3DXVECTOR2( 1.0f, 1.0f ) },
{ D3DXVECTOR3( -1.0f, 1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 1.0f ) },
{ D3DXVECTOR3( -1.0f, -1.0f, -1.0f ), D3DXVECTOR2( 0.0f, 0.0f ) },
{ D3DXVECTOR3( 1.0f, -1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 0.0f ) },
{ D3DXVECTOR3( 1.0f, -1.0f, 1.0f ), D3DXVECTOR2( 1.0f, 1.0f ) },
{ D3DXVECTOR3( -1.0f, -1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 1.0f ) },
{ D3DXVECTOR3( -1.0f, -1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 0.0f ) },
{ D3DXVECTOR3( -1.0f, -1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 0.0f ) },
{ D3DXVECTOR3( -1.0f, 1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 1.0f ) },
{ D3DXVECTOR3( -1.0f, 1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 1.0f ) },
{ D3DXVECTOR3( 1.0f, -1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 0.0f ) },
{ D3DXVECTOR3( 1.0f, -1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 0.0f ) },
{ D3DXVECTOR3( 1.0f, 1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 1.0f ) },
{ D3DXVECTOR3( 1.0f, 1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 1.0f ) },
{ D3DXVECTOR3( -1.0f, -1.0f, -1.0f ), D3DXVECTOR2( 0.0f, 0.0f ) },
{ D3DXVECTOR3( 1.0f, -1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 0.0f ) },
{ D3DXVECTOR3( 1.0f, 1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 1.0f ) },
{ D3DXVECTOR3( -1.0f, 1.0f, -1.0f ), D3DXVECTOR2( 0.0f, 1.0f ) },
{ D3DXVECTOR3( -1.0f, -1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 0.0f ) },
{ D3DXVECTOR3( 1.0f, -1.0f, 1.0f ), D3DXVECTOR2( 1.0f, 0.0f ) },
{ D3DXVECTOR3( 1.0f, 1.0f, 1.0f ), D3DXVECTOR2( 1.0f, 1.0f ) },
{ D3DXVECTOR3( -1.0f, 1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 1.0f ) },
};
Quand on dcoupe la texture, nous devons la moduler avec une couleur de materiau pour la gomtrie se trouvant
en dessous.
I-7-f - Attribuer une texture en tant que Shader Resource
Une texture est un objet comme les matrices et les vecteurs que nous avons vu dans les tutoriaux prcdents. Avant
qu'ils ne puissent tre utiliss par le shader, ils ont besoin d'tre dfinis dans l'effet. Ceci peut tre effectu en obtenant
un pointeur vers la variable, et ensuite, le dfinir en tant que shader resource.
g_pDiffuseVariable =
g_pEffect->GetVariableByName("txDiffuse")->AsShaderResource();
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 39 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
Aprs que le pointeur ressource ait t obtenu, il peut tre utilis pour accrocher la vue ressource texture 2D que
nous avons initialise plus tt.
g_pDiffuseVariable->SetResource( g_pTextureRV );
On continue, maintenant nous sommes prts utiliser la texture l'intrieur du shader.
I-7-g - Appliquer la Texture (fx)
Pour actuellement mapper la texture au dessus de la gomtrie, on appellera une fonction de recherche de texture
l'intrieur du pixel shader. La fonction, Sample effectuera un recherche de texture d'une texture 2D pour ensuite
retourner la couleur dcoupe. Le pixel shader montr ci-dessous appelle cette fonction et multiplie par la couleur
mesh souligne (ou la couleur matriau) et ensuite produit la couleur finale.
txDiffuse est l'objet stockant notre texture que l'on a passe depuis le code plus haut, quand on lui a attribu
la vue resource g_pTextureRV
samLinear sera dcrit plus bas, ce sont les spcifications dcoupes pour la recherche de texture.
input.Tex sont les coordonnes de la texture que nous avons spcifies dans la source
// Pixel Shader
float4 PS( PS_INPUT input) : SV_Target
{
return txDiffuse.Sample( samLinear, input.Tex ) * vMeshColor;
}
La variable samLinear est une structure qui contient les informations pour dire au pixel shader comment dcouper la
texture fournie. Dans notre cas, on a un filtre linaire, et nos deux adresses de synthse. Ces configurations seront
utiles pour de simples textures, et une explication des filtres dpasse le but de ce tutoriel.
SamplerState samLinear
{
Filter = MIN_MAG_MIP_LINEAR;
AddressU = Wrap;
AddressV = Wrap;
};
Une autre chose que nous devons nous rappeler de faire est de passer les coordonnes de texture dans le vertex
shader, ou sinon les donnes sont perdues quand elles atteignent le pixel shader. . Ici, on copie juste les coordonnes
d'input vers l'output, et on laisse l'hardware grer le reste.
// Vertex Shader
PS_INPUT VS( VS_INPUT input )
{
PS_INPUT output = (PS_INPUT)0;
output.Pos = mul( input.Pos, World );
output.Pos = mul( output.Pos, View );
output.Pos = mul( output.Pos, Projection );
output.Tex = input.Tex;

return output;
}
I-7-h - Constant Buffers
En commenant avec Direct3D 10, une application peut utiliser un constant buffer pour dfinir les shader constants
(shader variables). Les constant buffers sont dclars en utilisant une syntaxe similaire aux structures de style C.
La meilleure faon d'utiliser les constant buffers est d'organiser les shader variables dans des constant buffers bass
sur leur frquence de mise jour. Cela permet une application de minimiser la bande passante ncessaire pour
mettre jour les shader constants. Comme exemple, ce tutoriel groupe les constantes dans 3 structures : une pour
Tutoriels Direct3D 10 : Bases par Msdn - Romain Perruchon (Traducteur, relecteur) - Cyril Doillon (Traducteur, relecteur)
- 40 -
Cet article est une traduction d'un article original de Microsoft en anglais. Les ventuels problmes rsultant d'une mauvaise traduction ne sont pas imputables Microsoft. Lire l'article original Ici.
http://msdn.developpez.com/direct3d/10/tutoriels/base/
les variables qui changent chaque frame, une pour les variables qui changent seulement quand une taille de fentre
est change, et une pour les variables qui sont dfinies une seule fois et ensuite plus modifies.
cbuffer cbNeverChanges
{
matrix View;
};

cbuffer cbChangeOnResize
{
matrix Projection;
};

cbuffer cbChangesEveryFrame
{
matrix World;
float4 vMeshColor;
};

Vous aimerez peut-être aussi