Übersicht über Pinsel

In dieser Übersicht wird beschrieben, wie Sie ID2D1SolidColorBrush-, ID2D1LinearGradientBrush-, ID2D1RadialGradientBrush-und ID2D1BitmapBrush-Objekte erstellen und verwenden, um Bereiche mit Volltonfarben, Farbverläufen und Bitmaps zu zeichnen. Der Abschnitt ist wie folgt gegliedert.

Voraussetzungen

In dieser Übersicht wird davon ausgegangen, dass Sie mit der Struktur einer einfachen Direct2D-Anwendung vertraut sind, wie unter Erstellen einer einfachen Direct2D-Anwendung beschrieben.

Pinseltypen

Ein Pinsel "zeichnet" einen Bereich mit seiner Ausgabe. Verschiedene Pinsel haben unterschiedliche Ausgabetypen. Direct2D bietet vier Pinseltypen: ID2D1SolidColorBrush zeichnet einen Bereich mit einer Volltonfarbe, ID2D1LinearGradientBrush mit einem linearen Farbverlauf, ID2D1RadialGradientBrush mit einem radialen Farbverlauf und ID2D1BitmapBrush mit einer Bitmap.

Hinweis

Ab Windows 8 können Sie auch ID2D1ImageBrushverwenden. Dies ähnelt einem Bitmappinsel, aber Sie können auch Primitive verwenden.

Alle Pinsel erben von ID2D1Brush und teilen eine Reihe von allgemeinen Features (Festlegen und Abrufen der Deckkraft und Transformieren von Pinseln). Sie werden von ID2D1RenderTarget erstellt und sind geräteabhängige Ressourcen: Ihre Anwendung sollte Pinsel erstellen, nachdem sie das Renderziel initialisiert hat, mit dem die Pinsel verwendet werden, und die Pinsel neu erstellen, wenn das Renderziel neu erstellt werden muss. (Weitere Informationen zu Ressourcen finden Sie unter Übersicht über Ressourcen.)

Die folgende Abbildung zeigt Beispiele für jeden der verschiedenen Pinseltypen.

Abbildung der visuellen Effekte von Volltonfarbpinsel, Pinseln mit linearem Farbverlauf, Radialfarbpinsel und Bitmappinsel

Farbgrundkenntnisse

Bevor Sie mit einem ID2D1SolidColorBrush oder einem Farbverlaufspinsel zeichnen, müssen Sie Farben auswählen. In Direct2D werden Farben durch die D2D1 _ COLOR _ F-Struktur dargestellt (die eigentlich nur ein neuer Name für die Struktur ist, die von Direct3D, D3DCOLORVALUE)verwendet wird.

Vor der Windows 8 verwendet D2D1 _ COLOR _ F die sRGB-Codierung. Die sRGB-Codierung unterteilt Farben in vier Komponenten: Rot, Grün, Blau und Alpha. Jede Komponente wird durch einen Gleitkommawert mit einem normalen Bereich von 0,0 bis 1,0 dargestellt. Ein Wert von 0,0 gibt das vollständige Fehlen von Farbe an, während der Wert 1,0 angibt, dass die Farbe vollständig vorhanden ist. In der Alpha-Komponente steht 0,0 für vollständig transparente Farbe und 1,0 für vollständig deckende Farbe.

Ab Windows 8 akzeptiert D2D1 _ COLOR _ F auch scRGB-Codierung. scRGB ist eine Obermenge von , die Farbwerte über 1,0 und unter 0,0 zulässt.

Zum Definieren einer Farbe können Sie die D2D1 _ COLOR _ F-Struktur verwenden und ihre Felder selbst initialisieren, oder Sie können die Klasse D2D1::ColorF verwenden, um die Farbe zu erstellen. Die ColorF-Klasse stellt mehrere Konstruktoren zum Definieren von Farben zur Auswahl. Wenn der Alphawert in den Konstruktoren nicht angegeben ist, wird standardmäßig 1,0 verwendet.

  • Verwenden Sie den ColorF(Enum, FLOAT)-Konstruktor, um eine vordefinierte Farbe und einen Alphakanalwert anzugeben. Ein Alphakanalwert liegt zwischen 0,0 und 1,0, wobei 0,0 eine vollständig transparente Farbe und 1,0 eine vollständig deckende Farbe darstellt. Die folgende Abbildung zeigt mehrere vordefinierte Farben und ihre hexadezimalen Entsprechungen. Eine vollständige Liste vordefinierter Farben finden Sie im Abschnitt Farbkonst constants der ColorF-Klasse.

    Abbildung vordefinierter Farben

    Im folgenden Beispiel wird eine vordefinierte Farbe erstellt und verwendet, um die Farbe eines ID2D1SolidColorBrush anzugeben.

hr = m_pRenderTarget->CreateSolidColorBrush(
    D2D1::ColorF(D2D1::ColorF::Black, 1.0f),
    &m_pBlackBrush
    );
  • Verwenden Sie den ColorF(FLOAT, FLOAT, FLOAT, FLOAT)-Konstruktor, um eine Farbe in der Sequenz von Rot, Grün, Blau und Alpha anzugeben, wobei jedes Element einen Wert zwischen 0,0 und 1,0 hat.

    Im folgenden Beispiel werden die Werte rot, grün, blau und alpha für eine Farbe angegeben.

    ID2D1SolidColorBrush *pGridBrush = NULL;
    hr = pCompatibleRenderTarget->CreateSolidColorBrush(
        D2D1::ColorF(D2D1::ColorF(0.93f, 0.94f, 0.96f, 1.0f)),
        &pGridBrush
        );
    hr = m_pRenderTarget->CreateSolidColorBrush(
        D2D1::ColorF(D2D1::ColorF(0x9ACD32, 1.0f)),  
        &m_pYellowGreenBrush
        );

Alphamodi

Unabhängig vom Alphamodus des Renderziels, mit dem Sie einen Pinsel verwenden, werden D2D1 _ COLOR _ F-Werte immer als gerades Alpha interpretiert.

Verwenden von Volltonfarbpinsel

Rufen Sie zum Erstellen eines Volltonfarbpinsels die ID2D1RenderTarget::CreateSolidColorBrush-Methode auf, die ein HRESULT und ein ID2D1SolidColorBrush-Objekt zurückgibt. Die folgende Abbildung zeigt ein Quadrat, das mit einem schwarzen Farbpinsel gestrichelt und mit einem Volltonfarbpinsel gestrichelt wird, der den Farbwert 0x9ACD32.

Abbildung eines mit einem Volltonfarbpinsel gestrichenen Quadrats

Der folgende Code zeigt, wie Sie einen schwarzen Farbpinsel und einen Pinsel mit dem Farbwert 0x9ACD32 zum Füllen und Zeichnen dieses Quadrats erstellen und verwenden.

    ID2D1SolidColorBrush *m_pBlackBrush;
    ID2D1SolidColorBrush *m_pYellowGreenBrush;
if (SUCCEEDED(hr))
{
    hr = m_pRenderTarget->CreateSolidColorBrush(
        D2D1::ColorF(D2D1::ColorF::Black, 1.0f),
        &m_pBlackBrush
        );
}

// Create a solid color brush with its rgb value 0x9ACD32.
if (SUCCEEDED(hr))
{
    hr = m_pRenderTarget->CreateSolidColorBrush(
        D2D1::ColorF(D2D1::ColorF(0x9ACD32, 1.0f)),  
        &m_pYellowGreenBrush
        );
}
m_pRenderTarget->FillRectangle(&rcBrushRect, m_pYellowGreenBrush);
m_pRenderTarget->DrawRectangle(&rcBrushRect, m_pBlackBrush, 1, NULL);

Im Gegensatz zu anderen Pinseln ist das Erstellen eines ID2D1SolidColorBrush ein relativ kostengünstiger Vorgang. Sie können jedes Mal ID2D1SolidColorBrush-Objekte erstellen, wenn Sie rendern, ohne dass dies auswirkungen auf die Leistung hat. Dieser Ansatz wird für Farbverlaufs- oder Bitmappinsel nicht empfohlen.

Verwenden linearer Farbverlaufspinsel

Ein ID2D1LinearGradientBrush zeichnet einen Bereich mit einem linearen Farbverlauf, der entlang einer Linie, der Farbverlaufsachse, definiert ist. Sie geben die Farben des Farbverlaufs und deren Position entlang der Farbverlaufsachse mithilfe von ID2D1GradientStop-Objekten an. Sie können auch die Farbverlaufsachse ändern, wodurch Sie einen horizontalen und vertikalen Farbverlauf erstellen und die Farbverlaufsrichtung umkehren können. Um einen linearen Farbverlaufspinsel zu erstellen, rufen Sie die ID2D1RenderTarget::CreateLinearGradientBrush-Methode auf.

Die folgende Abbildung zeigt ein Quadrat, das mit einem ID2D1LinearGradientBrush gestrichen wird, der über zwei vordefinierte Farben verfügt: "Yellow" und "ForestGreen".

Abbildung eines Quadrats, das mit einem linearen Farbverlaufspinsel aus Gelb und Gesamtstrukturgrün gestrichen ist

Führen Sie die folgenden Schritte aus, um den in der vorherigen Abbildung gezeigten Farbverlauf zu erstellen:

  1. Deklarieren Sie zwei D2D1 _ GRADIENT _ STOP-Objekte. Jeder Farbverlaufsstopp gibt eine Farbe und eine Position an. Eine Position von 0,0 gibt den Anfang des Farbverlaufs an, während eine Position von 1,0 das Ende des Farbverlaufs angibt.

    Der folgende Code erstellt ein Array von zwei D2D1 _ GRADIENT _ STOP-Objekten. Der erste Stopp gibt die Farbe "Yellow" an position 0 an, und der zweite Stopp gibt die Farbe "ForestGreen" an Position 1 an.

    // Create an array of gradient stops to put in the gradient stop
    // collection that will be used in the gradient brush.
    ID2D1GradientStopCollection *pGradientStops = NULL;

    D2D1_GRADIENT_STOP gradientStops[2];
    gradientStops[0].color = D2D1::ColorF(D2D1::ColorF::Yellow, 1);
    gradientStops[0].position = 0.0f;
    gradientStops[1].color = D2D1::ColorF(D2D1::ColorF::ForestGreen, 1);
    gradientStops[1].position = 1.0f;
  1. Erstellen Sie eine ID2D1GradientStopCollection. Das folgende Beispiel ruft CreateGradientStopCollectionauf und überträgt das Array von D2D1 _ GRADIENT _ STOP-Objekten, die Anzahl der Farbverlaufsstopps (2), D2D1 _ GAMMA _ 2 _ 2 für die Interpolation und D2D1 _ EXTEND MODE _ _ CLAMP für den Extend-Modus.
    // Create the ID2D1GradientStopCollection from a previously
    // declared array of D2D1_GRADIENT_STOP structs.
    hr = m_pRenderTarget->CreateGradientStopCollection(
        gradientStops,
        2,
        D2D1_GAMMA_2_2,
        D2D1_EXTEND_MODE_CLAMP,
        &pGradientStops
        );
  1. Erstellen Sie id2D1LinearGradientBrush. Das nächste Beispiel ruft die CreateLinearGradientBrush-Methode auf und übergibt ihr die Linear Gradient Brush-Eigenschaften, die den Startpunkt bei (0, 0) und den Endpunkt bei (150, 150) enthalten, und der Farbverlauf wird beendet, der im vorherigen Schritt erstellt wurde.
    // The line that determines the direction of the gradient starts at
    // the upper-left corner of the square and ends at the lower-right corner.

    if (SUCCEEDED(hr))
    {
        hr = m_pRenderTarget->CreateLinearGradientBrush(
            D2D1::LinearGradientBrushProperties(
                D2D1::Point2F(0, 0),
                D2D1::Point2F(150, 150)),
            pGradientStops,
            &m_pLinearGradientBrush
            );
    }
  1. Verwenden Sie id2D1LinearGradientBrush. Im nächsten Codebeispiel wird der Pinsel verwendet, um ein Rechteck zu füllen.
    m_pRenderTarget->FillRectangle(&rcBrushRect, m_pLinearGradientBrush);

Weitere Informationen zu Farbverlaufsstopps

D2D1 _ GRADIENT _ STOP ist der grundlegende Baustein eines Farbverlaufspinsels. Ein Farbverlaufsstopp gibt die Farbe und die Position entlang der Farbverlaufsachse an. Der Wert der Farbverlaufsposition liegt zwischen 0,0 und 1,0. Je näher es an 0,0 liegt, je näher die Farbe am Anfang des Farbverlaufs liegt; Je näher es an 1,0 liegt, je näher die Farbe am Ende des Farbverlaufs liegt.

In der folgenden Abbildung werden die Farbverlaufsstopps dargestellt. Der Kreis markiert die Position von Farbverlaufsstopps, und eine gestrichelte Linie zeigt die Farbverlaufsachse an.

Abbildung eines Pinsels mit linearem Farbverlauf mit vier Stopps entlang der Achse

Der erste Farbverlaufsstopp gibt die Farbe Gelb an einer Position von 0,0 an. Der zweite Farbverlaufsstopp gibt die rote Farbe an einer Position von 0,25 an. Von links nach rechts entlang der Farbverlaufsachse ändern sich die Farben zwischen diesen beiden Stopps allmählich von gelb in rot. Der dritte Farbverlaufsstopp gibt die blaue Farbe an einer Position von 0,75 an. Die Farben zwischen dem zweiten und dritten Farbverlaufsstopp ändern sich allmählich von rot in blau. Der vierte Farbverlaufsstopp gibt Limonengrün an einer Position von 1,0 an. Die Farben zwischen dem dritten und vierten Farbverlaufsstopp ändern sich allmählich von Blau in Blaugrün.

Die Farbverlaufsachse

Wie bereits erwähnt, werden Farbverlaufsstopps eines Pinsels mit linearem Farbverlauf entlang einer Linie, der Farbverlaufsachse, positioniert. Sie können die Ausrichtung und Größe der Linie mithilfe der Felder startPoint und endPoint der D2D1 _ LINEAR GRADIENT BRUSH _ _ _ PROPERTIES-Struktur angeben, wenn Sie einen Pinsel mit linearem Farbverlauf erstellen. Nachdem Sie einen Pinsel erstellt haben, können Sie die Farbverlaufsachse anpassen, indem Sie die Methoden SetStartPoint und SetEndPoint des Pinsels aufrufen. Durch Bearbeiten des Start- und Endpunkts des Pinsels können Sie horizontale und vertikale Farbverläufe erstellen, die Farbverlaufsrichtung umkehren und mehr.

In der folgenden Abbildung ist der Startpunkt beispielsweise auf (0,0) und der Endpunkt auf (150, 50) festgelegt. dadurch wird ein diagonaler Farbverlauf erstellt, der in der oberen linken Ecke beginnt und sich bis zur unteren rechten Ecke des gestrichenen Bereichs erstreckt. Wenn Sie den Startpunkt auf (0, 25) und den Endpunkt auf (150, 25) festlegen, wird ein horizontaler Farbverlauf erstellt. Entsprechend wird durch Festlegen des Startpunkts auf (75, 0) und des Endpunkts auf (75, 50) ein vertikaler Farbverlauf erstellt. Durch Festlegen des Startpunkts auf (0, 50) und des Endpunkts auf (150, 0) wird ein diagonaler Farbverlauf erstellt, der in der unteren linken Ecke beginnt und sich bis zur oberen rechten Ecke des gestrichenen Bereichs erstreckt.

Abbildung von vier verschiedenen Farbverlaufsachsen über demselben Rechteck

Verwenden von Pinseln mit radialem Farbverlauf

Im Gegensatz zu einem ID2D1LinearGradientBrush,bei dem zwei oder mehr Farben entlang einer Farbverlaufsachse kombiniert werden, zeichnet ein ID2D1RadialGradientBrush einen Bereich mit einem radialen Farbverlauf, der zwei oder mehr Farben über eine Ellipse kombiniert. Während ein ID2D1LinearGradientBrush seine Farbverlaufsachse mit einem Startpunkt und einem Endpunkt definiert, definiert ein ID2D1RadialGradientBrush seine Farbverlaufsellipse durch Angabe eines Mittelpunkts, horizontaler und vertikaler Radien und eines Farbverlaufs-Ursprungsoffsets.

Wie ein ID2D1LinearGradientBrushverwendet ein ID2D1RadialGradientBrush eine ID2D1GradientStopCollection, um die Farben und Positionen im Farbverlauf anzugeben.

Die folgende Abbildung zeigt einen Kreis, der mit einem ID2D1RadialGradientBrush gestrichen ist. Der Kreis verfügt über zwei Farbverlaufsstopps: Der erste gibt eine vordefinierte Farbe "Yellow" an einer Position von 0,0 an, und der zweite gibt eine vordefinierte Farbe "ForestGreen" an einer Position von 1,0 an. Der Farbverlauf hat einen Mittelpunkt von (75, 75), einen Farbverlaufs-Ursprungsoffset von (0, 0) und einen x- und y-Radius von 75.

Abbildung eines kreisförmigen Pinsels, der mit einem radialen Farbverlauf gestrichen wurde

Die folgenden Codebeispiele zeigen, wie sie diesen Kreis mit einem ID2D1RadialGradientBrush zeichnen, der über zwei Farbstopps verfügt: "Yellow" an einer Position von 0,0 und "ForestGreen" an einer Position von 1,0. Ähnlich wie beim Erstellen eines ID2D1LinearGradientBrushruft das Beispiel CreateGradientStopCollection auf, um eine ID2D1GradientStopCollection aus einem Array von Farbverlaufsstopps zu erstellen.

// Create an array of gradient stops to put in the gradient stop
// collection that will be used in the gradient brush.
ID2D1GradientStopCollection *pGradientStops = NULL;

D2D1_GRADIENT_STOP gradientStops[2];
gradientStops[0].color = D2D1::ColorF(D2D1::ColorF::Yellow, 1);
gradientStops[0].position = 0.0f;
gradientStops[1].color = D2D1::ColorF(D2D1::ColorF::ForestGreen, 1);
gradientStops[1].position = 1.0f;
// Create the ID2D1GradientStopCollection from a previously
// declared array of D2D1_GRADIENT_STOP structs.
hr = m_pRenderTarget->CreateGradientStopCollection(
    gradientStops,
    2,
    D2D1_GAMMA_2_2,
    D2D1_EXTEND_MODE_CLAMP,
    &pGradientStops
    );

Verwenden Sie zum Erstellen eines ID2D1RadialGradientBrushdie ID2D1RenderTarget::CreateRadialGradientBrush-Methode. CreateRadialGradientBrush verwendet drei Parameter. Der erste Parameter, ein D2D1 _ RADIAL GRADIENT BRUSH _ _ _ PROPERTIES, gibt den Mittelpunkt, den Farbverlaufsursprungsoffset und die horizontalen und vertikalen Radien des Farbverlaufs an. Der zweite Parameter ist eine ID2D1GradientStopCollection, die die Farben und ihre Positionen im Farbverlauf beschreibt. Der dritte Parameter ist die Adresse des Zeigers, der den neuen ID2D1RadialGradientBrush-Verweis empfängt. Einige Überladungen akzeptieren einen zusätzlichen Parameter, eine D2D1 _ BRUSH _ PROPERTIES-Struktur, die einen Deckkraftwert und eine Transformation angibt, die auf den neuen Pinsel angewendet werden soll.

Das nächste Beispiel ruft CreateRadialGradientBrushauf, übergibt das Array von Farbverlaufsstopps und die Eigenschaften des radialen Farbverlaufspinsels, deren Mittelpunktwert auf (75, 75), gradientOriginOffset auf (0, 0) und radiusX und radiusY auf 75 festgelegt ist.

// The center of the gradient is in the center of the box.
// The gradient origin offset was set to zero(0, 0) or center in this case.
if (SUCCEEDED(hr))
{
    hr = m_pRenderTarget->CreateRadialGradientBrush(
        D2D1::RadialGradientBrushProperties(
            D2D1::Point2F(75, 75),
            D2D1::Point2F(0, 0),
            75,
            75),
        pGradientStops,
        &m_pRadialGradientBrush
        );
}

Im letzten Beispiel wird der Pinsel verwendet, um eine Ellipse auszufüllen.

m_pRenderTarget->FillEllipse(ellipse, m_pRadialGradientBrush);
m_pRenderTarget->DrawEllipse(ellipse, m_pBlackBrush, 1, NULL);

Konfigurieren eines radialen Farbverlaufs

Unterschiedliche Werte für zentriert, gradientOriginOffset, radiusX und/oder radiusY erzeugen unterschiedliche Farbverläufe. Die folgende Abbildung zeigt mehrere radiale Farbverläufe, die unterschiedliche Gradientenursprungsoffsets aufweisen, wodurch die Darstellung des Lichts entsteht, das die Kreise aus unterschiedlichen Winkeln hervorstrahlt.

Abbildung des gleichen Kreises, der mit radialen Farbverlaufspinsel mit unterschiedlichen Ursprungsoffsets gezeichnet wurde

Verwenden von Bitmappinsel

Ein ID2D1BitmapBrush zeichnet einen Bereich mit einer Bitmap (dargestellt durch ein ID2D1Bitmap-Objekt).

Die folgende Abbildung zeigt ein Quadrat, das mit einer Bitmap einer Anlage gezeichnet wurde.

Abbildung eines Quadrats, das mit einer Plantmap gezeichnet wurde

Die folgenden Beispiele zeigen, wie dieses Quadrat mit einem ID2D1BitmapBrushzeichnet wird.

Im ersten Beispiel wird eine ID2D1Bitmap für die Verwendung mit dem Pinsel initialisiert. Die ID2D1Bitmap wird von der Hilfsmethode LoadResourceBitmap bereitgestellt, die an anderer Stelle im Beispiel definiert ist.

// Create the bitmap to be used by the bitmap brush.
if (SUCCEEDED(hr))
{
    hr = LoadResourceBitmap(
        m_pRenderTarget,
        m_pWICFactory,
        L"FERN",
        L"Image",
        &m_pBitmap
        );
}

Um den Bitmappinsel zu erstellen, rufen Sie die ID2D1RenderTarget::CreateBitmapBrush-Methode auf, und geben Sie die ID2D1Bitmap an, mit der zusammengestellt werden soll. Die -Methode gibt ein HRESULT- und ein ID2D1BitmapBrush-Objekt zurück. Mit einigen CreateBitmapBrush-Überladungen können Sie zusätzliche Optionen angeben, indem Sie eine D2D1 _ BRUSH _ PROPERTIES- und eine D2D1 _ BITMAP BRUSH _ _ PROPERTIES-Struktur akzeptieren.

if (SUCCEEDED(hr))
{
    hr = m_pRenderTarget->CreateBitmapBrush(
        m_pBitmap,
        &m_pBitmapBrush
        );
}

Im nächsten Beispiel wird der Pinsel verwendet, um ein Rechteck auszufüllen.

m_pRenderTarget->FillRectangle(&rcBrushRect, m_pBitmapBrush);

Konfigurieren von Erweiterungsmodi

Manchmal füllt der Farbverlauf eines Farbverlaufspinsels oder der Bitmap für einen Bitmappinsel den gezeichneten Bereich nicht vollständig aus.

Die folgende Abbildung zeigt die Ergebnisse jeder möglichen Kombination der Extend-Modi für einen ID2D1BitmapBrush: D2D1 _ EXTEND MODE _ _ WRAP (WRAP), D2D1 _ EXTEND MODE _ _ WRAP (WRAP) und D2D1 _ EXTEND _ MIRROR (MIRROR).

Abbildung eines originalen Bilds und der resultierenden Bilder aus verschiedenen Erweiterungsmodi

Das folgende Beispiel zeigt, wie der x- und y-Extend-Modus des Bitmappinsels auf D2D1 _ EXTEND _ MIRRORfestgelegt wird. Anschließend zeichnet es das Rechteck mit dem ID2D1BitmapBrush.

m_pBitmapBrush->SetExtendModeX(D2D1_EXTEND_MODE_MIRROR);
m_pBitmapBrush->SetExtendModeY(D2D1_EXTEND_MODE_MIRROR);

m_pRenderTarget->FillRectangle(exampleRectangle, m_pBitmapBrush);

Die Ausgabe wird wie in der folgenden Abbildung dargestellt erzeugt.

Abbildung eines originalen Bilds und des resultierenden Bilds nach der Spiegelung der x- und y-Richtung

Transformieren von Pinseln

Wenn Sie mit einem Pinsel zeichnen, zeichnet er im Koordinatenbereich des Renderziels. Pinsel positionieren sich nicht automatisch so, dass sie mit dem gezeichneten Objekt übereinstimmen. standardmäßig beginnen sie mit dem Zeichnen am Ursprung (0, 0) des Renderziels.

Sie können den durch einen ID2D1LinearGradientBrush definierten Farbverlauf in einen Zielbereich "verschieben", indem Sie dessen Startpunkt und Endpunkt festlegen. Ebenso können Sie den durch einen ID2D1RadialGradientBrush definierten Farbverlauf verschieben, indem Sie seinen Mittelpunkt und seine Radien ändern.

Um den Inhalt eines ID2D1BitmapBrush an den gezeichneten Bereich auszurichten, können Sie die SetTransform-Methode verwenden, um die Bitmap an die gewünschte Position zu übersetzen. Diese Transformation wirkt sich nur auf den Pinsel aus. sie wirkt sich nicht auf andere Inhalte aus, die vom Renderziel gezeichnet werden.

Die folgenden Abbildungen zeigen die Auswirkung der Verwendung eines ID2D1BitmapBrush zum Ausfüllen eines Rechtecks unter (100, 100). Die Abbildung auf der linken Abbildung zeigt das Ergebnis der Füllung des Rechtecks ohne Transformation des Pinsels: Die Bitmap wird am Ursprung des Renderziels gezeichnet. Daher wird nur ein Teil der Bitmap im Rechteck angezeigt. Die Abbildung auf der rechten Seite zeigt das Ergebnis der Transformation des ID2D1BitmapBrush, sodass der Inhalt um 50 Pixel nach rechts und 50 Pixel nach unten verschoben wird. Die Bitmap füllt nun das Rechteck aus.

Abbildung eines Quadrats, das mit einem Bitmappinsel gezeichnet wurde, ohne den Pinsel zu transformieren und den Pinsel zu transformieren

Der folgende Code zeigt, wie dies erreicht werden kann. Wenden Sie zunächst eine Übersetzung auf den ID2D1BitmapBrushan, und verschieben Sie den Pinsel um 50 Pixel rechts entlang der x-Achse und 50 Pixel nach unten entlang der y-Achse. Verwenden Sie dann id2D1BitmapBrush, um das Rechteck mit der linken oberen Ecke bei (100, 100) und der unteren rechten Ecke bei (200, 200) auszufüllen.

// Create the bitmap to be used by the bitmap brush.
if (SUCCEEDED(hr))
{
    hr = LoadResourceBitmap(
        m_pRenderTarget,
        m_pWICFactory,
        L"FERN",
        L"Image",
        &m_pBitmap
        );
   
}

if (SUCCEEDED(hr))
{
    hr = m_pRenderTarget->CreateBitmapBrush(
        m_pBitmap,
        &m_pBitmapBrush
        );
}

D2D1_RECT_F rcTransformedBrushRect = D2D1::RectF(100, 100, 200, 200);

// Demonstrate the effect of transforming a bitmap brush.
m_pBitmapBrush->SetTransform(
     D2D1::Matrix3x2F::Translation(D2D1::SizeF(50,50))
     );

// To see the content of the rcTransformedBrushRect, comment
// out this statement.
m_pRenderTarget->FillRectangle(
     &rcTransformedBrushRect, 
     m_pBitmapBrush
     );

m_pRenderTarget->DrawRectangle(rcTransformedBrushRect, m_pBlackBrush, 1, NULL);