Freigeben über

Ebenenübersicht

In dieser Übersicht werden die Grundlagen der Verwendung von Direct2D-Ebenen beschrieben. Es enthält die folgenden Abschnitte.

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 Zeichenoperationen durch das Rendering-Ziel werden auf die Ebene geleitet. Nachdem Sie mit der Ebene fertig sind, entfernen Sie die Ebene aus dem Renderziel, wobei der Inhalt der Ebene wieder zum Renderziel zusammengesetzt wird.

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

Obwohl Layer eine leistungsstarke Renderingtechnik für die Herstellung interessanter Effekte bieten, kann sich eine übermäßige Anzahl von Schichten in einer Anwendung negativ auf die Leistung auswirken, da die verschiedenen Kosten für die Verwaltung von Layern und Layerressourcen entstehen. Es gibt zum Beispiel die Kosten für das Ausfüllen oder Löschen der Schicht und anschließende Wiederherstellung, insbesondere bei hochwertigerer Hardware. Dann gibt es die Kosten für die Verwaltung der Layerressourcen. Wenn Sie diese häufig neu zuweisen, sind die daraus resultierenden Stalls gegenüber der GPU das größte Problem. Wenn Sie Ihre Anwendung entwerfen, versuchen Sie, die wiederverwendenden Layerressourcen zu maximieren.

Ebenen in Windows 8 und höher

Windows 8 hat neue layerbezogene APIs eingeführt, die die Leistung vereinfachen, verbessern und Features zu Layern 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 gemeinsam nutzen.

D2D1_LAYER_PARAMETERS1 and D2D1_LAYER_OPTIONS1

Die D2D1_LAYER_PARAMETERS1 Struktur ist identisch mit D2D1_LAYER_PARAMETERS, mit der Ausnahme, dass das letzte Element der Struktur jetzt eine D2D1_LAYER_OPTIONS1 Enumeration ist.

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 elementaren Blendmodus, der bestimmt, wie jedes Element 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 verwenden, um Primitive mit Transparenz zu beschneiden, stellen Sie den D2D1_PRIMITIVE_BLEND_COPY-Modus im Gerätekontext ein, um korrekte Ergebnisse zu erzielen. Im Kopiermodus interpoliert der Gerätekontext linear alle vier Farbkanäle eines jeden Pixels, einschließlich des Alphakanals, mit dem Inhalt der Zieloberfläche, und das gemäß der geometrischen Maske der Ebene.

Interoperabilität

Ab Windows 8 unterstützt Direct2D die Interoperabilität mit Direct3D und GDI, während eine Ebene oder ein Clip verschoben wird. Sie rufen ID2D1GdiInteropRenderTarget::GetDC auf, während eine Ebene zum Zweck der Interoperabilität mit GDI gepusht wird. Sie rufen ID2D1DeviceContext::Flush auf und rendern dann auf der zugrunde liegenden Oberfläche, um mit Direct3D zu arbeiten. Es liegt in Ihrer 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, sind die Ergebnisse nicht definiert.

Erstellen von Ebenen

Das Arbeiten mit Layern erfordert Kenntnisse 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 gemeinsam zu nutzen.

     

  • Nachdem das Renderziel mit dem Zeichnen begonnen hat (nachdem die BeginDraw-Methode aufgerufen wurde), können Sie die PushLayer-Methode verwenden. Mit der PushLayer-Methode wird dem Renderziel die angegebene Ebene hinzugefügt, 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
    Inhaltsgrenzen Die Inhaltsgrenzen der Ebene. Der Inhalt wird nicht über diese Grenzen hinaus gerendert. Dieser Parameter ist standardmäßig auf InfiniteRect festgelegt. Wenn der Standardwert verwendet wird, werden die Inhaltsgrenzen effektiv als die Grenzen des Renderziels betrachtet.
    geometricMask (Optional) Der Bereich, der durch eine ID2D1Geometry definiert ist, zu dem die Ebene beschnitten werden soll. Legen Sie diesen Wert auf NULL fest, wenn die Ebene nicht auf eine Geometrie zugeschnitten werden soll.
    maskAntialiasMode Ein Wert, der den Antialiasingmodus für die geometrische Maske angibt, die durch das geometrischeMask-Feld angegeben wird.
    maskTransform Ein Wert, der die Transformation angibt, die beim Zusammenstellen der Ebene auf die geometrische Maske angewendet wird. Dies ist relativ zur Welttransformation.
    Deckkraft Der Deckkraftwert der Ebene. Die Deckkraft jeder Ressource der Ebene wird mit diesem Wert multipliziert, wenn sie zum Ziel zusammengesetzt wird.
    opacityBrush (Optional) Ein Pinsel, der zum Ändern der Deckkraft der Ebene verwendet wird. Der Pinsel wird der Ebene zugeordnet, und der Alphakanal jedes zugeordneten Pinselpixels wird mit dem entsprechenden Layerpixel multipliziert. Legen Sie diesen Wert auf NULL fest, wenn die Ebene keine Deckkraftmaske haben soll.
    layerOptions Ein Wert, der angibt, ob die Ebene Text mit ClearType-Antialiasing rendert. Dieser Parameter ist standardmäßig deaktiviert. Wenn Sie ihn aktivieren, kann ClearType ordnungsgemäß funktionieren, führt aber zu etwas langsamerer Renderinggeschwindigkeit.

     

    Hinweis

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

     

    Aus Gründen der Einfachheit stellt Direct2D die D2D1::LayerParameters-Methode bereit, mit der Sie D2D1_LAYER_PARAMETERS Strukturen erstellen können.

  • Um den Inhalt der Ebene zum Render-Ziel zusammenzusetzen, rufen Sie die PopLayer-Methode auf. 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, mit Ausnahme von opacityBrush, das auf einen 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 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 angezeigt werden, wird das Renderziel in einen Fehlerzustand versetzt und gibt einen Fehler zurück. Verwenden Sie EndDraw, um den Fehlerstatus zu löschen.

Inhaltsgrenzen

contentBounds- legt die Begrenzung dafür fest, was auf der Ebene gezeichnet werden soll. Nur diese Elemente innerhalb der Inhaltsgrenzen werden wieder zum Renderziel zusammengesetzt.

Im folgenden Beispiel wird gezeigt, wie Sie contentBounds angeben, so dass das ursprüngliche Bild innerhalb der Inhaltsgrenzen beschnitten wird, mit der oberen linken Ecke bei (10, 108) und der unteren rechten Ecke bei (121, 177). Die folgende Abbildung zeigt das originale Bild und das Ergebnis des Zuschneidens des Bildes auf die Inhaltsgrenzen.

Abbildung von Inhaltsgrenzen in einem Originalbild und dem resultierenden abgeschnittenen Bild

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 wird weiterhin beeinflusst, 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 einer Geometrie zu maskieren. Wenn Sie z. B. ein Bild mit einem Blockbuchstaben "A" anzeigen möchten, 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 Verschieben der Ebene das Bild zeichnen. Durch das Auffüllen der Ebene wird das Bild auf den Blockbuchstaben „A“ zugeschnitten.

Das folgende Beispiel zeigt, wie Sie eine ID2D1PathGeometry mit einer Form eines Berges erstellen und dann die Pfadgeometrie an die PushLayer übergeben. Anschließend zeichnet sie 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.

Abbildung eines Blatts und des resultierenden Bilds nach Anwendung einer geometrischen Bergmaske

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 geometrische Maske angeben, können Sie im Allgemeinen den Standardwert InfiniteRect für die "contentBounds" verwenden.

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

Wenn contentBounds ungleich NULL ist und geometricMask ungleich NULL ist, wird die transformierte geometrische Maske effektiv von den Inhaltsgrenzen begrenzt, und die Inhaltsgrenzen werden als unendlich betrachtet.

 

Deckkraftmasken

Eine Deckkraftmaske ist eine Maske, die durch einen Pinsel oder eine Bitmap definiert wird, und die 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. Sie können z. B. einen radialen Farbverlaufpinsel definieren, der von undurchsichtig bis transparent variiert, um einen Vignetteneffekt zu erstellen.

Im folgenden Beispiel wird eine ID2D1RadialGradientBrush (m_pRadialGradientBrush) als Deckkraftmaske verwendet. Anschließend zeichnet sie 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 dieses Beispiels.

Illustration eines Bildes von Bäumen und des resultierenden Bildes nach dem Anwenden einer Deckkraftmaske

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. Wenn Sie eine Deckkraftmaske auf ein einzelnes Objekt anwenden, ist es effizienter, die Methoden FillOpacityMask oder FillGeometry anstelle einer Ebene zu verwenden.

 

Anleitungen dazu, wie Sie eine Deckkraftmaske ohne Verwendung einer Ebene anwenden können, finden Sie in der Übersicht über Deckkraftmasken.

Alternativen zu Ebenen

Wie bereits erwähnt, kann sich eine übermäßige Anzahl von Ebenen negativ auf die Leistung Ihrer Anwendung auswirken. Um die Leistung zu verbessern, vermeiden Sie die Verwendung von Ebenen, wenn möglich; verwenden Sie stattdessen ihre Alternativen. Im folgenden Codebeispiel wird gezeigt, wie Sie PushAxisAlignedClip und PopAxisAlignedClip verwenden können, um einen Bereich zu schneiden, als Alternative zur Verwendung eines Layers mit Inhaltsgrenzen.

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 ebenso FillGeometry mit einem angehefteten Bitmap-Pinsel 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 zu beschneiden, 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 schließlich die Deckkraft auf ein einzelnes Primitiv anwenden möchten, sollten Sie die Deckkraft mit der Pinselfarbe multiplizieren und dann das Primitiv rendern. Sie benötigen keine Ebene oder oder 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
    );

Ausschneiden einer beliebigen Form

Die folgende Abbildung zeigt das Ergebnis des Anwendens 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 Methode FillGeometry mit einem Deckkraftpinsel verwenden.

Hier ist ein Beispiel, das eine Ebene verwendet:

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

Hier ist ein Beispiel, das 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());

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 Layern vorgenommen, und wir empfehlen, layer-APIs anstelle von FillGeometry nach Möglichkeit zu verwenden.

 

Achsenausgerichtete Clips

Wenn der zu beschneidende Bereich nicht beliebig, sondern an der Achse der Zeichenfläche ausgerichtet ist. Dieser Fall eignet sich für die Verwendung eines Clip-Rechtecks anstelle einer Ebene. Der Performance-Vorteil ist bei Geometrien mit Aliasing größer als bei Geometrien mit Anti-Aliasing. Weitere Informationen zu achsenausgerichteten Clips finden Sie im Thema PushAxisAlignedClip .

Direct2D-Referenz

 

 

  • Last updated on