Comparer le code EGL à DXGI et Direct3D

Article
07/05/2024

API importantes

L’interface graphique DirectX (DXGI) et plusieurs API Direct3D jouent le même rôle que EGL. Cette rubrique vous aide à comprendre DXGI et Direct3D 11 du point de vue d’EGL.

DXGI et Direct3D, comme EGL, fournissent des méthodes pour configurer des ressources graphiques, obtenir un contexte de rendu pour vos nuanceurs à dessiner et afficher les résultats dans une fenêtre. Toutefois, DXGI et Direct3D ont quelques options supplémentaires et nécessitent davantage d’efforts pour configurer correctement lors du portage à partir d’EGL.

Remarque : Khronos Native Platform Graphics Interface (EGL Version 1.4 - 6 avril 2011) [PDF]. Les différences de syntaxe propres à d’autres plateformes et langages de développement ne sont pas abordées dans cette aide.

Comment DXGI et Direct3D comparent-ils ?

L’avantage important d’EGL sur DXGI et Direct3D est qu’il est relativement simple de commencer à dessiner sur une surface de fenêtre. Cela est dû au fait que OpenGL ES 2.0 , et donc EGL, est une spécification implémentée par plusieurs fournisseurs de plateforme, tandis que DXGI et Direct3D sont une référence unique dont les pilotes de fournisseurs de matériel doivent se conformer. Cela signifie que Microsoft doit implémenter un ensemble d’API qui permettent l’ensemble le plus large possible de fonctionnalités du fournisseur, plutôt que de se concentrer sur un sous-ensemble fonctionnel proposé par un fournisseur spécifique, ou en combinant des commandes d’installation spécifiques au fournisseur en API plus simples. En revanche, Direct3D fournit un ensemble unique d’API qui couvrent un très large éventail de plateformes de matériel graphique et de niveaux de fonctionnalités, et offrent une plus grande flexibilité pour les développeurs expérimentés avec la plateforme.

Comme EGL, DXGI et Direct3D fournissent des API pour les comportements suivants :

Obtention, lecture et écriture dans une mémoire tampon d’images (appelée « chaîne d’échange » dans DXGI).
Association de la mémoire tampon de trame à une fenêtre d’interface utilisateur.
Obtention et configuration des contextes de rendu dans lesquels dessiner.
Émission de commandes au pipeline graphique pour un contexte de rendu spécifique.
Création et gestion des ressources du nuanceur et association de ces ressources à un contenu de rendu.
Rendu sur des cibles de rendu spécifiques (telles que des textures).
Mise à jour de l’aire d’affichage de la fenêtre avec les résultats du rendu avec les ressources graphiques.

Pour voir le processus Direct3D de base pour la configuration du pipeline graphique, consultez le modèle d’application DirectX 11 (Windows universel) dans Microsoft Visual Studio 2015. La classe de rendu de base dans celle-ci fournit une bonne base de référence pour configurer l’infrastructure graphique Direct3D 11 et la configuration des ressources de base sur celle-ci, ainsi que la prise en charge des fonctionnalités d’application plateforme Windows universelle (UWP), telles que la rotation de l’écran.

EGL a très peu d’API par rapport à Direct3D 11, et la navigation dans ce dernier peut être un défi si vous n’êtes pas familiarisé avec le nommage et le jargon particulier à la plateforme. Voici une vue d’ensemble simple pour vous aider à vous orienter.

Tout d’abord, passez en revue l’objet EGL de base sur le mappage d’interface Direct3D :

Abstraction EGL	Représentation Direct3D similaire
EGLDisplay	Dans Direct3D (pour les applications UWP), le handle d’affichage est obtenu via l’API Windows ::UI ::CoreWindow (ou l’interface ICoreWindowInterop qui expose le HWND). La configuration de l’adaptateur et du matériel est définie avec les interfaces COM IDXGIAdapter et IDXGIDevice1, respectivement.
EGLSurface	Dans Direct3D, les mémoires tampons et d’autres ressources de fenêtre (visibles ou hors écran) sont créées et configurées par des interfaces DXGI spécifiques, notamment IDXGIFactory2 (implémentation de modèle de fabrique utilisée pour acquérir des ressources DXGI telles queIDXGISwapChain1 (mémoires tampons d’affichage). ID3D11Device1 qui représente l’appareil graphique et ses ressources, est acquis avec D3D11Device ::CreateDevice. Pour les cibles de rendu, utilisez l’interface ID3D11RenderTargetView .
EGLContext	Dans Direct3D, vous configurez et émettez des commandes sur le pipeline graphique avec l’interface ID3D11DeviceContext1 .
EGLConfig	Dans Direct3D 11, vous créez et configurez des ressources graphiques telles qu’une mémoire tampon, des textures, des gabarits et des nuanceurs avec des méthodes sur l’interface ID3D11Device1 .

Voici maintenant le processus le plus simple pour configurer un affichage graphique, des ressources et un contexte simples dans DXGI et Direct3D pour une application UWP.

Obtenez un handle pour l’objet CoreWindow pour le thread d’interface utilisateur principal de l’application en appelant CoreWindow ::GetForCurrentThread.
Pour les applications UWP, achetez une chaîne d’échange à partir de l’IDXGIAdapter2 avec IDXGIFactory2 ::CreateSwapChainForCoreWindow et transmettez-la la référence CoreWindow obtenue à l’étape 1. Vous obtiendrez une instance IDXGISwapChain1 en retour. Limitez-le à votre objet renderer et à son thread de rendu.
Obtenez les instances ID3D11Device1 et ID3D11DeviceContext1 en appelant la méthode D3D11Device ::CreateDevice. Limitez-les également à votre objet renderer.
Créez des nuanceurs, des textures et d’autres ressources à l’aide de méthodes sur l’objet ID3D11Device1 de votre renderer.
Définissez des mémoires tampons, exécutez des nuanceurs et gérez les étapes de pipeline à l’aide de méthodes sur l’objet ID3D11DeviceContext1 de votre renderer.
Lorsque le pipeline est exécuté et qu’un frame est dessiné vers la mémoire tampon arrière, présentez-le à l’écran avec IDXGISwapChain1 ::P resent1.

Pour examiner ce processus plus en détail, consultez Prise en main des graphiques DirectX. Le reste de cet article décrit la plupart des étapes courantes pour la configuration et la gestion de pipelines graphiques de base.

Notez que les applications Windows Desktop ont des API différentes pour obtenir une chaîne d’échange Direct3D, telle que D3D11Device ::CreateDeviceAndSwapChain, et n’utilisez pas d’objet CoreWindow.

Obtention d’une fenêtre pour l’affichage

Dans cet exemple, eglGetDisplay est passé un HWND pour une ressource de fenêtre spécifique à la plateforme Microsoft Windows. D’autres plateformes, telles que iOS (Cocoa) d’Apple et Android de Google, ont des poignées ou références différentes aux ressources de fenêtre et peuvent avoir une syntaxe d’appel différente. Après avoir obtenu un affichage, vous l’initialisez, définissez la configuration par défaut et créez une surface avec une mémoire tampon arrière dans laquelle vous pouvez dessiner.

Obtention d’un affichage et configuration avec EGL..

// Obtain an EGL display object.
EGLDisplay display = eglGetDisplay(GetDC(hWnd));
if (display == EGL_NO_DISPLAY)
{
  return EGL_FALSE;
}

// Initialize the display
if (!eglInitialize(display, &majorVersion, &minorVersion))
{
  return EGL_FALSE;
}

// Obtain the display configs
if (!eglGetConfigs(display, NULL, 0, &numConfigs))
{
  return EGL_FALSE;
}

// Choose the display config
if (!eglChooseConfig(display, attribList, &config, 1, &numConfigs))
{
  return EGL_FALSE;
}

// Create a surface
surface = eglCreateWindowSurface(display, config, (EGLNativeWindowType)hWnd, NULL);
if (surface == EGL_NO_SURFACE)
{
  return EGL_FALSE;
}

Dans Direct3D, la fenêtre principale d’une application UWP est représentée par l’objet CoreWindow, qui peut être obtenu à partir de l’objet d’application en appelant CoreWindow ::GetForCurrentThread dans le cadre du processus d’initialisation du « fournisseur d’affichage » que vous créez pour Direct3D. (Si vous utilisez l’interopérabilité Direct3D-XAML, vous utilisez le fournisseur d’affichage du framework XAML.) Le processus de création d’un fournisseur de vues Direct3D est abordé dans Comment configurer votre application pour afficher une vue.

Obtention d’un CoreWindow pour Direct3D.

CoreWindow::GetForCurrentThread();

Une fois la référence CoreWindow obtenue, la fenêtre doit être activée, qui exécute la méthode Run de votre objet principal et commence le traitement des événements de fenêtre. Ensuite, créez un ID3D11Device1 et un ID3D11DeviceContext1, puis utilisez-les pour obtenir l’IDXGIDevice1 sous-jacent et IDXGIAdapter afin de pouvoir obtenir un objet IDXGIFactory2 pour créer une ressource de chaîne d’échange basée sur votre configuration DXGI_SWAP_CHAIN_DESC1.

Configuration et définition de la chaîne d’échange DXGI sur CoreWindow pour Direct3D.

// Called when the CoreWindow object is created (or re-created).
void SimpleDirect3DApp::SetWindow(CoreWindow^ window)
{
  // Register event handlers with the CoreWindow object.
  // ...

  // Obtain your ID3D11Device1 and ID3D11DeviceContext1 objects
  // In this example, m_d3dDevice contains the scoped ID3D11Device1 object
  // ...

  ComPtr<IDXGIDevice1>  dxgiDevice;
  // Get the underlying DXGI device of the Direct3D device.
  m_d3dDevice.As(&dxgiDevice);

  ComPtr<IDXGIAdapter> dxgiAdapter;
  dxgiDevice->GetAdapter(&dxgiAdapter);

  ComPtr<IDXGIFactory2> dxgiFactory;
  dxgiAdapter->GetParent(
    __uuidof(IDXGIFactory2), 
    &dxgiFactory);

  DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0};
  swapChainDesc.Width = static_cast<UINT>(m_d3dRenderTargetSize.Width); // Match the size of the window.
  swapChainDesc.Height = static_cast<UINT>(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_SEQUENTIAL; // All UWP apps must use this SwapEffect.
  swapChainDesc.Flags = 0;

  // ...

  Windows::UI::Core::CoreWindow^ window = m_window.Get();
  dxgiFactory->CreateSwapChainForCoreWindow(
    m_d3dDevice.Get(),
    reinterpret_cast<IUnknown*>(window),
    &swapChainDesc,
    nullptr, // Allow on all displays.
    &m_swapChainCoreWindow);
}

Appelez la méthode IDXGISwapChain1 ::P resent1 après avoir préparé un frame pour l’afficher.

Notez que dans Direct3D 11, il n’existe pas d’abstraction identique à EGLSurface. (Il y a IDXGISurface1, mais il est utilisé différemment.) L’approximation conceptuelle la plus proche est l’objet ID3D11RenderTargetView que nous utilisons pour affecter une texture (ID3D11Texture2D) en tant que mémoire tampon de retour dans laquelle notre pipeline de nuanceur va dessiner.

Configuration de la mémoire tampon de sauvegarde pour la chaîne d’échange dans Direct3D 11

ComPtr<ID3D11RenderTargetView>    m_d3dRenderTargetViewWin; // scoped to renderer object

// ...

ComPtr<ID3D11Texture2D> backBuffer2;
    
m_swapChainCoreWindow->GetBuffer(0, IID_PPV_ARGS(&backBuffer2));

m_d3dDevice->CreateRenderTargetView(
  backBuffer2.Get(),
  nullptr,
    &m_d3dRenderTargetViewWin);

Une bonne pratique consiste à appeler ce code chaque fois que la fenêtre est créée ou modifie la taille. Pendant le rendu, définissez la vue cible de rendu avec ID3D11DeviceContext1 ::OMSetRenderTargets avant de configurer d’autres sous-ressources telles que des tampons de vertex ou des nuanceurs.

// Set the render target for the draw operation.
m_d3dContext->OMSetRenderTargets(
        1,
        d3dRenderTargetView.GetAddressOf(),
        nullptr);

Création d’un contexte de rendu

Dans EGL 1.4, un « affichage » représente un ensemble de ressources de fenêtre. En règle générale, vous configurez une « surface » pour l’affichage en fournissant un ensemble d’attributs à l’objet d’affichage et en obtenant une surface en retour. Vous créez un contexte pour afficher le contenu de l’aire en créant ce contexte et en le liant à l’aire et à l’affichage.

Le flux d’appels ressemble généralement à ceci :

Appelez eglGetDisplay avec le handle vers une ressource d’affichage ou de fenêtre et obtenez un objet d’affichage.
Initialisez l’affichage avec eglInitialize.
Obtenez la configuration d’affichage disponible et sélectionnez-en une avec eglGetConfigs et eglChooseConfig.
Créez une surface de fenêtre avec eglCreateWindowSurface.
Créez un contexte d’affichage pour le dessin avec eglCreateContext.
Liez le contexte d’affichage à l’affichage et à la surface avec eglMakeCurrent.

n la section précédente, nous avons créé eGLDisplay et EGLSurface, et maintenant nous utilisons EGLDisplay pour créer un contexte et associer ce contexte à l’affichage, à l’aide de l’EGLSurface configuré pour paramétrer la sortie.

Obtention d’un contexte de rendu avec EGL 1.4

// Configure your EGLDisplay and obtain an EGLSurface here ...
// ...

// Create a drawing context from the EGLDisplay
context = eglCreateContext(display, config, EGL_NO_CONTEXT, contextAttribs);
if (context == EGL_NO_CONTEXT)
{
  return EGL_FALSE;
}   
   
// Make the context current
if (!eglMakeCurrent(display, surface, surface, context))
{
  return EGL_FALSE;
}

Un contexte de rendu dans Direct3D 11 est représenté par un objet ID3D11Device1 , qui représente l’adaptateur et vous permet de créer des ressources Direct3D telles que des mémoires tampons et des nuanceurs ; et par l’objet ID3D11DeviceContext1 , ce qui vous permet de gérer le pipeline graphique et d’exécuter les nuanceurs.

Tenez compte des niveaux de fonctionnalités Direct3D ! Ceux-ci sont utilisés pour prendre en charge les anciennes plateformes matérielles Direct3D, de DirectX 9.1 à DirectX 11. De nombreuses plateformes qui utilisent du matériel graphique à faible puissance, comme les tablettes, n’ont accès qu’aux fonctionnalités de DirectX 9.1, et le matériel graphique plus ancien pris en charge peut être de 9.1 à 11.

Création d’un contexte de rendu avec DXGI et Direct3D


// ... 

UINT creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
ComPtr<IDXGIDevice> dxgiDevice;

D3D_FEATURE_LEVEL featureLevels[] = 
{
        D3D_FEATURE_LEVEL_11_1,
        D3D_FEATURE_LEVEL_11_0,
        D3D_FEATURE_LEVEL_10_1,
        D3D_FEATURE_LEVEL_10_0,
        D3D_FEATURE_LEVEL_9_3,
        D3D_FEATURE_LEVEL_9_2,
        D3D_FEATURE_LEVEL_9_1
};

// Create the Direct3D 11 API device object and a corresponding context.
ComPtr<ID3D11Device> device;
ComPtr<ID3D11DeviceContext> d3dContext;

D3D11CreateDevice(
  nullptr, // Specify nullptr to use the default adapter.
  D3D_DRIVER_TYPE_HARDWARE,
  nullptr,
  creationFlags, // Set debug and Direct2D compatibility flags.
  featureLevels, // List of feature levels this app can support.
  ARRAYSIZE(featureLevels),
  D3D11_SDK_VERSION, // Always set this to D3D11_SDK_VERSION for UWP apps.
  &device, // Returns the Direct3D device created.
  &m_featureLevel, // Returns feature level of device created.
  &d3dContext // Returns the device immediate context.
);

Dessin dans une ressource de texture ou pixmap

Pour dessiner dans une texture avec OpenGL ES 2.0, configurez une mémoire tampon de pixels ou PBuffer. Une fois que vous avez correctement configuré et créé une EGLSurface pour celle-ci, vous pouvez lui fournir un contexte de rendu et exécuter le pipeline de nuanceur pour dessiner dans la texture.

Dessiner dans une mémoire tampon de pixels avec OpenGL ES 2.0

// Create a pixel buffer surface to draw into
EGLConfig pBufConfig;
EGLint totalpBufAttrs;

const EGLint pBufConfigAttrs[] =
{
    // Configure the pBuffer here...
};
 
eglChooseConfig(eglDsplay, pBufConfigAttrs, &pBufConfig, 1, &totalpBufAttrs);
EGLSurface pBuffer = eglCreatePbufferSurface(eglDisplay, pBufConfig, EGL_TEXTURE_RGBA);

Dans Direct3D 11, vous créez une ressource ID3D11Texture2D et créez-la comme cible de rendu. Configurez la cible de rendu à l’aide de D3D11_RENDER_TARGET_VIEW_DESC. Lorsque vous appelez la méthode ID3D11DeviceContext ::D raw (ou une opération Draw* similaire sur le contexte de l’appareil) à l’aide de cette cible de rendu, les résultats sont dessinés dans une texture.

Dessiner dans une texture avec Direct3D 11

ComPtr<ID3D11Texture2D> renderTarget1;

D3D11_RENDER_TARGET_VIEW_DESC renderTargetDesc = {0};
// Configure renderTargetDesc here ...

m_d3dDevice->CreateRenderTargetView(
  renderTarget1.Get(),
  nullptr,
  &m_d3dRenderTargetViewWin);

// Later, in your render loop...

// Set the render target for the draw operation.
m_d3dContext->OMSetRenderTargets(
        1,
        d3dRenderTargetView.GetAddressOf(),
        nullptr);

Cette texture peut être transmise à un nuanceur s’il est associé à un ID3D11ShaderResourceView.

Dessin à l’écran

Une fois que vous avez utilisé votre EGLContext pour configurer vos mémoires tampons et mettre à jour vos données, vous exécutez les nuanceurs liés à celui-ci et dessinez les résultats dans la mémoire tampon arrière avec glDrawElements. Vous affichez la mémoire tampon back en appelant eglSwapBuffers.

Ouvrez GL ES 2.0 : dessin sur l’écran.

glDrawElements(GL_TRIANGLES, renderer->numIndices, GL_UNSIGNED_INT, 0);

eglSwapBuffers(drawContext->eglDisplay, drawContext->eglSurface);

Dans Direct3D 11, vous configurez vos mémoires tampons et liez des nuanceurs à votre IDXGISwapChain ::P resent1. Ensuite, vous appelez l’une des méthodes ID3D11DeviceContext1 ::D raw* pour exécuter les nuanceurs et dessiner les résultats sur une cible de rendu configurée comme mémoire tampon de retour pour la chaîne d’échange. Ensuite, vous présentez simplement la mémoire tampon de retour à l’affichage en appelant IDXGISwapChain ::P resent1.

Direct3D 11 : Dessin à l’écran.


m_d3dContext->DrawIndexed(
        m_indexCount,
        0,
        0);

// ...

m_swapChainCoreWindow->Present1(1, 0, &parameters);

Libération des ressources graphiques

Dans EGL, vous relâchez les ressources de la fenêtre en passant l’EGLDisplay à eglTerminate.

Fin d’un affichage avec EGL 1.4

EGLBoolean eglTerminate(eglDisplay);

Dans une application UWP, vous pouvez fermer CoreWindow avec CoreWindow ::Close, bien que cela ne puisse être utilisé que pour les fenêtres d’interface utilisateur secondaire. Le thread d’interface utilisateur principal et son CoreWindow associé ne peuvent pas être fermés ; elles ont plutôt expiré par le système d’exploitation. Toutefois, lorsqu’un CoreWindow secondaire est fermé, l’événement CoreWindow ::Closed est déclenché.

Mappage de référence d’API pour EGL vers Direct3D 11

EGL API	API ou comportement Direct3D 11 similaire
eglBindAPI	N/A.
eglBindTexImage	Appelez ID3D11Device ::CreateTexture2D pour définir une texture 2D.
eglChooseConfig	Direct3D ne fournit pas d’ensemble de configurations de mémoire tampon de trame par défaut. Configuration de la chaîne d’échange
eglCopyBuffers	Pour copier des données de mémoire tampon, appelez ID3D11DeviceContext ::CopyStructureCount. Pour copier une ressource, appelez ID3DDeviceCOntext ::CopyResource.
eglCreateContext	Créez un contexte d’appareil Direct3D en appelant D3D11CreateDevice, qui retourne à la fois un handle à un appareil Direct3D et un contexte immédiat Direct3D par défaut (objet ID3D11DeviceContext1). Vous pouvez également créer un contexte différé Direct3D en appelant ID3D11Device2 ::CreateDeferredContext sur l’objet ID3D11Device1 retourné.
eglCreatePbufferFromClientBuffer	Toutes les mémoires tampons sont lues et écrites en tant que sous-ressource Direct3D, comme un ID3D11Texture2D. Copiez de l’un vers un autre type de sous-source compatible avec des méthodes telles que ID3D11DeviceContext1 :CopyResource.
eglCreatePbufferSurface	Pour créer un appareil Direct3D sans chaîne d’échange, appelez la méthode statique D3D11CreateDevice. Pour une vue cible de rendu Direct3D, appelez ID3D11Device ::CreateRenderTargetView.
eglCreatePixmapSurface	Pour créer un appareil Direct3D sans chaîne d’échange, appelez la méthode statique D3D11CreateDevice. Pour une vue cible de rendu Direct3D, appelez ID3D11Device ::CreateRenderTargetView.
eglCreateWindowSurface	Ontain un IDXGISwapChain1 (pour les mémoires tampons d’affichage) et un ID3D11Device1 (interface virtuelle pour l’appareil graphique et ses ressources). Utilisez l’ID3D11Device1 pour définir un ID3D11RenderTargetView que vous pouvez utiliser pour créer la mémoire tampon d’image que vous fournissez à IDXGISwapChain1.
eglDestroyContext	N/A. Utilisez ID3D11DeviceContext ::D iscardView1 pour vous débarrasser d’une vue cible de rendu. Pour fermer l’ID3D11DeviceContext1 parent, définissez l’instance sur Null et attendez que la plateforme récupère ses ressources. Vous ne pouvez pas détruire directement le contexte de l’appareil.
eglDestroySurface	N/A. Les ressources graphiques sont nettoyées lorsque le CoreWindow de l’application UWP est fermé par la plateforme.
eglGetCurrentDisplay	Appelez CoreWindow ::GetForCurrentThread pour obtenir une référence à la fenêtre d’application principale actuelle.
eglGetCurrentSurface	Il s’agit de l’ID3D11RenderTargetView actuel. En règle générale, il s’agit d’une étendue à votre objet renderer.
eglGetError	Les erreurs sont obtenues en tant que HRESULT retournés par la plupart des méthodes sur les interfaces DirectX. Si la méthode ne retourne pas de HRESULT, appelez GetLastError. Pour convertir une erreur système en valeur HRESULT, utilisez la macro HRESULT_FROM_WIN32.
eglInitialize	Appelez CoreWindow ::GetForCurrentThread pour obtenir une référence à la fenêtre d’application principale actuelle.
eglMakeCurrent	Définissez une cible de rendu pour le dessin sur le contexte actuel avec ID3D11DeviceContext1 ::OMSetRenderTargets.
eglQueryContext	N/A. Toutefois, vous pouvez acquérir des cibles de rendu à partir d’une instance ID3D11Device1 , ainsi que certaines données de configuration. (Consultez le lien pour obtenir la liste des méthodes disponibles.)
eglQuerySurface	N/A. Toutefois, vous pouvez acquérir des données sur les fenêtres d’affichage et le matériel graphique actuel à partir de méthodes sur une instance ID3D11Device1. (Consultez le lien pour obtenir la liste des méthodes disponibles.)
eglReleaseTexImage	N/A.
eglReleaseThread	Pour le multithreading GPU général, lisez multithreading.
eglSurfaceAttrib	Utilisez D3D11_RENDER_TARGET_VIEW_DESC pour configurer une vue cible de rendu Direct3D,
eglSwapBuffers	Utilisez IDXGISwapChain1 ::P resent1.
eglSwapInterval	Voir IDXGISwapChain1.
eglTerminate	CoreWindow utilisé pour afficher la sortie du pipeline graphique est géré par le système d’exploitation.
eglWaitClient	Pour les surfaces partagées, utilisez IDXGIKeyedMutex. Pour le multithreading GPU général, lisez multithreading.
eglWaitGL	Pour les surfaces partagées, utilisez IDXGIKeyedMutex. Pour le multithreading GPU général, lisez multithreading.
eglWaitNative	Pour les surfaces partagées, utilisez IDXGIKeyedMutex. Pour le multithreading GPU général, lisez multithreading.

Partager via