Instruções passo a passo: hospedando conteúdo de Direct3D9 no WPF

  • Artigo

Esta instrução passo a passo mostra como hospedar o conteúdo Direct3D9 em um aplicativo do Windows Presentation Foundation (WPF).

Neste passo a passo, você executará as seguintes tarefas:

  • Crie um projeto WPF para hospedar o conteúdo Direct3D9.

  • Importe o conteúdo Direct3D9.

  • Exiba o conteúdo do Direct3D9 usando a D3DImage classe.

Quando tiver terminado, você saberá como hospedar conteúdo Direct3D9 em um aplicativo WPF.

Pré-requisitos

Você precisará dos seguintes componentes para concluir este passo a passo:

Criando o projeto WPF

A primeira etapa é criar o projeto do aplicativo do WPF.

Para criar o projeto WPF

Crie um novo projeto de aplicativo do WPF no Visual C#, chamado D3DHost. Para obter mais informações, confira Passo a passo: Meu primeiro aplicativo de área de trabalho do WPF.

MainWindow.xaml é aberto no WPF Designer.

Importando o conteúdo Direct3D9

Importar o conteúdo Direct3D9 de uma DLL não gerenciada usando o DllImport atributo.

Para importar o conteúdo Direct3D9

  1. Abra MainWindow.xaml.cs no Editor de códigos.

  2. Substitua o código gerado automaticamente pelo código a seguir.

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Windows.Threading;
using System.Runtime.InteropServices;
using System.Security.Permissions;

namespace D3DHost
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            // Set up the initial state for the D3DImage.
            HRESULT.Check(SetSize(512, 512));
            HRESULT.Check(SetAlpha(false));
            HRESULT.Check(SetNumDesiredSamples(4));

            //
            // Optional: Subscribing to the IsFrontBufferAvailableChanged event.
            //
            // If you don't render every frame (e.g. you only render in
            // reaction to a button click), you should subscribe to the
            // IsFrontBufferAvailableChanged event to be notified when rendered content
            // is no longer being displayed. This event also notifies you when
            // the D3DImage is capable of being displayed again.

            // For example, in the button click case, if you don't render again when
            // the IsFrontBufferAvailable property is set to true, your
            // D3DImage won't display anything until the next button click.
            //
            // Because this application renders every frame, there is no need to
            // handle the IsFrontBufferAvailableChanged event.
            //
            CompositionTarget.Rendering += new EventHandler(CompositionTarget_Rendering);

            //
            // Optional: Multi-adapter optimization
            //
            // The surface is created initially on a particular adapter.
            // If the WPF window is dragged to another adapter, WPF
            // ensures that the D3DImage still shows up on the new
            // adapter.
            //
            // This process is slow on Windows XP.
            //
            // Performance is better on Vista with a 9Ex device. It's only
            // slow when the D3DImage crosses a video-card boundary.
            //
            // To work around this issue, you can move your surface when
            // the D3DImage is displayed on another adapter. To
            // determine when that is the case, transform a point on the
            // D3DImage into screen space and find out which adapter
            // contains that screen space point.
            //
            // When your D3DImage straddles two adapters, nothing
            // can be done, because one will be updating slowly.
            //
            _adapterTimer = new DispatcherTimer();
            _adapterTimer.Tick += new EventHandler(AdapterTimer_Tick);
            _adapterTimer.Interval = new TimeSpan(0, 0, 0, 0, 500);
            _adapterTimer.Start();

            //
            // Optional: Surface resizing
            //
            // The D3DImage is scaled when WPF renders it at a size
            // different from the natural size of the surface. If the
            // D3DImage is scaled up significantly, image quality
            // degrades.
            //
            // To avoid this, you can either create a very large
            // texture initially, or you can create new surfaces as
            // the size changes. Below is a very simple example of
            // how to do the latter.
            //
            // By creating a timer at Render priority, you are guaranteed
            // that new surfaces are created while the element
            // is still being arranged. A 200 ms interval gives
            // a good balance between image quality and performance.
            // You must be careful not to create new surfaces too
            // frequently. Frequently allocating a new surface may
            // fragment or exhaust video memory. This issue is more
            // significant on XDDM than it is on WDDM, because WDDM
            // can page out video memory.
            //
            // Another approach is deriving from the Image class,
            // participating in layout by overriding the ArrangeOverride method, and
            // updating size in the overriden method. Performance will degrade
            // if you resize too frequently.
            //
            // Blurry D3DImages can still occur due to subpixel
            // alignments.
            //
            _sizeTimer = new DispatcherTimer(DispatcherPriority.Render);
            _sizeTimer.Tick += new EventHandler(SizeTimer_Tick);
            _sizeTimer.Interval = new TimeSpan(0, 0, 0, 0, 200);
            _sizeTimer.Start();
        }

        ~MainWindow()
        {
            Destroy();
        }

        void AdapterTimer_Tick(object sender, EventArgs e)
        {
            POINT p = new POINT(imgelt.PointToScreen(new Point(0, 0)));

            HRESULT.Check(SetAdapter(p));
        }

        void SizeTimer_Tick(object sender, EventArgs e)
        {
            // The following code does not account for RenderTransforms.
            // To handle that case, you must transform up to the root and
            // check the size there.

            // Given that the D3DImage is at 96.0 DPI, its Width and Height
            // properties will always be integers. ActualWidth/Height
            // may not be integers, so they are cast to integers.
            uint actualWidth = (uint)imgelt.ActualWidth;
            uint actualHeight = (uint)imgelt.ActualHeight;
            if ((actualWidth > 0 && actualHeight > 0) &&
                (actualWidth != (uint)d3dimg.Width || actualHeight != (uint)d3dimg.Height))
            {
                HRESULT.Check(SetSize(actualWidth, actualHeight));
            }
        }

        void CompositionTarget_Rendering(object sender, EventArgs e)
        {
            RenderingEventArgs args = (RenderingEventArgs)e;

            // It's possible for Rendering to call back twice in the same frame
            // so only render when we haven't already rendered in this frame.
            if (d3dimg.IsFrontBufferAvailable && _lastRender != args.RenderingTime)
            {
                IntPtr pSurface = IntPtr.Zero;
                HRESULT.Check(GetBackBufferNoRef(out pSurface));
                if (pSurface != IntPtr.Zero)
                {
                    d3dimg.Lock();
                    // Repeatedly calling SetBackBuffer with the same IntPtr is
                    // a no-op. There is no performance penalty.
                    d3dimg.SetBackBuffer(D3DResourceType.IDirect3DSurface9, pSurface);
                    HRESULT.Check(Render());
                    d3dimg.AddDirtyRect(new Int32Rect(0, 0, d3dimg.PixelWidth, d3dimg.PixelHeight));
                    d3dimg.Unlock();

                    _lastRender = args.RenderingTime;
                }
            }
        }

        DispatcherTimer _sizeTimer;
        DispatcherTimer _adapterTimer;
        TimeSpan _lastRender;

        // Import the methods exported by the unmanaged Direct3D content.

        [DllImport("D3DCode.dll")]
        static extern int GetBackBufferNoRef(out IntPtr pSurface);

        [DllImport("D3DCode.dll")]
        static extern int SetSize(uint width, uint height);

        [DllImport("D3DCode.dll")]
        static extern int SetAlpha(bool useAlpha);

        [DllImport("D3DCode.dll")]
        static extern int SetNumDesiredSamples(uint numSamples);

        [StructLayout(LayoutKind.Sequential)]
        struct POINT
        {
            public POINT(Point p)
            {
                x = (int)p.X;
                y = (int)p.Y;
            }

            public int x;
            public int y;
        }

        [DllImport("D3DCode.dll")]
        static extern int SetAdapter(POINT screenSpacePoint);

        [DllImport("D3DCode.dll")]
        static extern int Render();

        [DllImport("D3DCode.dll")]
        static extern void Destroy();
    }

    public static class HRESULT
    {
        public static void Check(int hr)
        {
            Marshal.ThrowExceptionForHR(hr);
        }
    }
}

Hospedando o conteúdo Direct3D9

Finalmente, use a D3DImage classe para hospedar o conteúdo Direct3D9.

Para hospedar o conteúdo Direct3D9

  1. Em MainWindow.xaml, substitua o XAML gerado automaticamente pelo seguinte XAML.

        <Window x:Class="D3DHost.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:i="clr-namespace:System.Windows.Interop;assembly=PresentationCore"
    Title="MainWindow" Height="300" Width="300" Background="PaleGoldenrod">
    <Grid>
        <Image x:Name="imgelt">
            <Image.Source>
                <i:D3DImage x:Name="d3dimg" />
            </Image.Source>
        </Image>
    </Grid>
</Window>

  2. Compile o projeto.

  3. Copie a DLL que contém o conteúdo Direct3D9 para a pasta lixeira/Debug.

  4. Pressione F5 para executar o projeto.

    O conteúdo Direct3D9 aparece dentro do aplicativo do WPF.

Confira também