9 min read

(For more resources related to this topic, see here.)

Preparing the swap chain for a Windows Store app

Getting ready

To target Windows 8.1, we need to use Visual Studio 2013. For the remainder of the article, we will assume that these can be located upon navigating to .ExternalBinDirectX11_2-Signed-winrt under the solution location.

How to do it…

We’ll begin by creating a new class library and reusing a majority of the Common project used throughout the book so far, then we will create a new class D3DApplicationWinRT inheriting from D3DApplicationBase to be used as a starting point for our Windows Store app’s render targets.

  1. Within Visual Studio, create a new Class Library (Windows Store apps) called Common.WinRT.


    New Project dialog to create a class library project for Windows Store apps

  2. Add references to the following SharpDX assemblies: SharpDX.dll, SharpDX.D3DCompiler.dll, SharpDX.Direct2D1.dll, SharpDX.Direct3D11.dll, and SharpDX.DXGI within .ExternalBinDirectX11_2-Signed-winrt.
  3. Right-click on the new project; navigate to Add | Existing item… ; and select the following files from the existing Common project: D3DApplicationBase.cs, DeviceManager.cs, Mesh.cs, RendererBase.cs, and HLSLFileIncludeHandlers.hlsl, and optionally, FpsRenderer.cs and TextRenderer.cs.
  4. Instead of duplicating the files, we can choose to Add As Link within the file selection dialog, as shown in the following screenshot:


    Files can be added as a link instead of a copy

  5. Any platform-specific code can be wrapped with a check for the NETFX_CORE definition, as shown in the following snippet: 
    #if NETFX_CORE
    ...Windows Store app code
#else
    ...Windows Desktop code
#endif
  6. Add a new C# abstract class called D3DApplicationWinRT. 
    // Implements support for swap chain description for 
// Windows Store apps
public abstract class D3DApplicationWinRT
    : D3DApplicationBase
{
...
}
  7. In order to reduce the chances of our app being terminated to reclaim system resources, we will use the new SharpDX.DXGI.Device3.Trim function whenever our app is suspended (native equivalent is IDXGIDevice3::Trim). The following code shows how this is done: 
    public D3DApplicationWinRT()
    : base()
{
    // Register application suspending event
    Windows.ApplicationModel.Core
        .CoreApplication.Suspending += OnSuspending;
}
// When suspending hint that resources may be reclaimed
private void OnSuspending(Object sender, Windows.ApplicationModel.
    SuspendingEventArgs e)
{
    // Retrieve the DXGI Device3 interface from our 
    // existing Direct3D device.
    using (SharpDX.DXGI.Device3 dxgiDevice = DeviceManager
.Direct3DDevice.QueryInterface<SharpDX.DXGI.Device3>())
    {
        dxgiDevice.Trim(); 
    }
}
  8. The existing D3DApplicationBase.CreateSwapChainDescription function is not compatible with Windows Store apps. Therefore, we will override this and create a SwapChainDescription1 instance that is compatible with Windows Store apps. The following code shows the changes necessary: 
    protected override SharpDX.DXGI.SwapChainDescription1 CreateSwapChainDescription()
{
    var desc = new SharpDX.DXGI.SwapChainDescription1()
    {
        Width = Width,
        Height = Height,
        Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm,
        Stereo = false,
        SampleDescription.Count = 1,
        SampleDescription.Quality = 0,
        Usage = SharpDX.DXGI.Usage.BackBuffer | 
            SharpDX.DXGI.Usage.RenderTargetOutput,
        Scaling = SharpDX.DXGI.Scaling.Stretch,
        BufferCount = 2, 
        SwapEffect = SharpDX.DXGI.SwapEffect.FlipSequential, 
        Flags = SharpDX.DXGI.SwapChainFlags.None
    };
    return desc;
}
  9. We will not be implementing the Direct3D render loop within a Run method for our Windows Store apps—this is because we will use the existing composition events where appropriate. Therefore, we will create a new abstract method Render and provide a default empty implementation of Run. 
    public abstract void Render();

[Obsolete("Use the Render method for WinRT", true)]
public override void Run()
{ }

How it works…

As of Windows 8.1 and DirectX Graphics Infrastructure (DXGI) 1.3, all Direct3D devices created by our Windows Store apps should call SharpDX.DXGI.Device3.Trim when suspending to reduce the memory consumed by the app and graphics driver. This reduces the chance that our app will be terminated to reclaim resources while it is suspended—although our application should consider destroying other resources as well. When resuming, drivers that support trimming will recreate the resources as required.

We have used Windows.ApplicationModel.Core.CoreApplication rather than Windows.UI.Xaml.Application for the Suspending event, so that we can use the class for both an XAML-based Direct3D app as well as one that implements its own Windows.ApplicationModel.Core.IFrameworkView in order to render to CoreWindow directly.

Windows Store apps only support a flip presentation model and therefore require that the swap chain is created using a SharpDX.DXGI.SwapEffect.FlipSequential swap effect; this in turn requires between two and 16 buffers specified in the SwapChainDescription1.BufferCount property. When using a flip model, it is also necessary to specify the SwapChainDescription1.SampleDescription property with Count=1 and Quality=0, as multisample anti-aliasing (MSAA) is not supported on the swap chain buffers themselves. A flip presentation model avoids unnecessarily copying the swap-chain buffer and increases the performance.

By removing Windows 8.1 specific calls (such as the SharpDX.DXGI.Device3.Trim method), it is also possible to implement this recipe using Direct3D 11.1 for Windows Store apps that target Windows 8.

See also

Rendering to a CoreWindow

The XAML view provider found in the Windows Store app graphics framework cannot be modified. Therefore, when we want to implement the application’s graphics completely within DirectX/Direct3D without XAML interoperation, it is necessary to create a basic view provider that allows us to connect our DirectX graphics device resources to the windowing infrastructure of our Windows Store app.

In this recipe, we will implement a CoreWindow swap-chain target and look at how to hook Direct3D directly to the windowing infrastructure of a Windows Store app, which is exposed by the CoreApplication, IFrameworkViewSource, IFrameworkView, and CoreWindow .NET types.

This recipe continues from where we left off with the Preparing the swap chain for Windows Store apps recipe.

How to do it…

We will first update the Common.WinRT project to support the creation of a swap chain for a Windows Store app’s CoreWindow instance and then implement a simple Hello World application.

  1. Let’s begin by creating a new abstract class within the Common.WinRT project, called D3DAppCoreWindowTarget and descending from the D3DApplicationWinRT class from our previous recipe. The default constructor accepts the CoreWindow instance and attaches a handler to its SizeChanged event. 
    using Windows.UI.Core;
using SharpDX;
using SharpDX.DXGI;
...
public abstract class D3DAppCoreWindowTarget
    : D3DApplicationWinRT
{
    // The CoreWindow this instance renders to
    private CoreWindow _window;
    public CoreWindow Window { get { return _window; } }

    public D3DAppCoreWindowTarget(CoreWindow window)
    {
        _window = window;
        Window.SizeChanged += (sender, args) =>
        {
            SizeChanged();
        };
    }
...
}
  2. Within our new class, we will now override the CurrentBounds property and the CreateSwapChain function in order to return the correct size and create the swap chain for the associated CoreWindow. 
    // Retrieve current bounds of CoreWindow
public override SharpDX.Rectangle CurrentBounds
{   get
    {
        return new SharpDX.Rectangle( (int)_window.Bounds.X, (int)_window.Bounds.Y,
               (int)_window.Bounds.Width, (int)_window.Bounds.Height);
    }
}
// Create the swap chain
protected override SharpDX.DXGI.SwapChain1 CreateSwapChain( 
    SharpDX.DXGI.Factory2 factory, 
    SharpDX.Direct3D11.Device1 device, 
    SharpDX.DXGI.SwapChainDescription1 desc)
{
    // Create the swap chain for the CoreWindow
    using (var coreWindow = new ComObject(_window))
        return new SwapChain1(factory, device, coreWindow, 
          ref desc);
}

    This completes the changes to our Common.WinRT project. Next, we will create a Hello World Direct3D Windows Store app rendering directly to the application’s CoreWindow instance.

  3. Visual Studio 2013 does not provide us with a suitable C# project template to create a non-XAML Windows Store app, so we will begin by creating a new C# Windows Store Blank App (XAML) project.
  4. Add references to the SharpDX assemblies: SharpDX.dll, SharpDX.Direct3D11.dll, SharpDX.D3DCompiler.dll, and SharpDX.DXGI.dll. Also, add a reference to the Common.WinRT project.
  5. Next, we remove the two XAML files from the project: App.xaml and MainPage.xaml.
  6. We will replace the previous application entry point, App.xaml, with a new static class called App. This will house the main entry point for our application where we start our Windows Store app using a custom view provider, as shown in the following snippet: 
    using Windows.ApplicationModel.Core;
using Windows.Graphics.Display;
using Windows.UI.Core;
...
internal static class App
{
    [MTAThread] 
    private static void Main()
    {
        var viewFactory = new D3DAppViewProviderFactory();
        CoreApplication.Run(viewFactory);
    }
    // The custom view provider factory
    class D3DAppViewProviderFactory : IFrameworkViewSource
    {
        public IFrameworkView CreateView()
        {
            return new D3DAppViewProvider();
        }
    }

    class D3DAppViewProvider 
        : SharpDX.Component, IFrameworkView
    {
        ...
    } 
}
  7. The implementation of the IFrameworkView members of D3DAppViewProvider allows us to initialize an instance of a concrete descendent of the D3DAppCoreWindowTarget class within SetWindow and to implement the main application loop in the Run method. 
    Windows.UI.Core.CoreWindow window;
    D3DApp d3dApp; // descends from D3DAppCoreWindowTarget     
public void Initialize(CoreApplicationView applicationView) 
{ }
public void Load(string entryPoint) { }
public void SetWindow(Windows.UI.Core.CoreWindow window)
{    RemoveAndDispose(ref d3dApp);
    this.window = window;
    d3dApp = ToDispose(new D3DApp(window));
    d3dApp.Initialize(); 
}
public void Uninitialize() { }
public void Run()
{
    // Specify the cursor type as the standard arrow.
    window.PointerCursor = new CoreCursor( 
        CoreCursorType.Arrow, 0);

    // Activate the application window, making it visible 
    // and enabling it to receive events.
    window.Activate();

    // Set the DPI and handle changes
    d3dApp.DeviceManager.Dpi = Windows.Graphics.Display
      .DisplayInformation.GetForCurrentView().LogicalDpi;
    Windows.Graphics.Display.DisplayInformation
      .GetForCurrentView().DpiChanged += (sender, args) => 
    {
      d3dApp.DeviceManager.Dpi = Windows.Graphics.Display
        .DisplayInformation.GetForCurrentView().LogicalDpi;
    };

    // Enter the render loop. Note that Windows Store apps 
    // should never exit here.
    while (true)
    {
        // Process events incoming to the window.
        window.Dispatcher.ProcessEvents(
            CoreProcessEventsOption.ProcessAllIfPresent);
        // Render frame
        d3dApp.Render(); 
    }
}
  8. The D3DApp class follows the same structure from our previous recipes throughout the book. There are only a few minor differences as highlighted in the following code snippet: 
    class D3DApp: Common.D3DAppCoreWindowTarget 
{
    public D3DApp(Windows.UI.Core.CoreWindow window)
        : base(window)
    { this.VSync=true; }

    // Private member fields
    ...

    protected override void CreateDeviceDependentResources(
        Common.DeviceManager deviceManager)
    {
        ... create all device resources
        ... and create renderer instances here 
    }
    // Render frame
    public override void Render()
    {
        var context = this.DeviceManager.Direct3DContext;

        // OutputMerger targets must be set every frame 
        context.OutputMerger.SetTargets(  
          this.DepthStencilView, this.RenderTargetView); 

        // Clear depthstencil and render target
        context.ClearDepthStencilView( 
          this.DepthStencilView, 
          SharpDX.Direct3D11.DepthStencilClearFlags.Depth | 
          SharpDX.Direct3D11.DepthStencilClearFlags.Stencil
          , 1.0f, 0);
        context.ClearRenderTargetView( 
          this.RenderTargetView, SharpDX.Color.LightBlue);

        ... setup context pipeline state
        ... perform rendering commands

        // Present the render target
        Present();
    }
}
  9. The following screenshot shows an example of the output using CubeRenderer, and overlaying the 2D text with the TextRenderer class:


    Output from the simple Hello World sample using the CoreWindow render target

Packt

LEAVE A REPLY

Please enter your comment!
Please enter your name here