EGL コードと DXGI および Direct3D の比較Compare EGL code to DXGI and Direct3D

重要な APIImportant APIs

DirectX Graphics Interface (DXGI) といくつかの Direct3D API は EGL と同じ役割を果たします。The DirectX Graphics Interface (DXGI) and several Direct3D APIs serve the same role as EGL. このトピックは EGL の観点から DXGI と Direct3D 11 を理解するのに役立ちます。This topic helps you understand DXGI and Direct3D 11 from the perspective of EGL.

DXGI と Direct3D は EGL に似ており、グラフィックス リソースを構成するためのメソッドや、シェーダーの描画先となり、ウィンドウに結果を表示するために使われるレンダリング コンテキストを取得するためのメソッドがあります。DXGI and Direct3D, like EGL, provide methods to configure graphics resources, obtain a rendering context for your shaders to draw into, and to display the results in a window. ただし、DXGI と Direct3D にはかなりのオプションがあるため、EGL からの移植の際には、適切に設定するための余分な作業が必要です。However, DXGI and Direct3D have quite a few more options, and require more effort to set up correctly when porting from EGL.

  このガイダンスは、こちらの EGL 1.4 の Khronos グループのオープン仕様に基づいて。Khronos ネイティブ プラットフォーム グラフィック インターフェイス (EGL バージョン 1.4 - 2011 年 4 月 6 日) [PDF]します。Note   This guidance is based off the Khronos Group's open specification for EGL 1.4, found here: Khronos Native Platform Graphics Interface (EGL Version 1.4 - April 6, 2011) [PDF]. その他のプラットフォームと開発言語に固有の構文の違いは、このガイダンスでは説明していません。Differences in syntax specific to other platforms and development languages are not covered in this guidance.

 

DXGI と Direct3D の比較方法How does DXGI and Direct3D compare?

DXGI および Direct3D と比較したときの EGL の大きなメリットは、比較的簡単にウィンドウ サーフェスへの描画を開始できることです。The big advantage of EGL over DXGI and Direct3D is that it is relatively simple to start drawing to a window surface. これは、OpenGL ES 2.0 と EGL が複数のプラットフォーム プロバイダーによって実装された仕様であるのに対し、DXGI と Direct3D はハードウェア ベンダーのドライバーが準拠する必要のある単一のリファレンスであるためです。This is because OpenGL ES 2.0—and therefore EGL—is a specification implemented by multiple platform providers, whereas DXGI and Direct3D are a single reference that hardware vendor drivers must conform to. つまり、Microsoft がやるべきことは、特定のベンダーが提供する機能のサブセットに注力したり、ベンダー固有のセットアップ コマンドをよりシンプルな API に結合することで得られた機能のサブセットに注力したりすることではなく、可能な限り幅広いベンダー機能をサポートする API のセットを実装することです。This means that Microsoft must implement a set of APIs that enable the broadest possible set of vendor features, rather than focusing on a functional subset offered by a specific vendor, or by combining vendor-specific setup commands into simpler APIs. 一方、Direct3D は、非常に幅広いグラフィックス ハードウェア プラットフォームと機能レベルに対応し、プラットフォームで経験を積んだ開発者向けの柔軟性を提供する API の単一のセットを提供します。On the other hand, Direct3D provides a single set of APIs that cover a very broad range of graphics hardware platforms and feature levels, and offer more flexibility for developers experienced with the platform.

EGL と同様に、DXGI と Direct3D には次の動作のための API が用意されています。Like EGL, DXGI and Direct3D provide APIs for the following behaviors:

  • フレーム バッファーを取得し、その読み書きを行う (DXGI では "スワップ チェーン")。Obtaining, and reading and writing to a frame buffer (called a "swap chain" in DXGI).
  • フレーム バッファーを UI ウィンドウに関連付ける。Associating the frame buffer with a UI window.
  • 描画の場所となるレンダリング コンテキストを取得、構成する。Obtaining and configuring rendering contexts in which to draw.
  • 特定のレンダリング コンテキストのグラフィックス パイプラインにコマンドを発行する。Issuing commands to the graphics pipeline for a specific rendering context.
  • シェーダー リソースを作成して管理し、レンダリング コンテキストに関連付ける。Creating and managing shader resources, and associating them with a rendering content.
  • 特定のレンダー ターゲットにレンダリングする (テクスチャなど)。Rendering to specific render targets (such as textures).
  • グラフィックス リソースを使ったレンダリングの結果でウィンドウの表示サーフェスを更新する。Updating the window's display surface with the results of rendering with the graphics resources.

グラフィックス パイプラインを構成するための基本的な Direct3D プロセスを表示するには、Microsoft Visual Studio 2015 での DirectX 11 アプリ (ユニバーサル Windows) テンプレートを確認します。To see the basic Direct3D process for configuring the graphics pipeline, check out the DirectX 11 App (Universal Windows) template in Microsoft Visual Studio 2015. その基本レンダリング クラスは、Direct3D 11 のグラフィックス インフラストラクチャを設定し、それに基づいて基本的なリソースを構成したり、画面の回転などのユニバーサル Windows プラットフォーム (UWP) アプリの機能をサポートしたりするうえで、適切なベースラインとなります。The base rendering class in it provides a good baseline for setting up the Direct3D 11 graphics infrastructure and configuring basic resources on it, as well as supporting Universal Windows Platform (UWP) app features such as screen rotation.

EGL は Direct3D 11 と比べて API が非常に少なくなっています。プラットフォームに特定の命名規則や専門用語に慣れていないと、Direct3D 11 の理解は難しい場合があります。EGL has very few APIs relative to Direct3D 11, and navigating the latter can be a challenge if you aren't familiar with the naming and jargon particular to the platform. ここでは、初心者の役に立つ簡単な概要を示します。Here's a simple overview to help you get oriented.

まず、基本的な EGL オブジェクトと Direct3D インターフェイスのマッピングを確かめます。First, review the basic EGL object to Direct3D interface mapping:

EGL のアブストラクションEGL abstraction Direct3D での同様の表現Similar Direct3D representation
EGLDisplayEGLDisplay UWP アプリ向けの Direct3D では、表示ハンドルは Windows::UI::CoreWindow API (または HWND を公開する ICoreWindowInterop インターフェイス) を通じて取得されます。In Direct3D (for UWP apps), the display handle is obtained through the Windows::UI::CoreWindow API (or the ICoreWindowInterop interface that exposes the HWND). アダプターとハードウェア構成は、それぞれ IDXGIAdapter COM インターフェイスと IDXGIDevice1 COM インターフェイスを使って設定されます。The adapter and hardware configuration are set with the IDXGIAdapter and IDXGIDevice1 COM interfaces, respectively.
EGLSurfaceEGLSurface Direct3D では、IDXGIFactory2 (IDXGISwapChain1 (表示バッファー) などの DXGI リソースを取得するために使われるファクトリ パターンの実装) を含め、特定の DXGI インターフェイスでバッファーなどのウィンドウ リソース (表示またはオフ スクリーン) を作成し、構成します。In Direct3D, the buffers and other window resources (visible or offscreen) are created and configured by specific DXGI interfaces, including IDXGIFactory2 (a factory pattern implementation used to acquire DXGI resources such as theIDXGISwapChain1 (display buffers). グラフィックス デバイスとそのリソースを表す ID3D11Device1 は、D3D11Device::CreateDevice で取得されます。The ID3D11Device1 that represents the graphics device and its resources, is acquired with D3D11Device::CreateDevice. レンダー ターゲットには、ID3D11RenderTargetView インターフェイスを使います。For render targets, use the ID3D11RenderTargetView interface.
EGLContextEGLContext Direct3D では、ID3D11DeviceContext1 インターフェイスでコマンドを構成し、グラフィックス パイプラインに発行します。In Direct3D, you configure and issue commands to the graphics pipeline with the ID3D11DeviceContext1 interface.
EGLConfigEGLConfig Direct3D 11 では、バッファー、テクスチャ、ステンシル、シェーダーなどのグラフィックス リソースを、ID3D11Device1 インターフェイスのメソッドで作成、構成します。In Direct3D 11, you create and configure graphics resources such as a buffers, textures, stencils and shaders with methods on the ID3D11Device1 interface.

 

ここで、UWP アプリ用の DXGI と Direct3D でシンプルなグラフィックスの表示、リソース、コンテキストを設定するための最も基本的なプロセスを示します。Now, here's the most basic process for setting up a simple graphics display, resources and context in DXGI and Direct3D for a UWP app.

  1. CoreWindow::GetForCurrentThread を呼び出してアプリの中心的な UI スレッドの CoreWindow オブジェクトへのハンドルを取得します。Obtain a handle to the CoreWindow object for the app's core UI thread by calling CoreWindow::GetForCurrentThread.
  2. UWP アプリの場合、IDXGIFactory2::CreateSwapChainForCoreWindowIDXGIAdapter2 からスワップ チェーンを取得し、手順 1. で取得した CoreWindow の参照をそれに渡します。For UWP apps, acquire a swap chain from the IDXGIAdapter2 with IDXGIFactory2::CreateSwapChainForCoreWindow, and pass it the CoreWindow reference you obtained in step 1. IDXGISwapChain1 インスタンスが返されます。You will get an IDXGISwapChain1 instance in return. そのスコープをレンダラー オブジェクトとそのレンダリング スレッドに設定します。Scope it to your renderer object and its rendering thread.
  3. D3D11Device::CreateDevice メソッドを呼び出して ID3D11Device1ID3D11DeviceContext1 のインスタンスを取得します。Obtain ID3D11Device1 and ID3D11DeviceContext1 instances by calling the D3D11Device::CreateDevice method. そのスコープもレンダラー オブジェクトにします。Scope them to your renderer object as well.
  4. レンダラーの ID3D11Device1 オブジェクトのメソッドを使ってシェーダーやテクスチャなどのリソースを作成します。Create shaders, textures, and other resources using methods on your renderer's ID3D11Device1 object.
  5. バッファーを定義し、シェーダーを実行して、パイプライン ステージを管理します。それには、レンダラーの ID3D11DeviceContext1 オブジェクトのメソッドを使います。Define buffers, run shaders and manage the pipeline stages using methods on your renderer's ID3D11DeviceContext1 object.
  6. パイプラインが実行され、フレームがバック バッファーに描画されたら、IDXGISwapChain1::Present1 でそれを画面に表示します。When the pipeline has executed and a frame is drawn to the back buffer, present it to the screen with IDXGISwapChain1::Present1.

このプロセスについて詳しく調べるには、「DirectX グラフィックスの概要」をご覧ください。To examine this process in more detail, review Getting started with DirectX graphics. この記事の残りの部分では、基本的なグラフィックス パイプラインの設定と管理に関する一般的な手順の多くについて説明します。The rest of this article covers many of the common steps for basic graphics pipeline setup and management.

   Windows デスクトップ アプリなど、Direct3D スワップ チェーンを取得するためのさまざまな Api のある D3D11Device::CreateDeviceAndSwapChain、し、を使わない CoreWindow オブジェクト。Note   Windows Desktop apps have different APIs for obtaining a Direct3D swap chain, such as D3D11Device::CreateDeviceAndSwapChain, and do not use a CoreWindow object.

 

表示のためのウィンドウの取得Obtaining a window for display

この例では、Microsoft Windows プラットフォームに固有のウィンドウ リソース用の HWND が eglGetDisplay に渡されます。In this example, eglGetDisplay is passed an HWND for a window resource specific to the Microsoft Windows platform. Apple の iOS (Cocoa) や Google の Android などの他のプラットフォームには、ウィンドウ リソースへの別のハンドルや参照があり、別の呼び出し構文が存在することもあります。Other platforms, such as Apple's iOS (Cocoa) and Google's Android, have different handles or references to window resources, and may have different calling syntax altogether. 表示を取得した後で初期化し、優先する構成を設定して、描画先のバック バッファーを持つサーフェスを作成します。After obtaining a display, you initialize it, set the preferred configuration, and create a surface with a back buffer you can draw into.

EGL を使った表示の取得と構成Obtaining a display and configuring it with 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;
}

Direct3D では、UWP アプリのメイン ウィンドウは CoreWindow オブジェクトで表されます。このオブジェクトは、Direct3D 向けに構築した "ビュー プロバイダー" の初期化プロセスの一環として CoreWindow::GetForCurrentThread を呼び出すことでアプリ オブジェクトから取得できます In Direct3D, a UWP app's main window is represented by the CoreWindow object, which can be obtained from the app object by calling CoreWindow::GetForCurrentThread as part of the initialization process of the "view provider" you construct for Direct3D. (Direct3D XAML 相互運用機能を使用している場合、XAML フレームワークのビュー プロバイダー使用)。Direct3D ビュー プロバイダーを作成するプロセスについてはビューを表示するアプリをセットアップする方法します。(If you are using Direct3D-XAML interop, you use the XAML framework's view provider.) The process for creating a Direct3D view provider is covered in How to set up your app to display a view.

Direct3D の CoreWindow の取得Obtaining a CoreWindow for Direct3D.

CoreWindow::GetForCurrentThread();

CoreWindow の参照を取得したら、ウィンドウをアクティブ化する必要があります。それにより、メイン オブジェクトの Run メソッドが実行され、ウィンドウ イベントの処理が開始されます。Once the CoreWindow reference is obtained, the window must be activated, which executes the Run method of your main object and begins window event processing. その後、作成、 ID3D11Device1 ID3D11DeviceContext1、それらを使用して、基になるかを取得してIDXGIDevice1 IDXGIAdapter 取得できるように、 IDXGIFactory2スワップ チェーンのリソースを作成するオブジェクトに基づく、 DXGI_スワップ_チェーン_DESC1 構成します。After that, create an ID3D11Device1 and an ID3D11DeviceContext1, and use them to get the underlying IDXGIDevice1 and IDXGIAdapter so you can obtain an IDXGIFactory2 object to create a swap chain resource based on your DXGI_SWAP_CHAIN_DESC1 configuration.

Direct3D の CoreWindow での DXGI スワップ チェーンの構成と設定Configuring and setting the DXGI swap chain on the CoreWindow for 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);
}

フレームを表示する準備をした後で IDXGISwapChain1::Present1 メソッドを呼び出します。Call the IDXGISwapChain1::Present1 method after you prepare a frame in order to display it.

Direct3D 11 には、EGLSurface と同じアブストラクションがないことに注意してください Note that in Direct3D 11, there isn't an abstraction identical to EGLSurface. (ある IDXGISurface1、異なる方法で使用されます)。最も近い概念的なものは、 ID3D11RenderTargetView テクスチャの割り当てに使用するオブジェクト (ID3D11Texture2D ) として、バック バッファー、シェーダーのパイプラインに図形を描画します。(There is IDXGISurface1, but it is used differently.) The closest conceptual approximation is the ID3D11RenderTargetView object that we use to assign a texture (ID3D11Texture2D) as the back buffer that our shader pipeline will draw into.

Direct3D 11 でのスワップ チェーンのバック バッファーの設定Setting up the back buffer for the swap chain 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);

ウィンドウが作成されたときや、ウィンドウのサイズが変更されたときに、その都度以下のコードを呼び出すことをお勧めします。A good practice is to call this code whenever the window is created or changes size. レンダリング中には、頂点バッファーやシェーダーなどの他のサブリソースを設定する前に、ID3D11DeviceContext1::OMSetRenderTargets でレンダー ターゲット ビューを設定します。During rendering, set the render target view with ID3D11DeviceContext1::OMSetRenderTargets before setting up any other subresources like vertex buffers or shaders.

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

レンダリング コンテキストの作成Creating a rendering context

EGL 1.4 では、"表示" は、ウィンドウ リソースのセットを表します。In EGL 1.4, a "display" represents a set of window resources. 通常は、表示のための "サーフェス" を構成するために、表示オブジェクトに一連の属性を提供し、サーフェスを取得します。Typically, you configure a "surface" for the display by supplying a set of attributes to the display object and getting a surface in return. サーフェスのコンテンツを表示するためのコンテキストを作成するには、そのコンテキストを作成したうえで、サーフェスと表示にバインドします。You create a context for displaying the contents of the surface by creating that context and binding it to the surface and the display.

呼び出しのフローは通常、次のようになります。The call flow usually looks similar to this:

  • 表示 (ウィンドウ リソース) へのハンドルを使って eglGetDisplay を呼び出し、表示オブジェクトを取得します。Call eglGetDisplay with the handle to a display or window resource and obtain a display object.
  • eglInitialize で表示を初期化します。Initialize the display with eglInitialize.
  • 使用できる表示の構成を取得し、eglGetConfigs と eglChooseConfig でそのいずれかを選びます。Obtain the available display configuration and select one with eglGetConfigs and eglChooseConfig.
  • eglCreateWindowSurface でウィンドウ サーフェスを作成します。Create a window surface with eglCreateWindowSurface.
  • eglCreateContext で描画用の表示コンテキストを作成します。Create a display context for drawing with eglCreateContext.
  • eglMakeCurrent で表示とサーフェスに表示コンテキストをバインドします。Bind the display context to the display and the surface with eglMakeCurrent.

前のセクションでは EGLDisplay と EGLSurface を作成しました。次に、EGLDisplay を使ってコンテキストを作成し、そのコンテキストを表示に関連付けます。それには、構成済みの EGLSurface を使って出力をパラメーター化します。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 parameterize the output.

EGL 1.4 でのレンダリング コンテキストの取得Obtaining a rendering context with 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;
}

Direct3D 11 のレンダリング コンテキストは、ID3D11Device1 オブジェクトで表されます。これはアダプターを表し、バッファーやシェーダーなどの Direct3D リソースを作成するために利用できます。Direct3D 11 のレンダリング コンテキストは ID3D11DeviceContext1 オブジェクトでも表され、これを使うと、グラフィックス パイプラインを管理し、シェーダーを実行できます。A rendering context in Direct3D 11 is represented by an ID3D11Device1 object, which represents the adapter and allows you to create Direct3D resources such as buffers and shaders; and by the ID3D11DeviceContext1 object, which allows you to manage the graphics pipeline and execute the shaders.

Direct3D の機能レベルに注意してください。Be aware of Direct3D feature levels! これらは、DirectX 9.1 から DirectX 11 までの Direct3D ハードウェア プラットフォームをサポートするために使われます。These are used to support older Direct3D hardware platforms, from DirectX 9.1 to DirectX 11. タブレットなど、低電力のグラフィックス ハードウェアを使う多くのプラットフォームは、DirectX 9.1 の機能にしかアクセスできません。サポートされている古いグラフィックス ハードウェアは、9.1 ~ 11 です。Many platforms that use low power graphics hardware, such as tablets, only have access to DirectX 9.1 features, and older supported graphics hardware could be from 9.1 through 11.

DXGI と Direct3D でのレンダリング コンテキストの作成Creating a rendering context with DXGI and 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 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.
);

テクスチャまたは pixmap リソースへの描画Drawing into a texture or pixmap resource

OpenGL ES 2.0 でテクスチャに描画するには、ピクセル バッファー (PBuffer) を構成します。To draw into a texture with OpenGL ES 2.0, configure a pixel buffer, or PBuffer. それに対して EGLSurface を正常に構成して作成したら、それにレンダリング コンテキストを提供し、シェーダー パイプラインを実行してテクスチャに描画できます。After you successfully a configure and create an EGLSurface for it you can supply it with a rendering context and execute the shader pipeline to draw into the texture.

OpenGL ES 2.0 でのピクセル バッファーへの描画Draw into a pixel buffer with 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); 

Direct3D 11 では、ID3D11Texture2D リソースを作成してそれをレンダー ターゲットにします。In Direct3D 11, you create an ID3D11Texture2D resource and makei it a render target. レンダー ターゲットを使用して、構成 D3D11_レンダリング_ターゲット_ビュー_DESCします。Configure the render target using D3D11_RENDER_TARGET_VIEW_DESC. 呼び出すと、 ID3D11DeviceContext::Draw メソッド (または類似の描画*デバイス コンテキストでの操作)、結果はこのレンダー ターゲットを使用して、テクスチャに描画されます。When you call the ID3D11DeviceContext::Draw method(or a similar Draw* operation on the device context) using this render target, the results are drawn into a texture.

Direct3D 11 でのテクスチャへの描画Draw into a texture with 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);

このテクスチャは、ID3D11ShaderResourceView に関連付けられている場合はシェーダーに渡すことができます。This texture can be passed to a shader if it is associated with an ID3D11ShaderResourceView.

画面への描画Drawing to the screen

EGLContext を使ってバッファーの構成とデータの更新を行ったら、それにバインドされているシェーダーを実行し、glDrawElements でバック バッファーに結果を描画します。Once you have used your EGLContext to configure your buffers and update your data, you run the shaders bound to it and draw the results to the back buffer with glDrawElements. eglSwapBuffers を呼び出してバック バッファーを表示します。You display the back buffer by calling eglSwapBuffers.

Opengl ES 2.0:画面に描画します。Open GL ES 2.0: Drawing to the screen.

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

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

Direct3D 11 では、IDXGISwapChain::Present1 でバッファーを構成してシェーダーにバインドします。In Direct3D 11, you configure your buffers and bind shaders with your IDXGISwapChain::Present1. いずれかを呼び出す、 ID3D11DeviceContext1::Draw *シェーダーを実行し、結果をスワップ チェーンのバック バッファーとして構成されているレンダー ターゲットに描画するメソッド。Then you call one of the ID3D11DeviceContext1::Draw* methods to run the shaders and draw the results to a render target configured as the back buffer for the swap chain. その後、単純に IDXGISwapChain::Present1 を呼び出してバック バッファーをディスプレイに表示します。After that, you simply present the back buffer to the display by calling IDXGISwapChain::Present1.

Direct3D 11。画面に描画します。Direct3D 11: Drawing to the screen.


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

// ...

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

グラフィックス リソースの解放Releasing graphics resources

EGL では、eglTerminate に EGLDisplay を渡して、ウィンドウ リソースを解放します。In EGL, you release the window resources by passing the EGLDisplay to eglTerminate.

EGL 1.4 での表示の終了Terminating a display with EGL 1.4

EGLBoolean eglTerminate(eglDisplay);

UWP アプリでは、CoreWindow::Close で CoreWindow を閉じることができますが、これはセカンダリ UI ウィンドウに対してのみ使うことができます。In a UWP app, you can close the CoreWindow with CoreWindow::Close, although this can only be used for secondary UI windows. プライマリ UI スレッドとその関連の CoreWindow は閉じることはできません。オペレーティング システムによって有効期限切れの処理が行われます。The primary UI thread and its associated CoreWindow cannot be closed; rather, they are expired by the operating system. ただし、セカンダリ CoreWindow が閉じると、CoreWindow::Closed イベントが発生します。However, when a secondary CoreWindow is closed, the CoreWindow::Closed event is raised.

EGL と Direct3D 11 のマッピングを示す API リファレンスAPI Reference mapping for EGL to Direct3D 11

EGL APIEGL API 同様の Direct3D 11 API または動作Similar Direct3D 11 API or behavior
eglBindAPIeglBindAPI 該当なし。N/A.
eglBindTexImageeglBindTexImage ID3D11Device::CreateTexture2D を呼び出して 2D テクスチャを設定します。Call ID3D11Device::CreateTexture2D to set a 2D texture.
eglChooseConfigeglChooseConfig Direct3D は一連の既定のフレーム バッファー構成を提供しません。Direct3D does not supply a set of default frame buffer configurations. スワップ チェーンの構成The swap chain's configuration
eglCopyBufferseglCopyBuffers バッファー データをコピーするには、ID3D11DeviceContext::CopyStructureCount を呼び出します。To copy a buffer data, call ID3D11DeviceContext::CopyStructureCount. リソースをコピーするには、ID3DDeviceCOntext::CopyResource を呼び出します。To copy a resource, call ID3DDeviceCOntext::CopyResource.
eglCreateContexteglCreateContext Direct3D デバイス コンテキストを作成するには、D3D11CreateDevice を呼び出します。これは、Direct3D デバイスへのハンドルと既定の Direct3D イミディエイト コンテキスト (ID3D11DeviceContext1 オブジェクト) の両方を返します。Create a Direct3D device context by calling D3D11CreateDevice, which returns both a handle to a Direct3D device and a default Direct3D immediate context (ID3D11DeviceContext1 object). 返された ID3D11Device1 オブジェクトで ID3D11Device2::CreateDeferredContext を呼び出して、Direct3D 遅延コンテキストを作成することもできます。You can also create a Direct3D deferred context by calling ID3D11Device2::CreateDeferredContext on the returned ID3D11Device1 object.
eglCreatePbufferFromClientBuffereglCreatePbufferFromClientBuffer すべてのバッファーは、ID3D11Texture2D などの Direct3D サブリソースとして、読み取りと書き込みが行われます。All buffers are read and written as a Direct3D subresource, such as an ID3D11Texture2D. ID3D11DeviceContext1:CopyResource などのメソッドを使って、互換性のあるサブリソース型の間でコピーします。Copy from one to another compatible subresource type with a methods such as ID3D11DeviceContext1:CopyResource.
eglCreatePbufferSurfaceeglCreatePbufferSurface スワップ チェーンなしで Direct3D デバイスを作成するには、D3D11CreateDevice 静的メソッドを呼び出します。To create a Direct3D device with no swap chain, call the static D3D11CreateDevice method. Direct3D レンダー ターゲット ビューでは、ID3D11Device::CreateRenderTargetView を呼び出します。For a Direct3D render target view, call ID3D11Device::CreateRenderTargetView.
eglCreatePixmapSurfaceeglCreatePixmapSurface スワップ チェーンなしで Direct3D デバイスを作成するには、D3D11CreateDevice 静的メソッドを呼び出します。To create a Direct3D device with no swap chain, call the static D3D11CreateDevice method. Direct3D レンダー ターゲット ビューでは、ID3D11Device::CreateRenderTargetView を呼び出します。For a Direct3D render target view, call ID3D11Device::CreateRenderTargetView.
eglCreateWindowSurfaceeglCreateWindowSurface IDXGISwapChain1 (表示バッファー向け) と ID3D11Device1 (グラフィックス デバイスとそのリソースの仮想インターフェイス) を取得します。Ontain an IDXGISwapChain1 (for the display buffers) and an ID3D11Device1 (a virtual interface for the graphics device and its resources). IDXGISwapChain1 に提供するフレーム バッファーを作成するために使用できる ID3D11RenderTargetView を定義するには、ID3D11Device1 を使います。Use the ID3D11Device1 to define an ID3D11RenderTargetView that you can use to create the frame buffer you supply to the IDXGISwapChain1.
eglDestroyContexteglDestroyContext 該当なし。N/A. レンダー ターゲット ビューを削除するには、ID3D11DeviceContext::DiscardView1 を使います。Use ID3D11DeviceContext::DiscardView1 to get rid of a render target view. ID3D11DeviceContext1 を閉じるには、インスタンスを null に設定し、プラットフォームがそのリソースを再利用するまで待機します。To close the parent ID3D11DeviceContext1, set the instance to null and wait for the platform to reclaim its resources. デバイス コンテキストを直接破棄することはできません。You cannot destroy the device context directly.
eglDestroySurfaceeglDestroySurface 該当なし。N/A. グラフィックス リソースは、UWP アプリの CoreWindow がプラットフォームによって閉じられたときにクリーンアップされます。Graphics resources are cleaned up when the UWP app's CoreWindow is closed by the platform.
eglGetCurrentDisplayeglGetCurrentDisplay 現在のメイン アプリ ウィンドウへの参照を取得するには、CoreWindow::GetForCurrentThread を呼び出します。Call CoreWindow::GetForCurrentThread to get a reference to the current main app window.
eglGetCurrentSurfaceeglGetCurrentSurface これが現在の ID3D11RenderTargetView です。This is the current ID3D11RenderTargetView. 通常、これのスコープはレンダラー オブジェクトに限定されます。Typically, this is scoped to your renderer object.
eglGetErroreglGetError エラーは、DirectX インターフェイスのほとんどのメソッドによって返される HRESULT として取得されます。Errors are obtained as HRESULTs returned by most methods on DirectX interfaces. メソッドから HRESULT が返されない場合は、GetLastError を呼び出します。If the method does not return an HRESULT, call GetLastError. HRESULT 値にシステム エラーに変換する、 HRESULT_FROM_WIN32 マクロ。To convert a system error into an HRESULT value, use the HRESULT_FROM_WIN32 macro.
eglInitializeeglInitialize 現在のメイン アプリ ウィンドウへの参照を取得するには、CoreWindow::GetForCurrentThread を呼び出します。Call CoreWindow::GetForCurrentThread to get a reference to the current main app window.
eglMakeCurrenteglMakeCurrent ID3D11DeviceContext1::OMSetRenderTargets を使って、現在のコンテキストに描画するためのレンダー ターゲットを設定します。Set a render target for drawing on the current context with ID3D11DeviceContext1::OMSetRenderTargets.
eglQueryContexteglQueryContext 該当なし。N/A. ただし、ID3D11Device1 インスタンスからレンダリング ターゲットと一部の構成データを取得できます However, you may acquire rendering targets from an ID3D11Device1 instance, as well as some configuration data. (利用できるメソッドの一覧については、リンクをご覧ください)。(See the link for the list of available methods.)
eglQuerySurfaceeglQuerySurface 該当なし。N/A. ただし、ID3D11Device1 インスタンスのメソッドからビューポートと現在のグラフィックス ハードウェアに関するデータを取得できます However, you may acquire data about viewports and the current graphics hardware from methods on an ID3D11Device1 instance. (利用できるメソッドの一覧については、リンクをご覧ください)。(See the link for the list of available methods.)
eglReleaseTexImageeglReleaseTexImage 該当なし。N/A.
eglReleaseThreadeglReleaseThread 一般的な GPU マルチスレッドについては、「マルチスレッド」をご覧ください。For general GPU multithreading, read Multithreading.
eglSurfaceAttribeglSurfaceAttrib 使用 D3D11_レンダリング_ターゲット_ビュー_DESC Direct3D のレンダー ターゲット ビューを構成するにはUse D3D11_RENDER_TARGET_VIEW_DESC to configure a Direct3D render target view,
eglSwapBufferseglSwapBuffers IDXGISwapChain1::Present1 を使います。Use IDXGISwapChain1::Present1.
eglSwapIntervaleglSwapInterval IDXGISwapChain1」をご覧ください。See IDXGISwapChain1.
eglTerminateeglTerminate グラフィックス パイプラインの出力を表示するために使う CoreWindow は、オペレーティング システムによって管理されます。The CoreWindow used to display the output of the graphics pipeline is managed by the operating system.
eglWaitClienteglWaitClient 共有サーフェスについては、IDXGIKeyedMutex を使います。For shared surfaces, use IDXGIKeyedMutex. 一般的な GPU マルチスレッドについては、「マルチスレッド」をご覧ください。For general GPU multithreading, read Multithreading.
eglWaitGLeglWaitGL 共有サーフェスについては、IDXGIKeyedMutex を使います。For shared surfaces, use IDXGIKeyedMutex. 一般的な GPU マルチスレッドについては、「マルチスレッド」をご覧ください。For general GPU multithreading, read Multithreading.
eglWaitNativeeglWaitNative 共有サーフェスについては、IDXGIKeyedMutex を使います。For shared surfaces, use IDXGIKeyedMutex. 一般的な GPU マルチスレッドについては、「マルチスレッド」をご覧ください。For general GPU multithreading, read Multithreading.