Delen via

Snelstartgids voor Direct2D

Direct2D is een systeemeigen, immediate-mode API voor het maken van 2D-grafieken. In dit onderwerp wordt uitgelegd hoe u Direct2D kunt toepassen in een typische Win32-toepassing voor het tekenen op een HWND-.

Notitie

Als u een Windows Store-app wilt maken die Direct2D gebruikt, raadpleegt u het onderwerp Quickstart Direct2D voor Windows 8.

 

Dit onderwerp bevat de volgende secties:

Een eenvoudige rechthoek tekenen

Als u een rechthoek wilt tekenen met GDI-, kunt u het WM_PAINT bericht afhandelen, zoals wordt weergegeven in de volgende code.

switch(message)
{

    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            BeginPaint(hwnd, &ps);

            // Obtain the size of the drawing area.
            RECT rc;
            GetClientRect(
                hwnd,
                &rc
            );          

            // Save the original object
            HGDIOBJ original = NULL;
            original = SelectObject(
                ps.hdc,
                GetStockObject(DC_PEN)
            );

            // Create a pen.            
            HPEN blackPen = CreatePen(PS_SOLID, 3, 0);

            // Select the pen.
            SelectObject(ps.hdc, blackPen);

            // Draw a rectangle.
            Rectangle(
                ps.hdc, 
                rc.left + 100, 
                rc.top + 100, 
                rc.right - 100, 
                rc.bottom - 100);   

            DeleteObject(blackPen);

            // Restore the original object
            SelectObject(ps.hdc, original);

            EndPaint(hwnd, &ps);
        }
        return 0;

// Code for handling other messages.

De code voor het tekenen van dezelfde rechthoek met Direct2D is vergelijkbaar: hiermee worden tekenresources gemaakt, wordt een shape beschreven die moet worden getekend, wordt de shape getekend en worden vervolgens de tekenresources vrijgegeven. In de volgende secties wordt elk van deze stappen gedetailleerd beschreven.

Stap 1: Direct2D-header opnemen

Naast de headers die vereist zijn voor een Win32-toepassing, neemt u de d2d1.h-header op.

Stap 2: Een ID2D1Factory maken

Een van de eerste dingen die elk Direct2D-voorbeeld doet, is het creëren van een ID2D1Factory.

ID2D1Factory* pD2DFactory = NULL;
HRESULT hr = D2D1CreateFactory(
    D2D1_FACTORY_TYPE_SINGLE_THREADED,
    &pD2DFactory
    );

De interface ID2D1Factory is het startpunt voor het gebruik van Direct2D; gebruik een ID2D1Factory- om Direct2D-resources te maken.

Wanneer u een fabriek maakt, kunt u opgeven of deze meerdere threads of één thread bevat. (Zie de opmerkingen op de referentiepagina van ID2D1Factoryvoor meer informatie over multithreaded factory's. In dit voorbeeld wordt een factory met één thread gemaakt.

Over het algemeen moet uw toepassing de fabriek eenmaal maken en deze gedurende de levensduur van de toepassing behouden.

Stap 3: Een ID2D1HwndRenderTarget maken

Nadat u een fabriek hebt gemaakt, gebruikt u deze om een renderdoel te maken.



// Obtain the size of the drawing area.
RECT rc;
GetClientRect(hwnd, &rc);

// Create a Direct2D render target          
ID2D1HwndRenderTarget* pRT = NULL;          
HRESULT hr = pD2DFactory->CreateHwndRenderTarget(
    D2D1::RenderTargetProperties(),
    D2D1::HwndRenderTargetProperties(
        hwnd,
        D2D1::SizeU(
            rc.right - rc.left,
            rc.bottom - rc.top)
    ),
    &pRT
);

Een renderdoel is een apparaat dat tekenbewerkingen kan uitvoeren en apparaatafhankelijke tekenresources zoals borstels kan maken. Verschillende typen renderdoelen worden weergegeven op verschillende apparaten. In het voorgaande voorbeeld wordt een ID2D1HwndRenderTargetgebruikt, die rendert naar een schermgedeelte.

Indien mogelijk gebruikt een renderdoel de GPU om renderingbewerkingen te versnellen en tekenresources te maken. Anders gebruikt het renderdoel de CPU om renderinginstructies te verwerken en resources te maken. (U kunt dit gedrag wijzigen met behulp van de D2D1_RENDER_TARGET_TYPE vlaggen wanneer u het renderdoel maakt.)

De methode CreateHwndRenderTarget heeft drie parameters. De eerste parameter, een D2D1_RENDER_TARGET_PROPERTIES struct, geeft externe weergaveopties op, of het renderdoel moet worden geforceerd weergegeven naar software of hardware, en de DPI. In de code in dit voorbeeld wordt de helperfunctie D2D1::RenderTargetProperties gebruikt om standaardeigenschappen voor renderdoel te accepteren.

De tweede parameter, een D2D1_HWND_RENDER_TARGET_PROPERTIES-struct, specificeert de HWND- waarop de inhoud wordt weergegeven, de initiële grootte van het weergavedoel (in pixels), en de presentatieopties. In dit voorbeeld wordt de helperfunctie D2D1::HwndRenderTargetProperties helperfunctie gebruikt om een HWND en initiële grootte op te geven. Er worden standaardpresentatieopties gebruikt.

De derde parameter is het adres van de aanwijzer die de verwijzing naar het renderdoel ontvangt.

Wanneer u een renderdoel maakt en hardwareversnelling beschikbaar is, wijst u resources toe op de GPU van de computer. Door een renderdoel eenmaal te maken en zo lang mogelijk te behouden, profiteert u van prestatievoordelen. Uw toepassing moet eenmaal "render targets" maken en deze bewaren gedurende de levensduur van de toepassing of totdat de fout D2DERR_RECREATE_TARGET is ontvangen. Wanneer u deze fout ontvangt, moet u het renderdoel opnieuw maken (en alle hulpbronnen die daarbij zijn gemaakt).

Stap 4: Een borstel maken

Net als een fabriek kan een renderdoel tekenbronnen maken. In dit voorbeeld maakt het renderdoel een kwast.

ID2D1SolidColorBrush* pBlackBrush = NULL;
if (SUCCEEDED(hr))
{
            
    pRT->CreateSolidColorBrush(
        D2D1::ColorF(D2D1::ColorF::Black),
        &pBlackBrush
        ); 
}

Een borstel is een object dat een gebied schildert, zoals de lijn van een vorm of de opvulling van een geometrie. De kwast in dit voorbeeld schildert een gebied met een vooraf gedefinieerde effen kleur, zwart.

Direct2D biedt ook andere soorten borstels: kleurovergangsborstels voor het schilderen van lineaire en radiale kleurovergangen, en een bitmapborstel voor het schilderen met bitmaps en patronen.

Sommige teken-API's bieden pennen voor tekenkaders en borstels voor het vullen van vormen. Direct2D is anders: het biedt geen penobject, maar maakt gebruik van een penseel voor het tekenen van contouren en het vullen van vormen. Bij het tekenen van contouren, gebruikt u de ID2D1StrokeStyle interface met een kwast om het stroken van paden te beheren.

Een penseel kan alleen worden gebruikt met het renderdoel dat het heeft gegenereerd en met andere renderdoelen binnen hetzelfde resourcedomein. Over het algemeen moet u penselen eenmalig maken en ze behouden gedurende de levensduur van het rendertarget waarvoor ze zijn gemaakt. ID2D1SolidColorBrush is de enige uitzondering; omdat het relatief goedkoop is om te maken, kunt u elke keer dat u een frame tekent, een ID2D1SolidColorBrush maken zonder merkbaar prestatiedaling. U kunt ook één ID2D1SolidColorBrush gebruiken en de kleur ervan bij elk gebruik wijzigen.

Stap 5: De rechthoek tekenen

Gebruik vervolgens het renderdoel om de rechthoek te tekenen.

 
pRT->BeginDraw();

pRT->DrawRectangle(
    D2D1::RectF(
        rc.left + 100.0f,
        rc.top + 100.0f,
        rc.right - 100.0f,
        rc.bottom - 100.0f),
        pBlackBrush);

HRESULT hr = pRT->EndDraw();

De methode DrawRectangle heeft twee parameters: de rechthoek die moet worden getekend en de kwast die moet worden gebruikt om de omtrek van de rechthoek te schilderen. U kunt desgewenst ook de opties voor lijnbreedte, streepjespatroon, lijndeelname en eindlimiet opgeven.

U moet de methode BeginDraw aanroepen voordat u tekenopdrachten uitgeeft en u moet de methode EndDraw aanroepen nadat u klaar bent met het uitgeven van tekenopdrachten. De methode EndDraw retourneert een HRESULT- die aangeeft of de tekenopdrachten zijn geslaagd.

Stap 6: Resources vrijgeven

Wanneer er geen frames meer zijn om te tekenen, of wanneer u de fout D2DERR_RECREATE_TARGET ontvangt, maak dan het renderdoel en alle aangemaakte apparaten vrij.

 
SafeRelease(pRT);
SafeRelease(pBlackBrush);

Wanneer uw toepassing klaar is met het gebruik van Direct2D-resources (bijvoorbeeld wanneer deze op het punt staat af te sluiten), laat u de Direct2D-factory los.

 
SafeRelease(pD2DFactory);

Een eenvoudige Direct2D-toepassing maken

De code in dit onderwerp bevat de basiselementen van een Direct2D-toepassing. Kortom, het onderwerp laat het toepassingsframework en de code voor foutafhandeling weg die kenmerkend is voor een goed geschreven toepassing. Zie Een eenvoudige Direct2D-toepassing makenvoor een gedetailleerdere procedure die de volledige code laat zien voor het maken van een eenvoudige Direct2D-toepassing en de beste ontwerppraktijken demonstreert.

Een eenvoudige Direct2D-toepassing maken

 

 

  • Last updated on