Sdílet prostřednictvím

Grafické prvky (C++ AMP)

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 texture můžete použít jako datový kontejner pro výpočty a využít prostorovou lokalitu cache textur 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 trupové shadery č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 jakýchkoli hlaviček AMP definujte _SILENCE_AMP_DEPRECATION_WARNINGS, abyste ztlumili varování.

Typy norm a unorm

Typy norm a unorm jsou skalární typy, které omezují rozsah hodnot float; to se označuje jako omezení. Tyto typy lze explicitně vytvořit z jiných skalárních typů. Při přetypování je hodnota nejprve převedena na float a pak omezena na příslušnou oblast, kterou povoluje norm [-1.0, 1.0] nebo unorm [0.0, 1.0]. Přetypování z hodnoty +/- nekonečna vrátí hodnotu +/-1. Přetypování z NaN není definováno. Objekt norm lze implicitně vytvořit z unorm a nedojde při tom ke ztrátě dat. Implicitní operátor převodu na float je definován na těchto typech. Binární operátory jsou definovány mezi těmito typy a dalšími předdefinovanými skalárními typy, jako jsou float, int, +, -, *, /, ==, !=, >, <, >= a <=. 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 oboru názvů Concurrency::graphics::direct3d, 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
dvojitý double_2

double2		 double_3

double3		 double_4

double4
float float_2

float2		 float_3

float3		 float_4

float4
int (integer) int_2

int2		 int_3

int3		 int_4

int4
norma norm_2

norm2		 norm_3

norma3		 norma_4

norma4
uint uint_2

uint2		 uint_3

uint3		 uint_4

uint4
unorm unorm_2

unorm2		 unorm_3

unorm3		 unorm_4

unorm4

Operátoři

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ý je známý jako swizzling výraz, specifikuje 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, uint, float, 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 formátu. 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řijímá ukazatel na zdrojová data, velikost zdrojových dat v bajtech a počet bitů 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 accelerator_view, můžete použít další přetížení konstruktoru. 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 pro každou 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
norma, norma_2, norma_4

unorm, unorm_2, unorm, 4		 8, 16

Zápis do texturových objektů

Pro zápis do objektů použijte metodu texture::set. Objekt textury může být jen pro čtení nebo pro čtení a 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.

  • Vlastnost 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 akcelerátorových zobrazeních. 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 představuje třídu texture_view v aplikaci Visual Studio 2013. Zobrazení textur podporují stejné typy texelů a rozsahy jako texture Class, ale na rozdíl od textur poskytují přístup k dalším hardwarovým funkcím, jako je vzorkování textur a mipmapy. Zobrazení textur podporují přístup pouze pro čtení, pouze pro zápis a pro čtení i zápis 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á třída šablon texture_view<T, N>, která podporuje prvky s 2 nebo 4 komponentami a umožňuje přístup k jedné úrovni mipmap, která je určena při vytvoření instance zobrazení. Nepodporuje vzorkování.

  • Přístup pro čtení a zápis je poskytován nespecializovanou třídou šablon texture_view<T, N>, která, podobně jako textury, podporuje prvky s pouze jednou komponentou. Pohled může přistupovat 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í automatické funkce správy a přenosu dat, které třída array_view poskytuje u třídy pole. 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 je 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 — používat texture_view k přístupu k funkcím, které dříve zajišťoval writeonly_texture_view. 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 zápis 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_view z provozu viz Přehled návrhu texturového zobrazení v C++ AMP na blogu Paralelní programování v nativním kódu.

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 Components Čti Napiš 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 během instanciace.
<Texture_view T, N> 1

2, 4		 Ano

Ne (2)		 Ano

Ano		 Ne (1)

Ne (1)		 Ano, jedna úroveň. Úroveň je stanovena při instanciaci.

Ano, jedna úroveň. Úroveň je stanovena při instanciaci.

Z této tabulky vidíte, že zobrazení textury určená pouze ke čtení plně podporují nové možnosti výměnou za to, že do zobrazení nelze 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 texturového pohledu je podobně jako čtení ze samotné textury, s tím rozdílem, že textury jsou zachyceny jako odkaz, zatímco texturové pohledy jsou zachyceny jako hodnota. 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í desetinnou čárkou, například float, float_2 nebo float_4, lze také číst pomocí vzorkování textury, aby využívalo 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 ve výčtu address_mode.

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 najdete v tématu Vzorkování textury v C++ AMP v paralelním programování v blogu o nativním kódu.

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

Zápis do objektů pro zobrazení textury

Použijte metodu texture_view::get k zápisu do podkladového texture prostřednictvím objektu texture_view. Zobrazení textury může být pouze pro čtení, pro čtení i zápis, nebo pouze 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);
});

Interoperability

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

Viz také

třída 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
norm_3 Třída
Třída norm_4
short_vector – struktura
short_vector_traits – struktura
Třída uint_2
Třída uint_3
uint_4 třída
unorm_2 třída
Třída unorm_3
Třída unorm_4

  • Last updated on