Ü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, die durch ID2D1Layer-Objekte dargestellt werden, 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, "popen" Sie die Ebene aus dem Renderziel, wodurch der Inhalt der Ebene wieder zum Renderziel zusammengesetzt wird.

Wie Pinsel sind Ebenen geräteabhängige Ressourcen, die von Renderzielen erstellt werden. Ebenen können auf jedem Renderziel in derselben Ressourcendomäne verwendet werden, die das Renderziel enthält, mit dem es erstellt wurde. Eine Ebenenressource kann jedoch nur von einem Renderziel gleichzeitig verwendet werden. Weitere Informationen zu Ressourcen finden Sie unter Übersicht über Ressourcen.

Ebenen bieten zwar eine leistungsstarke Renderingtechnik zum Erzeugen interessanter Effekte, aber eine übermäßige Anzahl von Ebenen in einer Anwendung kann sich aufgrund der verschiedenen Kosten für die Verwaltung von Ebenen und Ebenenressourcen negativ auf die Leistung auswirken. Beispielsweise sind die Kosten für das Auffüllen oder Löschen der Schicht und das anschließende Wiederverblenden der Schicht erforderlich, insbesondere bei Hardware mit höherer Ebene. Anschließend sind die Kosten für die Verwaltung der Ebenenressourcen an. Wenn Sie diese häufig neu auffinden, sind die resultierenden Stags für die GPU das größte Problem. Versuchen Sie beim Entwerfen Ihrer Anwendung, die Wiederverwendung von Ebenenressourcen zu maximieren.

Ebenen in Windows 8 und höher

Windows 8 neue ebenenbezogene APIs eingeführt, die die Leistung von vereinfachen, verbessern und Ebenen Features 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 das Aufrufen der CreateLayer-Methode überspringen und dann NULL an die ID2D1DeviceContext::P ushLayer-Methode übergeben. Direct2D verwaltet die Ebenenressource automatisch 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,mit der Ausnahme, dass das letzte Member der Struktur jetzt eine D2D1 _ LAYER _ OPTIONS1-Enumeration ist.

D2D1 _ LAYER _ OPTIONS1 verfügt über 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 Überblendmodus, der bestimmt, wie die einzelnen Primitiven mit der Zieloberfläche kombiniert werden. Dieser Modus gilt auch für Ebenen, wenn Sie die PushLayer-Methode aufrufen.

Wenn Sie beispielsweise eine Ebene zum Beschneiden von Primitiven mit Transparenz verwenden, legen Sie den D2D1 _ PRIMITIVE _ BLEND _ COPY-Modus für den Gerätekontext fest, um die richtigen Ergebnisse zu erzielen. Durch den Kopiermodus interpoliert der Gerätekontext alle vier Farbkanäle, einschließlich des Alphakanals, jedes Pixels mit dem Inhalt der Zieloberfläche gemäß 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 mit pusht wird. Sie rufen ID2D1GdiInteropRenderTarget::GetDC auf, während eine Ebene für die Interoperabilität mit GDI pushed wird. Sie rufen ID2D1DeviceContext::Flush auf und rendern dann auf der zugrunde liegenden Oberfläche, um mit Direct3D zu zusammenarbeiten. Es liegt in Ihrer Verantwortung, innerhalb der Ebene zu rendern oder mit Direct3D oder GDI zu beschneiden. Wenn Sie versuchen, außerhalb der Ebene zu rendern oder die Ergebnisse zu beschneiden, sind die Ergebnisse nicht definiert.

Erstellen von Ebenen

Das Arbeiten mit Ebenen erfordert Vertrautheit mit den Methoden CreateLayer, PushLayerund PopLayer und der Struktur D2D1 _ LAYER _ PARAMETERS, die eine Reihe von parametrischen 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 Ebenenressource 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 automatische Verwaltung der Ebenenressource und die gemeinsame Nutzung von Ressourcen zwischen Ebenen und Effektdiagrammen.

  • Nachdem das Zeichnen des Renderziels 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 zurückgegeben wird, und ein layerParameters-Objekt in der D2D1 _ LAYER _ PARAMETERS-Struktur. In der folgenden Tabelle werden die Felder der -Struktur beschrieben.

    Feld BESCHREIBUNG
    contentBounds Die Inhaltsgrenze der Ebene. Inhalt wird außerhalb dieser Grenzen nicht gerendert. Dieser Parameter ist standardmäßig auf InfiniteRect festgelegt. Wenn der Standardwert verwendet wird, werden die Inhaltsgrenze effektiv als Begrenzungen des Renderziels verwendet.
    geometricMask (Optional) Der bereich, der durch eine ID2D1Geometrydefiniert wird, auf den die Ebene abgeschnitten werden soll. Wird auf NULL festgelegt, wenn die Ebene nicht auf eine Geometrie abgeschnitten werden soll.
    maskAntialiasMode Ein -Wert, der den Antialiasingmodus für die geometrische Maske angibt, die durch das feld geometricMask angegeben wird.
    maskTransform Ein -Wert, der die Transformation angibt, die beim Erstellen der Ebene auf die geometrische Maske angewendet wird. Dies ist relativ zur Welttransformation.
    Deckkraft Der Deckkraftwert der Ebene. Die Deckkraft jeder Ressource in der Ebene wird beim Zusammenordnen mit dem Ziel mit diesem Wert multipliziert.
    opacityBrush (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 Ebenenpixel multipliziert. Wird auf NULL festgelegt, wenn die Schicht keine Deckkraftmaske haben soll.
    layerOptions Ein -Wert, der angibt, ob die Ebene text mit ClearType-Antialiasing rendern möchte. Dieser Parameter ist standardmäßig deaktiviert. Wenn Sie es aktivieren, funktioniert ClearType ordnungsgemäß, führt jedoch zu einer etwas langsameren Renderinggeschwindigkeit.

    Hinweis

    Ab Windows 8 können Sie nicht mit ClearType in einer Ebene rendern, daher sollte der layerOptions-Parameter immer auf D2D1 _ LAYER OPTIONS NONE festgelegt _ _ werden.

    Der Einfachheit halber stellt Direct2D die D2D1::LayerParameters-Methode zum Erstellen von D2D1 _ LAYER _ PARAMETERS-Strukturen zur Verfügung.

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

Das folgende Beispiel zeigt die Verwendung von CreateLayer, PushLayerund PopLayer. Alle Felder in der Struktur D2D1 _ LAYER _ PARAMETERS werden auf ihre Standardwerte festgelegt, mit Ausnahme von opacityBrush, das auf 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 in diesem Beispiel ausgelassen.

Beachten Sie, dass beim Aufrufen von PushLayer und PopLayersichergestellt ist, dass jeder PushLayer über einen entsprechenden PopLayer-Aufruf verfügt. Wenn mehr PopLayer-Aufrufe als PushLayer-Aufrufe vorhanden sind, wird das Renderziel in einen Fehlerzustand versetzt. Wenn Flush aufgerufen wird, bevor alle ausstehenden Ebenen abgelegt werden, wird das Renderziel in einen Fehlerzustand versetzt und gibt einen Fehler zurück. Verwenden Sie EndDraw,um den Fehlerzustand zu löschen.

Inhaltsgrenzen

ContentBounds legt den Grenzwert für das fest, was auf die Ebene gezeichnet werden soll. Nur die Dinge innerhalb der Inhaltsgrenzen werden wieder mit dem Renderziel zusammengesetzt.

Das folgende Beispiel zeigt, wie contentBounds angegeben wird, sodass das ursprüngliche Bild an die Inhaltsgrenzen mit der linken oberen Ecke (10, 108) und der unteren rechten Ecke bei (121, 177) abgeschnitten wird. Die folgende Abbildung zeigt das ursprüngliche Bild und das Ergebnis des Abschneidens des Bilds an die Inhaltsgrenzen.

Abbildung der Inhaltsgrenzen eines originalen Bilds und des resultierenden abgeschnittenen Bilds

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 in diesem Beispiel ausgelassen.

Hinweis

Das resultierende abgeschnittene Bild wird weiter beeinflusst, wenn Sie ein geometrischesMask 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 feld geometricMask der D2D1 _ LAYER _ PARAMETERS-Struktur verwenden, um die Ergebnisse in einer Geometrie zu maskieren. Wenn Sie beispielsweise ein Bild anzeigen möchten, das durch einen Blockbuchstaben "A" maskiert ist, können Sie zunächst eine Geometrie erstellen, die den Blockbuchstaben "A" darstellt, und diese Geometrie als geometrische Maske für eine Ebene verwenden. Nach dem Pushen der Ebene können Sie dann das Bild zeichnen. Wenn Die Ebene per Pop abgeschnitten wird, wird das Bild auf die Form "A" des Blockbuchstabens abgeschnitten.

Das folgende Beispiel zeigt, wie Sie eine ID2D1PathGeometry erstellen, die eine Form eines Mountain enthält, und dann die Pfadgeometrie an pushLayerübergeben. Anschließend zeichnet sie eine Bitmap und Quadrate. Wenn nur eine Bitmap in der Ebene zum Rendern vorhanden ist, verwenden Sie FillGeometry mit einem klammerten Bitmappinsel zur Effizienz. Die folgende Abbildung zeigt die Ausgabe des Beispiels.

Abbildung eines Bilds eines Blatts und des resultierenden Bilds, nachdem eine geometrische Maske eines Mountain angewendet wurde

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 in diesem Beispiel ausgelassen.

Hinweis

Wenn Sie eine geometrischeMaske angeben, können Sie im Allgemeinen den Standardwert InfiniteRectfür contentBounds verwenden.

Wenn contentBounds NULL und geometricMask ungleich NULL ist, sind die Inhaltsgrenzen effektiv die Grenzen der geometrischen Maske, nachdem die Maskentransformation angewendet wurde.

Wenn contentBounds ungleich NULL und geometricMask ungleich NULL ist, wird die transformierte geometrische Maske effektiv an Inhaltsgrenzen abgeschnitten, und es wird davon ausgegangen, dass die Inhaltsgrenzen unendlich sind.

Deckkraftmasken

Eine Deckkraftmaske ist eine Maske, die von einem Pinsel oder einer Bitmap beschrieben wird und auf ein anderes Objekt angewendet wird, um dieses Objekt teilweise oder vollständig transparent zu machen. Sie ermöglicht die Verwendung des Alphakanals eines Pinsels als Inhaltsmaske. Beispielsweise können Sie einen radialen Farbverlaufspinsel definieren, der von deckend zu transparent variiert, um einen Effekt zu erzeugen.

Im folgenden Beispiel wird ein ID2D1RadialGradientBrush (m _ pRadialGradientBrush) als Deckkraftmaske verwendet. Anschließend zeichnet sie eine Bitmap und Quadrate. Wenn nur eine Bitmap in der Ebene zum Rendern vorhanden ist, verwenden Sie FillGeometry mit einem klammerten Bitmappinsel zur Effizienz. Die folgende Abbildung zeigt die Ausgabe dieses Beispiels.

Abbildung eines Bilds von Strukturen und des resultierenden Bilds, nachdem eine Deckkraftmaske angewendet wurde

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 in diesem Beispiel ausgelassen.

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 FillGeometry-Methode anstelle einer Ebene 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 eine übermäßige Anzahl von Ebenen die Leistung Ihrer Anwendung beeinträchtigen. Vermeiden Sie nach Möglichkeit die Verwendung von Ebenen, um die Leistung zu verbessern. Verwenden Sie stattdessen ihre Alternativen. Das folgende Codebeispiel zeigt, wie Sie PushAxisAlignedClip und PopAxisAlignedClip verwenden, um einen Bereich als Alternative zur Verwendung einer Ebene mit Inhaltsgrenzen zu beschneiden.

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 auf ähnliche Weise FillGeometry mit einem klammerten Bitmappinsel als Alternative zur Verwendung einer Ebene mit einer Deckkraftmaske, wenn nur ein Inhalt in der Ebene gerendert werden kann, 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 abzuschneiden, 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 auf einen einzelnen Primitiven anwenden möchten, sollten Sie die Deckkraft schließlich in die Pinselfarbe multiplizieren und dann den Primitiven rendern. Sie benötigen keine Schicht oder eine Deckkraftmaskenbitmap.

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
    ); 

Beschneiden einer beliebigen Form

Die folgende Abbildung zeigt das Ergebnis der Anwendung eines Clips auf ein Bild.

Ein Bild, das ein Beispiel für ein Bild vor und nach einem Clip zeigt.

Sie können dieses Ergebnis erzielen, indem Sie Ebenen mit einer Geometriemaske oder die FillGeometry-Methode mit einem Deckkraftpinsel verwenden.

Hier sehen Sie ein Beispiel, das eine Ebene verwendet:

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

Hier sehen Sie ein Beispiel, in dem die FillGeometry-Methode verwendet wird:

// 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()); 

Wenn Sie in diesem Codebeispiel die PushLayer-Methode aufrufen, übergeben Sie keine von der App erstellte 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, nach Möglichkeit die Verwendung von Ebenen-APIs anstelle von FillGeometry zu verwenden.

Achsenbündige Clips

Wenn der zu beschneidende Bereich an der Achse der Zeichnungsoberfläche ausgerichtet ist, anstatt an einer beliebigen. Dieser Fall eignet sich für die Verwendung eines Cliprechtecks anstelle einer Ebene. Der Leistungsgewinn ist eher für gealiaste Geometrie als für Gealiasengeometrie. Weitere Informationen zu achsenbündig ausgerichteten Clips finden Sie im Thema PushAxisAlignedClip.

Direct2D-Referenz