Utilisation du Windows 10 SDK [DirectX 11 – Partie 1.5]

Voilà enfin la suite de l’article précédent concernant l’utilisation de DirectX en C++. Il va y avoir quelques modifications concernant certains propos de l’article précédent. Effectivement dernièrement nous avions installé le SDK DirectX datant de 2010, qui permet de développer aisément sur Windows 7 et plus. Cependant, à partir de maintenant je pense me concentrer vers les possibilités qu’offre Windows 10. C’est pour cela que je vais par la suite utiliser la version de DirectX 11 qui est embarqué dans le Windows 10 SDK.

Remise à niveau

Installation de DirectX avec le Windows 10 SDK

Vous allez voir il n’y a pas de modification à faire, le code Win32 restes exactement le même. La seule différence et qu’il vous faut le Kit de Windows 10, attention cependant, le système d’exploitation associé est nécessaire. De plus, avec la sortie de Visual studio 2017 le projet ainsi que les manipulations concerneront exclusivement cette version.

Bien, maintenant je vous invite à démarrer Visual Studio Installer, puis de faire Modifier sur la version que vous utilisez, la Community pour moi. Un nouvel espace devrait s’ouvrir, je vous invite à cocher Game development with C++, qui comme ça description l’indique permet d’installer le Windows 10 SDK ainsi que par la même occasion DirectX (Voir image ci-dessous).

VS2017DirectX

Une fois le téléchargement et l’installation fini, vous pouvez rouvrir l’ancien projet, qui sera complètement compatible.
Pourquoi faire ce changement ? Simplement car la version de DirectX disponible ici est à jour et propose les dernières versions de directxmath par exemple et surtout car c’est beaucoup plus pratique. Pas besoin de configuration par rapport à la position du SDK dans l’environnement. Cela fonctionne maintenant comme pour windows.h, il suffit de faire un simple include et de link via un préprocesseur pragma et le tour est joué !

Modification du WinMain.cpp

Nous allons profiter des légères modifications pour inclure de suite la classe RenderingEngine qui gèrera l’affichage de notre contexte Direct3D. Comme d’habitude, voilà le code du fichier, j’expliquerais les modifications par la suite.

/////////////////////////////////////////////////////////////
// INCLUDE                                                 //
/////////////////////////////////////////////////////////////
#include <Windows.h>
#include <tchar.h>
#include <iostream>

#include "RenderingEngine.h"
/////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////
// LINKING                                                 //
/////////////////////////////////////////////////////////////
#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "dxgi.lib")
#pragma comment(lib, "d3dcompiler.lib")
/////////////////////////////////////////////////////////////

HWND hWnd;
int windowHeight = 600;
int windowWidth = 600;

LRESULT CALLBACK wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_KEYDOWN:
        if (wParam == VK_ESCAPE)
            PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
        break;
    }
}

bool InitWindow(HINSTANCE hInstance, int nCmdShow)
{
    // Init Window
    WNDCLASSEX wndStruct;
    ZeroMemory(&wndStruct, sizeof(WNDCLASSEX));
    wndStruct.cbSize = sizeof(WNDCLASSEX);
    wndStruct.style = CS_HREDRAW | CS_VREDRAW;
    wndStruct.lpfnWndProc = (WNDPROC)wndProc;
    wndStruct.hInstance = hInstance;
    wndStruct.hCursor = LoadCursor(NULL, IDC_ARROW);
    wndStruct.hbrBackground = (HBRUSH)COLOR_WINDOW;
    wndStruct.lpszClassName = TEXT("Window");
    RegisterClassEx(&wndStruct);

    // Create Window
    hWnd = CreateWindow(_T("Window"),
        _T("Nom de votre fenêtre"),
        WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        windowWidth,
        windowHeight,
        NULL,
        NULL,
        hInstance,
        NULL);

    if (!hWnd)
        return false;

    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);

    return true;
}

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    // Init Win32 Window
    if (!InitWindow(hInstance, nCmdShow))
        return 0;

    // Setup Direct3D
    RenderingEngine renderingEngine;
    renderingEngine.Initialize(windowWidth, windowHeight, hWnd);

    bool run = true;
    MSG msg = { 0 };

    while (WM_QUIT != msg.message && run)
    {
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        else
        {
            // Direct3D 11 Render
            renderingEngine.BeginScene();
                            // Rendu 3D
            renderingEngine.EndScene();
        }
    }

    return (int)msg.wParam;
}

Si vous avez suivi l’article précédent, vous devez voir qu’il y a très peu de différences. Dans la section INCLUDE vous remarquez l’ajout de notre future nouvelle classe, puis en dessous le code suivant :

/////////////////////////////////////////////////////////////
// LINKING                                                 //
/////////////////////////////////////////////////////////////
#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "dxgi.lib")
#pragma comment(lib, "d3dcompiler.lib")
/////////////////////////////////////////////////////////////

Celui-ci a des chances de ne fonctionner que sur Visual Studio, ce préprocesseur permet d’inclure les lib de DirectX sans se prendre la tête. Cependant, vous pouvez aussi le faire dans les paramètres du projet clique droit sur le projet -> Properties -> Linker -> Input (voir image ci-dessous). Dans la section Additional Dependencies cliquer sur la petite flèche puis Edit. Une nouvelle fenêtre s’ouvre et à partir d’ici il vous suffit de rentrer d3d11.lib, dxgi.lib et enfin d3dcompiler.lib avec un retour à la ligne entre chaque. Cela aura le même effet que le code précédemment.

Les autres modifications sont dans la fonction WinMain. On déclare et initialise la classe puis dans la boucle de jeu on nettoye l’image précédente avec BeginScene puis on affiche la nouvelle par la suite avec EndScene. La création de nos formes géométriques et l’utilisation de nos Shader (programme pour faire des effets comme la lumière, reflet) se feront entre les deux fonctions.

Nous attaquerons dans la prochaine partie la création de notre premier contexte DirectX !
Téléchargement du projet Visual Studio 2017 Community
Téléchargement du code source (sans projet)

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée.