Tutoriels Direct3D 10 : Bases

Dans ce premier tutoriel, nous allons examiner les éléments nécessaires pour créer une application minimale Direct3D 10. Toute application Direct3D 10 doit avoir ces éléments pour fonctionner correctement. Les éléments incluent la création d'une fenêtre et d'un objet device direct3D 10 puis l'affichage d'une couleur sur la fenêtre.

(SDKracine)\Samples\C++\Direct3D10\Tutorials\Tutorial01

Maintenant que nous avons une fenêtre qui est affichée, nous pouvons continuer à établir un objet device Direct3D 10, lequel est nécessaire si nous voulons afficher des scènes 3D. La première chose à faire est de créer deux objets : un device et une chaîne d'échanges.

L'objet device est utilisé par l'application pour améliorer l'affichage sur un tampon. L'objet device Direct3D 10 contient aussi des méthodes pour créer des ressources

La chaîne d'échanges est alors chargée de lire le tampon dans lequel le device Direct3D 10 effectue le rendu et en affiche le contenu sur l'écran du moniteur. La chaîne 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 chaîne d'échange présentera 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 créer la chaîne d'échanges, nous remplissons une structure DXGI_SWAPCHAIN_DESC qui décrit la chaîne d'échanges que nous sommes en train de créer. Quelques champs méritent d'être cités : 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 représente la fenêtre que la chaîne d'échanges va utiliser pour présenter 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 désactiver le multi-échantillonnage.

Une fois que la description a été remplie, nous pouvons appeler la fonction pour créer l'ensemble du device et de la chaîne d'échanges pour nous. Le code pour créer un device et une chaîne d'échange est listé ci-dessous :

	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 créer 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 reliée à la pipeline graphique lors d'une phase particulière. Pensez que la « ressource au niveau vue*» est comme un type cast en langage C. Un bout de mémoire brute en C peut être casté en n'importe quel type de données. Nous pouvons caster ce bout de mémoire en un tableau d'entiers, un tableau de flottants, une structure, un tableau de structures etc. La mémoire brute elle-même 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 manière similaire. Par exemple une texture 2D, analogue à un bout de mémoire brute est une ressource brute sous-jacente. Une fois que nous avons cette ressource nous pouvons créer différentes ressources au niveau vue pour relier cette texture aux différentes phases dans le pipeline graphique avec différents 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 mémoire d'être utilisé de différentes façons, les ressources au niveau vue de Direct3D 10 font de même.

Nous avons besoin de créer une vue de cible d'affichage car nous aimerions lier le tampon du fond de notre chaîne d'échange comme étant une cible d'affichage, de telle façon 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 décrit la vue cible d'affichage qui va être créée. Cette description est normalement le second paramètre de CreateRenderTarget. Cependant, pour ces tutoriels, la vue cible d'affichage par défaut suffira. La vue cible d'affichage par défaut peut être obtenue en passant NULL comme second paramètre. Une fois que nous avons créé la vue cible d'affichage, nous pouvons appeler OMSetRenderTargets() pour la lier au pipeline de façon à ce qu'à la sortie, cette dernière affiche ce qu'elle va écrire dans le tampon du fond. Le code pour créer 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 dernière chose que nous avons besoin de faire avant que Direct3D 10 puisse afficher est d'initialiser la zone d'affichage. Les coordonnées 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 défaut est créée pour être de la même taille que la cible d'affichage si l'application n'en crée pas d'autres. Dans Direct3D 10, il n'y a pas de zone d'affichage créée par défaut. Par conséquent, nous devons en créer une avant que nous puissions voir quelque chose sur l'écran. Puisque nous aimerions utiliser la cible d'affichage entière 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 présenté ci-dessous :

	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 );

Nous avons créée la fenêtre et le device Direct3D 10, et nous sommes prêts à afficher. Cependant, il y a toujours un problème avec notre boucle de messages : cette dernière utilise GetMessage() pour obtenir des messages. Le problème avec GetMessage() est que s'il n'y a pas de message dans la file pour la fenêtre applicatrice, GetMessage() bloque et ne retourne pas son résultat jusqu'à ce qu'un message soit libre. Par conséquent, au lieu d'afficher, notre application bloque à l'intérieur de GetMessage() quand la file de message est vide. Nous pouvons résoudre ce problème en utilisant PeekMessage() à la place de GetMessage(). PeekMessage() peut récupérer un message comme GetMessage() le fait, mais quand il n'y a pas de message qui attend, PeekMessage() retourne immédiatement son résultat au lieu de bloquer. Nous pouvons alors afficher quelque chose. La boucle de messages modifiée, 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
		}
	}

L'affichage est fait dans la fonction Render(). Dans ce tutoriel, nous afficherons la scène la plus simple possible, qui est de remplir l'écran avec une seule couleur. Dans Direct3D 10, une façon simple de remplir la cible d'affichage avec une seule couleur est d'utiliser la méthode ClearRenderTargetView() du device. Nous définissons d'abord une structure D3D10_COLOR qui décrit 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 méthode Present() de la chaîne d'échanges pour compléter l'affichage. Present() est responsable de l'affichage du contenu du tampon de la chaîne 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 );
	}