Grafické prvky (C++ AMP)

Článek
10/12/2023

C++ AMP obsahuje několik rozhraní API v Concurrency::graphics oboru názvů, které můžete použít pro přístup k podpoře textury v GPU. Mezi běžné scénáře patří:

Třídu můžete použít texture jako datový kontejner pro výpočty a využít prostorovou lokalitu mezipaměti textury a rozložení hardwaru GPU. Prostorová lokalita je vlastnost datových prvků, které jsou fyzicky blízko sebe.
Modul runtime poskytuje efektivní interoperabilitu s nepočítanými shadery. Pixely, vrcholy, tessellace a shadery trupu často spotřebovávají nebo vytvářejí textury, které můžete použít ve výpočtech C++ AMP.
Grafická rozhraní API v C++ AMP poskytují alternativní způsoby přístupu k dílčím slovům zabaleným vyrovnávacím pamětím. Textury s formáty, které představují texely (prvky textury ), které se skládají z 8bitových nebo 16bitových skalárů, umožňují přístup k takovým zabaleným datovým úložišti.

Poznámka:

Hlavičky C++ AMP jsou zastaralé od sady Visual Studio 2022 verze 17.0. Zahrnutím všech hlaviček AMP se vygenerují chyby sestavení. Před zahrnutím záhlaví AMP definujte _SILENCE_AMP_DEPRECATION_WARNINGS upozornění.

Typy norm a unorm

unorm Typy norm jsou skalární typy, které omezují rozsah float hodnot. To se označuje jako upnutí. Tyto typy lze explicitně vytvořit z jiných skalárních typů. Při přetypování je hodnota nejprve přetypována float a pak uchycena na příslušnou oblast, která je povolena norm [-1.0, 1.0] nebo unorm [0.0, 1.0]. Přetypování z +/- nekonečna vrátí +/-1. Přetypování z NaN není definováno. Z objektu unorm A norm lze implicitně vytvořit a nedojde ke ztrátě dat. Implicitní operátor převodu, který má float být definován v těchto typech. Binární operátory jsou definovány mezi těmito typy a dalšími předdefinovými skalárními typy, jako float jsou : +int, , -*, /, , !===>, <, , . <=>= Operátory složeného přiřazení jsou také podporovány: +=, -=, *=, /=. Unární negační operátor (-) je definován pro norm typy.

Krátká vektorová knihovna

Knihovna krátkých vektorů poskytuje některé funkce vektorového typu definovaného v HLSL a obvykle se používá k definování texelů. Krátký vektor je datová struktura, která obsahuje jednu až čtyři hodnoty stejného typu. Podporované typy jsou double, , floatint, norm, uint, a unorm. Názvy typů jsou uvedeny v následující tabulce. Pro každý typ existuje také odpovídající, typedef který v názvu nemá podtržítko. Typy s podtržítky jsou v oboru názvů Concurrency::graphics. Typy, které nemají podtržítka, jsou v Concurrency::graphics::d irect3d Obor názvů , aby byly jasně odděleny od podobně pojmenovaných základních typů jako __int8 a __int16.

Typ	Délka 2	Délka 3	Délka 4
double	double_2 double2	double_3 double3	double_4 double4
float (číslo s plovoucí řádovou čárkou)	float_2 float2	float_3 float3	float_4 float4
int	int_2 int2	int_3 int3	int_4 int4
norm	norm_2 norm2	norm_3 norm3	norm_4 norm4
uint	uint_2 uint2	uint_3 uint3	uint_4 uint4
unorm	unorm_2 unorm2	unorm_3 unorm3	unorm_4 unorm4

Operátory

Pokud je operátor definován mezi dvěma krátkými vektory, je také definován mezi krátkým vektorem a skalárem. Jedna z těchto hodnot musí být také pravdivá:

Skalární typ musí být stejný jako typ elementu krátkého vektoru.
Skalární typ lze implicitně převést na typ elementu vektoru pomocí pouze jednoho uživatelem definovaného převodu.

Operace se přenáší mezi každou komponentou krátkého vektoru a skaláru. Tady jsou platné operátory:

Typ operátora	Platné typy
Binární operátory	Platné pro všechny typy: `+`, `-*`, , `/`, Platné pro celočíselné typy: `%`, `\|^`, `&`, , `<<>>` Dva vektory musí mít stejnou velikost a výsledkem je vektor stejné velikosti.
Relační operátory	Platné pro všechny typy: `==` a `!=`
Operátor složeného přiřazení	Platné pro všechny typy: `+=`, `-=`, `*=`, `/=` Platné pro celočíselné typy: `%=`, `\|=^=`, `&=`, , `<<=>>=`
Operátory inkrementace a dekrementace	Platné pro všechny typy: `++`, `--` Předpona i přípona jsou platné.
Bitový operátor NOT (`~`)	Platné pro celočíselné typy.
Unární `-` operátor	Platné pro všechny typy s výjimkou `unorm` a `uint`.

Swizzling Expressions

Knihovna krátkých vektorů podporuje vector_type.identifier konstruktor příslušenství pro přístup k komponentám krátkého vektoru. Výraz identifier, který se označuje jako swizzling výraz, určuje komponenty vektoru. Výrazem může být l-hodnota nebo r-hodnota. Jednotlivé znaky v identifikátoru mohou být: x, y, z a w; nebo r, g, b a. "x" a "r" znamenají nulovou komponentu, "y" a "g" první komponentu atd. (Všimněte si, že "x" a "r" nelze použít ve stejném identifikátoru.) Proto výraz "rgba" a "xyzw" vrátí stejný výsledek. Přístupové objekty s jednou komponentou, například "x" a "y", jsou skalární typy hodnot. Přístupové objekty s více komponentami jsou krátké typy vektorů. Pokud například vytvoříte int_4 vektor s názvem fourInts a má hodnoty 2, 4, 6 a 8, fourInts.y vrátí celé číslo 4 a fourInts.rg vrátí int_2 objekt s hodnotami 2 a 4.

Třídy textury

Mnoho grafických procesorů má hardware a mezipaměti optimalizované pro načítání pixelů a texelů a vykreslování obrázků a textur. Třída texture<T,N> , která je třída kontejneru pro objekty texel, zveřejňuje texturové funkce těchto GPU. texel může být:

An int, , floatuint, double, norm, nebo unorm skalární.
Krátký vektor, který má dvě nebo čtyři komponenty. Jedinou výjimkou je double_4, která není povolena.

Objekt texture může mít pořadí 1, 2 nebo 3. Objekt texture lze zachytit pouze pomocí odkazu v lambda volání parallel_for_each. Textura je uložena na GPU jako objekty textury Direct3D. Další informace o texturách a texelech v Direct3D naleznete v tématu Úvod k texturám v Direct3D 11.

Typ texelu, který používáte, může být jedním z mnoha formátů textur, které se používají při programování grafiky. Například formát RGBA může používat 32 bitů s 8 bity pro skalární prvky R, G, B a A. Texturový hardware grafické karty má přístup k jednotlivým prvkům na základě formátu. Pokud například používáte formát RGBA, může texturový hardware extrahovat každý 8bitový prvek do 32bitového formuláře. V jazyce C++ AMP můžete nastavit bity na skalární prvek vašeho texelu, abyste mohli automaticky přistupovat k jednotlivým skalárním prvkům v kódu bez použití bitového posunu.

Vytváření instancí objektů textury

Objekt textury můžete deklarovat bez inicializace. Následující příklad kódu deklaruje několik objektů textury.

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

K deklaraci a inicializaci objektu texture můžete použít také konstruktor. Následující příklad kódu vytvoří instanci objektu texture z vektoru float_4 objektů. Bity na skalární prvek jsou nastaveny na výchozí. Tento konstruktor nelze použít s norm, unormnebo krátkými vektory norm a unorm, protože nemají výchozí bity na skalární prvek.

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

Objekt můžete také deklarovat a inicializovat texture pomocí přetížení konstruktoru, který přebírá ukazatel na zdrojová data, velikost zdrojových dat v bajtech a bity na skalární prvek.

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

Textury v těchto příkladech se vytvoří ve výchozím zobrazení výchozího akcelerátoru. Pokud chcete zadat objekt, můžete použít další přetížení konstruktoru accelerator_view . Objekt textury nelze vytvořit na akcelerátoru procesoru.

Existují omezení velikosti jednotlivých dimenzí objektu texture , jak je znázorněno v následující tabulce. Pokud překročíte limity, vygeneruje se chyba za běhu.

Textura	Omezení velikosti na dimenzi
textura<T,1>	16384
textura<T,2>	16384
textura<T,3>	2048

Čtení z objektů textury

Z objektu texture můžete číst pomocí texture::operator[], texture::operator() – operátor nebo texture::get – metoda. Dva operátory vrátí hodnotu, nikoli odkaz. Proto nelze zapisovat do objektu texture pomocí 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();
}

Následující příklad kódu ukazuje, jak ukládat texturové kanály v krátkém vektoru a pak přistupovat k jednotlivým skalárním prvkům jako vlastnosti krátkého vektoru.

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

Následující tabulka uvádí platné bity na kanál pro každý typ vektoru řazení.

Datový typ Textura	Platné bity na skalární prvek
int, int_2, int_4 uint, uint_2, uint_4	8, 16, 32
int_3, uint_3	32
float, float_2, float_4	16, 32
float_3	32
double, double_2	64
norm, norm_2, norm_4 unorm, unorm_2, unorm, 4	8, 16

Zápis do objektů textury

K zápisu do texture objektů použijte metodu texture::set. Objekt textury může být jen pro čtení nebo zápis. Aby objekt textury byl čitelný a zapisovatelný, musí být splněny následující podmínky:

T má pouze jednu skalární komponentu. (Krátké vektory nejsou povoleny.)
T není double, normnebo unorm.
Nemovitost texture::bits_per_scalar_element je 32.

Pokud všechny tři nejsou pravdivé, texture je objekt jen pro čtení. Během kompilace se kontrolují první dvě podmínky. Pokud máte kód, který se pokusí zapsat do objektu readonly textury, vygeneruje se chyba kompilace. Podmínka texture::bits_per_scalar_element je zjištěna za běhu a modul runtime vygeneruje výjimku unsupported_feature , pokud se pokusíte zapisovat do objektu jen pro čtení texture .

Následující příklad kódu zapíše hodnoty do objektu textury.

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

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

Kopírování objektů textury

Mezi objekty textury můžete kopírovat pomocí funkce kopírování nebo funkce copy_async , jak je znázorněno v následujícím příkladu kódu.

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

Můžete také kopírovat z jedné textury do druhé pomocí textury::copy_to metoda. Dvě textury mohou být na různých accelerator_views. Při kopírování do objektu writeonly_texture_view se data zkopírují do podkladového texture objektu. Bity na skalární prvek a rozsah musí být stejné u zdrojových a cílových texture objektů. Pokud tyto požadavky nejsou splněny, modul runtime vyvolá výjimku.

Třídy zobrazení textury

C++ AMP zavádí třídu texture_view v sadě Visual Studio 2013. Zobrazení textur podporují stejné typy texelů a řadí se jako třída textury, ale na rozdíl od textur poskytují přístup k dalším hardwarovým funkcím, jako je vzorkování textury a mipmapy. Zobrazení textur podporují přístup jen pro čtení, jen pro zápis a pro čtení k podkladovým datům textury.

Přístup jen pro čtení poskytuje texture_view<const T, N> specializace šablony, která podporuje prvky, které mají 1, 2 nebo 4 komponenty, vzorkování textury a dynamický přístup k rozsahu úrovní mipmap, které jsou určeny při vytvoření instance zobrazení.
Přístup jen pro zápis poskytuje nespecializovaných tříd texture_view<T, N>šablon , která podporuje prvky, které mají buď 2 nebo 4 komponenty, a mají přístup k jedné úrovni mipmap, která je určena při vytváření instance zobrazení. Nepodporuje vzorkování.
Přístup pro čtení i zápis je poskytován třídou nespecializovaných šablon texture_view<T, N>, která podobně jako textury podporuje prvky, které mají pouze jednu komponentu. Zobrazení má přístup k jedné úrovni mipmap, která je určena při vytvoření instance. Nepodporuje vzorkování.

Texturová zobrazení jsou podobná zobrazením polí, ale neposkytují funkce automatické správy a pohybu dat, které třída array_view poskytuje v maticové třídě. K objektu A texture_view lze získat přístup pouze v zobrazení akcelerátoru, kde se nacházejí podkladová data textury.

writeonly_texture_view zastaralé

V sadě Visual Studio 2013 zavádí C++ AMP lepší podporu funkcí textur hardwaru, jako jsou vzorkování a mipmapy, které writeonly_texture_view třída nepodporuje. Nově zavedená texture_view třída podporuje nadmnožinu funkcí v writeonly_texture_view; v důsledku toho writeonly_texture_view je zastaralá.

Doporučujeme ( alespoň pro nový kód), který používáte texture_view pro přístup k funkcím writeonly_texture_view, které dříve poskytl . Porovnejte následující dva příklady kódu, které zapisuje do objektu textury se dvěma komponentami (int_2). Všimněte si, že v obou případech musí být zobrazení wo_tv4zachyceno hodnotou ve výrazu lambda. Tady je příklad, který používá novou texture_view třídu:

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

A tady je zastaralá writeonly_texture_view třída:

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

Jak vidíte, dva příklady kódu jsou téměř stejné, když všechno, co děláte, je psaní na primární úroveň mipmap. Pokud jste použili writeonly_texture_view existující kód a neplánujete tento kód vylepšit, nemusíte ho měnit. Pokud ale uvažujete o přeposlání kódu, doporučujeme, abyste ho přepsali, aby se používal texture_view , protože jeho vylepšení podporují nové hardwarové texturové funkce. Přečtěte si další informace o těchto nových funkcích.

Další informace o vyřazení writeonly_texture_viewz provozu naleznete v tématu Přehled návrhu texturového zobrazení v C++ AMP v paralelním programování v nativním kódu blog.

Vytvoření instance objektů zobrazení textury

Deklarování texture_view je podobné deklarování array_view , které je přidružené k poli. Následující příklad kódu deklaruje několik texture objektů a texture_view objektů, které jsou k nim přidruženy.

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

Všimněte si, že zobrazení textury, jehož typ prvku není const a má jednu komponentu, je jen pro čtení a zápis, ale zobrazení textury, jehož typ prvku není const, ale má více než jeden komponenent jsou jen pro zápis. Zobrazení textury typů prvků const jsou vždy jen pro čtení, ale pokud typ prvku není const, pak počet komponent v prvku určuje, zda je to jen pro čtení (1 komponenta) nebo jen pro zápis (více komponent).

Typ prvku texture_view– jeho const-ness a také počet komponent, které má – hraje také roli při určování, zda zobrazení podporuje vzorkování textury a jak lze získat přístup k úrovním mapy mipmap:

Typ	Komponenty	Čtení	Zápis	Vzorkování	Přístup k mapě Mipmap
<texture_view const T, N>	1, 2, 4	Ano	Ne (1)	Ano	Ano, indexovatelné. Rozsah se určuje při vytváření instancí.
<Texture_view T, N>	0 2, 4	Ano Ne (2)	Ano Yes	Ne (1) Ne (1)	Ano, jedna úroveň. Úroveň je určena při vytváření instancí. Ano, jedna úroveň. Úroveň je určena při vytváření instancí.

Z této tabulky vidíte, že zobrazení textury jen pro čtení plně podporují nové možnosti výměny za to, že do zobrazení nepůjdou zapisovat. Zapisovatelná zobrazení textury jsou omezená v tom, že mají přístup pouze k jedné úrovni mapy mipmap. Zobrazení textur pro čtení i zápis jsou ještě specializovanější než zapisovatelné, protože přidávají požadavek, aby typ prvku zobrazení textury má pouze jednu komponentu. Všimněte si, že vzorkování není podporováno pro zapisovatelná zobrazení textury, protože se jedná o operaci zaměřenou na čtení.

Čtení z objektů zobrazení textury

Čtení nesamplovaných dat textury prostřednictvím zobrazení textury je stejně jako čtení ze samotné textury, s tím rozdílem, že textury jsou zachyceny odkazem, zatímco zobrazení textury jsou zachycena podle hodnoty. Následující dva příklady kódu ukazují; nejprve pouze pomocí 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));
    });
}

A tady je stejný příklad, s výjimkou toho, že teď používá texture_view třídu:

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

Zobrazení textury, jejichž prvky jsou založené na typech s plovoucí desetinou čárkou , například plovoucí desetině, float_2 nebo float_4, lze také číst pomocí vzorkování textury, aby bylo možné využít podporu hardwaru pro různé režimy filtrování a režimy adresování. C++ AMP podporuje dva režimy filtrování, které jsou nejběžnější ve výpočetních scénářích – filtrování bodů (nejbližší soused) a lineární filtrování (vážený průměr) a čtyři režimy adres – zabalené, zrcadlené, upínací a ohraničení. Další informace o režimech adresování najdete v tématu address_mode Výčtu.

Kromě režimů, které C++ AMP podporuje přímo, můžete přistupovat k jiným režimům filtrování a adresování režimů základní platformy pomocí rozhraní API pro interoperabilitu k přijetí vzorkovníku textury vytvořeného přímo pomocí rozhraní API platformy. Například Direct3D podporuje jiné režimy filtrování, jako je anisotropní filtrování, a může použít jiný režim adresování pro každou dimenzi textury. Můžete vytvořit vzorkovník textury, jehož souřadnice jsou zabaleny svisle, zrcadlené vodorovně a vzorkovány pomocí anisotropního filtrování pomocí rozhraní API Direct3D a pak pomocí rozhraní API pro spolupráci využít make_sampler vzorkovník ve vašem kódu C++ AMP. Další informace naleznete v tématu Vzorkování textury v C++ AMP v paralelním programování v blogu nativního kódu.

Zobrazení textury také podporují čtení mipmap. Zobrazení textury jen pro čtení (zobrazení s typem prvku const) nabízejí největší flexibilitu, protože se podporuje rozsah úrovní mip určených při vytváření instancí, a protože prvky, které mají 1, 2 nebo 4 komponenty, jsou podporovány. Zobrazení textury pro čtení i zápis, která mají prvky, které mají jednu komponentu, podporují také mipmapy, ale pouze úroveň určenou při vytváření instancí. Další informace naleznete v tématu Textura s Mipmaps na paralelní programování v blogu nativního kódu.

Zápis do objektů zobrazení textury

Použijte texture_view::get Metoda k zápisu do podkladového texture objektutexture_view. Zobrazení textury může být jen pro čtení, čtení i zápis nebo jen pro zápis. Aby bylo zobrazení textury zapisovatelné, musí mít typ prvku, který není const; aby bylo zobrazení textury čitelné a zapisovatelné, musí mít jeho typ prvku také pouze jednu komponentu. V opačném případě je zobrazení textury jen pro čtení. Prostřednictvím zobrazení textury můžete přistupovat pouze k jedné úrovni mapy mipmap najednou a úroveň se zadává při vytváření instance zobrazení.

Tento příklad ukazuje, jak napsat na druhou nejpodrobnější úroveň mipmap textury, která má 4 mipmap úrovně. Nejpodrobnější úroveň mapy mipmap je úroveň 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);
});

Vzájemná funkční spolupráce

Modul runtime C++ AMP podporuje interoperabilitu mezi texture<T,1> rozhraním ID3D11Texture1D, mezi texture<T,2> rozhraním ID3D11Texture2D a mezi texture<T,3> rozhraním ID3D11Texture3D. Metoda get_texture přebírá texture objekt a vrací IUnknown rozhraní. Make_texture metoda přebírá IUnknown rozhraní a accelerator_view objekt a vrací texture objekt.

Viz také

double_2 – třída
double_3 – třída
double_4 – třída
float_2 – třída
float_3 – třída
float_4 – třída
int_2 – třída
int_3 – třída
int_4 – třída
norm_2 – třída
norm_3 – třída
norm_4 – třída
short_vector – struktura
short_vector_traits – struktura
uint_2 – třída
uint_3 – třída
uint_4 – třída
unorm_2 – třída
unorm_3 – třída
unorm_4 – třída

Sdílet prostřednictvím