Übersicht über Geometrien

Artikel
06/13/2023

In dieser Übersicht wird beschrieben, wie ID2D1Geometry-Objekte zum Definieren und Bearbeiten von 2D-Abbildungen erstellt und verwendet werden. Der Abschnitt ist wie folgt gegliedert.

Was ist eine Direct2D-Geometrie?

Eine Direct2D-Geometrie ist ein ID2D1Geometry-Objekt . Dieses Objekt kann eine einfache Geometrie (ID2D1RectangleGeometry, ID2D1RoundedRectangleGeometry oder ID2D1EllipseGeometry), eine Pfadgeometrie (ID2D1PathGeometry) oder eine zusammengesetzte Geometrie (ID2D1GeometryGroup und ID2D1TransformedGeometry) sein.

Mit Direct2D-Geometrien können Sie zweidimensionale Figuren beschreiben und viele Verwendungsmöglichkeiten bieten, z. B. das Definieren von Treffertestbereichen, Clipbereichen und sogar Animationspfaden.

Direct2D-Geometrien sind unveränderliche und geräteunabhängige Ressourcen, die von ID2D1Factory erstellt werden. Im Allgemeinen sollten Sie Geometrien einmal erstellen und sie für die Lebensdauer der Anwendung oder bis zu ihrer Änderung aufbewahren. Weitere Informationen zu geräteunabhängigen und geräteabhängigen Ressourcen finden Sie in der Ressourcenübersicht.

In den folgenden Abschnitten werden die verschiedenen Arten von Geometrien beschrieben.

Einfache Geometrien

Einfache Geometrien umfassen ID2D1RectangleGeometry-, ID2D1RoundedRectangleGeometry- und ID2D1EllipseGeometry-Objekte und können verwendet werden, um grundlegende geometrische Figuren wie Rechtecke, abgerundete Rechtecke, Kreise und Ellipsen zu erstellen.

Um eine einfache Geometrie zu erstellen, verwenden Sie eine der Methoden ID2D1Factory::Create<geometryType>Geometry . Diese Methoden erstellen ein Objekt des angegebenen Typs. Um beispielsweise ein Rechteck zu erstellen, rufen Sie ID2D1Factory::CreateRectangleGeometry auf, das ein ID2D1RectangleGeometry-Objekt zurückgibt. Um ein abgerundetes Rechteck zu erstellen, rufen Sie ID2D1Factory::CreateRoundedRectangleGeometry auf, das ein ID2D1RoundedRectangleGeometry-Objekt zurückgibt usw.

Im folgenden Codebeispiel wird die CreateEllipseGeometry-Methode aufgerufen, wobei eine Ellipsenstruktur übergeben wird, wobei der Mittelpunkt auf (100, 100), x-Radius auf 100 und y-Radius auf 50 festgelegt ist. Anschließend wird DrawGeometry aufgerufen, wobei die zurückgegebene Ellipsengeometrie, ein Zeiger auf eine schwarze ID2D1SolidColorBrush und eine Strichbreite von 5 übergeben werden. Die folgende Abbildung zeigt die Ausgabe aus dem Codebeispiel.

Abbildung einer Ellipse

ID2D1EllipseGeometry *m_pEllipseGeometry;

if (SUCCEEDED(hr))
{
    hr = m_pD2DFactory->CreateEllipseGeometry(
        D2D1::Ellipse(D2D1::Point2F(100.f, 60.f), 100.f, 50.f),
        &m_pEllipseGeometry
        );
}

m_pRenderTarget->DrawGeometry(m_pEllipseGeometry, m_pBlackBrush, 5);

Um die Umrisse einer beliebigen Geometrie zu zeichnen, verwenden Sie die DrawGeometry-Methode . Um das Innere zu malen, verwenden Sie die FillGeometry-Methode .

Pfadgeometrien

Pfadgeometrien werden durch die ID2D1PathGeometry-Schnittstelle dargestellt. Diese Objekte können verwendet werden, um komplexe geometrische Figuren zu beschreiben, die aus Segmenten wie Bögen, Kurven und Linien bestehen. Die folgende Abbildung zeigt eine Zeichnung, die mithilfe der Pfadgeometrie erstellt wurde.

Abbildung eines Flusses, berges und der Sonne

Weitere Informationen und Beispiele finden Sie in der Übersicht über Pfadgeometrien.

Zusammengesetzte Geometrien

Eine zusammengesetzte Geometrie ist eine Geometrie, die mit einem anderen Geometrieobjekt oder mit einer Transformation gruppiert oder kombiniert wird. Zusammengesetzte Geometrien umfassen ID2D1TransformedGeometry - und ID2D1GeometryGroup-Objekte .

Geometriegruppen

Geometriegruppen sind eine praktische Möglichkeit, mehrere Geometrien gleichzeitig zu gruppieren, sodass alle Figuren mehrerer unterschiedlicher Geometrien zu einer verkettet werden. Um ein ID2D1GeometryGroup-Objekt zu erstellen, rufen Sie die CreateGeometryGroup-Methode für das ID2D1Factory-Objekt auf, und übergeben Sie den fillMode mit möglichen Werten von D2D1_FILL_MODE_ALTERNATE (alternativ) und D2D1_FILL_MODE_WINDING, einem Array von Geometrieobjekten, die der Geometriegruppe hinzugefügt werden sollen, und die Anzahl der Elemente in diesem Array.

Im folgenden Codebeispiel wird zunächst ein Array von Geometrieobjekten deklariert. Diese Objekte sind vier konzentrische Kreise mit den folgenden Radien: 25, 50, 75 und 100. Rufen Sie dann createGeometryGroup für das ID2D1Factory-Objekt auf, und übergeben Sie D2D1_FILL_MODE_ALTERNATE, ein Array von Geometrieobjekten, die der geometry-Gruppe hinzugefügt werden sollen, und die Anzahl der Elemente in diesem Array.

ID2D1Geometry *ppGeometries[] =
{
    m_pEllipseGeometry1,
    m_pEllipseGeometry2,
    m_pEllipseGeometry3,
    m_pEllipseGeometry4
};

hr = m_pD2DFactory->CreateGeometryGroup(
    D2D1_FILL_MODE_ALTERNATE,
    ppGeometries,
    ARRAYSIZE(ppGeometries),
    &m_pGeoGroup_AlternateFill
    );

if (SUCCEEDED(hr))
{
    hr = m_pD2DFactory->CreateGeometryGroup(
        D2D1_FILL_MODE_WINDING,
        ppGeometries,
        ARRAYSIZE(ppGeometries),
        &m_pGeoGroup_WindingFill
        );
}

Die folgende Abbildung zeigt die Ergebnisse des Renderns der beiden Gruppengeometrien aus dem Beispiel.

Abbildung von zwei Sätzen von vier konzentrischen Kreisen, einer mit abwechselnden Ringen gefüllt und einer mit allen Ringen gefüllt

Transformierte Geometrien

Es gibt mehrere Möglichkeiten, eine Geometrie zu transformieren. Sie können die SetTransform-Methode eines Renderziels verwenden, um alles zu transformieren, was das Renderziel zeichnet, oder Sie können eine Transformation direkt einer Geometrie zuordnen, indem Sie die CreateTransformedGeometry-Methode verwenden, um eine ID2D1TransformedGeometry zu erstellen.

Die Methode, die Sie verwenden sollten, hängt von der gewünschten Wirkung ab. Wenn Sie das Renderziel verwenden, um eine Geometrie zu transformieren und dann zu rendern, wirkt sich die Transformation auf alles an der Geometrie aus, einschließlich der Breite der von Ihnen angewendeten Striche. Wenn Sie hingegen eine ID2D1TransformedGeometry verwenden, wirkt sich die Transformation nur auf die Koordinaten aus, die die Form beschreiben. Die Transformation wirkt sich nicht auf die Strichstärke aus, wenn die Geometrie gezeichnet wird.

Hinweis

Ab Windows 8 die Welttransformation wirkt sich nicht auf die Strichstärke von Strichen mit D2D1_STROKE_TRANSFORM_TYPE_FIXEDoder D2D1_STROKE_TRANSFORM_TYPE_HAIRLINE aus. Sie sollten diese Transformationstypen verwenden, um transformationsunabhängige Striche zu erzielen.

Im folgenden Beispiel wird eine ID2D1RectangleGeometry erstellt und dann ohne Transformation gezeichnet. Es erzeugt die in der folgenden Abbildung dargestellte Ausgabe.

Abbildung eines Rechtecks

hr = m_pD2DFactory->CreateRectangleGeometry(
    D2D1::RectF(150.f, 150.f, 200.f, 200.f),
    &m_pRectangleGeometry
    );

// Draw the untransformed rectangle geometry.
m_pRenderTarget->DrawGeometry(m_pRectangleGeometry, m_pBlackBrush, 1);

Im nächsten Beispiel wird das Renderziel verwendet, um die Geometrie um den Faktor 3 zu skalieren und dann zu zeichnet. Die folgende Abbildung zeigt das Ergebnis des Zeichnens des Rechtecks ohne die Transformation und mit der Transformation. Beachten Sie, dass der Strich nach der Transformation dicker ist, obwohl die Strichstärke 1 beträgt.

Abbildung eines kleineren Rechtecks in einem größeren Rechteck mit einem dickeren Strich

// Transform the render target, then draw the rectangle geometry again.
m_pRenderTarget->SetTransform(
    D2D1::Matrix3x2F::Scale(
        D2D1::SizeF(3.f, 3.f),
        D2D1::Point2F(175.f, 175.f))
    );

m_pRenderTarget->DrawGeometry(m_pRectangleGeometry, m_pBlackBrush, 1);

Im nächsten Beispiel wird die CreateTransformedGeometry-Methode verwendet, um die Geometrie um den Faktor 3 zu skalieren und dann zu zeichnet. Es erzeugt die in der folgenden Abbildung dargestellte Ausgabe. Beachten Sie, dass das Rechteck zwar größer ist, sein Strich jedoch nicht erhöht wurde.

Abbildung eines kleineren Rechtecks in einem größeren Rechteck mit gleicher Strichstärke

 // Create a geometry that is a scaled version
 // of m_pRectangleGeometry.
 // The new geometry is scaled by a factory of 3
 // from the center of the geometry, (35, 35).

 hr = m_pD2DFactory->CreateTransformedGeometry(
     m_pRectangleGeometry,
     D2D1::Matrix3x2F::Scale(
         D2D1::SizeF(3.f, 3.f),
         D2D1::Point2F(175.f, 175.f)),
     &m_pTransformedGeometry
     );

// Replace the previous render target transform.
m_pRenderTarget->SetTransform(D2D1::Matrix3x2F::Identity());

// Draw the transformed geometry.
m_pRenderTarget->DrawGeometry(m_pTransformedGeometry, m_pBlackBrush, 1);

Geometrien als Masken

Sie können ein ID2D1Geometry-Objekt als geometrische Maske verwenden, wenn Sie die PushLayer-Methode aufrufen. Die geometrische Maske gibt den Bereich der Ebene an, die dem Renderziel zusammengesetzt ist. Weitere Informationen finden Sie im Abschnitt Geometrische Masken der Ebenenübersicht.

Geometrische Vorgänge

Die ID2D1Geometry-Schnittstelle bietet mehrere geometrische Vorgänge, mit denen Sie geometrische Figuren bearbeiten und messen können. Beispielsweise können Sie sie verwenden, um ihre Grenzen zu berechnen und zurückzugeben, vergleichen, um zu sehen, wie eine Geometrie räumlich mit einer anderen verknüpft ist (nützlich für Treffertests), die Bereiche und Längen berechnen und vieles mehr. In der folgenden Tabelle werden die allgemeinen geometrischen Vorgänge beschrieben.

Vorgang	Methode
Combine	CombineWithGeometry
Bounds/Widened Bounds/Retrieve Bounds, Dirty Region Update	Widen, GetBounds, GetWidenedBounds
Treffertests	FillContainsPoint, StrokeContainsPoint
Stroke	StrokeContainsPoint
Vergleich	CompareWithGeometry
Vereinfachung (entfernt Bögen und quadratische Bézierkurven)	Vereinfachung
Mosaik	Tessellate
Gliederung (Schnittmenge entfernen)	Outline
Berechnen der Fläche oder Länge einer Geometrie	ComputeArea, ComputeLength, ComputePointAtLength

Hinweis

Ab Windows 8 können Sie die ComputePointAndSegmentAtLength-Methode für id2D1PathGeometry1 verwenden, um die Fläche oder Länge einer Geometrie zu berechnen.

Kombinieren von Geometrien

Um eine Geometrie mit einer anderen zu kombinieren, rufen Sie die ID2D1Geometry::CombineWithGeometry-Methode auf . Wenn Sie die Geometrien kombinieren, geben Sie eine der vier Möglichkeiten zum Ausführen des Kombinationsvorgangs an: D2D1_COMBINE_MODE_UNION (Union), D2D1_COMBINE_MODE_INTERSECT (Schnitt), D2D1_COMBINE_MODE_XOR (xor) und D2D1_COMBINE_MODE_EXCLUDE (ausschließen). Das folgende Codebeispiel zeigt zwei Kreise, die mithilfe des Vereinigungs-Kombinationsmodus kombiniert werden, wobei der erste Kreis den Mittelpunkt (75, 75) und den Radius von 50 aufweist, und der zweite Kreis den Mittelpunkt (125, 75) und den Radius von 50 aufweist.

HRESULT hr = S_OK;
ID2D1GeometrySink *pGeometrySink = NULL;

// Create the first ellipse geometry to merge.
const D2D1_ELLIPSE circle1 = D2D1::Ellipse(
    D2D1::Point2F(75.0f, 75.0f),
    50.0f,
    50.0f
    );

hr = m_pD2DFactory->CreateEllipseGeometry(
    circle1,
    &m_pCircleGeometry1
    );

if (SUCCEEDED(hr))
{
    // Create the second ellipse geometry to merge.
    const D2D1_ELLIPSE circle2 = D2D1::Ellipse(
        D2D1::Point2F(125.0f, 75.0f),
        50.0f,
        50.0f
        );

    hr = m_pD2DFactory->CreateEllipseGeometry(circle2, &m_pCircleGeometry2);
}


if (SUCCEEDED(hr))
{
    //
    // Use D2D1_COMBINE_MODE_UNION to combine the geometries.
    //
    hr = m_pD2DFactory->CreatePathGeometry(&m_pPathGeometryUnion);

    if (SUCCEEDED(hr))
    {
        hr = m_pPathGeometryUnion->Open(&pGeometrySink);

        if (SUCCEEDED(hr))
        {
            hr = m_pCircleGeometry1->CombineWithGeometry(
                m_pCircleGeometry2,
                D2D1_COMBINE_MODE_UNION,
                NULL,
                NULL,
                pGeometrySink
                );
        }

        if (SUCCEEDED(hr))
        {
            hr = pGeometrySink->Close();
        }

        SafeRelease(&pGeometrySink);
    }
}

Die folgende Abbildung zeigt zwei Kreise, die mit einem Kombinationsmodus kombiniert werden.

Abbildung von zwei sich überlappenden Kreisen, die zu einer Union kombiniert sind

Abbildungen aller Kombinationsmodi finden Sie in der D2D1_COMBINE_MODE-Enumeration.

Erweitern

Die Widen-Methode generiert eine neue Geometrie, deren Füllung dem Streichen der vorhandenen Geometrie entspricht, und schreibt das Ergebnis dann in das angegebene ID2D1SimplifiedGeometrySink-Objekt . Im folgenden Codebeispiel wird Open für das ID2D1PathGeometry-Objekt aufgerufen. Wenn Open erfolgreich ist, wird Widen für das geometry-Objekt aufgerufen.

ID2D1GeometrySink *pGeometrySink = NULL;
hr = pPathGeometry->Open(&pGeometrySink);
if (SUCCEEDED(hr))
{
    hr = pGeometry->Widen(
            strokeWidth,
            pIStrokeStyle,
            pWorldTransform,
            pGeometrySink
            );

Tessellate

Die Tessellate-Methode erstellt eine Reihe von Dreiecken im Uhrzeigersinn, die die Geometrie abdecken, nachdem sie mithilfe der angegebenen Matrix transformiert und mithilfe der angegebenen Toleranz vereinfacht wurde. Im folgenden Codebeispiel wird Tessellate verwendet, um eine Liste von Dreiecken zu erstellen, die pPathGeometry darstellen. Die Dreiecke werden in einem ID2D1Mesh, pMesh gespeichert und dann zur späteren Verwendung beim Rendern in einen Klassenmember m_pStrokeMesh übertragen.

ID2D1Mesh *pMesh = NULL;
hr = m_pRT->CreateMesh(&pMesh);
if (SUCCEEDED(hr))
{
    ID2D1TessellationSink *pSink = NULL;
    hr = pMesh->Open(&pSink);
    if (SUCCEEDED(hr))
    {
        hr = pPathGeometry->Tessellate(
                NULL, // world transform (already handled in Widen)
                pSink
                );
        if (SUCCEEDED(hr))
        {
            hr = pSink->Close();
            if (SUCCEEDED(hr))
            {
                SafeReplace(&m_pStrokeMesh, pMesh);
            }
        }
        pSink->Release();
    }
    pMesh->Release();
}

FillContainsPoint und StrokeContainsPoint

Die FillContainsPoint-Methode gibt an, ob der von der Geometrie ausgefüllte Bereich den angegebenen Punkt enthält. Sie können diese Methode verwenden, um Treffertests durchzuführen. Im folgenden Codebeispiel wird FillContainsPoint für ein ID2D1EllipseGeometry-Objekt aufgerufen, wobei ein Punkt bei (0,0) und eine Identitätsmatrix übergeben werden.

BOOL containsPoint1;
hr = m_pCircleGeometry1->FillContainsPoint(
    D2D1::Point2F(0,0),
    D2D1::Matrix3x2F::Identity(),
    &containsPoint1
    );

if (SUCCEEDED(hr))
{
    // Process containsPoint.
}

Die StrokeContainsPoint-Methode bestimmt, ob der Strich der Geometrie den angegebenen Punkt enthält. Sie können diese Methode verwenden, um Treffertests durchzuführen. Im folgenden Codebeispiel wird StrokeContainsPoint verwendet.

BOOL containsPoint;

hr = m_pCircleGeometry1->StrokeContainsPoint(
    D2D1::Point2F(0,0),
    10,     // stroke width
    NULL,   // stroke style
    NULL,   // world transform
    &containsPoint
    );

if (SUCCEEDED(hr))
{
    // Process containsPoint.
}

Vereinfachung

Die Simplify-Methode entfernt Bögen und quadratische Bézierkurven aus einer angegebenen Geometrie. Die resultierende Geometrie enthält also nur Linien und optional kubische Bézierkurven. Im folgenden Codebeispiel wird Simplify verwendet, um eine Geometrie mit Bézierkurven in eine Geometrie zu transformieren, die nur Liniensegmente enthält.

HRESULT D2DFlatten(
    ID2D1Geometry *pGeometry,
    float flatteningTolerance,
    ID2D1Geometry **ppGeometry
    )
{
    HRESULT hr;
    ID2D1Factory *pFactory = NULL;
    pGeometry->GetFactory(&pFactory);

    ID2D1PathGeometry *pPathGeometry = NULL;
    hr = pFactory->CreatePathGeometry(&pPathGeometry);

    if (SUCCEEDED(hr))
    {
        ID2D1GeometrySink *pSink = NULL;
        hr = pPathGeometry->Open(&pSink);

        if (SUCCEEDED(hr))
        {
            hr = pGeometry->Simplify(
                    D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES,
                    NULL, // world transform
                    flatteningTolerance,
                    pSink
                    );

            if (SUCCEEDED(hr))
            {
                hr = pSink->Close();

                if (SUCCEEDED(hr))
                {
                    *ppGeometry = pPathGeometry;
                    (*ppGeometry)->AddRef();
                }
            }
            pSink->Release();
        }
        pPathGeometry->Release();
    }

    pFactory->Release();

    return hr;
}

ComputeLength und ComputeArea

Die ComputeLength-Methode berechnet die Länge der angegebenen Geometrie, wenn jedes Segment in eine Zeile aufgerollt wurde. Dies schließt das implizit schließende Segment ein, wenn die Geometrie geschlossen ist. Im folgenden Codebeispiel wird ComputeLength verwendet, um die Länge eines angegebenen Kreises (m_pCircleGeometry1) zu berechnen.

float length;

// Compute the area of circle1
hr = m_pCircleGeometry1->ComputeLength(
    D2D1::IdentityMatrix(),
    &length
    );

if (SUCCEEDED(hr))
{
    // Process the length of the geometry.
}

Die ComputeArea-Methode berechnet den Bereich der angegebenen Geometrie. Im folgenden Codebeispiel wird ComputeArea verwendet, um den Bereich eines angegebenen Kreises (m_pCircleGeometry1) zu berechnen.

float area;

// Compute the area of circle1
hr = m_pCircleGeometry1->ComputeArea(
    D2D1::IdentityMatrix(),
    &area
    );

CompareWithGeometry

Die CompareWithGeometry-Methode beschreibt die Schnittmenge zwischen der Geometrie, die diese Methode aufruft, und der angegebenen Geometrie. Mögliche Werte für Schnittmengen sind D2D1_GEOMETRY_RELATION_DISJOINT (disjoint), D2D1_GEOMETRY_RELATION_IS_CONTAINED (enthalten), D2D1_GEOMETRY_RELATION_CONTAINS (enthält) und D2D1_GEOMETRY_RELATION_OVERLAP (Überlappung). "disjoint" bedeutet, dass sich zwei Geometriefüllungen überhaupt nicht überschneiden. "is contained" bedeutet, dass die Geometrie vollständig in der angegebenen Geometrie enthalten ist. "contains" bedeutet, dass die Geometrie die angegebene Geometrie vollständig enthält, und "überlappen" bedeutet, dass sich die beiden Geometrien überlappen, aber keine der anderen vollständig enthält.

Im folgenden Codebeispiel wird gezeigt, wie zwei Kreise verglichen werden, die denselben Radius von 50 haben, aber um 50 versetzt sind.

HRESULT hr = S_OK;
ID2D1GeometrySink *pGeometrySink = NULL;

// Create the first ellipse geometry to merge.
const D2D1_ELLIPSE circle1 = D2D1::Ellipse(
    D2D1::Point2F(75.0f, 75.0f),
    50.0f,
    50.0f
    );

hr = m_pD2DFactory->CreateEllipseGeometry(
    circle1,
    &m_pCircleGeometry1
    );

if (SUCCEEDED(hr))
{
    // Create the second ellipse geometry to merge.
    const D2D1_ELLIPSE circle2 = D2D1::Ellipse(
        D2D1::Point2F(125.0f, 75.0f),
        50.0f,
        50.0f
        );

    hr = m_pD2DFactory->CreateEllipseGeometry(circle2, &m_pCircleGeometry2);
}

D2D1_GEOMETRY_RELATION result = D2D1_GEOMETRY_RELATION_UNKNOWN;

// Compare circle1 with circle2
hr = m_pCircleGeometry1->CompareWithGeometry(
    m_pCircleGeometry2,
    D2D1::IdentityMatrix(),
    0.1f,
    &result
    );

if (SUCCEEDED(hr))
{
    static const WCHAR szGeometryRelation[] = L"Two circles overlap.";
    m_pRenderTarget->SetTransform(D2D1::IdentityMatrix());
    if (result == D2D1_GEOMETRY_RELATION_OVERLAP)
    {
        m_pRenderTarget->DrawText(
            szGeometryRelation,
            ARRAYSIZE(szGeometryRelation) - 1,
            m_pTextFormat,
            D2D1::RectF(25.0f, 160.0f, 200.0f, 300.0f),
            m_pTextBrush
            );
    }
}

Outline

Die Outline-Methode berechnet die Kontur der Geometrie (eine Version der Geometrie, in der sich keine Figur selbst oder eine andere Abbildung kreuzt) und schreibt das Ergebnis in einen ID2D1SimplifiedGeometrySink. Im folgenden Codebeispiel wird Outline verwendet, um eine äquivalente Geometrie ohne Selbst schnittmengen zu erstellen. Dabei wird die Standardtoleranz für die Vereinfachung verwendet.

HRESULT D2DOutline(
    ID2D1Geometry *pGeometry,
    ID2D1Geometry **ppGeometry
    )
{
    HRESULT hr;
    ID2D1Factory *pFactory = NULL;
    pGeometry->GetFactory(&pFactory);

    ID2D1PathGeometry *pPathGeometry = NULL;
    hr = pFactory->CreatePathGeometry(&pPathGeometry);

    if (SUCCEEDED(hr))
    {
        ID2D1GeometrySink *pSink = NULL;
        hr = pPathGeometry->Open(&pSink);

        if (SUCCEEDED(hr))
        {
            hr = pGeometry->Outline(NULL, pSink);

            if (SUCCEEDED(hr))
            {
                hr = pSink->Close();

                if (SUCCEEDED(hr))
                {
                    *ppGeometry = pPathGeometry;
                    (*ppGeometry)->AddRef();
                }
            }
            pSink->Release();
        }
        pPathGeometry->Release();
    }

    pFactory->Release();

    return hr;
}

GetBounds und GetWidenedBounds

Die GetBounds-Methode ruft die Begrenzungen der Geometrie ab. Im folgenden Codebeispiel wird GetBounds verwendet, um die Grenzen eines angegebenen Kreises (m_pCircleGeometry1) abzurufen.

D2D1_RECT_F bounds;

hr = m_pCircleGeometry1->GetBounds(
      D2D1::IdentityMatrix(),
      &bounds
     );

if (SUCCEEDED(hr))
{
    // Retrieve the bounds.
}

Die GetWidenedBounds-Methode ruft die Begrenzungen der Geometrie ab, nachdem sie um die angegebene Strichbreite und den angegebenen Stil erweitert und von der angegebenen Matrix transformiert wurde. Im folgenden Codebeispiel wird GetWidenedBounds verwendet, um die Grenzen eines angegebenen Kreises (m_pCircleGeometry1) abzurufen, nachdem er um die angegebene Strichbreite erweitert wurde.

float dashes[] = {1.f, 1.f, 2.f, 3.f, 5.f};

m_pD2DFactory->CreateStrokeStyle(
    D2D1::StrokeStyleProperties(
        D2D1_CAP_STYLE_FLAT,
        D2D1_CAP_STYLE_FLAT,
        D2D1_CAP_STYLE_ROUND,
        D2D1_LINE_JOIN_ROUND,   // lineJoin
        10.f,   //miterLimit
        D2D1_DASH_STYLE_CUSTOM,
        0.f     //dashOffset
        ),
     dashes,
     ARRAYSIZE(dashes)-1,
     &m_pStrokeStyle
     );

D2D1_RECT_F bounds1;
hr = m_pCircleGeometry1->GetWidenedBounds(
      5.0,
      m_pStrokeStyle,
      D2D1::IdentityMatrix(),
      &bounds1
     );
if (SUCCEEDED(hr))
{
    // Retrieve the widened bounds.
}

ComputePointAtLength

Die ComputePointAtLength-Methode berechnet den Punkt und den Tangensvektor im angegebenen Abstand entlang der Geometrie. Im folgenden Codebeispiel wird ComputePointAtLength verwendet.

D2D1_POINT_2F point;
D2D1_POINT_2F tangent;

hr = m_pCircleGeometry1->ComputePointAtLength(
    10, 
    NULL, 
    &point, 
    &tangent);

Übersicht über Pfadgeometrien
Direct2D-Referenz

Freigeben über

Übersicht über Geometrien

Was ist eine Direct2D-Geometrie?

Einfache Geometrien

Pfadgeometrien

Zusammengesetzte Geometrien

Geometriegruppen

Transformierte Geometrien

Geometrien als Masken

Geometrische Vorgänge

Kombinieren von Geometrien

Erweitern

Tessellate

FillContainsPoint und StrokeContainsPoint

Vereinfachung

ComputeLength und ComputeArea

CompareWithGeometry

Outline

GetBounds und GetWidenedBounds

ComputePointAtLength

Feedback

Zusätzliche Ressourcen

Freigeben über

Übersicht über Geometrien

Was ist eine Direct2D-Geometrie?

Einfache Geometrien

Pfadgeometrien

Zusammengesetzte Geometrien

Geometriegruppen

Transformierte Geometrien

Geometrien als Masken

Geometrische Vorgänge

Kombinieren von Geometrien

Erweitern

Tessellate

FillContainsPoint und StrokeContainsPoint

Vereinfachung

ComputeLength und ComputeArea

CompareWithGeometry

Outline

GetBounds und GetWidenedBounds

ComputePointAtLength

Zugehörige Themen

Feedback

Zusätzliche Ressourcen