Swap chain scaling and overlays

Artigo
10/13/2015

[This article is for Windows 8.x and Windows Phone 8.x developers writing Windows Runtime apps. If you’re developing for Windows 10, see the latest documentation]

Learn how to create scaled swap chains for faster rendering on mobile devices, and use overlay swap chains (when available) to increase visual quality.

Swap chains in DirectX 11.2

Direct3D 11.2 allows you to create Windows Store apps with swap chains that are scaled up from non-native (reduced) resolutions, enabling faster fill rates. Direct3D 11.2 also includes APIs for rendering with hardware overlays so that you can present a UI in another swap chain at native resolution. This allows your game to draw UI at full native resolution while maintaining a high framerate, thereby making the best use of mobile devices and high DPI displays (such as 3840 by 2160). This article explains how to use overlapping swap chains.

Direct3D 11.2 also introduces a new feature for reduced latency with flip model swap chains. See Reduce latency with DXGI 1.3 swap chains.

This walkthrough uses code from the DirectX Foreground Swap Chains sample.

Use swap chain scaling

When your game is running on downlevel hardware - or hardware optimized for power savings - it can be beneficial to render real-time game content at a lower resolution than the display is natively capable of. To do this, the swap chain used for rendering game content must be smaller than the native resolution, or a subregion of the swapchain must be used.

First, create a swap chain at full native resolution.

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 Windows Store apps must use this SwapEffect.
swapChainDesc.Flags = 0;
swapChainDesc.Scaling = DXGI_SCALING_STRETCH;

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

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

ComPtr<IDXGIFactory2> dxgiFactory;
DX::ThrowIfFailed(
    dxgiAdapter->GetParent(IID_PPV_ARGS(&dxgiFactory))
    );

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

DX::ThrowIfFailed(
    swapChain.As(&m_swapChain)
    );

Then, choose a subregion of the swap chain to scale up by setting the source size to a reduced resolution.

The DX Foreground Swap Chains sample calculates a reduced size based on a percentage:

m_d3dRenderSizePercentage = percentage;

UINT renderWidth = static_cast<UINT>(m_d3dRenderTargetSize.Width * percentage + 0.5f);
UINT renderHeight = static_cast<UINT>(m_d3dRenderTargetSize.Height * percentage + 0.5f);

// Change the region of the swap chain that will be presented to the screen.
DX::ThrowIfFailed(
    m_swapChain->SetSourceSize(
        renderWidth,
        renderHeight
        )
    );

Create a viewport to match the subregion of the swap chain.

// In Direct3D, change the Viewport to match the region of the swap
// chain that will now be presented from.
m_screenViewport = CD3D11_VIEWPORT(
    0.0f,
    0.0f,
    static_cast<float>(renderWidth),
    static_cast<float>(renderHeight)
    );

m_d3dContext->RSSetViewports(1, &m_screenViewport);

If Direct2D is being used, the rotation transform needs to be adjusted to compensate for the source region.

Create a hardware overlay swap chain for UI elements

When using swap chain scaling, there is an inherent disadvantage in that the UI is also scaled down, potentially making it blurry and harder to use. On devices with hardware support for overlay swap chains, this problem is alleviated entirely by rendering the UI at native resolution in a swap chain that's separate from the real-time game content. Note that this technique applies only to CoreWindow swap chains - it cannot be used with XAML interop.

Use the following steps to create a foreground swap chain that uses hardware overlay capability. These steps are performed after first creating a swap chain for real-time game content as described above.

First, determine whether the DXGI adapter supports overlays. Get the DXGI output adapter from the swap chain:
```
ComPtr<IDXGIAdapter> outputDxgiAdapter;
DX::ThrowIfFailed(
    dxgiFactory->EnumAdapters(0, &outputDxgiAdapter)
    );

ComPtr<IDXGIOutput> dxgiOutput;
DX::ThrowIfFailed(
    outputDxgiAdapter->EnumOutputs(0, &dxgiOutput)
    );

ComPtr<IDXGIOutput2> dxgiOutput2;
DX::ThrowIfFailed(
    dxgiOutput.As(&dxgiOutput2)
    );
```
The DXGI adapter supports overlays if the output adapter returns True for SupportsOverlays.
```
m_overlaySupportExists = dxgiOutput2->SupportsOverlays() ? true : false;
```
Note If the DXGI adapter supports overlays, continue to the next step. If the device does not support overlays, rendering with multiple swap chains will not be efficient. Instead, render the UI at reduced resolution in the same swap chain as real-time game content. See the DirectX Foreground Swap Chains sample for an example of how to fall back to a single swap chain.

Create the foreground swap chain with IDXGIFactory2::CreateSwapChainForCoreWindow. The following options must be set in the DXGI_SWAP_CHAIN_DESC1 supplied to the pDesc parameter:

Specify the DXGI_SWAP_CHAIN_FLAG_FOREGROUND_LAYER swap chain flag to indicate a foreground swap chain.
Use the DXGI_ALPHA_MODE_PREMULTIPLIED alpha mode flag. Foreground swap chains are always premultiplied.
Set the DXGI_SCALING_NONE flag. Foreground swap chains always run at native resolution.

 foregroundSwapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_FOREGROUND_LAYER;
 foregroundSwapChainDesc.Scaling = DXGI_SCALING_NONE;
 foregroundSwapChainDesc.AlphaMode = DXGI_ALPHA_MODE_PREMULTIPLIED; // Foreground swap chain alpha values must be premultiplied.

Note Set the DXGI_SWAP_CHAIN_FLAG_FOREGROUND_LAYER again every time the swap chain is resized.

HRESULT hr = m_foregroundSwapChain->ResizeBuffers(
    2, // Double-buffered swap chain.
    static_cast<UINT>(m_d3dRenderTargetSize.Width),
    static_cast<UINT>(m_d3dRenderTargetSize.Height),
    DXGI_FORMAT_B8G8R8A8_UNORM,
    DXGI_SWAP_CHAIN_FLAG_FOREGROUND_LAYER // The FOREGROUND_LAYER flag cannot be removed with ResizeBuffers.
    );

When two swap chains are being used, increase the maximum frame latency to 2 so that the DXGI adapter has time to present both swap chains simultaneously (within the same VSync interval).

// Create a render target view of the foreground swap chain's back buffer.
if (m_foregroundSwapChain)
{
    ComPtr<ID3D11Texture2D> foregroundBackBuffer;
    DX::ThrowIfFailed(
        m_foregroundSwapChain->GetBuffer(0, IID_PPV_ARGS(&foregroundBackBuffer))
        );

    DX::ThrowIfFailed(
        m_d3dDevice->CreateRenderTargetView(
            foregroundBackBuffer.Get(),
            nullptr,
            &m_d3dForegroundRenderTargetView
            )
        );
}

Foreground swap chains always use premultiplied alpha. Each pixel's color values are expected to be already multiplied by the alpha value before the frame is presented. For example, a 100% white BGRA pixel at 50% alpha is set to (0.5, 0.5, 0.5, 0.5).

The alpha premultiplication step can be done in the output-merger stage by applying an app blend state (see ID3D11BlendState) with the D3D11_RENDER_TARGET_BLEND_DESC structure's SrcBlend field set to D3D11_SRC_ALPHA. Assets with pre-multiplied alpha values can also be used.

If the alpha premultiplication step is not done, colors on the foreground swap chain will be brighter than expected.

Depending on whether the foreground swap chain was created, the Direct2D drawing surface for UI elements might need be associated with the foreground swap chain.

Creating render target views:

// Create a render target view of the foreground swap chain's back buffer.
if (m_foregroundSwapChain)
{
    ComPtr<ID3D11Texture2D> foregroundBackBuffer;
    DX::ThrowIfFailed(
        m_foregroundSwapChain->GetBuffer(0, IID_PPV_ARGS(&foregroundBackBuffer))
        );

    DX::ThrowIfFailed(
        m_d3dDevice->CreateRenderTargetView(
            foregroundBackBuffer.Get(),
            nullptr,
            &m_d3dForegroundRenderTargetView
            )
        );
}

// Create a render target view of the swap chain's back buffer.
ComPtr<ID3D11Texture2D> backBuffer;
DX::ThrowIfFailed(
    m_swapChain->GetBuffer(0, IID_PPV_ARGS(&backBuffer))
    );

DX::ThrowIfFailed(
    m_d3dDevice->CreateRenderTargetView(
        backBuffer.Get(),
        nullptr,
        &m_d3dRenderTargetView
        )
    );

Creating the Direct2D drawing surface:

if (m_foregroundSwapChain)
{
    // Create Direct2D target bitmap for foreground swap chain.
    ComPtr<IDXGISurface2> dxgiForegroundSwapChainBackBuffer;
    DX::ThrowIfFailed(
        m_foregroundSwapChain->GetBuffer(0, IID_PPV_ARGS(&dxgiForegroundSwapChainBackBuffer))
        );

    DX::ThrowIfFailed(
        m_d2dContext->CreateBitmapFromDxgiSurface(
            dxgiForegroundSwapChainBackBuffer.Get(),
            &bitmapProperties,
            &m_d2dTargetBitmap
            )
        );
}
else
{
    // Create Direct2D target bitmap for swap chain.
    ComPtr<IDXGISurface2> dxgiSwapChainBackBuffer;
    DX::ThrowIfFailed(
        m_swapChain->GetBuffer(0, IID_PPV_ARGS(&dxgiSwapChainBackBuffer))
        );

    DX::ThrowIfFailed(
        m_d2dContext->CreateBitmapFromDxgiSurface(
            dxgiSwapChainBackBuffer.Get(),
            &bitmapProperties,
            &m_d2dTargetBitmap
            )
        );
}

m_d2dContext->SetTarget(m_d2dTargetBitmap.Get());

Present the foreground swap chain together with the scaled swap chain used for real-time game content. Since frame latency was set to 2 for both swap chains, DXGI can present them both within the same VSync interval.

The DirectX Foreground Swap Chains sample modifies DeviceResources.cpp as follows to present the foreground swap chain:

// Present the contents of the swap chain to the screen.
void DX::DeviceResources::Present()
{
    // The first argument instructs DXGI to block until VSync, putting the application
    // to sleep until the next VSync. This ensures we don't waste any cycles rendering
    // frames that will never be displayed to the screen.
    HRESULT hr = m_swapChain->Present(1, 0);

    if (SUCCEEDED(hr) && m_foregroundSwapChain)
    {
        m_foregroundSwapChain->Present(1, 0);
    }

    // Discard the contents of the render targets.
    // This is a valid operation only when the existing contents will be entirely
    // overwritten. If dirty or scroll rects are used, this call should be removed.
    m_d3dContext->DiscardView(m_d3dRenderTargetView.Get());
    if (m_foregroundSwapChain)
    {
        m_d3dContext->DiscardView(m_d3dForegroundRenderTargetView.Get());
    }

    // Discard the contents of the depth stencil.
    m_d3dContext->DiscardView(m_d3dDepthStencilView.Get());

    // If the device was removed either by a disconnection or a driver upgrade, we
    // must recreate all device resources.
    if (hr == DXGI_ERROR_DEVICE_REMOVED)
    {
        HandleDeviceLost();
    }
    else
    {
        DX::ThrowIfFailed(hr);
    }
}

Compartilhar via

Swap chain scaling and overlays

Swap chains in DirectX 11.2

Use swap chain scaling

Create a hardware overlay swap chain for UI elements

Recursos adicionais