Geometriák áttekintése

Ez az áttekintés azt ismerteti, hogyan hozhat létre és használhat ID2D1Geometry objektumokat a 2D számok definiálásához és kezeléséhez. A következő szakaszokat tartalmazza.

Mi az a Direct2D geometria?

A Direct2D geometria egy ID2D1Geometry objektum. Ez az objektum lehet egyszerű geometria (ID2D1RectangleGeometry, ID2D1RoundedRectangleGeometry, vagy ID2D1EllipseGeometry), útvonal geometria (ID2D1PathGeometry), vagy összetett geometria (ID2D1GeometryGroup és ID2D1TransformedGeometry).

A Direct2D geometriák lehetővé teszik a kétdimenziós számok leírását, és számos felhasználási lehetőséget kínálnak, például a találattesztelési régiók, a kliprégiók és akár az animációs útvonalak meghatározását.

A Direct2D geometriák nem módosíthatók, és az ID2D1Factoryáltal létrehozott eszközfüggetlen erőforrások. Általában egyszer létre kell hoznia a geometriákat, és meg kell tartania őket az alkalmazás élettartama alatt, vagy amíg módosítani nem kell őket. Az eszközfüggetlen és az eszközfüggő erőforrásokról további információt az Erőforrások áttekintésecímű témakörben talál.

A következő szakaszok a különböző típusú geometriákat ismertetik.

Egyszerű geometriák

Az egyszerű geometriák közé tartoznak az ID2D1RectangleGeometry, ID2D1RoundedRectangleGeometryés ID2D1EllipseGeometry objektumok, és használhatók alapszintű geometriai ábrák, például téglalapok, lekerekített téglalapok, körök és ellipszisek létrehozására.

Egyszerű geometria létrehozásához használja az ID2D1Factory::Create<geometryType>Geometry metódusokat. Ezek a metódusok a megadott típusú objektumot hoznak létre. Téglalap létrehozásához például hívja meg ID2D1Factory::CreateRectangleGeometry, amely egy ID2D1RectangleGeometry objektumot ad vissza; lekerekített téglalap létrehozásához hívja meg ID2D1Factory::CreateRoundedRectangleGeometry, amely egy ID2D1RoundedRectangleGeometry objektumot ad vissza stb.

Az alábbi kódpélda meghívja a CreateEllipseGeometry metódust, melynek paraméterei egy olyan ellipszis-struktúrát tartalmaznak, amelynek középpontja (100, 100), x-sugara 100, és y-sugara 50. Ezután meghívja a DrawGeometryfüggvényt, átadva a visszaadott ellipszis geometriát, egy mutatót egy fekete ID2D1SolidColorBrush-hez, és egy 5-ös vonalvastagságot. Az alábbi ábrán a példakód kimenete látható.

ábrája

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

Bármely geometria körvonalának rajzolásához használja a DrawGeometry metódust. A belső festéshez használja a FillGeometry metódust.

Útvonalgeometriák

Az útvonalgeometriákat az ID2D1PathGeometry interfész jelöli. Ezek az objektumok olyan szegmensekből, például ívekből, görbékből és vonalakból álló összetett geometriai ábrák leírására használhatók. Az alábbi ábrán egy útvonalgeometriával létrehozott rajz látható.

További információkért és példákért lásd a Útvonalgeometria áttekintése.

Összetett geometriák

Az összetett geometria egy más geometriai objektummal vagy átalakítással csoportosított vagy kombinált geometria. Az összetett geometriák közé tartozik ID2D1TransformedGeometry és ID2D1GeometryGroup objektum.

Geometriai csoportok

A geometriai csoportok kényelmesen csoportosíthatók egyszerre több geometria között, így a különböző geometriák összes ábrája össze van fűzve egybe. Ha létre szeretne hozni egy ID2D1GeometryGroup objektumot, hívja meg az ID2D1Factory objektumon a CreateGeometryGroup metódust. Adja meg a fillMode paramétert, amely a következő értékeket veheti fel: D2D1_FILL_MODE_ALTERNATE (alternatív) és D2D1_FILL_MODE_WINDING. Továbbá adjon meg egy tömböt a geometriai objektumokkal, amelyeket a geometriai csoporthoz hozzá szeretne adni, valamint a tömb elemeinek számát.

Az alábbi példakód először geometriai objektumok tömböt deklarál. Ezek az objektumok négy koncentrikus kör, amelyek sugarai a következők: 25, 50, 75 és 100. Ezután hívja meg a CreateGeometryGroup az ID2D1Factory objektumon, és adja át a D2D1_FILL_MODE_ALTERNATE, a geometriai csoporthoz hozzáadni kívánt geometriai objektumok tömbjét, valamint a tömb elemeinek számát.

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

Az alábbi ábra a példában szereplő két csoportgeometria megjelenítésének eredményeit mutatja be.

Átalakított geometriák

A geometria átalakításának több módja is van. A renderelési cél SetTransform metódusával átalakíthat mindent, amelyet a renderelési cél rajzol, vagy közvetlenül társíthat átalakítást egy geometriához a CreateTransformedGeometry metódussal egy ID2D1TransformedGeometrylétrehozásához.

A használni kívánt módszer a kívánt hatástól függ. Amikor a renderelési célfelületet használja a geometria átalakítására, majd renderelésére, az átalakítás mindenre hatással van a geometriával kapcsolatban, beleértve bármely alkalmazott vonás szélességét is. Ha viszont ID2D1TransformedGeometryhasznál, az átalakítás csak az alakzatot leíró koordinátákat érinti. Az átalakítás nem befolyásolja a körvonal vastagságát a geometria rajzolásakor.

Az alábbi példa létrehoz egy ID2D1RectangleGeometry-t, majd azt átalakítás nélkül rajzolja meg. Az alábbi ábrán látható kimenetet hozza létre.

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

A következő példa a renderelési célt használja a geometria 3-ra történő skálázásához, majd megrajzolja. Az alábbi ábrán a téglalap átalakítása nélküli és az átalakítással történő rajzolásának eredménye látható. Figyelje meg, hogy a vonás vastagabb az átalakítás után, annak ellenére, hogy a vonás vastagsága 1.

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

A következő példa a CreateTransformedGeometry metódust használja a geometria 3 tényezővel való skálázásához, majd megrajzolja. Az alábbi ábrán látható kimenetet hozza létre. Figyelje meg, hogy bár a téglalap nagyobb, a körvonala nem nőtt.

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

Geometriák maszkként

Az ID2D1Geometry objektumot geometriai maszkként használhatja, amikor a PushLayer metódust hívja meg. A geometriai maszk a rétegnek a renderelési célba összetett területét adja meg. További információt a Rétegek áttekintésegeometriai maszkok szakaszában talál.

Geometriai műveletek

Az ID2D1Geometry interfész számos geometriai műveletet biztosít, amelyekkel geometriai ábrákat kezelhet és mérhet. Használhatja például őket a határaik kiszámítására és visszaadására, összehasonlíthatja, hogy az egyik geometria hogyan kapcsolódik térbelileg a másikhoz (a találatteszteléshez hasznos), kiszámíthatja a területeket és a hosszokat stb. Az alábbi táblázat a gyakori geometriai műveleteket ismerteti.

Geometriák kombinálása

Ha egy geometriát egy másikkal szeretne kombinálni, hívja meg az ID2D1Geometry::CombineWithGeometry metódust. A geometriák kombinálásakor meg kell határoznia a kombinálási művelet végrehajtásának egyik módját: D2D1_COMBINE_MODE_UNION (egyesítés), D2D1_COMBINE_MODE_INTERSECT (metszet), D2D1_COMBINE_MODE_XOR (xor) és D2D1_COMBINE_MODE_EXCLUDE (kizárás). Az alábbi példakód két kört mutat be, amelyek az egyesítési móddal vannak kombinálva, ahol az első kör középpontja (75, 75) és az 50-es sugarú, a második kör pedig a középpontja (125, 75) és az 50-es sugara.

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

Az alábbi ábrán két kör látható egyesítési móddal kombinálva.

Az összevonási módok illusztrációihoz lásd a D2D1_COMBINE_MODE felsorolást.

Kibővít

A Widen metódus létrehoz egy új geometriát, amelynek kitöltése egyenértékű a meglévő geometria simításával, majd az eredményt a megadott ID2D1SimplifiedGeometrySink objektumba írja. Az alábbi példakód meghívja Open az ID2D1PathGeometry objektumon. Ha Open sikeres, meghívja a Widen függvényt a geometriai objektumon.

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

Tessellate

A Tessellate metódus óramutató járásával megegyező irányba háromszögeket hoz létre, amelyek a geometria lefedésére szolgálnak, miután a megadott mátrix használatával történő átalakítás megtörtént, és a megadott tűrés használatával simítva lettek. Az alábbi példakód a Tessellate használatával hozza létre a pPathGeometry ábrázoló háromszögek listáját. A háromszögeket egy ID2D1Meshtárolja, pMesh, majd át lesz osztva egy osztálytagnak, m_pStrokeMesh, a későbbi megjelenítéshez.

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 és StrokeContainsPoint

A FillContainsPoint metódus azt jelzi, hogy a geometria által kitöltött terület tartalmazza-e a megadott pontot. Ezzel a módszerrel elvégezheti az ütközési tesztet. Az alábbi példakód meghívja a FillContainsPoint metódust egy ID2D1EllipseGeometry objektumon, megadva benne egy (0,0) pontot és egy Identity mátrixot.

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

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

A StrokeContainsPoint metódus határozza meg, hogy a geometria körvonala tartalmazza-e a megadott pontot. Ezzel a módszerrel elvégezheti a találatérzékelést. Az alábbi példakód a StrokeContainsPointhasználja.

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.
}

Egyszerűsít

A Egyszerűsítés metódus eltávolítja az íveket és a kvadratikus Bezier-görbéket egy megadott geometriából. Az eredményül kapott geometria tehát csak vonalakat és opcionálisan köb alakú Bezier-görbéket tartalmaz. Az alábbi példakód a Simplify használatával alakít át egy Bezier-görbékkel rendelkező geometriát olyan geometriává, amely csak vonalszegmenseket tartalmaz.

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

HosszKiszámítás és TerületKiszámítás

A ComputeLength metódus kiszámítja a megadott geometria hosszát, ha az egyes szegmenseket kiegyenesítenénk és vonallá alakítanánk. Ez magában foglalja az implicit záró szegmenst, ha a geometria bezárult. Az alábbi példakód ComputeLength használatával számítja ki egy adott kör (m_pCircleGeometry1) hosszát.

float length;

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

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

A ComputeArea metódus kiszámítja a megadott geometria területét. Az alábbi példakód ComputeArea használatával számítja ki egy adott kör (m_pCircleGeometry1) területét.

float area;

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

CompareWithGeometry

A CompareWithGeometry metódus a metódust meghívó geometria és a megadott geometria metszetét írja le. A metszet lehetséges értékei közé tartozik a D2D1_GEOMETRY_RELATION_DISJOINT (különálló), D2D1_GEOMETRY_RELATION_IS_CONTAINED (benne foglaltatik), D2D1_GEOMETRY_RELATION_CONTAINS (tartalmaz) és D2D1_GEOMETRY_RELATION_OVERLAP (átfedés). A "különálló" azt jelenti, hogy két geometriai kitöltés egyáltalán nem metszi egymást. Az "tartalmazva" azt jelenti, hogy a geometriát a megadott geometria teljesen magában foglalja. A "contains" azt jelenti, hogy a geometria teljesen tartalmazza a megadott geometriát, az "átfedés" pedig azt jelenti, hogy a két geometria átfedésben van, de egyik sem tartalmazza teljesen a másikat.

Az alábbi példakód bemutatja, hogyan hasonlítható össze két olyan kör, amelyek azonos 50-es sugarúak, de 50-zel vannak eltolva.

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

Vázlat

A Outline metódus kiszámítja a geometria körvonalát (a geometria olyan verzióját, amelyben egyetlen ábra sem keresztezi önmagát vagy más ábrát), és az eredményt egy ID2D1SimplifiedGeometrySinkírja. Az alábbi példakód a Vázlat-t használja egy önmetszéseket nem tartalmazó ekvivalens geometria létrehozására. Az alapértelmezett simítási tűrést használja.

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 és GetWidenedBounds

A GetBounds metódus lekéri a geometria határait. Az alábbi példakód GetBounds használatával kéri le egy adott kör (m_pCircleGeometry1) határait.

D2D1_RECT_F bounds;

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

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

A GetWidenedBounds metódus lekéri a geometria határait, miután a megadott körvonalszélességgel és stílussal ki van bővítve, és a megadott mátrixszal átalakítva. Az alábbi példakód GetWidenedBounds használatával kéri le egy adott kör (m_pCircleGeometry1) határait, miután a megadott körvonalszélesség ki lett szélesítve.

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.
}

Hosszmenti Pont Számítása

A ComputePointAtLength metódus kiszámítja a pont- és érintővektort a megadott távolságra a geometria mentén. Az alábbi példakód ComputePointAtLengthhasznál.

D2D1_POINT_2F point;
D2D1_POINT_2F tangent;

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

Kapcsolódó témakörök

útvonalgeometriák áttekintése

Direct2D-referencia