Vergleichen von EGL-Code mit DXGI und Direct3D

Artikel
07/05/2024

Wichtige APIs

Die DirectX Graphics Interface (DXGI) und mehrere Direct3D-APIs dienen der gleichen Rolle wie EGL. Dieses Thema hilft Ihnen, DXGI und Direct3D 11 aus sicht der EGL zu verstehen.

DXGI und Direct3D, z. B. EGL, bieten Methoden zum Konfigurieren von Grafikressourcen, Abrufen eines Renderingkontexts für Ihre Shader zum Zeichnen und Anzeigen der Ergebnisse in einem Fenster. DxGI und Direct3D verfügen jedoch über einige weitere Optionen und erfordern mehr Aufwand, um beim Portieren von EGL ordnungsgemäß einzurichten.

Hinweis Diese Anleitung basiert auf der offenen Spezifikation der Khronos Group für EGL 1.4, die hier zu finden ist: Khronos Native Platform Graphics Interface (EGL Version 1.4 - 6. April 2011) [PDF]. Unterschiede in der Syntax, die speziell für andere Plattformen und Entwicklungssprachen gelten, werden in dieser Anleitung nicht behandelt.

Wie vergleicht DXGI und Direct3D?

Der große Vorteil von EGL gegenüber DXGI und Direct3D besteht darin, dass es relativ einfach ist, mit dem Zeichnen auf eine Fensteroberfläche zu beginnen. Dies liegt daran, dass OpenGL ES 2.0 – und daher EGL – eine Spezifikation ist, die von mehreren Plattformanbietern implementiert wird, während DXGI und Direct3D ein einzelner Verweis sind, den Hardwareanbietertreiber erfüllen müssen. Dies bedeutet, dass Microsoft eine Reihe von APIs implementieren muss, die den größtmöglichen Satz von Anbieterfeatures ermöglichen, anstatt sich auf eine funktionale Teilmenge zu konzentrieren, die von einem bestimmten Anbieter angeboten wird, oder indem anbieterspezifische Setupbefehle in einfachere APIs kombiniert werden. Auf der anderen Seite stellt Direct3D eine einzelne Gruppe von APIs bereit, die eine sehr breite Palette von Grafikhardwareplattformen und Featureebenen abdecken, und bieten mehr Flexibilität für Entwickler, die mit der Plattform vertraut sind.

Wie EGL stellen DXGI und Direct3D APIs für das folgende Verhalten bereit:

Abrufen und Lesen und Schreiben in einen Framepuffer (als "Swapchain" in DXGI bezeichnet).
Zuordnen des Framepuffers zu einem Benutzeroberflächenfenster.
Abrufen und Konfigurieren von Renderingkontexten, in denen gezeichnet werden soll.
Ausgeben von Befehlen an die Grafikpipeline für einen bestimmten Renderingkontext.
Erstellen und Verwalten von Shaderressourcen und Zuordnen dieser Ressourcen zu einem Renderinginhalt.
Rendern an bestimmte Renderziele (z. B. Texturen).
Aktualisieren der Anzeigeoberfläche des Fensters mit den Ergebnissen des Renderns mit den Grafikressourcen.

Wenn Sie den grundlegenden Direct3D-Prozess zum Konfigurieren der Grafikpipeline anzeigen möchten, lesen Sie die DirectX 11-App-Vorlage (Universelle Windows-App) in Microsoft Visual Studio 2015. Die Basisrenderingklasse bietet einen guten Basisplan zum Einrichten der Direct3D 11-Grafikinfrastruktur und zum Konfigurieren grundlegender Ressourcen darauf sowie die Unterstützung von Universelle Windows-Plattform(UWP)-App-Features wie z. B. Bildschirmdrehung.

EGL verfügt über sehr wenige APIs im Verhältnis zu Direct3D 11, und das Navigieren im letzteren kann eine Herausforderung sein, wenn Sie nicht mit der Benennung und dem Jargon vertraut sind, die speziell für die Plattform gelten. Hier ist eine einfache Übersicht, die Ihnen dabei hilft, sich zu orientieren.

Überprüfen Sie zunächst das grundlegende EGL-Objekt zur Direct3D-Schnittstellenzuordnung:

EGL-Abstraktion	Ähnliche Direct3D-Darstellung
EGLDisplay	In Direct3D (für UWP-Apps) wird das Anzeigehandle über die Windows::UI::CoreWindow-API (oder die ICoreWindowInterop-Schnittstelle abgerufen, die den HWND verfügbar macht). Die Adapter- und Hardwarekonfiguration werden mit den COM-Schnittstellen IDXGIAdapter und IDXGIDevice1 festgelegt.
EGLSurface	In Direct3D werden die Puffer und andere Fensterressourcen (sichtbar oder offscreen) durch bestimmte DXGI-Schnittstellen erstellt und konfiguriert, einschließlich IDXGIFactory2 (eine Factorymusterimplementierung, die zum Abrufen von DXGI-Ressourcen wie derIDXGISwapChain1 (Anzeigepuffer) verwendet wird. Die ID3D11Device1 , die das Grafikgerät und die zugehörigen Ressourcen darstellt, wird mit D3D11Device::CreateDevice abgerufen. Verwenden Sie für Renderziele die ID3D11RenderTargetView-Schnittstelle.
EGLContext	In Direct3D konfigurieren und ausgeben Sie Befehle für die Grafikpipeline mit der ID3D11DeviceContext1-Schnittstelle.
EGLConfig	In Direct3D 11 erstellen und konfigurieren Sie Grafikressourcen wie Puffer, Texturen, Schablonen und Shader mit Methoden auf der ID3D11Device1-Schnittstelle.

Im Folgenden finden Sie den grundlegendsten Prozess zum Einrichten einer einfachen Grafikanzeige, Ressourcen und Kontext in DXGI und Direct3D für eine UWP-App.

Rufen Sie ein Handle für das CoreWindow-Objekt für den Kern-UI-Thread der App ab, indem Sie CoreWindow::GetForCurrentThread aufrufen.
Erwerben Sie für UWP-Apps eine Swapchain aus der IDXGIAdapter2 mit IDXGIFactory2::CreateSwapChainForCoreWindow, und übergeben Sie sie an den CoreWindow-Verweis, den Sie in Schritt 1 abgerufen haben. Sie erhalten eine IDXGISwapChain1-Instanz zurück. Legen Sie den Bereich auf das Rendererobjekt und den Renderthread fest.
Rufen Sie ID3D11Device1- und ID3D11DeviceContext1-Instanzen ab, indem Sie die D3D11Device::CreateDevice-Methode aufrufen. Beschränken Sie sie auch auf das Rendererobjekt.
Erstellen Sie Shader, Texturen und andere Ressourcen mithilfe von Methoden für das ID3D11Device1-Objekt des Renderers.
Definieren Von Puffern, Ausführen von Shadern und Verwalten der Pipelinephasen mithilfe von Methoden für das ID3D11DeviceContext1-Objekt des Renderers.
Wenn die Pipeline ausgeführt wurde und ein Frame in den Hintergrundpuffer gezeichnet wird, präsentieren Sie sie auf dem Bildschirm mit IDXGISwapChain1::P resent1.

Wenn Sie diesen Prozess ausführlicher untersuchen möchten, lesen Sie "Erste Schritte mit DirectX-Grafiken". Im restlichen Artikel werden viele der allgemeinen Schritte für die Einrichtung und Verwaltung der Grafikpipeline behandelt.

Beachten Sie, dass Windows-Desktop-Apps unterschiedliche APIs zum Abrufen einer Direct3D-Swapchain haben, z. B. D3D11Device::CreateDeviceAndSwapChain, und verwenden Sie kein CoreWindow-Objekt.

Abrufen eines Fensters für die Anzeige

In diesem Beispiel wird eglGetDisplay eine HWND für eine Fensterressource übergeben, die für die Microsoft Windows-Plattform spezifisch ist. Andere Plattformen, z. B. Apples iOS (Cocoa) und Googles Android, weisen unterschiedliche Handles oder Verweise auf Fensterressourcen auf und weisen möglicherweise insgesamt unterschiedliche Aufrufsyntax auf. Nach dem Abrufen einer Anzeige initialisieren Sie sie, legen die bevorzugte Konfiguration fest und erstellen eine Oberfläche mit einem Hintergrundpuffer, in den Sie zeichnen können.

Abrufen einer Anzeige und Konfiguration mit 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;
}

In Direct3D wird das Hauptfenster einer UWP-App durch das CoreWindow-Objekt dargestellt, das vom App-Objekt abgerufen werden kann, indem CoreWindow::GetForCurrentThread als Teil des Initialisierungsprozesses des "Ansichtsanbieters" aufgerufen wird, den Sie für Direct3D erstellen. (Wenn Sie die Direct3D-XAML-Interoperabilität verwenden, verwenden Sie den Ansichtsanbieter des XAML-Frameworks.) Der Prozess zum Erstellen eines Direct3D-Ansichtsanbieters wird in der Einrichtung Ihrer App zum Anzeigen einer Ansicht behandelt.

Abrufen eines CoreWindow für Direct3D.

CoreWindow::GetForCurrentThread();

Sobald der CoreWindow-Verweis abgerufen wurde, muss das Fenster aktiviert werden, das die Run-Methode des Hauptobjekts ausführt und mit der Verarbeitung von Fensterereignissen beginnt. Erstellen Sie danach eine ID3D11Device1 und eine ID3D11DeviceContext1, und verwenden Sie diese, um die zugrunde liegende IDXGIDevice1 und IDXGIAdapter abzurufen, damit Sie ein IDXGIFactory2-Objekt abrufen können, um eine Swapchainressource basierend auf Ihrer DXGI_SWAP_CHAIN_DESC1 Konfiguration zu erstellen.

Konfigurieren und Festlegen der DXGI-Swapchain für CoreWindow für 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);
}

Rufen Sie die IDXGISwapChain1::P resent1-Methode auf, nachdem Sie einen Frame vorbereitet haben, um ihn anzuzeigen.

Beachten Sie, dass in Direct3D 11 keine Abstraktion mit EGLSurface identisch ist. (Es gibt IDXGISurface1, aber es wird anders verwendet.) Die nächstgelegene konzeptionelle Annäherung ist das ID3D11RenderTargetView-Objekt, das wir verwenden, um eine Textur (ID3D11Texture2D) als Hintergrundpuffer zuzuweisen, in den unsere Shaderpipeline zeichnen wird.

Einrichten des Hintergrundpuffers für die Swapchain in 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);

Es empfiehlt sich, diesen Code immer dann aufzurufen, wenn das Fenster erstellt oder die Größe geändert wird. Legen Sie beim Rendern die Renderzielansicht mit ID3D11DeviceContext1::OMSetRenderTargets fest, bevor Sie andere Unterressourcen wie Vertexpuffer oder Shader einrichten.

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

Erstellen eines Renderingkontexts

In EGL 1.4 stellt ein "Display" eine Reihe von Fensterressourcen dar. In der Regel konfigurieren Sie eine "Oberfläche" für die Anzeige, indem Sie eine Reihe von Attributen für das Anzeigeobjekt bereitstellen und eine Oberfläche zurückgeben. Sie erstellen einen Kontext zum Anzeigen des Inhalts der Oberfläche, indem Sie diesen Kontext erstellen und an die Oberfläche und die Anzeige binden.

Der Anruffluss sieht in der Regel ähnlich wie folgt aus:

Rufen Sie eglGetDisplay mit dem Handle für eine Anzeige- oder Fensterressource auf, und rufen Sie ein Anzeigeobjekt ab.
Initialisieren Sie die Anzeige mit eglInitialize.
Rufen Sie die verfügbare Anzeigekonfiguration ab, und wählen Sie eine mit eglGetConfigs und eglChooseConfig aus.
Erstellen Sie eine Fensteroberfläche mit eglCreateWindowSurface.
Erstellen Sie einen Anzeigekontext für die Zeichnung mit eglCreateContext.
Binden Sie den Anzeigekontext an die Anzeige und die Oberfläche mit eglMakeCurrent.

n the previous section, we created the EGLDisplay and the EGLSurface, and now we use the EGLDisplay to create a context and associate that context with the display, using the configured EGLSurface to parametrize the output.

Abrufen eines Renderingkontexts mit 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;
}

Ein Renderingkontext in Direct3D 11 wird durch ein ID3D11Device1 -Objekt dargestellt, das den Adapter darstellt und Es Ihnen ermöglicht, Direct3D-Ressourcen wie Puffer und Shader zu erstellen; und durch das ID3D11DeviceContext1 -Objekt, mit dem Sie die Grafikpipeline verwalten und die Shader ausführen können.

Achten Sie auf Direct3D-Featureebenen! Diese werden verwendet, um ältere Direct3D-Hardwareplattformen von DirectX 9.1 bis DirectX 11 zu unterstützen. Viele Plattformen, die Grafikhardware mit geringer Leistung verwenden, z. B. Tablets, haben nur Zugriff auf DirectX 9.1-Features, und ältere unterstützte Grafikhardware kann von 9.1 bis 11 sein.

Erstellen eines Renderingkontexts mit DXGI und 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.
);

Zeichnen in eine Textur- oder Pixmap-Ressource

Um in eine Textur mit OpenGL ES 2.0 zu zeichnen, konfigurieren Sie einen Pixelpuffer oder PBuffer. Nachdem Sie eine EGLSurface-Datei erfolgreich konfiguriert und erstellt haben, können Sie sie mit einem Renderingkontext bereitstellen und die Shaderpipeline ausführen, um in die Textur zu zeichnen.

Zeichnen in einen Pixelpuffer mit 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);

In Direct3D 11 erstellen Sie eine ID3D11Texture2D-Ressource und machen es zu einem Renderziel. Konfigurieren Sie das Renderziel mithilfe von D3D11_RENDER_TARGET_VIEW_DESC. Wenn Sie die ID3D11DeviceContext::D raw-Methode (oder einen ähnlichen Draw*-Vorgang im Gerätekontext) mithilfe dieses Renderziels aufrufen, werden die Ergebnisse in eine Textur gezeichnet.

Zeichnen in eine Textur mit 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);

Diese Textur kann an einen Shader übergeben werden, wenn sie einer ID3D11ShaderResourceView zugeordnet ist.

Zeichnen auf dem Bildschirm

Nachdem Sie ihren EGLContext zum Konfigurieren der Puffer und Zum Aktualisieren der Daten verwendet haben, führen Sie die an sie gebundenen Shader aus und zeichnen die Ergebnisse mit glDrawElements in den Hintergrundpuffer. Sie zeigen den Hintergrundpuffer an, indem Sie eglSwapBuffers aufrufen.

Öffnen Sie GL ES 2.0: Zeichnen auf dem Bildschirm.

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

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

In Direct3D 11 konfigurieren Sie Ihre Puffer und binden Shader mit Ihrer IDXGISwapChain::P resent1. Anschließend rufen Sie eine der ID3D11DeviceContext1::D raw*-Methoden auf, um die Shader auszuführen und die Ergebnisse auf ein Renderziel zu zeichnen, das als Hintergrundpuffer für die Swapchain konfiguriert ist. Danach stellen Sie einfach den Hintergrundpuffer auf der Anzeige dar, indem Sie IDXGISwapChain::P resent1 aufrufen.

Direct3D 11: Zeichnen auf dem Bildschirm.


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

// ...

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

Freigeben von Grafikressourcen

In EGL geben Sie die Fensterressourcen frei, indem Sie das EGLDisplay an eglTerminate übergeben.

Beenden einer Anzeige mit EGL 1.4

EGLBoolean eglTerminate(eglDisplay);

In einer UWP-App können Sie "CoreWindow" mit "CoreWindow::Close" schließen, dies kann jedoch nur für sekundäre UI-Fenster verwendet werden. Der primäre UI-Thread und der zugehörige CoreWindow-Thread können nicht geschlossen werden. sie sind vielmehr vom Betriebssystem abgelaufen. Wenn jedoch ein sekundärer CoreWindow geschlossen wird, wird das CoreWindow::Closed-Ereignis ausgelöst.

API-Referenzzuordnung für EGL zu Direct3D 11

EGL-API	Ähnliche Direct3D 11-API oder ähnliches Verhalten
eglBindAPI	N/V.
eglBindTexImage	Rufen Sie ID3D11Device::CreateTexture2D auf, um eine 2D-Textur festzulegen.
eglChooseConfig	Direct3D stellt keine Reihe von Standardframepufferkonfigurationen zur Verfügung. Konfiguration der Swapchain
eglCopyBuffers	Rufen Sie ID3D11DeviceContext::CopyStructureCount auf, um pufferdaten zu kopieren. Rufen Sie zum Kopieren einer Ressource ID3DDeviceCOntext::CopyResource auf.
eglCreateContext	Erstellen Sie einen Direct3D-Gerätekontext, indem Sie D3D11CreateDevice aufrufen, der sowohl ein Handle an ein Direct3D-Gerät als auch einen Standardmäßigen Direct3D-Direktkontext (ID3D11DeviceContext1-Objekt) zurückgibt. Sie können auch einen verzögerten Direct3D-Kontext erstellen, indem Sie ID3D11Device2::CreateDeferredContext für das zurückgegebene ID3D11Device1-Objekt aufrufen.
eglCreatePbufferFromClientBuffer	Alle Puffer werden als Direct3D-Unterressource gelesen und geschrieben, z. B. eine ID3D11Texture2D. Kopieren Von einem in einen anderen kompatiblen Unterressourcentyp mit methoden wie ID3D11DeviceContext1:CopyResource.
eglCreatePbufferSurface	Rufen Sie die statische D3D11CreateDevice-Methode auf, um ein Direct3D-Gerät ohne Swapchain zu erstellen. Rufen Sie für eine Direct3D-Renderzielansicht ID3D11Device::CreateRenderTargetView auf.
eglCreatePixmapSurface	Rufen Sie die statische D3D11CreateDevice-Methode auf, um ein Direct3D-Gerät ohne Swapchain zu erstellen. Rufen Sie für eine Direct3D-Renderzielansicht ID3D11Device::CreateRenderTargetView auf.
eglCreateWindowSurface	Ontain an IDXGISwapChain1 (for the display buffers) and an ID3D11Device1 (a virtual interface for the graphics device and its resources). Verwenden Sie die ID3D11Device1, um eine ID3D11RenderTargetView zu definieren, die Sie zum Erstellen des framepuffers verwenden können, den Sie für die IDXGISwapChain1 bereitstellen.
eglDestroyContext	N/V. Verwenden Sie ID3D11DeviceContext::D iscardView1 , um eine Renderzielansicht zu entfernen. Um das übergeordnete ID3D11DeviceContext1 zu schließen, legen Sie die Instanz auf NULL fest, und warten Sie, bis die Plattform ihre Ressourcen zurückgibt. Sie können den Gerätekontext nicht direkt zerstören.
eglDestroySurface	N/V. Grafikressourcen werden bereinigt, wenn die CoreWindow-App der UWP-App von der Plattform geschlossen wird.
eglGetCurrentDisplay	Rufen Sie CoreWindow::GetForCurrentThread auf, um einen Verweis auf das aktuelle Haupt-App-Fenster abzurufen.
eglGetCurrentSurface	Dies ist die aktuelle ID3D11RenderTargetView. In der Regel ist dies auf das Rendererobjekt festgelegt.
eglGetError	Fehler werden als HRESULTs abgerufen, die von den meisten Methoden für DirectX-Schnittstellen zurückgegeben werden. Wenn die Methode kein HRESULT zurückgibt, rufen Sie GetLastError auf. Um einen Systemfehler in einen HRESULT-Wert zu konvertieren, verwenden Sie das HRESULT_FROM_WIN32 Makro.
eglInitialize	Rufen Sie CoreWindow::GetForCurrentThread auf, um einen Verweis auf das aktuelle Haupt-App-Fenster abzurufen.
eglMakeCurrent	Legen Sie ein Renderziel für das Zeichnen im aktuellen Kontext mit ID3D11DeviceContext1::OMSetRenderTargets fest.
eglQueryContext	N/V. Sie können jedoch Renderingziele aus einer ID3D11Device1-Instanz sowie einige Konfigurationsdaten abrufen. (Siehe Link zur Liste der verfügbaren Methoden.)
eglQuerySurface	N/V. Sie können jedoch Daten zu Viewports und der aktuellen Grafikhardware aus Methoden in einer ID3D11Device1-Instanz abrufen. (Siehe Link zur Liste der verfügbaren Methoden.)
eglReleaseTexImage	N/V.
eglReleaseThread	Für allgemeine GPU-Multithreading lesen Sie Multithreading.
eglSurfaceAttrib	Verwenden sie D3D11_RENDER_TARGET_VIEW_DESC zum Konfigurieren einer Direct3D-Renderzielansicht,
eglSwapBuffers	Verwenden Sie IDXGISwapChain1::P resent1.
eglSwapInterval	Siehe IDXGISwapChain1.
eglTerminate	Das CoreWindow-Element, das zum Anzeigen der Ausgabe der Grafikpipeline verwendet wird, wird vom Betriebssystem verwaltet.
eglWaitClient	Verwenden Sie für gemeinsam genutzte Oberflächen IDXGIKeyedMutex. Für allgemeine GPU-Multithreading lesen Sie Multithreading.
eglWaitGL	Verwenden Sie für gemeinsam genutzte Oberflächen IDXGIKeyedMutex. Für allgemeine GPU-Multithreading lesen Sie Multithreading.
eglWaitNative	Verwenden Sie für gemeinsam genutzte Oberflächen IDXGIKeyedMutex. Für allgemeine GPU-Multithreading lesen Sie Multithreading.

Freigeben über