énumération DXGI_SWAP_EFFECT (dxgi.h)

Article
02/26/2024

Options de gestion des pixels dans une surface d’affichage après l’appel d’IDXGISwapChain1 ::P resent1.

Syntax

typedef enum DXGI_SWAP_EFFECT {
  DXGI_SWAP_EFFECT_DISCARD = 0,
  DXGI_SWAP_EFFECT_SEQUENTIAL = 1,
  DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL = 3,
  DXGI_SWAP_EFFECT_FLIP_DISCARD = 4
} ;

Constantes


`DXGI_SWAP_EFFECT_DISCARD` Valeur : 0 Utilisez cet indicateur pour spécifier le modèle de transfert de bloc de bits (bitblt) et pour spécifier que DXGI ignore le contenu de la mémoire tampon arrière après avoir appelé IDXGISwapChain1 ::P resent1. Cet indicateur est valide pour une chaîne d’échange avec plusieurs mémoires tampons arrière, bien que les applications aient uniquement un accès en lecture et en écriture à la mémoire tampon 0. Utilisez cet indicateur pour permettre au pilote d’affichage de sélectionner la technique de présentation la plus efficace pour la chaîne d’échange. Direct3D 12 : Cette valeur d’énumération n’est jamais prise en charge. Les applications D3D12 doivent utiliser DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL ou DXGI_SWAP_EFFECT_FLIP_DISCARD. Note Il existe des différences entre UWP en plein écran et UWP en plein écran. Si vous portez une application Direct3D 11 vers UWP sur un PC Windows, n’oubliez pas que l’utilisation de DXGI_SWAP_EFFECT_DISCARD lors de la création de chaînes d’échange ne se comporte pas de la même façon dans UWP que dans Win32, et son utilisation peut nuire aux performances gpu. Cela est dû au fait que les applications UWP sont forcées à passer aux modes d’échange FLIP (même si d’autres modes d’échange sont définis), car cela réduit le calcul heure utilisée par les copies de mémoire effectuées à l’origine par l’ancien modèle bitblt. L’approche recommandée consiste à convertir manuellement les chaînes d’échange d’abandon DX11 pour utiliser des modèles inversés dans UWP, en utilisant DXGI_SWAP_EFFECT_FLIP_DISCARD au lieu de DXGI_SWAP_EFFECT_DISCARD si possible. Reportez-vous à l’exemple ci-dessous et consultez cet article pour plus d’informations.
`DXGI_SWAP_EFFECT_SEQUENTIAL` Valeur : 1 Utilisez cet indicateur pour spécifier le modèle bitblt et pour spécifier que DXGI conserve le contenu de la mémoire tampon arrière après avoir appelé IDXGISwapChain1 ::P resent1. Utilisez cette option pour présenter le contenu de la chaîne d’échange dans l’ordre, de la première mémoire tampon (mémoire tampon 0) au dernier tampon. Cet indicateur ne peut pas être utilisé avec le multi-échantillonnage. Direct3D 12 : Cette valeur d’énumération n’est jamais prise en charge. Les applications D3D12 doivent utiliser DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL ou DXGI_SWAP_EFFECT_FLIP_DISCARD. Note Pour des performances optimales, utilisez DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL au lieu de DXGI_SWAP_EFFECT_SEQUENTIAL. Pour plus d’informations, voir cet article.
`DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL` Valeur : 3 Utilisez cet indicateur pour spécifier le modèle de présentation inversée et pour spécifier que DXGI conserve le contenu de la mémoire tampon arrière après avoir appelé IDXGISwapChain1 ::P resent1. Cet indicateur ne peut pas être utilisé avec le multi-échantillonnage. Direct3D 11 : Cette valeur d’énumération est prise en charge à partir de Windows 8.
`DXGI_SWAP_EFFECT_FLIP_DISCARD` Valeur : 4 Utilisez cet indicateur pour spécifier le modèle de présentation inversé et pour spécifier que DXGI ignore le contenu de la mémoire tampon arrière après avoir appelé IDXGISwapChain1 ::P resent1. Cet indicateur ne peut pas être utilisé avec plusieurs échantillons et une présentation partielle. Consultez Améliorations de DXGI 1.4. Direct3D 11 : Cette valeur d’énumération est prise en charge à partir de Windows 10. Cet indicateur est valide pour une chaîne d’échange avec plusieurs mémoires tampons arrière ; bien que les applications aient un accès en lecture et en écriture uniquement à la mémoire tampon 0. Note Les applications du Windows Store doivent utiliser DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL ou DXGI_SWAP_EFFECT_FLIP_DISCARD.

Remarques

Cette énumération est utilisée par les structures DXGI_SWAP_CHAIN_DESC et DXGI_SWAP_CHAIN_DESC1 .

Dans D3D12, seuls les DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL et les DXGI_SWAP_EFFECT_FLIP_DISCARD sont pris en charge, et les modèles bitblt ne le sont pas. Pour cette raison, le multi-échantillonnage d’une mémoire tampon arrière n’est pas pris en charge dans D3D12, et vous devez effectuer manuellement le multi-échantillonnage dans l’application à l’aide de ID3D12GraphicsCommandList ::ResolveSubresource ou ID3D12GraphicsCommandList1 ::ResolveSubresourceRegion.

Pour utiliser le multi-échantillonnage avec DXGI_SWAP_EFFECT_SEQUENTIAL ou DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL, vous devez effectuer le multi-échantillonnage dans une cible de rendu distincte. Par exemple, créez une texture multi-échantillonnée en appelant ID3D11Device ::CreateTexture2D avec une structure de D3D11_TEXTURE2D_DESC remplie (membre BindFlags défini sur D3D11_BIND_RENDER_TARGET et membre SampleDesc avec des paramètres multi-échantillonnage). Appelez ensuite ID3D11Device ::CreateRenderTargetView pour créer une vue cible de rendu pour la texture et restituer votre scène dans la texture. Enfin, appelez ID3D11DeviceContext ::ResolveSubresource pour résoudre la texture multi-échantillonnée dans votre chaîne d’échange non multi-échantillonnée.

La principale différence entre les modèles de présentation est la façon dont le contenu de la mémoire tampon principale est renvoyé au Gestionnaire de fenêtres du bureau (DWM) pour la composition. Dans le modèle bitblt, qui est utilisé avec les valeurs DXGI_SWAP_EFFECT_DISCARD et DXGI_SWAP_EFFECT_SEQUENTIAL , le contenu de la mémoire tampon arrière est copié dans la surface de redirection à chaque appel à IDXGISwapChain1 ::P resent1. Dans le modèle de retournement, qui est utilisé avec la valeur DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL , toutes les mémoires tampons arrière sont partagées avec le DWM. Par conséquent, le DWM peut composer directement à partir de ces mémoires tampons arrière sans aucune opération de copie supplémentaire. En général, le modèle à retournement est le modèle le plus efficace. Le modèle de retournement fournit également d’autres fonctionnalités, telles que des statistiques actuelles améliorées.

La différence entre DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL et DXGI_SWAP_EFFECT_FLIP_DISCARD est que DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL force DXGI à garantir que le contenu de chaque mémoire tampon arrière est conservé entre les IDXGISwapChain::Present appels, alors que DXGI_SWAP_EFFECT_FLIP_DISCARD ne fournit pas cette garantie. Dans certains scénarios, le compositor peut utiliser DirectFlip, où il utilise la mémoire tampon arrière de l’application comme mémoire tampon d’arrière-mémoire d’affichage entière, ce qui élude le coût de copie de la mémoire tampon arrière de l’application dans la mémoire tampon arrière finale du bureau. Avec DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL et DXGI_SWAP_EFFECT_FLIP_DISCARD, cette optimisation peut se produire lorsque l’application est le seul élément visible à l’écran. Toutefois, même lorsque l’application n’est pas le seul élément visible à l’écran, si le modèle de retournement est DXGI_SWAP_EFFECT_FLIP_DISCARD, le compositeur peut toujours effectuer cette optimisation dans certains scénarios, en dessinant d’autres contenus sur la mémoire tampon arrière de l’application.

Lorsque vous appelez IDXGISwapChain1 ::P resent1 sur une chaîne d’échange de modèle inversé (DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL) avec 0 spécifié dans le paramètre SyncInterval, le comportement d’IDXGISwapChain1 ::P resent1 est le même que celui du IDirect3DDevice9Ex de Direct3D 9Ex ::P resentEx avec D3DSWAPEFFECT_FLIPEX et D3DPRESENT_FORCEIMMEDIATE. Autrement dit, le runtime présente non seulement l’image suivante au lieu de toutes les trames précédemment mises en file d’attente, mais il met également fin au temps restant sur les images précédemment mises en file d’attente.

Que le modèle de retournement soit plus efficace ou non, une application peut toujours choisir le modèle bitblt, car le modèle bitblt est le seul moyen de combiner la présentation GDI et DirectX. Dans le modèle de retournement, l’application doit créer la chaîne d’échange avec DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE, puis doit utiliser GetDC sur la mémoire tampon arrière explicitement. Après le premier appel réussi à IDXGISwapChain1 ::P resent1 sur une chaîne d’échange de modèle inversé, GDI ne fonctionne plus avec le HWND associé à cette chaîne d’échange, même après la destruction de la chaîne d’échange. Cette restriction s’étend même aux méthodes telles que ScrollWindowEx.

Pour plus d’informations sur la chaîne d’échange de modèle inversé et l’optimisation de la présentation, consultez Amélioration de la présentation avec le modèle de retournement, les rectangles sale et les zones défilantes.

Exemples

Pour créer une chaîne d’échange dans UWP, il vous suffit de créer une nouvelle instance du modèle DX11 et d’examiner l’implémentation de DeviceResources::CreateWindowSizeDependentResources dans les exemples D3D12.

DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0};

       swapChainDesc.Width = lround(m_d3dRenderTargetSize.Width);    // Match the size of the window.
       swapChainDesc.Height = lround(m_d3dRenderTargetSize.Height);
       swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;            // This is the most common swap chain format.
       swapChainDesc.Stereo = false;
       swapChainDesc.SampleDesc.Count = 1;                           // Don't use multi-sampling.
       swapChainDesc.SampleDesc.Quality = 0;
       swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
       swapChainDesc.BufferCount = 2;                                // Use double-buffering to minimize latency.
       swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;     // All Windows Store apps must use a flip effect.
       swapChainDesc.Flags = 2048;
       swapChainDesc.Scaling = scaling;
       swapChainDesc.AlphaMode = DXGI_ALPHA_MODE_IGNORE;

       // This sequence obtains the DXGI factory that was used to create the Direct3D device above.
       ComPtr&lt;IDXGIDevice3&gt; dxgiDevice;
       DX::ThrowIfFailed(m_d3dDevice.As(&amp;dxgiDevice));

       ComPtr&lt;IDXGIAdapter&gt; dxgiAdapter;
       DX::ThrowIfFailed(dxgiDevice-&gt;GetAdapter(&amp;dxgiAdapter));

       ComPtr&lt;IDXGIFactory4&gt; dxgiFactory;
       DX::ThrowIfFailed(dxgiAdapter-&gt;GetParent(IID_PPV_ARGS(&amp;dxgiFactory)));

       ComPtr&lt;IDXGISwapChain1&gt; swapChain;
       DX::ThrowIfFailed(
              dxgiFactory-&gt;CreateSwapChainForCoreWindow(
                     m_d3dDevice.Get(),
                     reinterpret_cast&lt;IUnknown*&gt;(m_window.Get()),
                     &amp;swapChainDesc,
                     nullptr,
                     &amp;swapChain
                     )
              );

Configuration requise

Condition requise	Valeur
En-tête	dxgi.h

Voir aussi

Énumérations DXGI

Pour de meilleures performances, utilisez le modèle de basculement DXGI