Übersicht über Geometrien
In dieser Übersicht wird beschrieben, wie ID2D1Geometry-Objekte erstellt und verwendet werden, um 2D-Abbildungen zu definieren und zu bearbeiten. 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, ID2D1RoundedRectangleGeometryoder ID2D1EllipseGeometry), eine Pfadgeometrie (ID2D1PathGeometry) oder eine zusammengesetzte Geometrie (ID2D1GeometryGroup und ID2D1TransformedGeometry) sein.
Mit Direct2D-Geometrien können Sie zweidimensionale Abbildungen beschreiben und viele Verwendungsmöglichkeiten bieten, z. B. das Definieren von Treffertestregionen, Clipregionen 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 für die Lebensdauer der Anwendung oder so lange halten, bis sie geändert werden müssen. Weitere Informationen zu geräteunabhängigen und geräteabhängigen Ressourcen finden Sie unter Übersicht über Ressourcen.
In den folgenden Abschnitten werden die verschiedenen Arten von Geometrien beschrieben.
Einfache Geometrien
Zu den einfachen Geometrien gehören ID2D1RectangleGeometry, ID2D1RoundedRectangleGeometryund ID2D1EllipseGeometry-Objekte und können verwendet werden, um grundlegende geometrische Abbildungen wie Rechtecke, abgerundete Rechtecke, Kreise und Ellipsen zu erstellen.
Verwenden Sie zum Erstellen einer einfachen Geometrie eine der Methoden ID2D1Factory::Create<geometryType>Geometry. Diese Methoden erstellen ein Objekt des angegebenen Typs. Um beispielsweise ein Rechteck zu erstellen, rufen Sie ID2D1Factory::CreateRectangleGeometryauf, das ein ID2D1RectangleGeometry-Objekt zurückgibt. Um ein abgerundetes Rechteck zu erstellen, rufen Sie ID2D1Factory::CreateRoundedRectangleGeometryauf, das ein ID2D1RoundedRectangleGeometry-Objekt zurückgibt, und so weiter.
Im folgenden Codebeispiel wird die CreateEllipseGeometry-Methode mit einer Ellipsenstruktur mit dem Mittelpunkt (100, 100), x-radius auf 100 und y-radius auf 50 aufruft. Anschließend ruft sie DrawGeometryauf und überträgt die zurückgegebene Ellipsegeometrie, einen Zeiger auf einen schwarzen ID2D1SolidColorBrushund eine Strichbreite von 5. Die folgende Abbildung zeigt die Ausgabe des Codebeispiels.

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);
Verwenden Sie die DrawGeometry-Methode, um die Kontur einer geometrie zu zeichnen. Verwenden Sie die FillGeometry-Methode, um das Innere zu zeichnen.
Pfadgeometrien
Pfadgeometrien werden durch die ID2D1PathGeometry-Schnittstelle dargestellt. Diese Objekte können verwendet werden, um komplexe geometrische Abbildungen zu beschreiben, die aus Segmenten wie Bogen, Kurven und Linien bestehen. Die folgende Abbildung zeigt eine Zeichnung, die mithilfe der Pfadgeometrie erstellt wurde.

Weitere Informationen und Beispiele finden Sie unter Übersicht über Pfadgeometrien.
Zusammengesetzte Geometrien
Eine zusammengesetzte Geometrie ist eine Geometrie, die mit einem anderen geometry-Objekt oder mit einer Transformation zusammengefasst oder kombiniert wird. Zusammengesetzte Geometrien umfassen ID2D1TransformedGeometry- und ID2D1GeometryGroup-Objekte.
Geometriegruppen
Geometriegruppen sind eine bequeme Möglichkeit, mehrere Geometrien gleichzeitig zu gruppiert, sodass alle Abbildungen 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 dabei fillMode mit möglichen Werten von D2D1 _ FILL MODE _ _ ALTERNATE (alternate) und D2D1 _ FILL MODE _ _ WINDING, ein Array von Geometry-Objekten, die der Geometriegruppe hinzugefügt werden, und die Anzahl der Elemente in diesem Array.
Im folgenden Codebeispiel wird zuerst ein Array von geometry-Objekten deklariert. Diese Objekte sind vier konzentrierte Kreise mit den folgenden Radien: 25, 50, 75 und 100. Rufen Sie dann createGeometryGroup für das ID2D1Factory-Objekt auf, und übergeben Sie dabei D2D1 _ FILL MODE _ _ ALTERNATE,ein Array von geometry-Objekten, die der Geometriegruppe hinzugefügt werden, 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.

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 ID2D1TransformedGeometryzu erstellen.
Die Methode, die Sie verwenden sollten, hängt von dem effekt ab, den Sie wünschen. Wenn Sie das Renderziel verwenden, um eine Geometrie zu transformieren und dann zu rendern, wirkt sich die Transformation auf alle Geometrien aus, einschließlich der Breite aller angewendeten Striche. Wenn Sie hingegen eine ID2D1TransformedGeometryverwenden, 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 die Strichstärke von Strichen mit D2D1 _ STROKE TRANSFORM TYPE _ _ _ FIXEDoder D2D1 STROKE TRANSFORM TYPE HAIRLINE nicht _ _ _ _ beeinflusst. Sie sollten diese Transformationstypen verwenden, um transformationsunabhängige Striche zu erzielen.
Im folgenden Beispiel wird eine ID2D1RectangleGeometryerstellt und dann ohne Transformation ge zeichnet. Sie erzeugt die in der folgenden Abbildung gezeigte Ausgabe.

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 besser ist, obwohl die Strichstärke 1 ist.

// 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. Sie erzeugt die in der folgenden Abbildung gezeigte Ausgabe. Beachten Sie, dass der Strich nicht erhöht wurde, obwohl das Rechteck größer ist.

// 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 in das Renderziel zusammengesetzt wird. Weitere Informationen finden Sie im Abschnitt Geometrische Masken der Übersicht über Ebenen.
Geometrische Operationen
Die ID2D1Geometry-Schnittstelle bietet mehrere geometrische Operationen, mit denen Sie geometrische Abbildungen bearbeiten und messen können. Sie können sie beispielsweise verwenden, um ihre Grenzen zu berechnen und zurück zu geben, 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 mehr. In der folgenden Tabelle werden die gängigen geometrischen Operationen beschrieben.
| Vorgang | Methode |
|---|---|
| Kombinieren | CombineWithGeometry |
| Bounds/Widened Bounds/Retrieve Bounds, Dirty Region update | Widen, GetBounds, GetWidenedBounds |
| Treffertests | FillContainsPoint, StrokeContainsPoint |
| Stroke | StrokeContainsPoint |
| Vergleich | CompareWithGeometry |
| Vereinfachung (entfernt Bogen und quadratische Bézierkurven) | Vereinfachen |
| Mosaik | Mosaik |
| Kontur (Schnittmenge entfernen) | Outline |
| Berechnen des Bereichs oder der Länge einer Geometrie | ComputeArea, ComputeLength, ComputePointAtLength |
Hinweis
Ab Windows 8 können Sie die ComputePointAndSegmentAtLength-Methode für ID2D1PathGeometry1 verwenden, um den Bereich oder die 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 an, den Kombinationsvorgang durchzuführen: D2D1 _ COMBINE _ MODE _ UNION (union), D2D1 _ COMBINE MODE _ _ INTERSECT (intersect), D2D1 _ COMBINE MODE XOR _ _ (xor) und D2D1 _ COMBINE MODE _ _ EXCLUDE (exclude). Das folgende Codebeispiel zeigt zwei Kreise, die mithilfe des Union-Kombinierungsmodus kombiniert werden, wobei der erste Kreis den Mittelpunkt (75, 75) und den Radius von 50 und der zweite Kreis den Mittelpunkt (125, 75) und den Radius von 50 hat.
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 in Kombination mit einem Kombinationsmodus von Union.

Abbildungen zu allen Kombinationsmodi finden Sie in der D2D1 _ COMBINE _ MODE-Enumeration.
Erweitern
Die Widen-Methode generiert eine neue Geometrie, deren Füllung der Füllung der vorhandenen Geometrie entspricht, und schreibt dann das Ergebnis in das angegebene ID2D1SimplifiedGeometrySink-Objekt. Im folgenden Codebeispiel wird Open für das ID2D1PathGeometry-Objekt aufruft. Wenn Open erfolgreich ist, ruft es Widen für das geometry-Objekt auf.
ID2D1GeometrySink *pGeometrySink = NULL;
hr = pPathGeometry->Open(&pGeometrySink);
if (SUCCEEDED(hr))
{
hr = pGeometry->Widen(
strokeWidth,
pIStrokeStyle,
pWorldTransform,
pGeometrySink
);
Mosaik
Die Tessellate-Methode erstellt einen Satz von dreieckigen Dreiecken im Uhrzeigersinn, die die Geometrie abdecken, nachdem sie mithilfe der angegebenen Matrix transformiert und mithilfe der angegebenen Toleranz abgeflachen wurde. Im folgenden Codebeispiel wird Tessellate verwendet, um eine Liste von Dreiecken zu erstellen, die pPathGeometry darstellen. Die Dreiecke werden in id2D1Mesh, pMesh gespeichert und dann zur späteren Verwendung beim Rendering an den Klassen member 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 für Treffertests verwenden. Das folgende Codebeispiel ruft FillContainsPoint für ein ID2D1EllipseGeometry-Objekt auf und überträgt einen Punkt bei (0,0) und eine Identitätsmatrix.
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 für Treffertests verwenden. 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.
}
Vereinfachen von
Die Simplify-Methode entfernt Bogen 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 Linie entrollt wurde. Dies schließt das implizite 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. Zu den möglichen Werten für die Schnittmenge zählen D2D1 _ GEOMETRY _ RELATION _ DISJOINT (disjoint), D2D1 _ GEOMETRY _ RELATION IS _ _ CONTAINED (enthalten), D2D1 _ GEOMETRY RELATION _ _ CONTAINS (contains) und D2D1 _ GEOMETRY RELATION _ _ OVERLAP (overlap). "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 "overlap" bedeutet, dass sich die beiden Geometrien überlappen, aber keines von beiden vollständig die andere enthält.
Das folgende Codebeispiel zeigt, wie zwei Kreise verglichen werden, die den gleichen 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 keine Abbildung sich selbst oder eine andere Abbildung überkreuzt) und schreibt das Ergebnis in eine ID2D1SimplifiedGeometrySink. Im folgenden Codebeispiel wird Outline verwendet, um eine entsprechende Geometrie ohne Selbstschnitte zu erstellen. Es wird die standardmäßige Flatteningtoleranz 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 abzurufen (m _ pCircleGeometry1).
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 geweitet 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 geweitet 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 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);