Partage
  • Partager sur Facebook
  • Partager sur Twitter

DirectX 11 Peu de FPS

    16 juillet 2021 à 11:25:25

    Bonjour, bonsoir. J'ai un problème avec un petit programme fait avec Direct3D 11. J'explique :

    Récemment, j'ai décidé d'arrêter OpenGL et de passer à D3D 11.

    Pour l'instant, je sais dessiner un carré, le faire tourner et faire une caméra statique.

    Mais, en faisant tourner mon carré, j'ai remarqué que ce n'était parfois pas très fluide.

    J'ai alors crée un compteur de FPS.

    J'ai enlevé tous les graphismes sauf l'écran noir, je n'ai donc plus aucun carré, ni mouvement, ni rien. Juste un écran noir de 800 x 600.

    Les valeurs des FPS sont assez faibles (~720 FPS).

    C'est vrai que j'ai un vieux PC (2013) mais je ne pense que ça viennent de ça, car avec OpenGL, j'en obtenais ~1200.


    Voici mon code :


    Window.h

    #pragma once
    
    #include <Windows.h>
    
    class Window
    {
    public:
    	HWND hwnd = HWND();
    
    	int width = 800;
    	int height = 600;
    
    	Window();
    	bool isDestroyed();
    	~Window();
    };


    Window.cpp

    #include "Window.h"
    
    bool destroyed = false;
    
    LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
    	switch (msg)
    	{
    	case WM_CLOSE:
    		DestroyWindow(hwnd);
    		break;
    
    	case WM_DESTROY:
    		destroyed = true;
    		break;
    
    	default:
    		return DefWindowProc(hwnd, msg, wParam, lParam);
    	}
    
    	return 0;
    }
    
    Window::Window()
    {
    	HINSTANCE hInstance = GetModuleHandle(nullptr);
    
    	WNDCLASSEX wc;
    	ZeroMemory(&wc, sizeof(wc));
    
    	wc.cbSize = sizeof(wc);
    	wc.lpfnWndProc = WndProc;
    	wc.hInstance = hInstance;
    	wc.hIcon = LoadIcon(nullptr, IDI_APPLICATION);
    	wc.hCursor = LoadCursor(nullptr, IDI_APPLICATION);
    	wc.hbrBackground = (HBRUSH)COLOR_WINDOW;
    	wc.lpszMenuName = L"";
    	wc.lpszClassName = L"className";
    	wc.hIconSm = wc.hIcon;
    	RegisterClassEx(&wc);
    
    	hwnd = CreateWindowEx(0, wc.lpszClassName, L"DirectX", WS_OVERLAPPEDWINDOW, 0, 0, width, height, nullptr, nullptr, hInstance, nullptr);
    
    	ShowWindow(hwnd, SW_SHOW);
    	UpdateWindow(hwnd);
    }
    
    bool Window::isDestroyed()
    {
    	MSG msg;
    	ZeroMemory(&msg, sizeof(msg));
    
    	while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE) > 0)
    	{
    		TranslateMessage(&msg);
    		DispatchMessage(&msg);
    	}
    
    	return destroyed;
    }
    
    Window::~Window()
    {
    	PostQuitMessage(0);
    }


    Renderer.h

    #pragma once
    
    #include "Window.h"
    #include <D3D11.h>
    
    class Renderer
    {
    private:
    	IDXGISwapChain* swapChain = nullptr;
    	ID3D11Device* device = nullptr;
    	ID3D11DeviceContext* deviceContext = nullptr;
    	ID3D11RenderTargetView* renderTargetView = nullptr;
    
    public:
    	Renderer(const Window& window);
    	void render();
    	~Renderer();
    };


    Renderer.cpp

    #include "Renderer.h"
    
    Renderer::Renderer(const Window& window)
    {
    	DXGI_SWAP_CHAIN_DESC swapChainDesc;
    	ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
    
    	swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    	swapChainDesc.SampleDesc.Count = 8;
    	swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    	swapChainDesc.BufferCount = 1;
    	swapChainDesc.OutputWindow = window.hwnd;
    	swapChainDesc.Windowed = true;
    
    	D3D11CreateDeviceAndSwapChain(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, 0, nullptr, 0, D3D11_SDK_VERSION, &swapChainDesc, &swapChain, &device, nullptr, &deviceContext);
    
    	ID3D11Texture2D* buffer;
    	swapChain->GetBuffer(0, __uuidof(buffer), (void**)&buffer);
    
    	device->CreateRenderTargetView(buffer, nullptr, &renderTargetView);
    	buffer->Release();
    }
    
    void Renderer::render()
    {
    	swapChain->Present(0, 0);
    }
    
    Renderer::~Renderer()
    {
    	swapChain->Release();
    	device->Release();
    	deviceContext->Release();
    	renderTargetView->Release();
    }


    Main.cpp

    #include "Renderer.h"
    
    #include <iostream>
    #include <time.h>
    
    int main()
    {
    	Window window;
    	Renderer renderer(window);
    
    	int fps = 0;
    	time_t timer = time(nullptr);
    
    	while (!window.isDestroyed())
    	{
    		renderer.render();
    		fps++;
    
    		if (time(nullptr) - timer >= 1)
    		{
    			std::cout << fps << std::endl;
    
    			fps = 0;
    			timer++;
    		}
    	}
    }



    Et aussi, mon utilisation du CPU est faible.


    IDE : VS 2019

    Compilateur : MSVC

    OS : Windows 10 64 bit

    GPU : AMD Radeon 8600/8700M

    CPU : Intel I5 3210M


    Merci de m'aider :D !

    -
    Edité par MO9845 16 juillet 2021 à 11:28:51

    • Partager sur Facebook
    • Partager sur Twitter
      16 juillet 2021 à 12:32:23

      Faire des tests "à vide", ça n'a pas beaucoup de sens.

      On n'a même pas les réglages de la compilation (niveau d'optimisation, ...).

      Si vous cherchez des goulots d'étranglement, il y a le profiler et le débogueur DirectX.

      • Partager sur Facebook
      • Partager sur Twitter
      Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.
        16 juillet 2021 à 13:21:07

        bacelar a écrit:

        On n'a même pas les réglages de la compilation (niveau d'optimisation, ...).

        Ah oui, c'est vrai.

        J'utilise l'option Release en 64 bit avec -O2.



        -
        Edité par MO9845 16 juillet 2021 à 13:21:56

        • Partager sur Facebook
        • Partager sur Twitter
          18 juillet 2021 à 11:38:56

          Salut !

          Quand on veut se faire une idée au niveau perfs, on ne compte pas les FPS, mais le temps de rendu d'une frame.

          Le soucis est que le GPU travaille de manière asynchrone par rapport aux commandes qu'on lui envoie.

          Il faut donc mesurer 2 temps : le temps CPU (std::chrono est ton ami pour ça) et le temps GPU (les timestamp queries sont à utiliser dans ce cas).

          A partir de ces mesures de temps, on peut déterminer les FPS, effectivement, mais elles ne sont bien qu'une information complémentaire, calculée à partir des informations nécessaires que sont les temps d'exécution.

          • Partager sur Facebook
          • Partager sur Twitter

          Si vous ne trouvez plus rien, cherchez autre chose.

            19 juillet 2021 à 8:39:56

            MO9845 a écrit:

            Bonjour, bonsoir. J'ai un problème avec un petit programme fait avec Direct3D 11. J'explique :

            Récemment, j'ai décidé d'arrêter OpenGL et de passer à D3D 11.


            Quel choix décevant. Tu vas considérablement réduire ton audience en utilisant un framework privateur qui plus est limité à un système. OpenGL c'est vieux et pas forcément pratique mais du coup on a inventé Vulkan pour pallier tous les problèmes de cette vieillissante spec. En contrepartie, ton code et ton jeu sera performant et multiplateforme (il n'y a pas que Windows et macOS dans la vie, il y a Linux, l'embarqué, android, iOS, les consoles, etc).

            -
            Edité par markand 19 juillet 2021 à 8:40:56

            • Partager sur Facebook
            • Partager sur Twitter

            l'azerty est aux dispositions ce que subversion est aux SCM

              19 juillet 2021 à 15:10:30

              Oui enfin Vulkan sur macOS, faut s'accrocher puisqu'il faut passer par MoltenVK du fait que c'est Apple qui fournit les drivers et non pas les vendeurs de carte graphique comme sur Windows. En plus Apple a déjà bloqué des applications utilisant MoltenVK sur leur store, ils n'apprécient guère qu'on n'utilise pas Metal.

              En général les moteurs graphiques ont un support pour tous les backends possibles (DirectX12, Vulkan, Metal, et OpenGL/DirectX11 pour du vieux).

              Maintenant pour débuter, c'est sur qu'OpenGL c'est très bien, et supporté grosso modo partout (mais pas les versions trop récentes sur macOS, genre pas au delà de 4.1 je crois).

              • Partager sur Facebook
              • Partager sur Twitter
                19 juillet 2021 à 16:06:35

                > Oui enfin Vulkan sur macOS, faut s'accrocher puisqu'il faut passer par MoltenVK

                Oui mais bon, c'est pas grand chose à mettre en place, MoltenVK...
                De là à "s'accrocher", il y a un monde.

                Pour Vulkan/D3D12, un débutant n'y gagnera rien, pas même en perfs.
                Autant rester sur OpenGL/D3D11 tant qu'on n'est pas CPU bound.

                • Partager sur Facebook
                • Partager sur Twitter

                Si vous ne trouvez plus rien, cherchez autre chose.

                  19 juillet 2021 à 17:29:02

                  dragonjoker a écrit:

                  Quand on veut se faire une idée au niveau perfs, on ne compte pas les FPS, mais le temps de rendu d'une frame.


                  Ok, je viens de l'apprendre :p.

                  Pour mesurer mes FPS, je sais que ce logiciel n'est pas fait pour, mais j'utilise RenderDoc. Il me donne les FPS et le temps d'une frame.

                  markand a écrit:

                  mais du coup on a inventé Vulkan pour pallier tous les problèmes de cette vieillissante


                  Oui, c'est vrai. J'ai essayé d'apprendre Vulkan mais il y a un soucis de difficulté d'apprentissage.

                  Au début, j'ai voulu l'apprendre. Mais j'ai tellement galéré que j'ai préféré passer à DX11.

                  markand a écrit:

                  En contrepartie, ton code et ton jeu sera performant et multiplateforme

                  C'est bien vrai... Peut-être je devrais re-passer à Vulkan.

                  • Partager sur Facebook
                  • Partager sur Twitter
                    26 juillet 2021 à 15:48:27

                    Petit détail : ma carte graphique n'est pas à 100 % avec DirectX.

                    Autre petit détail : avec OpenGL, je n'ai pas précisé que j'avais ~1200 FPS avec SFML, mais j'en ai autant que DX11 avec GLFW.

                    • Partager sur Facebook
                    • Partager sur Twitter

                    DirectX 11 Peu de FPS

                    × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                    • Editeur
                    • Markdown