Ü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. Es enthält die folgenden Abschnitte.

Voraussetzungen

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

Pinseltypen

Ein Pinsel „bemalt“ einen Bereich mit seiner Ausgabe. Verschiedene Pinsel erzeugen unterschiedliche Ergebnisse. Direct2D bietet vier Pinseltypen: ID2D1SolidColorBrush zeichnet einen Bereich mit einer Volltonfarbe, ID2D1LinearGradientBrush mit einem linearen Farbverlauf, ID2D1RadialGradientBrush mit radialem Farbverlauf und ID2D1BitmapBrush mit einer Bitmap.

Hinweis

Ab Windows 8 können Sie auch ID2D1ImageBrush verwenden, das einem Bitmap-Pinsel ähnelt, wobei Sie auch primitive Formen verwenden können.

Alle Pinsel erben von ID2D1Brush und teilen eine Reihe allgemeiner 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 das Renderziel initialisiert wurde, 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 "Ressourcenübersicht".)

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

Farbgrundlagen

Bevor Sie mit einem ID2D1SolidColorBrush oder einem Farbverlaufpinsel 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 verwendet wird, D3DCOLORVALUE).

Vor Windows 8 verwendet D2D1_COLOR_F 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 dieser Farbe an, während ein Wert von 1,0 angibt, dass die Farbe vollständig vorhanden ist. Für die Alphakomponente stellt 0,0 eine vollständig transparente Farbe dar, und 1,0 stellt eine vollständig undurchsichtige Farbe dar.

Ab Windows 8 akzeptiert D2D1_COLOR_F auch scRGB-Codierung. scRGB ist eine Obermenge davon, die Farbwerte über 1,0 und unter 0,0 zulässt.

Um eine Farbe zu definieren, können Sie die D2D1_COLOR_F Struktur verwenden und ihre Felder selbst initialisieren, oder Sie können die D2D1::ColorF-Klasse verwenden, um die Farbe zu erstellen. Die ColorF-Klasse stellt mehrere Konstruktoren zum Definieren von Farben bereit. Wenn der Alphawert in den Konstruktoren nicht angegeben ist, wird standardmäßig 1,0 festgelegt.

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

  

  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 Reihenfolge von Rot, Grün, Blau und Alphaanzugeben, wobei jedes Element einen Wert zwischen 0,0 und 1,0 aufweist.

  Im folgenden Beispiel werden die Rot-, Grün-, Blau- und Alphawerte für eine Farbe angegeben.

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

• Verwenden Sie den ColorF(UINT32, FLOAT) -Konstruktor, um den Hexadezimalwert einer Farbe und einen Alphawert anzugeben, wie im folgenden Beispiel gezeigt.

    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 Pinsel mit Volltonfarbe

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 Pinsel umrandet und mit einer Volltonfarbe ausgemalt wird, die den Farbwert 0x9ACD32 hat.

Der folgende Code zeigt, wie Sie einen schwarzen Pinsel und einen Pinsel mit einem Farbwert von 0x9ACD32 erstellen und verwenden, um dieses Quadrat auszufüllen und zu zeichnen.

    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 preiswerter Vorgang. Sie können ID2D1SolidColorBrush-Objekte jedes Mal erstellen, wenn Sie mit geringen bis keinen Leistungseinbußen rendern. Dieser Ansatz wird für Farbverlaufs- oder Bitmap-Pinsel nicht empfohlen.

Verwenden von Pinseln mit linearem Farbverlauf

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, mit der Sie horizontalen und vertikalen Farbverlauf erstellen und die Farbverlaufsrichtung umkehren können. Rufen Sie zum Erstellen eines linearen Farbverlaufpinsels die ID2D1RenderTarget::CreateLinearGradientBrush-Methode auf.

Die folgende Abbildung zeigt ein Quadrat, das mit einem ID2D1LinearGradientBrush gezeichnet wird, das zwei vordefinierte Farben enthält: "Yellow" und "ForestGreen".

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 Farbverlaufstopp gibt eine Farbe und 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 "Gelb" an einer 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;

2. Erstellen Sie eine ID2D1GradientStopCollection. Im folgenden Beispiel wird CreateGradientStopCollectionaufgerufen und es werden das Array von D2D1_GRADIENT_STOP-Objekten, die Anzahl der Farbverlaufstopps (2), D2D1_GAMMA_2_2 für die Interpolation und D2D1_EXTEND_MODE_CLAMP für den Erweiterungsmodus übergeben.

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

3. Erstellen Sie den ID2D1LinearGradientBrush. Im nächsten Beispiel wird die Methode CreateLinearGradientBrush aufgerufen und es werden die Eigenschaften des Pinsels mit linearem Farbverlauf übergeben. Diese beinhalten den Startpunkt bei (0, 0) und den Endpunkt bei (150, 150) sowie die im vorherigen Schritt erstellten Farbverlaufstopps.

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

4. Verwenden Sie den ID2D1LinearGradientBrush. Im nächsten Codebeispiel wird der Pinsel verwendet, um ein Rechteck auszufüllen.

    m_pRenderTarget->FillRectangle(&rcBrushRect, m_pLinearGradientBrush);

Weitere Informationen zu Farbverlaufstopps

D2D1_GRADIENT_STOP bildet die Grundlage für einen Farbverlaufspinsel. Ein Farbverlaufstopp 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 0,0 ist, desto näher ist die Farbe am Anfang des Farbverlaufs; je näher es auf 1,0 liegt, desto näher liegt die Farbe am Ende des Farbverlaufs.

In der folgenden Abbildung sind die Farbverlaufstopps hervorgehoben. Die Kreise markieren die Position der Farbverlaufstopps, und die gestrichelte Linie zeigt die Farbverlaufsachse an.

Der erste Farbverlaufstopp gibt die Farbe Gelb an der Position 0.0 an. Der zweite Farbverlaufstopp gibt die Farbe Rot an der Position 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 Farbverlaufstopp gibt die Farbe Blau an der Position 0,75 an. Die Farben zwischen dem zweiten und dritten Farbverlaufstopp ändern sich allmählich von Rot zu Blau. Der vierte Farbverlaufstopp gibt die Farbe Gelbgrün bei der Position 1,0 an. Die Farben zwischen dem dritten und vierten Farbverlaufstopp ändern sich allmählich von Blau zu Gelbgrün.

Die Gradientenachse

Wie bereits erwähnt, befinden sich die Farbverlaufstopps eines Pinsels mit linearem Farbverlauf auf einer Linie, der Farbverlaufsachse. Sie können die Ausrichtung und Größe der Zeile mithilfe der Startpoint - und EndPoint-Felder der D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES Struktur angeben, wenn Sie einen linearen Farbverlaufpinsel erstellen. Nachdem Sie einen Pinsel erstellt haben, können Sie die Farbverlaufsachse anpassen, indem Sie die SetStartPoint - und SetEndPoint-Methoden des Pinsels aufrufen. Indem Sie den Start- und Endpunkt des Pinsels bearbeiten, können Sie horizontale und vertikale Farbverläufe erstellen, die Farbverlaufsrichtung umkehren und vieles mehr.

In der folgenden Abbildung ist beispielsweise der Startpunkt 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 auf die untere rechte Ecke des zu bemalenden 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 erzeugt. Wenn Sie den Startpunkt auf (0, 50) und den Endpunkt auf (150, 0) festlegen, wird ein diagonaler Farbverlauf erstellt, der in der unteren linken Ecke beginnt und sich auf die obere rechte Ecke des zu bemalenden Bereichs erstreckt.

Verwenden von Pinseln mit radialem Farbverlauf

Im Gegensatz zu einem ID2D1LinearGradientBrush, der zwei oder mehr Farben entlang einer Farbverlaufsachse kombiniert, zeichnet ein ID2D1RadialGradientBrush einen Bereich mit einem Radialfarbverlauf, der zwei oder mehr Farben über eine Ellipse verschmilzt. Während ein ID2D1LinearGradientBrush seine Farbverlaufsachse mit einem Startpunkt und einem Endpunkt definiert, definiert ein ID2D1RadialGradientBrush seine Farbverlaufsellipse durch Angeben eines Mittelpunkts, horizontaler und vertikaler Bogenradien und eines Farbverlaufsursprung-Offsets.

Wie bei einem ID2D1LinearGradientBrush verwendet ein ID2D1RadialGradientBrush eine ID2D1GradientStopCollection , um die Farben und Positionen im Farbverlauf anzugeben.

Die folgende Abbildung zeigt einen Kreis, der mit einem ID2D1RadialGradientBrush gezeichnet wurde. Der Kreis hat zwei Farbverlaufstopps: Der erste gibt eine vordefinierte Farbe „Gelb“ an der Position 0.0 an, der zweite eine vordefinierte Farbe „ForestGreen“ an der Position 1.0. Der Mittelpunkt des Farbverlaufs befindet sich bei (75, 75), der Offset des Farbverlaufsursprungs liegt bei (0, 0) und der x- und y-Radius betragen 75.

Die folgenden Codebeispiele zeigen, wie Sie diesen Kreis mit einem ID2D1RadialGradientBrush zeichnen, der zwei Farbstopps aufweist: "Gelb" an einer Position von 0,0 und "ForestGreen" an einer Position von 1,0. Ähnlich wie beim Erstellen eines ID2D1LinearGradientBrush ruft das Beispiel CreateGradientStopCollection auf, um eine ID2D1GradientStopCollection aus einem Array von Verlaufsstopps 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 ID2D1RadialGradientBrush die ID2D1RenderTarget::CreateRadialGradientBrush-Methode . Der CreateRadialGradientBrush akzeptiert drei Parameter. Der erste Parameter, D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES, gibt den Mittelpunkt, den Offset des Farbverlaufsursprungs sowie den horizontalen und vertikalen Radius des Farbverlaufs an. Der zweite Parameter ist eine ID2D1GradientStopCollection , die die Farben und deren Positionen im Farbverlauf beschreibt, und der dritte Parameter ist die Adresse des Zeigers, der den neuen ID2D1RadialGradientBrush-Verweis empfängt. Bei einigen Überladungen wird ein zusätzlicher Parameter, eine D2D1_BRUSH_PROPERTIES-Struktur verwendet, die einen Deckkraftwert und eine Transformation angibt, die auf den neuen Pinsel angewendet werden sollen.

Im nächsten Beispiel wird CreateRadialGradientBrushaufgerufen und es werden das Array von Farbverlaufstopps und die Eigenschaften des Pinsels mit radialem Farbverlauf übergeben, für die der Wert für center auf (75, 75), gradientOriginOffset auf (0, 0) und radiusX sowie radiusY beide auf 75 festgelegt sind.

// 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 center, gradientOriginOffset, radiusX und/oder radiusY erzeugen unterschiedliche Farbverläufe. Die folgende Abbildung zeigt mehrere radiale Farbverläufe mit unterschiedlichen Offsets des Farbverlaufsursprungs. Dadurch entsteht der Eindruck, das Licht würde die Kreise aus verschiedenen Winkeln beleuchten.

Verwenden von Bitmap-Pinseln

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

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

Die folgenden Beispiele zeigen, wie Sie dieses Quadrat mit einem ID2D1BitmapBrush zeichnen.

Im ersten Beispiel wird eine ID2D1Bitmap für die Verwendung mit dem Pinsel initialisiert. Die ID2D1Bitmap wird von einer 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
        );
}

Rufen Sie zum Erstellen des Bitmappinsels die ID2D1RenderTarget::CreateBitmapBrush-Methode auf und geben Sie die ID2D1Bitmap an, mit der gemalt werden soll. Die Methode gibt ein HRESULT - und ein ID2D1BitmapBrush-Objekt zurück. Bei 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 die Bitmap eines Bitmap-Pinsels den gezeichneten Bereich nicht vollständig aus.

• Wenn dies bei einem ID2D1BitmapBrush geschieht, verwendet Direct2D die Horizontaleinstellungen (SetExtendModeX) und vertikale (SetExtendModeY) des Pinsels, um zu bestimmen, wie der verbleibende Bereich gefüllt wird.

• Wenn dies bei einem Farbverlaufpinsel geschieht, bestimmt Direct2D, wie der verbleibende Bereich mithilfe des Werts des D2D1_EXTEND_MODE-Parameters gefüllt wird, den Sie beim Aufrufen der CreateGradientStopCollection angegeben haben, um die ID2D1GradientStopCollection des Farbverlaufspinsels zu erstellen.

Die folgende Abbildung zeigt die Ergebnisse aus jeder möglichen Kombination der Erweiterungsmodi für einen ID2D1BitmapBrush: D2D1_EXTEND_MODE_CLAMP (CLAMP), D2D1_EXTEND_MODE_WRAP (WRAP) und D2D1_EXTEND_MIRROR (MIRROR).

Das folgende Beispiel zeigt, wie sie die X- und Y-Erweiterungsmodi des Bitmappinsels auf D2D1_EXTEND_MIRROR festlegen. 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 sieht wie in der folgenden Abbildung dargestellt aus.

Transformieren der Pinsel

Wenn Sie mit einem Pinsel zeichnen, zeichnet es sich im Koordinatenbereich des Renderziels. Pinsel positionieren sich nicht automatisch, um das zu bemalende Objekt auszurichten; standardmäßig beginnen sie mit dem Malen am Ursprung (0, 0) des Renderziels.

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

Zum Ausrichten des Inhalts eines ID2D1BitmapBrush-Objekts an dem zu bemalten Bereich 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 den Effekt der Verwendung eines ID2D1BitmapBrush zum Ausfüllen eines Rechtecks an der Position (100, 100). Die Abbildung auf der linken Abbildung zeigt das Ergebnis des Ausfüllens 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.

Der folgende Code zeigt, wie Sie dies erreichen. Wenden Sie zuerst eine Übersetzung auf den ID2D1BitmapBrush an, und bewegen Sie den Pinsel um 50 Pixel entlang der X-Achse und 50 Pixel entlang der Y-Achse nach unten. Benutzen Sie dann den ID2D1BitmapBrush um das Rechteck zu füllen, das die obere linke Ecke bei (100, 100) und die untere rechte Ecke bei (200, 200) hat.

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

Zugehörige Themen

• Direct2D-Referenz
• So erstellen Sie einen Volltonfarbpinsel
• So erstellen Sie einen linearen Farbverlaufpinsel
• So erstellen Sie einen radialen Farbverlaufpinsel
• So erstellen Sie einen Bitmappinsel