Alvos de Renderização, Dispositivos e Recursos

Um de destino de renderização é simplesmente o local onde o seu programa desenhará. Normalmente, o destino de renderização é uma janela (especificamente, a área do cliente da janela). Também pode ser um bitmap na memória que não é exibido. Um destino de renderização é representado pela interface ID2D1RenderTarget.

Um dispositivo é uma abstração que representa aquilo que realmente desenha os píxeis. Um dispositivo de hardware usa a GPU para um desempenho mais rápido, enquanto um dispositivo de software usa a CPU. O aplicativo não cria o dispositivo. Em vez disso, o dispositivo é criado implicitamente quando o aplicativo cria o destino de renderização. Cada destino de renderização está associado a um dispositivo específico, seja hardware ou software.

Um recurso é um objeto que o programa usa para desenhar. Aqui estão alguns exemplos de recursos definidos no Direct2D:

• Pincel. Controla como as linhas e regiões são pintadas. Os tipos de pincel incluem pincéis de cor sólida e pincéis gradiente.
• Estilo de traçado. Controla a aparência de uma linha, por exemplo, tracejada ou sólida.
• Geometria. Representa uma coleção de linhas e curvas.
• Malha. Uma forma formada a partir de triângulos. Os dados de malha podem ser consumidos diretamente pela GPU, ao contrário dos dados de geometria, que devem ser convertidos antes da renderização.

Os destinos de renderização também são considerados um tipo de recurso.

Alguns recursos se beneficiam da aceleração de hardware. Um recurso deste tipo está sempre associado a um dispositivo específico, seja hardware (GPU) ou software (CPU). Esse tipo de recurso é chamado de dependente de dispositivo. Pincéis e malhas são exemplos de recursos dependentes do dispositivo. Se o dispositivo ficar indisponível, o recurso deve ser recriado para um novo dispositivo.

Outros recursos são mantidos na memória da CPU, independentemente do dispositivo usado. Esses recursos são independentes do dispositivo, porque não estão associados a um dispositivo específico. Não é necessário recriar recursos independentes do dispositivo quando o dispositivo é alterado. Estilos e geometrias de traçado são recursos independentes do dispositivo.

A documentação do Windows para cada recurso indica se o recurso é dependente do dispositivo ou independente do dispositivo. Cada tipo de recurso é representado por uma interface que deriva de ID2D1Resource. Por exemplo, os pincéis são representados pela interface ID2D1Brush.

O objeto de fábrica Direct2D

A primeira etapa ao usar o Direct2D é criar uma instância do objeto de fábrica Direct2D. Em programação de computadores, uma fábrica é um objeto que cria outros objetos. A fábrica do Direct2D cria os seguintes tipos de objetos:

• Alvos de renderização.
• Recursos independentes do dispositivo, como estilos de traçado e geometrias.

Recursos dependentes do dispositivo, como pincéis e bitmaps, são criados pelo objeto de destino de renderização.

Para criar o objeto de fábrica Direct2D, chame a função D2D1CreateFactory.

ID2D1Factory *pFactory = NULL;

HRESULT hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &pFactory);

O primeiro parâmetro é um sinalizador que especifica as opções de criação. O indicador D2D1_FACTORY_TYPE_SINGLE_THREADED significa que não vais chamar o Direct2D a partir de múltiplas threads. Para suportar chamadas de vários threads, especifique D2D1_FACTORY_TYPE_MULTI_THREADED. Se o seu programa usa um único thread para chamar o Direct2D, a opção single-threaded é mais eficiente.

O segundo parâmetro para a funçãoD2D1CreateFactory recebe um ponteiro para a interfaceID2D1Factory.

Você deve criar o objeto de fábrica Direct2D antes da primeira mensagem WM_PAINT. O manipulador de mensagens WM_CREATE é um bom lugar para criar a fábrica:

    case WM_CREATE:
        if (FAILED(D2D1CreateFactory(
                D2D1_FACTORY_TYPE_SINGLE_THREADED, &pFactory)))
        {
            return -1;  // Fail CreateWindowEx.
        }
        return 0;

Criando recursos Direct2D

O programa Circle usa os seguintes recursos dependentes do dispositivo:

• Um destino de renderização associado à janela do aplicativo.
• Um pincel de cor sólida para pintar o círculo.

Cada um desses recursos é representado por uma interface COM:

• A interface ID2D1HwndRenderTarget representa o destino de renderização.
• A interface ID2D1SolidColorBrush representa o pincel.

O programa Circle armazena ponteiros para essas interfaces como variáveis de membro da classe MainWindow:

ID2D1HwndRenderTarget   *pRenderTarget;
ID2D1SolidColorBrush    *pBrush;

O código a seguir cria esses dois recursos.

HRESULT MainWindow::CreateGraphicsResources()
{
    HRESULT hr = S_OK;
    if (pRenderTarget == NULL)
    {
        RECT rc;
        GetClientRect(m_hwnd, &rc);

        D2D1_SIZE_U size = D2D1::SizeU(rc.right, rc.bottom);

        hr = pFactory->CreateHwndRenderTarget(
            D2D1::RenderTargetProperties(),
            D2D1::HwndRenderTargetProperties(m_hwnd, size),
            &pRenderTarget);

        if (SUCCEEDED(hr))
        {
            const D2D1_COLOR_F color = D2D1::ColorF(1.0f, 1.0f, 0);
            hr = pRenderTarget->CreateSolidColorBrush(color, &pBrush);

            if (SUCCEEDED(hr))
            {
                CalculateLayout();
            }
        }
    }
    return hr;
}

Para criar um destino de renderização para uma janela, chame o método ID2D1Factory::CreateHwndRenderTarget na fábrica Direct2D.

• O primeiro parâmetro especifica opções que são comuns a qualquer tipo de destino de renderização. Aqui, passamos as opções padrão chamando a função auxiliar D2D1::RenderTargetProperties.
• O segundo parâmetro especifica o identificador da janela e o tamanho do alvo de renderização, em pixels.
• O terceiro parâmetro recebe um ponteiro ID2D1HwndRenderTarget.

Para criar o pincel de cor sólida, chame o ID2D1RenderTarget::CreateSolidColorBrush método no destino de renderização. A cor é dada como um valor D2D1_COLOR_F. Para obter mais informações sobre cores no Direct2D, consulte Usando cores no Direct2D.

Além disso, observe que, se o destino de renderização já existir, o método CreateGraphicsResources retornará S_OK sem fazer nada. A razão para este design ficará clara no próximo tópico.

Seguinte

Desenho com Direct2D