Gráficos (C++ AMP)

C++ AMP contém várias APIs no Concurrency::graphics namespace que você pode usar para acessar o suporte de textura em GPUs. Alguns cenários comuns são:

• Você pode usar a texture classe como um contêiner de dados para computação e explorar a localidade espacial do cache de textura e layouts do hardware da GPU. Localidade espacial é a propriedade de elementos de dados estarem fisicamente próximos uns dos outros.

• O tempo de execução oferece interoperabilidade eficiente com sombreadores não computacionais. Os sombreadores de pixel, vértice, tesselação e casco frequentemente consomem ou produzem texturas que podes usar nos teus cálculos de AMP C++.

• As APIs gráficas em C++ AMP oferecem maneiras alternativas de acessar buffers empacotados com subpalavras. Texturas que possuem formatos que representam texels (elementos de textura) que são compostos por escalares de 8 bits ou 16 bits permitem o acesso a esse armazenamento de dados compactado.

Os tipos norm e unorm

Os tipos norm e unorm são tipos escalares que limitam o intervalo de valores float; isto é conhecido como limitação. Estes tipos podem ser explicitamente construídos a partir de outros tipos escalares. Na conversão, o valor é primeiro convertido para float e, em seguida, limitado à respetiva região permitida por norm [-1.0, 1.0] ou unorm [0.0, 1.0]. A conversão de +/- infinito retorna +/-1. O casting da NaN é indefinido. A norm pode ser implicitamente construído a partir de um unorm e não há perda de dados. O operador de conversão implícito para float é definido nesses tipos. Os operadores binários são definidos entre esses tipos e outros tipos escalares internos, como float, int, +, -, *, /, ==, !=, >, <, >=, <=. Os operadores de atribuição compostos também são suportados: +=, -=, *=, /=. O operador de negação unária (-) é definido para norm tipos.

Biblioteca de vetores reduzida

A Short Vetor Library fornece algumas das funcionalidades do tipo de vetor que é definido em HLSL e normalmente é usado para definir texels. Um vetor curto é uma estrutura de dados que contém de um a quatro valores do mesmo tipo. Os tipos suportados são double, float, int, norm, uint, e unorm. Os nomes dos tipos são mostrados na tabela a seguir. Para cada tipo, há também um correspondente typedef que não tem um sublinhado no nome. Os tipos que têm os sublinhados estão no Namespace Concurrency::graphics. Os tipos que não têm os sublinhados estão no Namespace Concurrency::graphics::direct3d para garantir que sejam claramente separados dos tipos fundamentais com nomes semelhantes, como __int8 e __int16.

Operadores

Se um operador é definido entre dois vetores curtos, então ele também é definido entre um vetor curto e um escalar. Além disso, uma delas deve ser verdadeira:

• O tipo do escalar deve ser o mesmo que o tipo de elemento do vetor curto.

• O tipo escalar pode ser implicitamente convertido para o tipo de elemento do vetor usando apenas uma conversão definida pelo usuário.

A operação é realizada componente por componente entre cada componente do vetor curto e o escalar. Aqui estão os operadores válidos:

Expressões Oscilantes

A Biblioteca de Vetores Curtos suporta a vector_type.identifier construção de acessador que permite acessar os componentes de um vetor curto. O identifier, que é conhecido como uma expressão de "swizzling", especifica os componentes do vetor. A expressão pode ser um valor l ou um valor r. Os caracteres individuais no identificador podem ser: x, y, z e w; ou r, g, b e a. "x" e "r" significam o zero-ésimo componente, "y" e "g" significam o primeiro componente, e assim por diante. (Observe que "x" e "r" não podem ser usados no mesmo identificador.) Portanto, "rgba" e "xyzw" retornam o mesmo resultado. Acessadores de componente único, como "x" e "y", são tipos de valores escalares. Os acessadores multicomponentes são tipos de vetores curtos. Por exemplo, se você construir um int_4 vetor nomeado fourInts e com os valores 2, 4, 6 e 8, fourInts.y retornará o inteiro 4 e fourInts.rg retornará um int_2 objeto com os valores 2 e 4.

Classes de textura

Muitas GPUs têm hardware e caches otimizados para buscar pixels e texels e renderizar imagens e texturas. A texture<T,N> classe, que é uma classe de contêiner para objetos texel, expõe a funcionalidade de textura dessas GPUs. Um texel pode ser:

• Um int, uint, float, double, norm, ou unorm escalar.

• Um vetor curto que tem dois ou quatro componentes. A única exceção é double_4, que não é permitido.

O texture objeto pode ter uma classificação de 1, 2 ou 3. O texture objeto só pode ser capturado por referência na lambda de uma chamada para parallel_for_each. A textura é armazenada na GPU como objetos de textura Direct3D. Para obter mais informações sobre texturas e texels no Direct3D, consulte Introdução às texturas no Direct3D 11.

O tipo texel que você usa pode ser um dos muitos formatos de textura que são usados na programação gráfica. Por exemplo, um formato RGBA pode usar 32 bits, com 8 bits cada para os elementos escalares R, G, B e A. O hardware de textura de uma placa gráfica pode acessar os elementos individuais com base no formato. Por exemplo, se estiver a usar o formato RGBA, o hardware gráfico pode extrair cada elemento de 8 bits numa forma de 32 bits. Em C++ AMP, você pode definir os bits por elemento escalar do seu texel para que você possa acessar automaticamente os elementos escalares individuais no código sem usar o deslocamento de bits.

Instanciando objetos de textura

Você pode declarar um objeto de textura sem inicialização. O exemplo de código a seguir declara vários objetos de textura.

#include <amp.h>
#include <amp_graphics.h>
using namespace concurrency;
using namespace concurrency::graphics;

void declareTextures() {
    // Create a 16-texel texture of int.
    texture<int, 1> intTexture1(16);
    texture<int, 1> intTexture2(extent<1>(16));

    // Create a 16 x 32 texture of float_2.
    texture<float_2, 2> floatTexture1(16, 32);
    texture<float_2, 2> floatTexture2(extent<2>(16, 32));

    // Create a 2 x 4 x 8 texture of uint_4.
    texture<uint_4, 3> uintTexture1(2, 4, 8);
    texture<uint_4, 3> uintTexture2(extent<3>(2, 4, 8));
}

Você também pode usar um construtor para declarar e inicializar um texture objeto. O exemplo de código a seguir instancia um texture objeto de um vetor de float_4 objetos. Os bits por elemento escalar são definidos como padrão. Você não pode usar esse construtor com norm, unorm, ou os vetores curtos de norm e unorm, porque eles não têm um bit padrão por elemento escalar.

#include <amp.h>
#include <amp_graphics.h>
#include <vector>
using namespace concurrency;
using namespace concurrency::graphics;

void initializeTexture() {
    std::vector<int_4> texels;
    for (int i = 0; i < 768 * 1024; i++) {
        int_4 i4(i, i, i, i);
        texels.push_back(i4);
    }

    texture<int_4, 2> aTexture(768, 1024, texels.begin(), texels.end());
}

Você também pode declarar e inicializar um texture objeto usando uma sobrecarga de construtor que leva um ponteiro para os dados de origem, o tamanho dos dados de origem em bytes e os bits por elemento escalar.

void createTextureWithBPC() { // Create the source data.
    float source[1024* 2];
    for (int i = 0; i <1024* 2; i++) {
        source[i] = (float)i;
    }
    // Initialize the texture by using the size of source in bytes // and bits per scalar element.
    texture<float_2, 1> floatTexture(1024, source, (unsigned int)sizeof(source), 32U);
}

As texturas nesses exemplos são criadas na visualização padrão do acelerador padrão. Você pode usar outras sobrecargas do construtor se quiser especificar um accelerator_view objeto. Não é possível criar um objeto de textura em um acelerador de CPU.

Há limites para o tamanho de cada dimensão do texture objeto, conforme mostrado na tabela a seguir. Um erro em tempo de execução é gerado se você exceder os limites.

Leitura de objetos de textura

Você pode ler a partir de um texture objeto usando texture::operator[], texture::operator() Operator ou texture::get Method. Os dois operadores retornam um valor, não uma referência. Portanto, você não pode gravar em um texture objeto usando texture::operator[].

void readTexture() {
    std::vector<int_2> src;
    for (int i = 0; i <16 *32; i++) {
        int_2 i2(i, i);

        src.push_back(i2);
    }

    std::vector<int_2> dst(16* 32);

    array_view<int_2, 2> arr(16, 32, dst);

    arr.discard_data();

    const texture<int_2, 2> tex9(16, 32, src.begin(), src.end());

    parallel_for_each(tex9.extent, [=, &tex9] (index<2> idx) restrict(amp) { // Use the subscript operator.
        arr[idx].x += tex9[idx].x; // Use the function () operator.
        arr[idx].x += tex9(idx).x; // Use the get method.
        arr[idx].y += tex9.get(idx).y; // Use the function () operator.
        arr[idx].y += tex9(idx[0], idx[1]).y;
    });

    arr.synchronize();
}

O exemplo de código a seguir demonstra como armazenar canais de textura em um vetor curto e, em seguida, acessar os elementos escalares individuais como propriedades do vetor curto.

void UseBitsPerScalarElement() { // Create the image data. // Each unsigned int (32-bit) represents four 8-bit scalar elements(r,g,b,a values).
    const int image_height = 16;
    const int image_width = 16;
    std::vector<unsigned int> image(image_height* image_width);

    extent<2> image_extent(image_height, image_width);

    // By using uint_4 and 8 bits per channel, each 8-bit channel in the data source is // stored in one 32-bit component of a uint_4.
    texture<uint_4, 2> image_texture(image_extent, image.data(), image_extent.size()* 4U,  8U);

    // Use can access the RGBA values of the source data by using swizzling expressions of the uint_4.
    parallel_for_each(image_extent,
        [&image_texture](index<2> idx) restrict(amp)
        { // 4 bytes are automatically extracted when reading.
            uint_4 color = image_texture[idx];
            unsigned int r = color.r;
            unsigned int g = color.g;
            unsigned int b = color.b;
            unsigned int a = color.a;
        });
}

A tabela a seguir lista os bits válidos por canal para cada tipo de vetor de classificação.

Gravando em objetos de textura

Utilize o método texture::set para escrever em objetos texture. Um objeto de textura pode ser somente leitura ou leitura/gravação. Para que um objeto de textura seja legível e gravável, as seguintes condições devem ser verdadeiras:

• T tem apenas um componente escalar. (Vetores curtos não são permitidos.)

• T não é double, norm ou unorm.

• A propriedade texture::bits_per_scalar_element é 32.

Se todos os três não forem verdadeiros, o objeto texture estará em modo de apenas leitura. As duas primeiras condições são verificadas durante a compilação. Um erro de compilação é gerado se você tiver código que tenta gravar em um readonly objeto de textura. A condição para texture::bits_per_scalar_element é detetada em tempo de execução, e o tempo de execução gera a exceção unsupported_feature se tentar gravar num objeto só de leitura texture.

O exemplo de código a seguir grava valores em um objeto texture.

void writeTexture() {
    texture<int, 1> tex1(16);

    parallel_for_each(tex1.extent, [&tex1] (index<1> idx) restrict(amp) {
        tex1.set(idx, 0);
    });
}

Copiando objetos de textura

Você pode copiar entre objetos de textura usando a função copy ou a função copy_async , conforme mostrado no exemplo de código a seguir.

void copyHostArrayToTexture() { // Copy from source array to texture object by using the copy function.
    float floatSource[1024* 2];
    for (int i = 0; i <1024* 2; i++) {
        floatSource[i] = (float)i;
    }
    texture<float_2, 1> floatTexture(1024);

    copy(floatSource, (unsigned int)sizeof(floatSource), floatTexture);

    // Copy from source array to texture object by using the copy function.
    char charSource[16* 16];
    for (int i = 0; i <16* 16; i++) {
        charSource[i] = (char)i;
    }
    texture<int, 2> charTexture(16, 16, 8U);

    copy(charSource, (unsigned int)sizeof(charSource), charTexture);
    // Copy from texture object to source array by using the copy function.
    copy(charTexture, charSource, (unsigned int)sizeof(charSource));
}

Você também pode copiar de uma textura para outra usando o método texture::copy_to . As duas texturas podem estar em accelerator_views diferentes. Quando você copia para um writeonly_texture_view objeto, os dados são copiados para o objeto subjacente texture . Os bits por elemento escalar e a extensão devem ser os mesmos nos objetos de origem e destino texture . Se esses requisitos não forem atendidos, o ambiente de execução gerará uma exceção.

Classes de visualização de textura

C++ AMP apresenta a classe texture_view no Visual Studio 2013. As visualizações de textura suportam os mesmos tipos e classificações de texel que a classe de textura, mas, ao contrário das texturas, elas fornecem acesso a recursos de hardware adicionais, como amostragem de textura e mipmaps. As visualizações de textura oferecem suporte a acesso somente leitura, somente gravação e leitura-gravação aos dados de textura subjacentes.

• O acesso de leitura é fornecido pela especialização do modelo texture_view<const T, N>, que suporta elementos com 1, 2 ou 4 componentes, amostragem de textura e acesso dinâmico a uma gama de níveis de mipmap, determinados quando a visualização é instanciada.

• O acesso de escrita é fornecido pela classe de modelo não especializada texture_view<T, N>, que suporta elementos com 2 ou 4 componentes e pode acessar um nível de mipmap que é determinado quando o modo de exibição é instanciado. Não suporta amostragem.

• O acesso de leitura e gravação é proporcionado pela classe de modelo não especializada texture_view<T, N>. Tal como as texturas, suporta elementos que têm apenas um componente. A visualização pode acessar um nível de mipmap determinado no momento em que é instanciada. Não suporta amostragem.

As visualizações de textura são análogas às exibições de matriz, mas não fornecem a funcionalidade automática de gerenciamento e movimentação de dados que a classe array_view fornece sobre a classe de matriz. Um texture_view só pode ser acedido na vista do acelerador onde os dados de textura subjacentes se encontram.

A vista de textura somente para escrita está preterida

Para o Visual Studio 2013, o C++ AMP introduz um melhor suporte para recursos de textura de hardware, como amostragem e mipmaps, que não poderiam ser suportados pela classe writeonly_texture_view. A classe recém-introduzida texture_view suporta um superconjunto da funcionalidade em writeonly_texture_view, como resultado, writeonly_texture_view é preterida.

Recomendamos — pelo menos para o novo código — que você use texture_view para acessar a funcionalidade que era fornecida anteriormente pelo writeonly_texture_view. Compare os dois exemplos de código a seguir que gravam em um objeto de textura que tem dois componentes (int_2). Observe que, em ambos os casos, a exibição, wo_tv4, deve ser capturada por valor na expressão lambda. Aqui está o exemplo que usa a nova texture_view classe:

void write2ComponentTexture() {
    texture<int_2, 1> tex4(16);

    texture_view<int_2, 1> wo_tv4(tex4);

    parallel_for_each(extent<1>(16), [=] (index<1> idx) restrict(amp) {
        wo_tv4.set(idx, int_2(1, 1));
    });
}

E aqui está a classe obsoleta writeonly_texture_view :

void write2ComponentTexture() {
    texture<int_2, 1> tex4(16);

    writeonly_texture_view<int_2, 1> wo_tv4(tex4);

    parallel_for_each(extent<1>(16), [=] (index<1> idx) restrict(amp) {
        wo_tv4.set(idx, int_2(1, 1));
    });
}

Como se pode ver, os dois exemplos de código são quase idênticos quando tudo o que se está a fazer é escrever no nível mipmap primário. Se você usou writeonly_texture_view no código existente e não está planejando aprimorar esse código, não é necessário alterá-lo. No entanto, se você está pensando em trazer esse código adiante, sugerimos que você o reescreva para usar texture_view porque os aprimoramentos nele suportam novos recursos de textura de hardware. Continue lendo para obter mais informações sobre esses novos recursos.

Para obter mais informações sobre a substituição do writeonly_texture_view, consulte Visão geral do design de exibição de textura em C++ AMP no blog Programação paralela em código nativo.

Instanciando objetos de exibição de textura

Declarar um texture_view é semelhante a declarar um array_view que está associado a um array. O exemplo de código a seguir declara vários texture objetos e texture_view objetos que estão associados a eles.

#include <amp.h>
#include <amp_graphics.h>
using namespace concurrency;
using namespace concurrency::graphics;

void declareTextureViews()
{
    // Create a 16-texel texture of int, with associated texture_views.
    texture<int, 1> intTexture(16);
    texture_view<const int, 1> intTextureViewRO(intTexture);  // read-only
    texture_view<int, 1> intTextureViewRW(intTexture);        // read-write

    // Create a 16 x 32 texture of float_2, with associated texture_views.
    texture<float_2, 2> floatTexture(16, 32);
    texture_view<const float_2, 2> floatTextureViewRO(floatTexture);  // read-only
    texture_view<float_2, 2> floatTextureViewRO(floatTexture);        // write-only

    // Create a 2 x 4 x 8 texture of uint_4, with associated texture_views.
    texture<uint_4, 3> uintTexture(2, 4, 8);
    texture_view<const uint_4, 3> uintTextureViewRO(uintTexture);  // read-only
    texture_view<uint_4, 3> uintTextureViewWO(uintTexture);        // write-only
}

Observe como uma vista de textura cujo tipo de elemento é não-const e tem um componente é de leitura e gravação, mas uma vista de textura cujo tipo de elemento é não-const e tem mais de um componente são somente de gravação. As visualizações de textura dos tipos de elemento const são sempre somente leitura, mas se o tipo de elemento for não-const, o número de componentes no elemento determinará se ele é leitura-gravação (1 componente) ou somente gravação (vários componentes).

O tipo de elemento de a texture_view— sua constabilidade e também o número de componentes que ele tem — também desempenha um papel na determinação se a exibição suporta amostragem de textura e como os níveis de mipmap podem ser acessados:

Nesta tabela, pode ver que as visualizações de textura somente leitura suportam totalmente as novas funcionalidades, embora não seja possível escrever na visualização. As visualizações de textura que podem ser gravadas são limitadas, pois só têm acesso a um único nível de mipmap. As visualizações de textura de leitura e escrita são ainda mais especializadas do que as graváveis, porque adicionam o requisito de que o tipo de elemento da visualização de textura tenha apenas um componente. Note que a amostragem não é suportada para visualizações de textura graváveis, uma vez que é uma operação voltada para leitura.

Leitura de objetos de exibição de textura

Ler dados de textura sem amostragem através de uma visualização de textura é semelhante a lê-los da própria textura, exceto que as texturas são capturadas por referência, enquanto as visualizações de textura são capturadas por valor. Os dois exemplos de código a seguir demonstram: Primeiro, utilizando texture apenas:

void write2ComponentTexture() {
    texture<int_2, 1> text_data(16);

    parallel_for_each(extent<1>(16), [&] (index<1> idx) restrict(amp) {
        tex_data.set(idx, int_2(1, 1));
    });
}

E aqui está o mesmo exemplo, exceto que agora usa a texture_view classe:

void write2ComponentTexture() {
    texture<int_2, 1> tex_data(16);

    texture_view<int_2, 1> tex_view(tex_data);

    parallel_for_each(extent<1>(16), [=] (index<1> idx) restrict(amp) {
        tex_view.set(idx, int_2(1, 1));
    });
}

As visualizações de textura cujos elementos são baseados em tipos de ponto flutuante — por exemplo, float, float_2 ou float_4 — também podem ser lidas usando amostragem de textura para aproveitar o suporte de hardware para vários modos de filtragem e modos de endereçamento. O C++ AMP suporta os dois modos de filtragem mais comuns em cenários de computação — filtragem de pontos (vizinho mais próximo) e filtragem linear (média ponderada) — e quatro modos de endereçamento — encapsulado, espelhado, fixo e borda. Para obter mais informações sobre modos de endereçamento, consulte address_mode Enumeração.

Além dos modos que o C++ AMP suporta diretamente, você pode acessar outros modos de filtragem e modos de endereçamento da plataforma subjacente usando as APIs de interoperabilidade para adotar um amostrador de textura que foi criado usando as APIs da plataforma diretamente. Por exemplo, o Direct3D suporta outros modos de filtragem, como filtragem anisotrópica, e pode aplicar um modo de endereçamento diferente a cada dimensão de uma textura. Você pode criar um amostrador de textura cujas coordenadas são encapsuladas verticalmente, espelhadas horizontalmente e amostradas com filtragem anisotrópica usando as APIs do Direct3D e, em seguida, aproveitar o amostrador em seu código AMP C++ usando a make_sampler API de interoperabilidade. Para obter mais informações, consulte Amostragem de textura em C++ AMP no blog Programação paralela em código nativo.

As visualizações de texturas também suportam a leitura de mipmaps. As visualizações de textura somente leitura (aquelas que têm um tipo de elemento constante) oferecem a maior flexibilidade, porque um intervalo de níveis de mip, determinado no momento da instanciação, pode ser amostrado de forma dinâmica, e porque há suporte para elementos com 1, 2 ou 4 componentes. As visualizações de textura de leitura e gravação que contêm elementos com um componente também suportam mipmaps, mas apenas de um nível determinado na instanciação. Para obter mais informações, consulte Textura com Mipmaps no blog Programação paralela em código nativo.

Escrevendo em objetos de visualização de textura

Use o método texture_view::get para gravar no subjacente texture através do texture_view objeto. Uma exibição de textura pode ser somente leitura, leitura-gravação ou somente gravação. Para que uma visualização de textura seja gravável, ela deve ter um tipo de elemento que não seja const; Para que uma visualização de textura seja legível e gravável, seu tipo de elemento também deve ter apenas um componente. Caso contrário, a exibição de textura será somente leitura. Você só pode acessar um nível mipmap de uma textura de cada vez através de uma visualização de textura, e o nível é especificado quando a exibição é instanciada.

Este exemplo mostra como escrever no segundo nível de detalhe mais alto de mipmap de uma textura que tem 4 níveis de mipmap. O nível mipmap mais detalhado é o nível 0.

// Create a texture that has 4 mipmap levels : 16x16, 8x8, 4x4, 2x2
texture<int, 2> tex(extent<2>(16, 16), 16U, 4);

// Create a writable texture view to the second mipmap level :4x4
texture_view<int, 2> w_view(tex, 1);

parallel_for_each(w_view.extent, [=](index<2> idx) restrict(amp)
{
    w_view.set(idx, 123);
});

Interoperabilidade

O tempo de execução do C++ AMP suporta interoperabilidade entre texture<T,1> e a interface ID3D11Texture1D, entre texture<T,2> e a interface ID3D11Texture2D e entre texture<T,3> e a interface ID3D11Texture3D. O método get_texture pega um texture objeto e retorna uma IUnknown interface. O método make_texture usa uma IUnknown interface e um accelerator_view objeto e retorna um texture objeto.

Ver também

double_2 Classe
double_3 Classe
double_4 Classe
float_2 Classe
float_3 Classe
float_4 Classe
Classe int_2
int_3 Classe
int_4 Classe
Classe norm_2
norm_3 Classe
norm_4 Classe
Estrutura de short_vetor
Estrutura de short_vector_traits
uint_2 Classe
uint_3 Classe
uint_4 Classe
unorm_2 Classe
unorm_3 Classe
unorm_4 Classe