2D-Zeichnung-Performance (GDI+ vs SlimDX)

Ich habe vor kurzem portiert, einige Zeichnung code über DirectX und sind bisher sehr zufrieden mit den Ergebnissen. Wir waren vor allem das Rendern von bitmaps unter Verwendung von bit-bashing und sehen die rendering-Zeiten, die gemessen werden können, die in wenigen Minuten reduziert um 1-2 Sekunden.

Diese können nicht direkt miteinander verglichen werden, um Ihnen die Nutzung, da haben wir uns von bit-bashing in C++ zu Direct3D in C# using SlimDX, aber ich glaube, Sie werden sehen, performance-Vorteile, auch wenn Sie nicht die Größenordnungen, die wir sehen.

Ich würde Ihnen raten, nehmen Sie einen Blick auf Verwendung von Direct2D mit SlimDX. Benötigen Sie DirectX 10.1, wie Direct2D ist nicht kompatibel mit DirectX 11 für einige Grund. Wenn Sie bereits mit der Zeichnungs-API in WPF-dann sind Sie bereits vertraut mit Direct2D als seine API basiert auf der WPF-drawing-API, soweit ich das sagen kann. Die wichtigsten Probleme, mit Direct2D sind die fehlende Dokumentation und die Tatsache, es funktioniert nur unter Vista ab.

Habe ich noch nicht experimentiert mit DirectX 10/WPF-interop, aber ich glaube, es ist möglich (http://stackoverflow.com/questions/1252780/d3dimage-using-dx10)

EDIT: ich dachte, ich würde Ihnen einen Vergleich aus unserer code, der Zeichnung ein einfaches polygon. Zuerst wird die WPF-version:

        StreamGeometry geometry = new StreamGeometry();

        using (StreamGeometryContext ctx = geometry.Open())
        {
            foreach (Polygon polygon in mask.Polygons)
            {
                bool first = true;

                foreach (Vector2 p in polygon.Points)
                {
                    Point point = new Point(p.X, p.Y);

                    if (first)
                    {
                        ctx.BeginFigure(point, true, true);
                        first = false;
                    }
                    else
                    {
                        ctx.LineTo(point, false, false);
                    }
                }
            }
        }

Nun die Direct2D version:

        Texture2D maskTexture = helper.CreateRenderTexture(width, height);

        RenderTargetProperties props = new RenderTargetProperties
        {
            HorizontalDpi = 96,
            PixelFormat = new PixelFormat(SlimDX.DXGI.Format.Unknown, AlphaMode.Premultiplied),
            Type = RenderTargetType.Default,
            Usage = RenderTargetUsage.None,
            VerticalDpi = 96,
        };

        using (SlimDX.Direct2D.Factory factory = new SlimDX.Direct2D.Factory())
        using (SlimDX.DXGI.Surface surface = maskTexture.AsSurface())
        using (RenderTarget target = RenderTarget.FromDXGI(factory, surface, props))
        using (SlimDX.Direct2D.Brush brush = new SolidColorBrush(target, new SlimDX.Color4(System.Drawing.Color.Red)))
        using (PathGeometry geometry = new PathGeometry(factory))
        using (SimplifiedGeometrySink sink = geometry.Open())
        {
            foreach (Polygon polygon in mask.Polygons)
            {
                PointF[] points = new PointF[polygon.Points.Count()];
                int i = 0;

                foreach (Vector2 p in polygon.Points)
                {
                    points[i++] = new PointF(p.X * width, p.Y * height);
                }

                sink.BeginFigure(points[0], FigureBegin.Filled);
                sink.AddLines(points);
                sink.EndFigure(FigureEnd.Closed);
            }

            sink.Close();
            target.BeginDraw();
            target.FillGeometry(geometry, brush);
            target.EndDraw();
        }

Wie Sie sehen können, die Direct2D version ist etwas mehr Arbeit (und stützt sich auf ein paar Hilfsfunktionen, die ich geschrieben habe) aber es ist eigentlich ziemlich ähnlich.