Grafiken (C++ AMP)

C++-AMP enthält einige APIs im Concurrency::graphics-Namespace, den Sie verwenden können, um auf die Beschaffenheitsunterstützung auf GPU zuzugreifen.Es folgen einige gängige Szenarien:

• Sie können die Textur-Klasse als Datencontainer für Berechnung verwenden und die räumliche Position des Beschaffenheitscachen und Layouts von GPU-Hardware ausnutzen.Räumliche Stelle ist die Eigenschaft von Datenelementen, die physisch in die Nähe miteinander kommunizieren.

• Die Laufzeit bietet effiziente Interoperabilität mit NichtCOMPUTE-Shadern.Pixel, verschiebt, tesselation und Hüllenshader häufig verarbeiten oder erzeugen Texturen, die Sie in den C++-AMPberechnungen verwenden können.

• Die Grafiken APIs in C++-AMP stellen alternative Methoden, auf SubWord gepackte Puffer zuzugreifen.Texturen, Formate haben, die Texel darstellen (Beschaffenheitselemente) die von den 8-Bit 64-Bit- oder 16-Bit-Skalaren bestehen, ermöglichen Zugriff zu solchem Speicher der gepackten Daten.

Hinweis
Das C++-AMP APIs stellen keine Beschaffenheitssampling und Filterfunktionen.Sie müssen die Interoperationsfunktionen von C++-AMP verwenden und den Code in DirectCompute und in HLSL schreiben.

Die Norm und unorm Typen

Die norm und unorm-Typen sind skalare Typen, die den Bereich von float-Werte beschränkt; dieses bekannt ist, wie festklemmend.Diese Typen können von anderen skalaren Typen explizit erstellt werden.In der Umwandlung ist der Wert die erste Umwandlung in float und am jeweiligen Bereich dann blockiert, der von Norm [1,0 - 1,0...] oder unorm zulässig ist 0,0... [1,0].Typumwandlung von +/- unendlich gibt +/--1 zurück.Typumwandlung von NaN wird nicht definiert.Eine Norm kann von einem unorm implizit erstellt und es gibt keinen Datenverlust.Der implizite Konvertierung in float wird mit diesen Typen definiert.Binäre Operatoren werden zwischen diesen Typen und anderen integrierten Skalartypen wie float und int definiert: +, -, *,/, ==! =, >, <, >=, <=.Die Verbundzuweisungsoperatoren werden ebenfalls unterstützt: +=, - =, *=,/=.Der unären Negationsoperator (-) wird für Normentypen definiert.

Kurze Vektor-Bibliothek

Die kurze Vektor-Bibliothek stellt einige der Funktionen von, Vektor-Typ das in HLSL definiert und normalerweise verwendet wird, um Texel zu definieren.Ein kurzer Vektor ist eine Datenstruktur, die eine bis vier Werte desselben Typs enthält.Die unterstützten Typen sind double, float, int, norm, uint und unorm.Die Typnamen werden in der folgenden Tabelle dargestellt.Für jeden Typ gibt es auch entsprechendes typedef, der keinen Unterstrich im Namen.Die Typen, die die Unterstriche haben, sind in Concurrency::graphics-Namespace.Die Typen, die keine Unterstriche haben, sind in Concurrency::graphics::direct3d-Namespace, damit sie deutlich von den auf ähnliche Weise-benannten grundlegenden Typen wie __int8 und __int16 getrennt werden.

Operatoren

Wenn ein Operator zwischen zwei Vektoren kurzen definiert ist, wird es auch zwischen einem kurzen Vektor und einem Skalar definiert.Außerdem einen dieser muss erfüllt sein:

• Der Typ des Skalars muss dem kurzen Elementtyp des Vektors sein.

• Der Typ des Skalars kann dem Elementtyp des Vektors implizit konvertiert werden, indem nur eine benutzerdefinierte Konvertierung verwendet.

Der Vorgang ist zwischen jeder Komponente des kurzen Vektor- und dem Skalarwert übertragen Komponente-mäßiges.Im Folgenden finden Sie die gültigen Operatoren:

Swizzeln von Ausdrücken

Die kurze Vektor-Bibliothek unterstützt das vector_type.identifier Accessorkonstrukt, um auf die Komponenten eines kurzen Vektor- zuzugreifen.identifier, der als swizzelnder Ausdruck bekannt ist, gibt die Komponenten des Vektors an.Der Ausdruck kann ein l-Wert oder ein R-Wert sein.Einzelne Zeichen im Bezeichner sind möglicherweise: x, y, z und w; oder r, g, b und. "x" und "r Durchschnitt die Nullth Komponente, "y-" und "g Durchschnitt die erste Komponente, u. a.(Beachten Sie, dass "x" und "r" nicht im gleichen Bezeichner verwendet werden können.) Daher "rgba" und "xyzw" geben den gleichen Ergebnis.Einzel-Komponente Accessoren wie "x" und "y" sind Skalarwerttypen.Mehrkomponenten- Accessoren sind kurze Vektortypen.Wenn Sie beispielsweise einen int_4 Vektor erstellen, der fourInts benannt und die Werte 2, 4, 6 und 8 enthält, gibt fourInts.y die ganze Zahl 4 und fourInts.rgint_2 gibt ein Objekt zurück, das die Werte 2 und 4. verfügt.

Beschaffenheits-Klassen

Ein Großteil GPU hat Hardware und Cache, das, um Pixel und optimiert werden Texel abzurufen und Bilder und Texturen zu rendern.Die Textur<T,N>-Klasse, die eine Containerklasse für Texelobjekte ist, macht die Beschaffenheitsfunktionalität dieses GPU verfügbar.Ein Texel kann sein:

• int, uint, float, double, norm oder unorm Skalar.

• Ein kurzer Vektor, der zwei oder vier Komponenten enthält.Die einzige Ausnahme ist double_4, die nicht zulässig ist.

Das Objekt texture kann einen Rang von 1, 2 oder 3. haben.Das texture-Objekt kann nur durch Verweis im Lambda eines Aufrufs zu parallel_for_each aufgezeichnet werden.Die Struktur wird auf dem GPU als Direct3D-Beschaffenheitsobjekte gespeichert.Weitere Informationen zu Texturen und Texel in Direct3d, finden Sie unter Einführung in den Texturen in 11 Direct3D.

Der Texeltyp, den Sie verwenden, kann eine der vielen Beschaffenheitsformate, die in der Grafikprogrammierung verwendet werden.Beispielsweise kann ein RGBA-Format 32 Bits, mit 8 Bit für das R, G ruft B auf, und a-Skalar Elemente verwenden.Die Beschaffenheitshardware einer Grafikkarte kann auf die einzelnen Elemente auf dem Format zugreifen.Wenn Sie beispielsweise das RGBA-Format verwenden, kann die Beschaffenheitshardware jedes 8-Bit-Element in ein 32-Bit-Formular extrahieren.In C++-AMP können Sie die Bits pro skalares Element des Texels festlegen, sodass Sie sich auf die einzelnen Elemente im skalaren automatisch Code zugreifen können, ohne Bitverschiebung zu verwenden.

Instanziieren von Beschaffenheits-Objekten

Sie können ein Beschaffenheitsobjekt ohne Initialisierung deklarieren.Im folgenden Codebeispiel deklariert mehrere Beschaffenheitsobjekte.

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

Sie können einen Konstruktor auch verwenden, um ein texture-Objekt zu deklarieren und zu initialisieren.Im folgenden Codebeispiel texture instanziiert ein Objekt von einem Vektor float_4 von Objekten.Die Bits pro skalares Element wird dem Standardwert festgelegt.Sie können diesen Konstruktor mit norm, unorm oder den kurzen Vektoren von norm und von unorm nicht verwenden, da sie nicht standardmäßige Bits pro skalares Element haben.

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

Sie können ein texture-Objekt auch deklarieren und initialisieren, indem Sie eine Konstruktorüberladung verwenden, die einen Zeiger auf den Quelldaten, die Größe von Quelldaten in Bytes und zu den Bits pro skalares Element akzeptiert.

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

Die Texturen in diesen Beispielen werden auf der Standardansicht der standardmäßige Zugriffstaste erstellt.Sie können andere Überladungen des Konstruktors verwenden, wenn Sie ein Objekt accelerator_view angeben möchten.Sie können ein Beschaffenheitsobjekt auf einer CPUzugriffstaste nicht erstellen.

Es gibt Grenzen hinsichtlich der Größe jeder Dimension des texture-Objekts, wie in der folgenden Tabelle dargestellt.Ein Laufzeitfehler wird generiert, wenn Sie die Grenzen überschreiten.

Lesen von Beschaffenheits-Objekten

Sie können von einem texture-Objekt lesen, indem Sie texture::operator[]-Operator, texture::operator()-Operator oder texture::get-Methode verwenden.texture::operator[]-Operator und texture::operator()-Operator geben einen Wert, keinen Verweis zurück.Daher können Sie kein Objekt schreiben texture, indem Sie texture::operator[]-Operator verwenden.

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

Im folgenden Codebeispiel wird veranschaulicht, wie Beschaffenheitschannel in einem kurzen Vektor speichert und greift dann auf die einzelnen skalaren Elemente als Eigenschaften des kurzen Vektor- zu.

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

In der folgenden Tabelle werden die gültigen Bits pro Kanal für jeden Sortierungsvektortyp auf.

Schreiben, um von Objekten zu masern

Verwenden Sie die texture::set-Methode, um Objekte zu schreiben texture.Ein Beschaffenheitsobjekt kann schreibgeschützt oder Lese-/Schreibzugriff aufweisen.Damit ein Beschaffenheitsobjekt lesbar und aufgehoben ist, müssen die folgenden Bedingungen erfüllt sein:

• T verfügt nur über eine skalare Komponente.Kurze (Vektoren werden nicht zulässig).

• T ist nicht double, norm oder unorm.

• Die texture::bits_per_scalar_element-Eigenschaft ist 32.

Wenn alle drei nicht zutrifft, dann ist das texture-Objekt schreibgeschützt.Die ersten beiden Bedingungen werden während der Kompilierung überprüft.Ein Fehler wird generiert, wenn Sie Code haben, den die Versuche, um eine Textur zu schreiben readonly-Objekts.Die Bedingung für texture::bits_per_scalar_element wird zur Laufzeit erkannt, und die Laufzeit generiert die unsupported_feature Ausnahme, wenn Sie versuchen, ein Objekt schreiben schreibgeschütztes texture.

Im folgenden Codebeispiel wird Werte zu einem Beschaffenheitsobjekt.

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

}

Verwenden eines Objekts writeonly_texture_view

Die Klasse stellt eine writeonly_texture_view writeonly Ansicht eines Beschaffenheitsobjekts.Das Objekt writeonly_texture_view muss durch Wert im Lambda-Ausdruck erfasst werden.Im folgenden Codebeispiel wird ein writeonly_texture_view-Objekt, um ein Objekt schreiben texture, das zwei Komponenten (int_2) verfügt.

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

Kopieren von Beschaffenheits-Objekten

Verwendung kann zwischen Beschaffenheitsobjekten kopieren, indem sie die Kopie-Funktion oder die copy_async-Funktion, wie im folgenden Codebeispiel veranschaulicht.

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

Sie können von einer Textur auch anderen zu kopieren, indem Sie die Methode verwenden. texture::copy_toDie beiden Texturen können auf verschiedenen accelerator_views sein.Wenn Sie zu writeonly_texture_view ein Objekt kopieren, werden die Daten in den zugrunde liegenden texture-Objekt kopiert.Die Bits pro skalares Element und der Wertebereich müssen auf den texture-Quell- und Zielobjekten gleich sein.Wenn diese Bedingungen nicht erfüllt, löst die CLR eine Ausnahme aus.

Interoperabilität

Die C++-AMPlaufzeitunterstützungsinteroperabilität zwischen texture<T,1> und ID3D11Texture1D-Schnittstelle, texture<T,2> zwischen und ID3D11Texture2D-Schnittstelle sowie zwischen texture<T,3> und ID3D11Texture3D-Schnittstelle.Die get_texture-Methode akzeptiert ein texture-Objekt und gibt eine IUnknown-Schnittstelle zurück.Die make_texture-Methode akzeptiert eine IUnknown-Schnittstelle und ein accelerator_view-Objekt und gibt ein texture-Objekt zurück.

Siehe auch

Referenz

double_2-Klasse

double_3-Klasse

double_4-Klasse

float_2-Klasse

float_3-Klasse

float_4-Klasse

int_2-Klasse

int_3-Klasse

int_4-Klasse

norm_2-Klasse

norm_3-Klasse

norm_4-Klasse

short_vector-Struktur

short_vector_traits-Struktur

uint_2-Klasse

uint_3-Klasse

uint_4-Klasse

unorm_2-Klasse

unorm_3-Klasse

unorm_4-Klasse