Condividi tramite

Guida introduttiva direct2D

  • Articolo

Direct2D è un'API in modalità immediata e nativa per la creazione di grafica 2D. Questo argomento illustra come usare Direct2D all'interno di un'applicazione Win32 tipica per disegnare in un HWND.

Nota

Per creare un'app di Windows Store che usa Direct2D, vedere l'argomento di avvio rapido Direct2D per Windows 8.

 

In questo argomento sono incluse le sezioni seguenti:

Disegno di un rettangolo semplice

Per disegnare un rettangolo usando GDI, è possibile gestire il messaggio di WM_PAINT , come illustrato nel codice seguente.

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.

Il codice per disegno dello stesso rettangolo con Direct2D è simile: crea risorse di disegno, descrive una forma da disegnare, disegna la forma, quindi rilascia le risorse di disegno. Le sezioni che seguono descrivono ognuno di questi passaggi in dettaglio.

Passaggio 1: Includere intestazione Direct2D

Oltre alle intestazioni necessarie per un'applicazione Win32, includere l'intestazione d2d1.h.

Passaggio 2: Creare un ID2D1Factory

Una delle prime operazioni eseguite da qualsiasi esempio Direct2D è la creazione di un ID2D1Factory.

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

L'interfaccia ID2D1Factory è il punto di partenza per l'uso di Direct2D; usare un ID2D1Factory per creare risorse Direct2D .

Quando si crea una factory, è possibile specificare se è multi-o a thread singolo. Per altre informazioni sulle factory multi-thread, vedere le osservazioni nella pagina di riferimento ID2D1Factory. In questo esempio viene creata una factory a thread singolo.

In generale, l'applicazione deve creare la factory una volta e conservarla per la vita dell'applicazione.

Passaggio 3: Creare un ID2D1HwndRenderTarget

Dopo aver creato una factory, usarla per creare una destinazione di rendering.



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

Una destinazione di rendering è un dispositivo che può eseguire operazioni di disegno e creare risorse di disegno dipendenti dal dispositivo, ad esempio pennelli. Diversi tipi di destinazioni di rendering vengono sottoposti a rendering in diversi dispositivi. L'esempio precedente usa un ID2D1HwndRenderTarget, che esegue il rendering in una parte dello schermo.

Quando possibile, una destinazione di rendering usa la GPU per accelerare le operazioni di rendering e creare risorse di disegno. In caso contrario, la destinazione di rendering usa la CPU per elaborare le istruzioni di rendering e creare risorse. È possibile modificare questo comportamento usando i flag di D2D1_RENDER_TARGET_TYPE quando si crea la destinazione di rendering.

Il metodo CreateHwndRenderTarget accetta tre parametri. Il primo parametro, un D2D1_RENDER_TARGET_PROPERTIES struct, specifica le opzioni di visualizzazione remota, se forzare il rendering della destinazione per il rendering in software o hardware e dpi. Il codice in questo esempio usa la funzione helper D2D1::RenderTargetProperties per accettare le proprietà di destinazione di rendering predefinite.

Il secondo parametro, un D2D1_HWND_RENDER_TARGET_PROPERTIES struct, specifica hWND a cui viene eseguito il rendering del contenuto, le dimensioni iniziali della destinazione di rendering (in pixel) e le relative opzioni di presentazione. In questo esempio viene usata la funzione helper D2D1::HwndRenderTargetProperties per specificare una dimensione HWND e iniziale. Usa le opzioni di presentazione predefinite.

Il terzo parametro è l'indirizzo del puntatore che riceve il riferimento di destinazione di rendering.

Quando si crea una destinazione di rendering e l'accelerazione hardware è disponibile, allocare le risorse nella GPU del computer. Creando una destinazione di rendering una volta e conservandola il più a lungo possibile, si ottengono vantaggi per le prestazioni. L'applicazione deve creare destinazioni di rendering una volta e conservarle per la vita dell'applicazione o fino a quando non viene ricevuto l'errore di D2DERR_RECREATE_TARGET . Quando si riceve questo errore, è necessario ricreare la destinazione di rendering e tutte le risorse create.

Passaggio 4: Creare un pennello

Come una factory, una destinazione di rendering può creare risorse di disegno. In questo esempio la destinazione di rendering crea un pennello.

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

Un pennello è un oggetto che disegna un'area, ad esempio il tratto di una forma o il riempimento di una geometria. Il pennello in questo esempio disegna un'area con un colore a tinta unita predefinita, nero.

Direct2D fornisce anche altri tipi di pennelli: pennelli sfumature sfumature per disegnare sfumature lineari e radiali e un pennello bitmap per disegnare con bitmap e modelli.

Alcune API di disegno forniscono penne per disegno contorni e pennelli per riempire le forme. Direct2D è diverso: non fornisce un oggetto penna ma usa un pennello per i contorni e la riempimento delle forme. Quando si disegnano i contorni, usare l'interfaccia ID2D1StrokeStyle con un pennello per controllare le operazioni di strozzamento del percorso.

Un pennello può essere usato solo con la destinazione di rendering che l'ha creata e con altre destinazioni di rendering nello stesso dominio di risorse. In generale, è necessario creare pennelli una volta e conservarli per la vita della destinazione di rendering che li ha creati. ID2D1SolidColorBrush è l'eccezione solitaria; poiché è relativamente economico per creare, è possibile creare un ID2D1SolidColorBrush ogni volta che si disegna un frame, senza alcun colpo di prestazioni evidente. È anche possibile usare un singolo ID2D1SolidColorBrush e modificare il colore ogni volta che lo si usa.

Passaggio 5: Disegnare il rettangolo

Usare quindi la destinazione di rendering per disegnare il rettangolo.

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

Il metodo DrawRectangle accetta due parametri: il rettangolo da disegnare e il pennello da utilizzare per disegnare la struttura del rettangolo. Facoltativamente, è anche possibile specificare le opzioni di larghezza del tratto, modello trattino, join linea e limite finale.

È necessario chiamare il metodo BeginDraw prima di emettere comandi di disegno e è necessario chiamare il metodo EndDraw dopo aver completato l'emissione di comandi di disegno. Il metodo EndDraw restituisce un valore HRESULT che indica se i comandi di disegno hanno avuto esito positivo.

Passaggio 6: Rilasciare le risorse

Quando non sono presenti più fotogrammi da disegnare o quando si riceve l'errore di D2DERR_RECREATE_TARGET , rilasciare la destinazione di rendering e tutti i dispositivi creati.

 
SafeRelease(pRT);
SafeRelease(pBlackBrush);

Al termine dell'uso delle risorse Direct2D, ad esempio quando si sta per uscire, rilasciare la factory Direct2D.

 
SafeRelease(pD2DFactory);

Creare un'applicazione Direct2D semplice

Il codice in questo argomento mostra gli elementi di base di un'applicazione Direct2D. Per brevità, l'argomento omette il framework dell'applicazione e il codice di gestione degli errori che è caratteristica di un'applicazione ben scritta. Per una procedura dettagliata più dettagliata che illustra il codice completo per la creazione di un'applicazione Direct2D semplice e illustra le procedure consigliate di progettazione, vedere Creare un'applicazione Direct2D semplice.

Creare un'applicazione Direct2D semplice