Grafica (C++ AMP)

C++ AMP contiene diverse API nello spazio dei Concurrency::graphics nomi che è possibile usare per accedere al supporto delle texture nelle GPU. Di seguito sono illustrati alcuni scenari:

• È possibile usare la texture classe come contenitore di dati per il calcolo e sfruttare la località spaziale della cache delle trame e i layout dell'hardware GPU. La località spaziale è la proprietà degli elementi dati fisicamente vicini gli uni agli altri.

• Il runtime consente un'efficiente interoperabilità con shader non di calcolo. Pixel shader, vertex shader, tessellation shader e hull shader spesso utilizzano o producono texture utilizzabili nei calcoli di C++ AMP.

• Le API grafiche di C++ AMP offrono modalità alternative per accedere ai buffer sub-word compressi. Le trame con formati che rappresentano texel (elementi trama) composti da scalari a 8 bit o a 16 bit consentono l'accesso a tali archivi dati compressi.

Tipi norm e unorm

I norm tipi e unorm sono tipi scalari che limitano l'intervallo di float valori, noto come bloccaggio. Questi tipi possono essere costruiti in modo esplicito da altri tipi scalari. Nel casting, il valore viene prima convertito in float e quindi limitato nell'intervallo rispettivo consentito da norm [-1.0, 1.0] o unorm [0.0, 1.0]. Il cast da +/- all'infinito restituisce +/-1. Il cast da NaN non è definito. Un norm oggetto può essere costruito in modo implicito da un unorm oggetto e non si verifica alcuna perdita di dati. L'operatore di conversione implicito a float viene definito in questi tipi. Gli operatori binari sono definiti tra questi tipi e altri tipi scalari predefiniti, ad esempio float e int, +, -, *, /, ==, !=, >, <, >=, <=. Sono supportati anche gli operatori di assegnazione composta: +=, -=, *=, /=. L'operatore di negazione unario (-) è definito per i tipi norm.

Libreria Short Vector

La libreria short vector fornisce alcune delle funzionalità del tipo di vettore definito in HLSL e viene in genere usato per definire i texel. Un vettore short è una struttura di dati che contiene da uno a quattro valori dello stesso tipo. I tipi supportati sono double, float, intnorm, , uinte unorm. I nomi dei tipi sono riportati nella tabella seguente. Per ogni tipo, esiste anche un'equivalente typedef che non ha un carattere di sottolineatura nel nome. I tipi con caratteri di sottolineatura si trovano nel namespace Concurrency::graphics. I tipi che non hanno i caratteri di sottolineatura si trovano nel Namespace Concurrency::graphics::direct3d in modo che siano chiaramente separati dai tipi fondamentali denominati in modo analogo, come __int8 e __int16.

Operatori

Se un operatore è definito tra due vettori brevi, allora è definito anche tra un vettore breve e uno scalare. Inoltre, uno di questi deve essere vero:

• Il tipo scalare deve essere uguale al tipo di elemento del vettore breve.

• Il tipo scalare può essere convertito in modo implicito nel tipo di elemento del vettore usando una sola conversione definita dall'utente.

L'operazione viene eseguita elemento per elemento tra ciascun elemento del vettore corto e lo scalare. Di seguito sono elencati gli operatori validi:

Espressioni swizzling

La Libreria dei Vettori Brevi supporta il costrutto accessorio vector_type.identifier per accedere ai componenti di un vettore breve. L'oggetto identifier, noto come espressione di "swizzling", specifica i componenti del vettore. L'espressione può essere un *l-value* o un *r-value*. I singoli caratteri nell'identificatore possono essere: x, y, z e w; o r, g, b e a. "x" e "r" indicano il componente zero-th, "y" e "g" significano il primo componente e così via. Si noti che "x" e "r" non possono essere usati nello stesso identificatore. Pertanto, "rgba" e "xyzw" restituiscono lo stesso risultato. Le funzioni di accesso con un solo componente come "x" e "y" sono tipi di valore scalari. Le funzioni di accesso con più componenti sono tipi vettoriali brevi. Se ad esempio si crea un vettore di int_4 denominato fourInts con i valori 2, 4, 6 e 8, fourInts.y restituisce il numero intero 4 e fourInts.rg restituisce un oggetto int_2 con i valori 2 e 4.

Classi Texture

Molte GPU dispongono di hardware e cache ottimizzati per recuperare pixel e texel ed eseguire il rendering di immagini e texture. La texture<T,N> classe , che è una classe contenitore per gli oggetti texel, espone la funzionalità di trama di queste GPU. Un texel può essere:

• Un int, uint, float, double, norm o unorm scalare.

• Un vettore breve a due o quattro componenti. L'unica eccezione è double_4, che non è consentito.

L'oggetto texture può avere una dimensione pari a 1, 2 o 3. L'oggetto texture può essere acquisito solo per riferimento nell'espressione lambda di una chiamata a parallel_for_each. La trama viene archiviata sulla GPU come oggetto texture Direct3D. Per altre informazioni sulle trame e i texel in Direct3D, vedere Introduzione alle trame in Direct3D 11.

Il tipo di texel utilizzato può essere uno dei molti formati di trama utilizzati nella programmazione grafica. Un formato RGBA, ad esempio, potrebbe utilizzare 32 bit, con 8 bit per ciascun elemento scalare R, G, B e A. L'hardware di texture di una scheda grafica può accedere ai singoli elementi in base al formato. Se, ad esempio, si utilizza il formato RGBA, l'hardware di texture consente di estrarre ciascun elemento a 8 bit in un formato a 32 bit. In C++ AMP è possibile impostare i bit per elemento scalare del texel per poter accedere automaticamente ai singoli elementi scalari nel codice senza scorrere i bit.

Creazione di istanze di oggetti di texture

È possibile dichiarare un oggetto texture senza inizializzazione. Nell'esempio di codice seguente vengono dichiarati diversi oggetti texture.

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

È inoltre possibile utilizzare un costruttore per dichiarare e inizializzare un oggetto texture. Nell'esempio di codice seguente viene creata un'istanza di un oggetto texture da un vettore di oggetti float_4. I bit per elemento scalare sono impostati sul valore predefinito. Non è possibile utilizzare questo costruttore con norm, unorm o gli short vector di norm e unorm, poiché non presentano bit predefiniti per elemento scalare.

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

È anche possibile dichiarare e inizializzare un oggetto texture utilizzando un overload del costruttore che accetta un puntatore ai dati di origine, le dimensioni dei dati di origine in byte e i bit per elemento scalare.

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

Le trame di questi esempi vengono create nella visualizzazione predefinita dell'acceleratore predefinito. È possibile utilizzare altri overload del costruttore se si desidera specificare un oggetto accelerator_view. Non è possibile creare un oggetto texture su un acceleratore della CPU.

Esistono limiti alla grandezza di ogni dimensione dell'oggetto texture, come illustrato nella tabella seguente. Se si superano questi limiti, viene generato un errore di runtime.

Lettura da oggetti di texture

È possibile leggere da un texture oggetto usando texture::operator[], texture::operator() Operator o texture::get Method. I due operatori restituiscono un valore, non un riferimento. Di conseguenza, non è possibile scrivere su un oggetto texture utilizzando 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();
}

Nell'esempio di codice seguente viene illustrato come archiviare i canali di trama in uno short vector e accedere ai singoli elementi scalari come proprietà dello short vector.

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

Nella tabella seguente sono elencati i bit validi per canale per ciascun tipo di sort vector.

Scrittura su oggetti di texture

Usare il metodo texture::set per scrivere negli texture oggetti. Un oggetto texture può essere di sola lettura o lettura/scrittura. Affinché sia possibile leggere e scrivere su un oggetto texture, devono essere soddisfatte le condizioni seguenti:

• T ha un solo componente scalare. Gli short vector non sono consentiti.

• T non è double, norm, o unorm.

• La proprietà texture::bits_per_scalar_element è 32.

Se non vengono soddisfatte tutte e tre le condizioni, l'oggetto texture è di sola lettura. Le prime due condizioni vengono verificate durante la compilazione. Viene generato un errore di compilazione se è presente codice che tenta di scrivere su un oggetto texture readonly. La condizione per texture::bits_per_scalar_element viene rilevata in fase di esecuzione e il runtime genera l'eccezione unsupported_feature se si tenta di scrivere in un oggetto readonly texture .

Nell'esempio di codice seguente vengono scritti valori su un oggetto texture.

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

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

Copiare oggetti texture

È possibile copiare tra oggetti trama usando la funzione di copia o la funzione copy_async , come illustrato nell'esempio di codice seguente.

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

È anche possibile copiare da una trama a un'altra usando il metodo texture::copy_to . Le due texture possono trovarsi su diversi accelerator_view. Quando si esegue una copia su un oggetto writeonly_texture_view, i dati vengono copiati sull'oggetto texture sottostante. I bit per elemento scalare e l'estensione devono essere uguali sugli oggetti texture di destinazione e su quelli di origine. Se questi requisiti non vengono soddisfatti, durante la fase di esecuzione viene generata un'eccezione.

Classi di visualizzazioni di trama

C++ AMP introduce la classe texture_view in Visual Studio 2013. Le viste texture supportano gli stessi tipi di texel e classifiche della Classe texture, ma a differenza delle texture, forniscono l'accesso a funzionalità hardware aggiuntive come il campionamento delle texture e le mipmap. Le visualizzazioni delle texture supportano l'accesso di sola scrittura, di sola lettura e di lettura e scrittura ai dati delle texture sottostanti.

• L'accesso in sola lettura viene fornito dalla specializzazione del modello texture_view<const T, N> che supporta elementi con 1, 2 o 4 componenti, il campionamento delle trame e l'accesso dinamico a un intervallo di livelli di mipmap che vengono determinati quando viene creata un'istanza della visualizzazione.

• L'accesso in sola scrittura viene fornito dalla classe template non specializzata texture_view<T, N> che supporta elementi con 2 o 4 componenti e può accedere a un livello di mipmap determinato al momento dell'istanza della vista. Non è compatibile con il campionamento

• L'accesso in lettura-scrittura viene fornito dalla classe template non specializzata texture_view<T, N>, che, analogamente alle trame, supporta elementi con un solo componente; la visualizzazione può accedere a un livello di mipmap che viene determinato all'istanziazione. Non supporta il campionamento.

Le visualizzazioni trama sono analoghe alle visualizzazioni di matrice, ma non forniscono la funzionalità di gestione e spostamento automatica dei dati fornita dalla classe array_view sulla classe di matrice. Una texture_view può essere accessibile unicamente sulla visualizzazione dell'acceleratore in cui risiedono i dati di texture sottostanti.

writeonly_texture_view deprecata

Per Visual Studio 2013, C++ AMP introduce un supporto migliore per le funzionalità delle trame hardware, ad esempio il campionamento e mipmap, che non possono essere supportate dalla classe writeonly_texture_view. La classe texture_view appena introdotta supporta un superset della funzionalità in writeonly_texture_view. Di conseguenza, writeonly_texture_view è deprecata.

È consigliabile, almeno per il nuovo codice, utilizzare texture_view per accedere alla funzionalità fornita in precedenza da writeonly_texture_view. Confrontare i due esempi di codice seguenti che prevedono la scrittura su un oggetto texture con due componenti (int_2). Si noti che, in entrambi i casi, la visualizzazione wo_tv4 deve essere acquisita come valore nell'espressione lambda. Di seguito è riportato un esempio che utilizza la nuova classe texture_view:

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

Di seguito è riportata la classe writeonly_texture_view deprecata:

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

Come si può notare, i due esempi di codice sono quasi identici quando si scrive sul livello di mipmap principale. Se nel codice esistente si è utilizzato writeonly_texture_view e non si intende migliorare tale codice, non è necessario modificarlo. Tuttavia, se stai pensando di portare avanti quel codice, ti consigliamo di riscriverlo per utilizzare texture_view perché i miglioramenti presenti sostengono nuove caratteristiche delle texture hardware. Per ulteriori informazioni sulle nuove funzionalità, continuare a leggere.

Per ulteriori informazioni sulla deprecazione di writeonly_texture_view, vedere Panoramica della progettazione della vista texture in C++ AMP nel blog programmazione parallela in Codice nativo.

Creazione di istanze di oggetti Texture View

La dichiarazione di un texture_view oggetto è simile alla dichiarazione di un array_view oggetto associato a una matrice. Nell'esempio di codice seguente vengono dichiarati molti oggetti texture e oggetti texture_view a essi associati.

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

Si noti come una vista di texture il cui tipo di elemento è non const e ha un solo componente sia di lettura/scrittura, mentre una vista di texture il cui tipo di elemento è non const ma ha più di un componente sia di sola scrittura. Le visualizzazioni di trama di tipi di elementi const sono sempre di sola lettura, ma se il tipo di elemento è non const, il numero di componenti nell'elemento determina se è di lettura e scrittura (1 componente) o di sola scrittura (più componenti).

Il tipo di elemento di un oggetto texture_view, il relativo stato const e il numero dei componenti sono fondamentali per determinare se la visualizzazione supporta il campionamento delle trame e la modalità di accesso ai livelli di mipmap:

Da questa tabella, è possibile vedere che le visualizzazioni di trama in sola lettura supportano completamente le nuove funzionalità a fronte dell'impossibilità di scrivere sulla visualizzazione. Le visualizzazioni delle texture che consentono la scrittura sono limitate in quanto possono accedere a un unico livello di mipmap. Le visualizzazioni di trama in lettura e scrittura sono ancora più specializzate di quelle scrivibili, poiché richiedono che il tipo di elemento della visualizzazione di trama abbia un solo componente. Si noti che il campionamento non è supportato per le texture view scrivibili perché è un'operazione orientata alla lettura.

Lettura da oggetti di visualizzazione texture

La lettura dei dati di texture non campionati attraverso una visualizzazione di texture è del tutto simile alla lettura direttamente dalla texture stessa, tranne per il fatto che le texture vengono acquisite per riferimento, mentre le visualizzazioni di texture sono acquisite per valore. Nei due esempi di codice seguenti viene illustrato il concetto, prima mediante texture:

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

Di seguito è riportato lo stesso esempio con la differenza che si utilizza la classe texture_view:

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

Le visualizzazioni di trama i cui elementi sono basati su tipi a virgola mobile, ad esempio float, float_2 o float_4, possono anche essere letti utilizzando il campionamento delle trame per sfruttare il supporto hardware per varie modalità di filtro e indirizzamento. C++ AMP supporta le due modalità di filtro più comuni negli scenario di calcolo, filtro punto (più simile) e filtro lineare (media ponderata) e quattro modalità di indirizzamento, ovvero wrapping, mirroring, clamping e bordo. Per altre informazioni sulle modalità di indirizzamento, vedere address_mode enumerazione.

Oltre alle modalità supportate direttamente da C++ AMP, è possibile accedere ad altre modalità di filtro e modalità di indirizzamento della piattaforma sottostante utilizzando le API di interoperabilità per utilizzare un campionatore di trame creato utilizzando direttamente le API della piattaforma. Ad esempio, Direct3D supporta altre modalità di filtro, come il filtro anisotropico, e consente l'applicazione di una modalità di indirizzamento diversa a ogni dimensione di una trama. È possibile creare un campionatore di trame sulle cui coordinate sono state eseguite operazioni di wrapping verticale, mirroring orizzontale e di campionamento con filtro anisotropico mediante le API di Direct3D e utilizzare il campionatore nel codice C++ AMP tramite l'API di interoperabilità make_sampler. Per altre informazioni, vedere Campionamento delle trame in C++ AMP sul blog "Programmazione Parallela in Codice Nativo".

Le visualizzazioni di trama supportano inoltre la lettura delle mipmap. Le visualizzazioni di texture di sola lettura, quelle che hanno un tipo di elemento const, offrono la massima flessibilità. Questo perché è possibile campionare dinamicamente un intervallo di livelli di mipmap determinato al momento dell'istanziamento e perché gli elementi con 1, 2 o 4 componenti sono supportati. Anche le visualizzazioni di texture di lettura e scrittura che contengono elementi con un solo componente supportano le mipmap, ma solo di un livello stabilito al momento della creazione. Per altre informazioni, vedere Trama con Mipmaps nel blog programmazione parallela in Codice nativo.

Scrittura su oggetti TextureView

Utilizzare il metodo texture_view::get per scrivere al sottostante texture attraverso l'oggetto texture_view. Una visualizzazione di trama può essere di sola lettura, di lettura e scrittura o di sola scrittura. Per essere scrivibile, una visualizzazione di trama deve avere un tipo di elemento non const; per essere leggibile e scrivibile, il relativo tipo di elemento deve avere un solo componente. In caso contrario, la vista texture è di sola lettura. È possibile accedere a un solo livello di mipmap di una texture alla volta tramite una vista texture, e il livello viene specificato quando la vista viene istanziata.

In questo esempio viene illustrato come scrivere sul secondo livello di mipmap più dettagliato di una trama con 4 livelli di mipmap. Il livello di mipmap più dettagliato è il livello 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);
});

Interoperabilità

Il runtime C++ AMP supporta l'interoperabilità tra texture<T,1> e l'interfaccia ID3D11Texture1D, tra texture<T,2> e l'interfaccia ID3D11Texture2D e tra texture<T,3> e l'interfaccia ID3D11Texture3D. Il metodo get_texture accetta un texture oggetto e restituisce un'interfaccia IUnknown . Il metodo make_texture accetta un'interfaccia IUnknown e un accelerator_view oggetto e restituisce un texture oggetto .

Vedi anche

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