Übersicht über Ebenen

In dieser Übersicht werden die Grundlagen der Verwendung von Direct2D-Ebenen beschrieben. Der Abschnitt ist wie folgt gegliedert.

Was sind Ebenen?

Ebenen, dargestellt durch ID2D1Layer-Objekte , ermöglichen es einer Anwendung, eine Gruppe von Zeichnungsvorgängen zu bearbeiten. Sie verwenden eine Ebene, indem Sie sie auf ein Renderziel "pushen". Nachfolgende Zeichnungsvorgänge durch das Renderziel werden an die Ebene geleitet. Nachdem Sie mit der Ebene fertig sind, "popieren" Sie die Ebene aus dem Renderziel, wodurch der Inhalt der Ebene zurück zum Renderziel zusammengesetzt wird.

Wie Pinsel sind Ebenen geräteabhängige Ressourcen, die durch Renderziele erstellt werden. Ebenen können für jedes Renderziel in derselben Ressourcendomäne verwendet werden, die das Renderziel enthält, das sie erstellt hat. Eine Layerressource kann jedoch nur jeweils von einem Renderziel verwendet werden. Weitere Informationen zu Ressourcen finden Sie in der Ressourcenübersicht.

Obwohl Ebenen eine leistungsstarke Renderingtechnik zum Erzeugen interessanter Effekte bieten, kann die übermäßige Anzahl von Ebenen in einer Anwendung ihre Leistung beeinträchtigen, da die verschiedenen Kosten, die mit der Verwaltung von Layern und Layerressourcen verbunden sind, beeinträchtigt werden. Zum Beispiel gibt es die Kosten für das Ausfüllen oder Löschen der Schicht und anschließendes Blenden zurück, insbesondere auf höherer Hardware. Dann gibt es die Kosten für die Verwaltung der Layerressourcen. Wenn Sie diese häufig zuweisen, sind die resultierenden Stände gegen die GPU das wichtigste Problem. Wenn Sie Ihre Anwendung entwerfen, versuchen Sie, die Wiederverwenderung von Layerressourcen zu maximieren.

Ebenen in Windows 8 und höher

Windows 8 neue layerbezogene APIs eingeführt, die die Leistung vereinfachen, verbessern und Features zu Ebenen hinzufügen.

ID2D1DeviceContext und PushLayer

Die ID2D1DeviceContext-Schnittstelle wird von der ID2D1RenderTarget-Schnittstelle abgeleitet und ist der Schlüssel zum Anzeigen von Direct2D-Inhalten in Windows 8, weitere Informationen zu dieser Schnittstelle finden Sie unter "Geräte" und "Gerätekontexte". Mit der Gerätekontextschnittstelle können Sie den Aufruf der CreateLayer-Methode überspringen und dann NULL an die ID2D1DeviceContext::P ushLayer-Methode übergeben. Direct2D verwaltet automatisch die Layerressource und kann Ressourcen zwischen Ebenen und Effektdiagrammen freigeben.

D2D1_LAYER_PARAMETERS1 und D2D1_LAYER_OPTIONS1

Die D2D1_LAYER_PARAMETERS1 Struktur ist identisch mit D2D1_LAYER_PARAMETERS, außer das endgültige Element der Struktur ist jetzt eine D2D1_LAYER_OPTIONS1 Enumeration.

D2D1_LAYER_OPTIONS1 hat keine ClearType-Option und verfügt über zwei verschiedene Optionen, mit denen Sie die Leistung verbessern können:

Füllmethoden

Ab Windows 8 verfügt der Gerätekontext über einen primitiven Blendmodus, der bestimmt, wie jeder Grundtyp mit der Zieloberfläche kombiniert wird. Dieser Modus gilt auch für Ebenen, wenn Sie die PushLayer-Methode aufrufen.

Wenn Sie z. B. eine Ebene zum Abschneiden von Grundtypen mit Transparenz verwenden, legen Sie den D2D1_PRIMITIVE_BLEND_COPY-Modus im Gerätekontext auf ordnungsgemäße Ergebnisse fest. Durch den Kopiermodus wird der Gerätekontext linear alle vier Farbkanäle interpoliert, einschließlich des Alphakanals, jedes Pixels mit dem Inhalt der Zieloberfläche entsprechend der geometrischen Maske der Ebene.

Interoperation

Ab Windows 8 unterstützt Direct2D die Interoperation mit Direct3D und GDI, während eine Ebene oder ein Clip verschoben wird. Sie rufen ID2D1GdiInteropRenderTarget::GetDC auf, während eine Ebene mit GDI interoperiert wird. Sie rufen ID2D1DeviceContext::Flush auf, und rendern Sie dann an der zugrunde liegenden Oberfläche, um mit Direct3D zu interoperieren. Es ist Ihre Verantwortung, innerhalb der Ebene oder des Clips mit Direct3D oder GDI zu rendern. Wenn Sie versuchen, außerhalb der Ebene zu rendern oder zu clipen, werden die Ergebnisse nicht definiert.

Erstellen von Ebenen

Das Arbeiten mit Layern erfordert Vertrautheit mit den Methoden CreateLayer, PushLayer und PopLayer und der D2D1_LAYER_PARAMETERS Struktur, die einen Satz parametrischer Daten enthält, die definieren, wie die Ebene verwendet werden kann. In der folgenden Liste werden die Methoden und die Struktur beschrieben.

  • Rufen Sie die CreateLayer-Methode auf, um eine Layerressource zu erstellen.

    Hinweis

    Ab Windows 8 können Sie den Aufruf der CreateLayer-Methode überspringen und dann NULL an die PushLayer-Methode auf der ID2D1DeviceContext-Schnittstelle übergeben. Dies ist einfacher und ermöglicht Direct2D, die Layerressource automatisch zu verwalten und Ressourcen zwischen Ebenen und Effektdiagrammen zu teilen.

     

  • Nachdem das Renderziel mit der Zeichnung begonnen hat (nachdem die BeginDraw-Methode aufgerufen wurde), können Sie die PushLayer-Methode verwenden. Die PushLayer-Methode fügt dem Renderziel die angegebene Ebene hinzu, sodass das Ziel alle nachfolgenden Zeichnungsvorgänge empfängt, bis PopLayer aufgerufen wird. Diese Methode verwendet ein ID2D1Layer-Objekt , das durch Aufrufen von CreateLayer und einer LayerParameters in der D2D1_LAYER_PARAMETERS Struktur zurückgegeben wird. In der folgenden Tabelle werden die Felder der Struktur beschrieben.

    Feld BESCHREIBUNG
    contentBounds Die Inhaltsgrenzen der Ebene. Inhalte werden außerhalb dieser Grenzen nicht gerendert. Dieser Parameter ist standardmäßig auf InfiniteRect festgelegt. Wenn der Standardwert verwendet wird, werden die Inhaltsgrenzen effektiv als Begrenzungen des Renderziels verwendet.
    geometrischeMaske (Optional) Der durch eine ID2D1Geometrie definierte Bereich, auf den die Ebene zugeschnitten werden soll. Legen Sie auf NULL fest, wenn die Ebene nicht auf eine Geometrie zugeschnitten werden soll.
    maskAntialiasMode Ein Wert, der den Antialiasingmodus für die durch das geometrischeMask-Feld angegebene geometrische Maske angibt.
    maskTransform Ein Wert, der die Transformation angibt, die beim Verfassen der Ebene auf die geometrische Maske angewendet wird. Dies ist relativ zur Welttransformation.
    Deckkraft Der Deckkraftwert der Ebene. Die Deckkraft der einzelnen Ressourcen auf der Ebene wird mit diesem Wert multipliziert, wenn sie dem Ziel zugeordnet werden.
    DeckkraftBrush (Optional) Ein Pinsel, der verwendet wird, um die Deckkraft der Ebene zu ändern. Der Pinsel wird der Ebene zugeordnet, und der Alphakanal jedes zugeordneten Pinselpixels wird mit dem entsprechenden Layerpixel multipliziert. Legen Sie auf NULL fest, wenn die Ebene keine Deckkraftmaske aufweisen soll.
    layerOptions Ein Wert, der angibt, ob die Ebene Text mit ClearType-Antialiasing rendern soll. Dieser Parameter ist standardmäßig deaktiviert. Wenn Sie es aktivieren, kann ClearType ordnungsgemäß funktionieren, führt jedoch zu einer etwas langsameren Renderinggeschwindigkeit.

     

    Hinweis

    Ab Windows 8 können Sie mit ClearType in einer Ebene nicht rendern, sodass der Parameter "layerOptions" immer auf D2D1_LAYER_OPTIONS_NONE festgelegt werden sollte.

     

    Für den Komfort bietet Direct2D die D2D1::LayerParameters-Methode , mit der Sie D2D1_LAYER_PARAMETERS Strukturen erstellen können.

  • Rufen Sie die PopLayer-Methode auf, um den Inhalt der Ebene in das Renderziel zu zusammengesetzt. Sie müssen die PopLayer-Methode aufrufen, bevor Sie die EndDraw-Methode aufrufen.

Das folgende Beispiel zeigt, wie Sie CreateLayer, PushLayer und PopLayer verwenden. Alle Felder in der D2D1_LAYER_PARAMETERS Struktur werden auf ihre Standardwerte festgelegt, außer opacityBrush, das auf eine ID2D1RadialGradientBrush festgelegt ist.

// Create a layer.
ID2D1Layer *pLayer = NULL;
hr = pRT->CreateLayer(NULL, &pLayer);

if (SUCCEEDED(hr))
{
    pRT->SetTransform(D2D1::Matrix3x2F::Translation(300, 250));

    // Push the layer with the content bounds.
    pRT->PushLayer(
        D2D1::LayerParameters(
            D2D1::InfiniteRect(),
            NULL,
            D2D1_ANTIALIAS_MODE_PER_PRIMITIVE,
            D2D1::IdentityMatrix(),
            1.0,
            m_pRadialGradientBrush,
            D2D1_LAYER_OPTIONS_NONE),
        pLayer
        );

    pRT->DrawBitmap(m_pBambooBitmap, D2D1::RectF(0, 0, 190, 127));

    pRT->FillRectangle(
        D2D1::RectF(25.f, 25.f, 50.f, 50.f), 
        m_pSolidColorBrush
        );
    pRT->FillRectangle(
        D2D1::RectF(50.f, 50.f, 75.f, 75.f),
        m_pSolidColorBrush
        ); 
    pRT->FillRectangle(
        D2D1::RectF(75.f, 75.f, 100.f, 100.f),
        m_pSolidColorBrush
        );    
 
    pRT->PopLayer();
}
SafeRelease(&pLayer);

Code wurde aus diesem Beispiel weggelassen.

Beachten Sie, dass beim Aufrufen von PushLayer und PopLayer sichergestellt wird, dass jeder PushLayer über einen übereinstimmenden PopLayer-Anruf verfügt. Wenn mehr PopLayer-Aufrufe alsPushLayer-Aufrufe vorhanden sind, wird das Renderziel in einen Fehlerzustand gesetzt. Wenn Flush aufgerufen wird, bevor alle ausstehenden Ebenen eingetaucht werden, wird das Renderziel in einen Fehlerzustand gesetzt und gibt einen Fehler zurück. Verwenden Sie EndDraw, um den Fehlerstatus zu löschen.

Inhaltsgrenzen

Der contentBounds legt den Grenzwert fest, der auf die Ebene gezeichnet werden soll. Nur diese Dinge innerhalb der Inhaltsgrenzen werden wieder zum Renderziel zusammengesetzt.

Das folgende Beispiel zeigt, wie Sie ContentBounds angeben, sodass das ursprüngliche Bild an die Grenzen des Inhalts mit der oberen linken Ecke (10, 108) und der unteren rechten Ecke bei (121, 177) zugeschnitten wird. Die folgende Abbildung zeigt das ursprüngliche Bild und das Ergebnis des Clippings des Bilds an die Grenzen des Inhalts.

illustration of content bounds on an original picture and the resulting clipped picture

HRESULT DemoApp::RenderWithLayerWithContentBounds(ID2D1RenderTarget *pRT)
{
    
    HRESULT hr = S_OK;

    // Create a layer.
    ID2D1Layer *pLayer = NULL;
    hr = pRT->CreateLayer(NULL, &pLayer);

    if (SUCCEEDED(hr))
    {
        pRT->SetTransform(D2D1::Matrix3x2F::Translation(300, 0));

        // Push the layer with the content bounds.
        pRT->PushLayer(
            D2D1::LayerParameters(D2D1::RectF(10, 108, 121, 177)),
            pLayer
            );

        pRT->DrawBitmap(m_pWaterBitmap, D2D1::RectF(0, 0, 128, 192));
        pRT->PopLayer();
    }

    SafeRelease(&pLayer);

    return hr;
    
}

Code wurde aus diesem Beispiel weggelassen.

Hinweis

Das resultierende abgeschnittene Bild ist weiter betroffen, wenn Sie eine geometrische Maske angeben. Weitere Informationen finden Sie im Abschnitt "Geometrische Masken ".

 

Geometrische Masken

Eine geometrische Maske ist ein Clip oder ein Cutout, definiert durch ein ID2D1Geometry-Objekt , das eine Ebene maskiert, wenn sie von einem Renderziel gezeichnet wird. Sie können das geometrischeMask-Feld der D2D1_LAYER_PARAMETERS Struktur verwenden, um die Ergebnisse in eine Geometrie zu maskieren. Wenn Sie beispielsweise ein Bild anzeigen möchten, das von einem Blockbuchstaben "A" maskiert wird, können Sie zuerst eine Geometrie erstellen, die den Blockbuchstaben "A" darstellt, und diese Geometrie als geometrische Maske für eine Ebene verwenden. Anschließend können Sie nach dem Pushen der Ebene das Bild zeichnen. Das Auffüllen der Ebene führt dazu, dass das Bild auf das Blockbuchstaben "A"-Shape zugeschnitten wird.

Das folgende Beispiel zeigt, wie Sie eine ID2D1PathGeometrie erstellen, die eine Form eines Bergs enthält, und übergeben Sie dann die Pfadgeometrie an den PushLayer. Anschließend zeichnet es eine Bitmap und Quadrate. Wenn nur eine Bitmap in der Ebene gerendert werden soll, verwenden Sie FillGeometry mit einem geklammerten Bitmappinsel zur Effizienz. Die folgende Abbildung zeigt die Ausgabe des Beispiels.

illustration of a picture of a leaf and the resulting picture after a geometric mask of a mountain is applied

Im ersten Beispiel wird die Geometrie definiert, die als Maske verwendet werden soll.

hr = m_pD2DFactory->CreatePathGeometry(&m_pPathGeometry);
    
if(SUCCEEDED(hr))
{
    ID2D1GeometrySink *pSink = NULL;
    // Write to the path geometry using the geometry sink.
    hr = m_pPathGeometry->Open(&pSink);

    if (SUCCEEDED(hr))
    {
        pSink->SetFillMode(D2D1_FILL_MODE_WINDING);
        pSink->BeginFigure(
            D2D1::Point2F(0, 90),
            D2D1_FIGURE_BEGIN_FILLED
            );

        D2D1_POINT_2F points[7] = {
           D2D1::Point2F(35, 30),
           D2D1::Point2F(50, 50),
           D2D1::Point2F(70, 45),
           D2D1::Point2F(105, 90),
           D2D1::Point2F(130, 90),
           D2D1::Point2F(150, 60),
           D2D1::Point2F(170, 90)
           };

        pSink->AddLines(points, 7);
        pSink->EndFigure(D2D1_FIGURE_END_CLOSED);
        hr = pSink->Close();
    }
    SafeRelease(&pSink);
       }

Im nächsten Beispiel wird die Geometrie als Maske für die Ebene verwendet.

HRESULT DemoApp::RenderWithLayerWithGeometricMask(ID2D1RenderTarget *pRT)
{
    
    HRESULT hr;

    // Create a layer.
    ID2D1Layer *pLayer = NULL;
    hr = pRT->CreateLayer(NULL, &pLayer);

    if (SUCCEEDED(hr))
    {
        pRT->SetTransform(D2D1::Matrix3x2F::Translation(300, 450));

        pRT->PushLayer(
            D2D1::LayerParameters(D2D1::InfiniteRect(), m_pPathGeometry),
            pLayer
            );

        pRT->DrawBitmap(m_pLeafBitmap, D2D1::RectF(0, 0, 198, 132));

        pRT->FillRectangle(
            D2D1::RectF(50.f, 50.f, 75.f, 75.f), 
            m_pSolidColorBrush
            ); 
        pRT->FillRectangle(
            D2D1::RectF(75.f, 75.f, 100.f, 100.f),
            m_pSolidColorBrush
            );        

        pRT->PopLayer();
    }

    SafeRelease(&pLayer);

    return hr;
    
}

Code wurde aus diesem Beispiel weggelassen.

Hinweis

Wenn Sie eine geometrischeMaske angeben, können Sie den Standardwert " InfiniteRect" für die "contentBounds" verwenden.

Wenn contentBounds NULL ist und geometrischeMask nicht NULL ist, sind die Grenzen der Inhalte effektiv die Grenzen der geometrischen Maske, nachdem die Maskentransformation angewendet wurde.

Wenn contentBounds nicht NULL ist und geometrischeMask nicht NULL ist, wird die transformierte geometrische Maske effektiv an Inhaltsgrenzen abgeschnitten, und die Inhaltsgrenzen werden als unendlich angenommen.

 

Deckkraftmasken

Eine Deckkraftmaske ist eine Maske, die durch einen Pinsel oder eine Bitmap beschrieben wird, die auf ein anderes Objekt angewendet wird, um dieses Objekt teilweise oder vollständig transparent zu machen. Es ermöglicht die Verwendung des Alphakanals eines Pinsels als Inhaltsmaske. Sie können z. B. einen radialen Farbverlaufspinsel definieren, der von undurchsichtig bis transparent ist, um einen Vignetteeffekt zu erstellen.

Im folgenden Beispiel wird eine ID2D1RadialGradientBrush (m_pRadialGradientBrush) als Deckkraftmaske verwendet. Anschließend zeichnet es eine Bitmap und Quadrate. Wenn nur eine Bitmap in der Ebene gerendert werden soll, verwenden Sie FillGeometry mit einem geklammerten Bitmappinsel zur Effizienz. Die folgende Abbildung zeigt die Ausgabe aus diesem Beispiel.

illustration of a picture of trees and the resulting picture after an opacity mask is applied

HRESULT DemoApp::RenderWithLayerWithOpacityMask(ID2D1RenderTarget *pRT)
{   

    HRESULT hr = S_OK;

    // Create a layer.
    ID2D1Layer *pLayer = NULL;
    hr = pRT->CreateLayer(NULL, &pLayer);

    if (SUCCEEDED(hr))
    {
        pRT->SetTransform(D2D1::Matrix3x2F::Translation(300, 250));

        // Push the layer with the content bounds.
        pRT->PushLayer(
            D2D1::LayerParameters(
                D2D1::InfiniteRect(),
                NULL,
                D2D1_ANTIALIAS_MODE_PER_PRIMITIVE,
                D2D1::IdentityMatrix(),
                1.0,
                m_pRadialGradientBrush,
                D2D1_LAYER_OPTIONS_NONE),
            pLayer
            );

        pRT->DrawBitmap(m_pBambooBitmap, D2D1::RectF(0, 0, 190, 127));

        pRT->FillRectangle(
            D2D1::RectF(25.f, 25.f, 50.f, 50.f), 
            m_pSolidColorBrush
            );
        pRT->FillRectangle(
            D2D1::RectF(50.f, 50.f, 75.f, 75.f),
            m_pSolidColorBrush
            ); 
        pRT->FillRectangle(
            D2D1::RectF(75.f, 75.f, 100.f, 100.f),
            m_pSolidColorBrush
            );    
 
        pRT->PopLayer();
    }
    SafeRelease(&pLayer);
   
    return hr;
    
}

Code wurde aus diesem Beispiel weggelassen.

Hinweis

In diesem Beispiel wird eine Ebene verwendet, um eine Deckkraftmaske auf ein einzelnes Objekt anzuwenden, um das Beispiel so einfach wie möglich zu halten. Beim Anwenden einer Deckkraftmaske auf ein einzelnes Objekt ist es effizienter, die FillOpacityMask - oder FillGeometrie-Methoden anstelle einer Schicht zu verwenden.

 

Anweisungen zum Anwenden einer Deckkraftmaske ohne Verwendung einer Ebene finden Sie in der Übersicht über Deckkraftmasken.

Alternativen zu Ebenen

Wie bereits erwähnt, kann sich die übermäßige Anzahl von Ebenen negativ auf die Leistung Ihrer Anwendung auswirken. Um die Leistung zu verbessern, vermeiden Sie die Verwendung von Ebenen nach Möglichkeit; verwenden Sie stattdessen ihre Alternativen. Im folgenden Codebeispiel wird gezeigt, wie Sie PushAxisAlignedClip und PopAxisAlignedClip verwenden, um einen Bereich als Alternative zur Verwendung einer Ebene mit Inhaltsgrenzen zu verwenden.

pRT->PushAxisAlignedClip(
    D2D1::RectF(20, 20, 100, 100),
    D2D1_ANTIALIAS_MODE_PER_PRIMITIVE
    );

pRT->FillRectangle(D2D1::RectF(0, 0, 200, 133), m_pOriginalBitmapBrush);
pRT->PopAxisAlignedClip();

Verwenden Sie fillGeometry mit einem geklammerten Bitmappinsel als Alternative zur Verwendung einer Ebene mit einer Deckkraftmaske, wenn nur ein Inhalt in der Ebene gerendert werden soll, wie im folgenden Beispiel gezeigt.

        m_pRenderTarget->FillGeometry(
            m_pRectGeo, 
            m_pLinearFadeFlowersBitmapBrush, 
            m_pLinearGradientBrush
            );

Als Alternative zur Verwendung einer Ebene mit einer geometrischen Maske sollten Sie eine Bitmapmaske verwenden, um einen Bereich zu schneiden, wie im folgenden Beispiel gezeigt.

// D2D1_ANTIALIAS_MODE_ALIASED must be set for FillOpacityMask
// to function properly.
m_pRenderTarget->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);

m_pRenderTarget->FillOpacityMask(
    m_pBitmapMask,
    m_pOriginalBitmapBrush,
    D2D1_OPACITY_MASK_CONTENT_GRAPHICS,
    &rcBrushRect,
    NULL
    );

m_pRenderTarget->SetAntialiasMode(D2D1_ANTIALIAS_MODE_PER_PRIMITIVE);

Wenn Sie die Deckkraft schließlich auf einen einzelnen Grundtyp anwenden möchten, sollten Sie die Deckkraft in die Pinselfarbe multiplizieren und dann den Grundtyp rendern. Sie benötigen keine Ebene oder eine Deckkraftmasken-Bitmap.

float opacity = 0.9f;

ID2D1SolidColorBrush *pBrush = NULL;
hr = pCompatibleRenderTarget->CreateSolidColorBrush(
    D2D1::ColorF(D2D1::ColorF(0.93f, 0.94f, 0.96f, 1.0f * opacity)),
    &pBrush
    );

m_pRenderTarget->FillRectangle(
    D2D1::RectF(50.0f, 50.0f, 75.0f, 75.0f), 
    pBrush
    ); 

Abschneiden einer beliebigen Form

Die folgende Abbildung zeigt das Ergebnis des Anwendens eines Clips auf ein Bild.

an image that shows an example of an image before and after a clip.

Sie können dieses Ergebnis mithilfe von Ebenen mit einer Geometriemaske oder der FillGeometry-Methode mit einem Deckkraftpinsel abrufen.

Im folgenden Beispiel wird eine Ebene verwendet:

// Call PushLayer() and pass in the clipping geometry.
m_d2dContext->PushLayer(
    D2D1::LayerParameters(
        boundsRect,
        geometricMask));

Im folgenden Beispiel wird die FillGeometry-Methode verwendet:

// Create an opacity bitmap and render content.
m_d2dContext->CreateBitmap(size, nullptr, 0,
    D2D1::BitmapProperties(
        D2D1_BITMAP_OPTIONS_TARGET,
        D2D1::PixelFormat(
            DXGI_FORMAT_A8_UNORM,
            D2D1_ALPHA_MODE_PREMULTIPLIED),
        dpiX, dpiY),
    &opacityBitmap);

m_d2dContext->SetTarget(opacityBitmap.Get());
m_d2dContext->BeginDraw();
…
m_d2dContext->EndDraw();

// Create an opacity brush from the opacity bitmap.
m_d2dContext->CreateBitmapBrush(opacityBitmap.Get(),
    D2D1::BitmapBrushProperties(),
    D2D1::BrushProperties(),
    &bitmapBrush);

// Call the FillGeometry method and pass in the clip geometry and the opacity brush
m_d2dContext->FillGeometry( 
    clipGeometry.Get(),
    brush.Get(),
    opacityBrush.Get()); 

In diesem Codebeispiel übergeben Sie beim Aufrufen der PushLayer-Methode nicht in einer app erstellten Ebene. Direct2D erstellt eine Ebene für Sie. Direct2D kann die Zuordnung und Zerstörung dieser Ressource ohne Beteiligung der App verwalten. Dadurch kann Direct2D Ebenen intern wiederverwenden und Ressourcenverwaltungsoptimierungen anwenden.

Hinweis

In Windows 8 wurden viele Optimierungen an der Verwendung von Ebenen vorgenommen, und es wird empfohlen, layer-APIs anstelle von FillGeometrie nach Möglichkeit zu verwenden.

 

Achsenausrichtungsclips

Wenn der zu beschneidende Bereich an der Achse der Zeichnungsoberfläche ausgerichtet ist, statt beliebig. Dieser Fall eignet sich für die Verwendung eines Clip-Rechtecks anstelle einer Ebene. Der Leistungsgewinn ist mehr für aliasierte Geometrie als antialiasierte Geometrie. Weitere Informationen zu achsen ausgerichteten Clips finden Sie im Thema "PushAxisAlignedClip ".

Direct2D-Referenz