Ü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 in Windows 8 und höher
  • ID2D1DeviceContext und PushLayer
  • D2D1_LAYER_PARAMETERS1 und D2D1_LAYER_OPTIONS1
  • Füllmethoden
  • Interoperation
• Erstellen von Ebenen
• Inhaltsgrenzen
• Geometrische Masken
• Deckkraftmasken
• Alternativen zu Ebenen
• Ausschneiden einer beliebigen Form
  • Achsenorientierte Clips
• Zugehörige Themen

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 weitergeleitet. Nachdem Sie mit der Ebene fertig sind, "popen" Sie die Ebene aus dem Renderziel, wodurch der Inhalt der Ebene wieder dem Renderziel zugeordnet wird.

Ebenen sind wie Pinsel geräteabhängige Ressourcen, die von Renderzielen erstellt werden. Ebenen können für jedes Renderziel in derselben Ressourcendomäne verwendet werden, die das Renderziel enthält, von dem es erstellt wurde. Eine Ebenenressource kann jedoch nur von einem Renderziel gleichzeitig verwendet werden. Weitere Informationen zu Ressourcen finden Sie in der Ressourcenübersicht.

Obwohl Ebenen eine leistungsfähige Renderingtechnik zum Erzeugen interessanter Effekte bieten, kann eine übermäßige Anzahl von Ebenen in einer Anwendung aufgrund der verschiedenen Kosten, die mit der Verwaltung von Ebenen und Ebenenressourcen verbunden sind, die Leistung beeinträchtigen. Beispielsweise fallen die Kosten für das Füllen oder Löschen der Schicht und das anschließende Wiedervermischen der Schicht an, insbesondere auf höherwertige Hardware. Dann fallen die Kosten für die Verwaltung der Ebenenressourcen an. Wenn Sie diese häufig neu zuweisen, sind die daraus resultierenden Würstchen gegenüber der GPU das größte Problem. Wenn Sie Ihre Anwendung entwerfen, versuchen Sie, die Wiederverwendung von Ebenenressourcen zu maximieren.

Ebenen in Windows 8 und höher

Windows 8 neue ebenenbezogene APIs eingeführt, die die Leistung von Ebenen 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 Ebenenressource und kann Ressourcen zwischen Ebenen und Effektdiagrammen gemeinsam nutzen.

D2D1_LAYER_PARAMETERS1 und D2D1_LAYER_OPTIONS1

Die D2D1_LAYER_PARAMETERS1-Struktur ist mit D2D1_LAYER_PARAMETERS identisch, mit der Ausnahme, dass das letzte Element 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:

• D2D1_LAYER_OPTIONS1_INITIALIZE_FROM_BACKGROUND: Direct2D rendert Primitive auf der Ebene, ohne sie mit transparentem Schwarz zu löschen. Dies ist nicht der Standard, führt aber in den meisten Fällen zu einer besseren Leistung.

• D2D1_LAYER_OPTIONS1_IGNORE_ALPHA: Wenn die zugrunde liegende Oberfläche auf D2D1_ALPHA_MODE_IGNORE festgelegt ist, kann Direct2D mit dieser Option verhindern, dass der Alphakanal der Ebene geändert wird. Verwenden Sie dies nicht in anderen Fällen.

Füllmethoden

Ab Windows 8 verfügt der Gerätekontext über einen primitiven Mischmodus, der bestimmt, wie die einzelnen Grundelemente mit der Zieloberfläche gemischt werden. Dieser Modus gilt auch für Ebenen, wenn Sie die PushLayer-Methode aufrufen.

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

Interoperation

Ab Windows 8 unterstützt Direct2D die Zusammenarbeit mit Direct3D und GDI, während eine Ebene oder ein Clip gepusht wird. Sie rufen ID2D1GdiInteropRenderTarget::GetDC auf, während eine Ebene gepusht wird, um mit GDI zu arbeiten. 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 Ebenen erfordert Vertrautheit mit den Methoden CreateLayer, PushLayer und PopLayer sowie mit der D2D1_LAYER_PARAMETERS-Struktur , die einen Satz parametrischer Daten enthält, der definiert, 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 Ebenenressource 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. Die PushLayer-Methode fügt die angegebene Ebene dem Renderziel 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 einen layerParameters in der D2D1_LAYER_PARAMETERS-Struktur . In der folgenden Tabelle werden die Felder der Struktur beschrieben.

  Feld	BESCHREIBUNG
  contentBounds	Die Inhaltsgrenzen der Ebene. Inhalte werden nicht außerhalb dieser Grenzen gerendert. Dieser Parameter ist standardmäßig InfiniteRect. Wenn der Standardwert verwendet wird, werden die Inhaltsgrenzen effektiv als Grenzen des Renderziels festgelegt.
  geometricMask	(Optional) Der Bereich, der durch eine ID2D1Geometry definiert ist, an den die Ebene abgeschnitten werden soll. Legen Sie auf NULL fest, wenn die Ebene nicht an eine Geometrie gekappt 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 Komponieren 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 Kompositing 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. 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 möchte. Dieser Parameter ist standardmäßig deaktiviert. Wenn Sie ihn 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

   

  Der Einfachheit halber stellt Direct2D die D2D1::LayerParameters-Methode bereit, mit der Sie D2D1_LAYER_PARAMETERS Strukturen erstellen können.

• Um den Inhalt der Ebene mit dem Renderziel zusammenzufügen, rufen Sie die PopLayer-Methode auf. Sie müssen die PopLayer-Methode aufrufen, bevor Sie die EndDraw-Methode aufrufen.

Im folgenden Beispiel wird gezeigt, wie Sie CreateLayer, PushLayer und PopLayer verwenden. Alle Felder in der D2D1_LAYER_PARAMETERS-Struktur sind auf ihre Standardwerte festgelegt, mit Ausnahme von opacityBrush, der 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 aus diesem Beispiel weggelassen.

Beachten Sie, dass sie beim Aufrufen von PushLayer und PopLayer sicherstellen, dass jeder PushLayer über einen entsprechenden PopLayer-Anruf 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 geknallt 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 den Grenzwert fest, der auf die Ebene gezeichnet werden soll. Nur die Elemente innerhalb der Inhaltsgrenzen werden mit dem Renderziel zusammengesetzt.

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

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 beschnittene Bild ist weiter betroffen, wenn Sie eine geometrischeMaske angeben. Weitere Informationen finden Sie im Abschnitt Geometrische Masken .

 

Geometrische Masken

Eine geometrische Maske ist ein Clip oder ein Ausschnitt, der durch ein ID2D1Geometry-Objekt definiert wird und 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 beispielsweise ein Bild anzeigen möchten, das von einem 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. Nachdem Sie die Ebene gepusht haben, können Sie das Bild zeichnen. Durch das Auffüllen der Ebene wird das Bild an die Form "A" des Blockbuchstabens abgeschnitten.

Das folgende Beispiel zeigt, wie Sie eine ID2D1PathGeometry erstellen, die eine Form eines Berges enthält, und dann die Pfadgeometrie an pushLayer übergeben. Anschließend zeichnet es eine Bitmap und Quadrate. Wenn nur eine Bitmap in der Ebene gerendert werden soll, verwenden Sie FillGeometry mit einem gespannten Bitmappinsel, um die Effizienz zu erzielen. Die folgende Abbildung zeigt die Ausgabe des Beispiels.

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 geometrischeMask angeben, können Sie im Allgemeinen den Standardwert InfiniteRect fü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 die Inhaltsgrenzen werden als unendlich angenommen.

 

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. Es ermöglicht die Verwendung des Alphakanals eines Pinsels als Inhaltsmaske. Sie können beispielsweise einen radialen Farbverlaufspinsel definieren, der von undurchsichtig bis transparent variiert, um einen Vignetteneffekt zu erzeugen.

Im folgenden Beispiel wird ein 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 gespannten Bitmappinsel, um die Effizienz zu erzielen. Die folgende Abbildung zeigt die Ausgabe aus diesem Beispiel.

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 FillOpacityMask - oder FillGeometry-Methoden 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 sich eine übermäßige Anzahl von Ebenen negativ auf die Leistung Ihrer Anwendung auswirken. Um die Leistung zu verbessern, sollten Sie möglichst keine Ebenen verwenden. verwenden Sie stattdessen ihre Alternativen. Im folgenden Codebeispiel wird gezeigt, wie Sie mithilfe von PushAxisAlignedClip und PopAxisAlignedClip einen Bereich als Alternative zur Verwendung einer Ebene mit Inhaltsgrenzen ausschneiden.

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

Ebenso verwenden Sie FillGeometry mit einem gespannten Bitmappinsel als Alternative zur Verwendung einer Ebene mit einer Deckkraftmaske, wenn nur ein Inhalt in der Ebene gerendert werden muss, 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 die Deckkraft 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
    ); 

Beschneiden einer beliebigen Form

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

Sie können dieses Ergebnis erhalten, 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 viele Optimierungen für die Verwendung von Ebenen vorgenommen wurden, und es wird empfohlen, nach Möglichkeit die Verwendung von Ebenen-APIs anstelle von FillGeometry zu verwenden.

 

Achsenbündig ausgerichtete Clips

Wenn der zu beschneidende Bereich an der Achse der Zeichnungsoberfläche ausgerichtet ist, anstatt an beliebiger Stelle. Dieser Fall eignet sich für die Verwendung eines Cliprechtecks anstelle einer Ebene. Die Leistungssteigerung ist eher für Aliasgeometrie als für antialiasierte Geometrie. Weitere Informationen zu Achsen ausgerichteten Clips finden Sie im Thema PushAxisAlignedClip .

Zugehörige Themen

Direct2D-Referenz