Grafika (C++ AMP)

A C++ AMP több API-t tartalmaz a Concurrency::graphics névtérben, amelyekkel hozzáférhet a GPU-k textúrájának támogatásához. Néhány gyakori forgatókönyv a következő:

• Az texture osztályt adattárolóként használhatja a számításokhoz, és kihasználhatja a textúragyorsítótár és a GPU-hardver elrendezéseinek térbeli területi beállításait . A térbeli helység azon adatelemek tulajdonsága, amelyek fizikailag közel állnak egymáshoz.

• A futtatókörnyezet hatékony együttműködést biztosít a nem számítási árnyékolókkal. A képpontok, csúcspontok, tessellációk és a burkolatárnyékolók gyakran használnak vagy állítanak elő olyan textúrákat, amelyeket a C++ AMP-számításokban használhat.

• A C++ AMP grafikus API-jai alternatív módszereket kínálnak az alszavas pufferek elérésére. A 8 bites vagy 16 bites skalárokból álló texeleket (textúraelemeket) ábrázoló formátumokkal rendelkező textúrák lehetővé teszik az ilyen csomagolt adattárolás elérését.

Megjegyzés:

A C++ AMP fejlécek elavultak a Visual Studio 2022 17.0-s verziójától kezdve. Az AMP-fejlécek beépítése építési hibákat fog okozni. A figyelmeztetések elnémításához a _SILENCE_AMP_DEPRECATION_WARNINGS definiálása előtt az AMP-fejléceket be kell vonni.

A norma- és unormtípusok

A norm és unorm típusok skaláris típusok, amelyek korlátozzák a float értékek tartományát; ezt korlátozásnak nevezzük. Ezek a típusok explicit módon más skaláris típusokból is felépíthetők. Az öntés során az értéket először float típusra alakítják át, majd norm [-1.0, 1.0] vagy unorm [0.0, 1.0] által engedélyezett megfelelő tartományba szorítják be. A +/- végtelenből való öntés +/-1 értéket ad vissza. A NaN-ből történő öntés nincs meghatározva. Az A norm implicit módon létrehozható egy unorm-ből, és nincs adatvesztés. Az implicit konverziós operátor float az ilyen típusokon van definiálva. A bináris operátorok ezen típusok és más beépített skaláris típusok között vannak definiálva, például float, int: +, -, *, /, ==, !=, >, <, >=, <=. Az összetett hozzárendelési operátorok is támogatottak: +=, -=, *=, /=. A - unáris negációs operátor a norm típusokhoz van definiálva.

Kis vektorkódtár

A Rövid vektortár a HLSL-ben definiált vektortípus néhány funkcióját biztosítja, és általában a texelek definiálására szolgál. A rövid vektor olyan adatszerkezet, amely egy-négy azonos típusú értéket tartalmaz. A támogatott típusok a következőkdouble: , float, int, normuintés unorm. A típusnevek az alábbi táblázatban láthatók. Minden típushoz tartozik egy megfelelő typedef is, amely nem rendelkezik aláhúzásjelekkel a névben. Az aláhúzásjelekkel rendelkező típusok az Egyidejűség::grafikus névtérben találhatók. Azok a típusok, amelyek nem rendelkeznek aláhúzásjelekkel , a Concurrency::graphics::d irect3d névtérben találhatók, hogy egyértelműen elkülönülhessenek a hasonló nevű alapvető típusoktól, például __int8 és __int16.

Típus	Hossz 2	Hossz 3	Hossz 4
dupla	double_2 dupla2	double_3 dupla3	double_4 dupla4
float	float_2 float2	float_3 float3	float_4 float4
Int	int_2 int2	int_3 int3	int_4 int4
norma	norm_2 norm2	norm_3 norma3	norm_4 norm4
uint (előjel nélküli egész szám)	uint_2 uint2	uint_3 uint3	uint_4 uint4
unormális	unorm_2 unorm2	unorm_3 unorm3	unorm_4 unorm4

Működtetők

Ha egy operátor két rövid vektor között van definiálva, akkor egy rövid vektor és egy skalár között is definiálva van. Emellett az egyiknek igaznak kell lennie:

• A skalár típusának meg kell egyeznie a rövid vektor elemtípusával.

• A skalár típusa implicit módon konvertálható a vektor elemtípusává csak egy felhasználó által meghatározott átalakítással.

A művelet komponensenként történik a rövid vektor és a skaláris minden egyes összetevője között. Az érvényes operátorok a következők:

Operátor típusa	Érvényes típusok
Bináris operátorok	Minden típusra érvényes: +, -, *, , / Egész számtípusokra érvényes: %, ^, |, &, <<>> A két vektornak azonos méretűnek kell lennie, és az eredmény egy azonos méretű vektor.
Relációs operátorok	Minden típusra érvényes: == és !=
Összetett hozzárendelés operátora	Minden típusra érvényes: +=, -=, , *=/= Egész számtípusokra érvényes: %=, ^=, |=, &=, <<=>>=
Növekmény- és csökkentés operátorok	Minden típusra érvényes: ++, -- Az előtag és a postfix is érvényes.
Bitenkénti NOT operátor (~)	Egész számtípusokra érvényes.
Unary - operátor	Érvényes az összes típusra, kivéve unorm és uint.

Örvénylő kifejezések

A rövid vektortár támogatja a vector_type.identifier kiegészítő szerkezetet egy rövid vektor összetevőinek eléréséhez. Az identifierúgynevezett örvénylő kifejezés a vektor összetevőit határozza meg. A kifejezés lehet l-érték vagy r-érték. Az azonosító egyes karakterei lehetnek: x, y, z és w; vagy r, g, b és a. Az "x" és az "r" a nulladik összetevőt jelenti, az "y" és a "g" az első összetevőt jelenti, és így tovább. (Figyelje meg, hogy az "x" és az "r" nem használható ugyanabban az azonosítóban.) Ezért az "rgba" és a "xyzw" ugyanazt az eredményt adja vissza. Az egykomponensű tartozékok, például az "x" és az "y" skaláris értéktípusok. A többkomponensű hozzáférők rövid vektortípusok. Ha például egy int_4 elnevezett fourInts és 2, 4, 6 és 8 értéket tartalmazó vektort hoz létre, akkor fourInts.y a 4 egész számot adja vissza, és fourInts.rg egy int_2 2 és 4 értéket tartalmazó objektumot ad vissza.

Textúraosztályok

Sok GPU rendelkezik olyan hardverekkel és gyorsítótárral, amelyek képpontok és texelek lekérésére, valamint képek és textúrák renderelésére vannak optimalizálva. Az texture<T,N> osztály, amely a texel objektumok tárolóosztálya, elérhetővé teszi ezeknek a GPU-knak a textúráját. A texel lehet:

• Egy int, uint, float, double, normvagy unorm skaláris.

• Egy rövid vektor, amely két vagy négy összetevőből áll. Az egyetlen kivétel a double_4, amely nem engedélyezett.

Az texture objektum rangja 1, 2 vagy 3 lehet. Az texture objektum csak a meghívás parallel_for_eachlambdájában található hivatkozással rögzíthető. A textúra a GPU-n Direct3D textúraobjektumként van tárolva. A Direct3D textúráiról és texeljeiről további információt a Direct3D 11 textúráinak bemutatása című témakörben talál.

A használt texel típus egyike lehet a grafikus programozásban használt számos textúraformátumnak. Az RGBA-formátumok például 32 bitet használhatnak, amelyek mindegyike 8 bittel rendelkezik az R, G, B és A skaláris elemekhez. A grafikus kártya textúra hardvere a formátum alapján elérheti az egyes elemeket. Ha például az RGBA formátumot használja, a textúrahardver minden 8 bites elemet 32 bites formában képes kinyerni. A C++ AMP-ben beállíthatja a texel skaláris elemenkénti bitjeinek számát, hogy biteltolás nélkül automatikusan hozzáférhessen a kód egyes skaláris elemeihez.

Textúraobjektumok példányosítása

A textúraobjektum inicializálás nélkül deklarálható. Az alábbi példakód több textúraobjektumot deklarál.

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

Konstruktorokkal is deklarálhat és inicializálhat objektumokat texture . Az alábbi példakód egy texture objektumot példányosít az objektumok vektorából float_4 . A skaláris elemenkénti bitek az alapértelmezett értékre lesznek beállítva. Ezt a konstruktort nem használhatja norm, unorm, vagy a norm és unorm rövid vektoraival, mert nem rendelkeznek alapértelmezett bitekkel skaláris elemenként.

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

Az objektumokat deklarálhatja és inicializálhatja texture egy konstruktor túlterhelésével is, amely a forrásadatokra mutató mutatót, a forrásadatok bájtban megadott méretét és a skaláris elemenkénti biteket mutatja.

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

Az ezekben a példákban szereplő textúrák az alapértelmezett gyorsító alapértelmezett nézetében jönnek létre. A konstruktor egyéb túlterheléseit is használhatja, ha objektumot accelerator_view szeretne megadni. Nem hozhat létre textúraobjektumot processzorgyorsítón.

Az objektum egyes dimenzióinak méretére texture az alábbi táblázatban látható korlátozások vonatkoznak. Futásidejű hiba lép fel, ha túlléped a határokat.

Textúra	Méretkorlátozás dimenziónként
textúra<T,1>	16384
textúra<T,2>	16384
textúra<T,3>	2048

Olvasás textúraobjektumokból

Egy objektumból texture a textúra::operátor[], textúra::operátor(), vagy a textúra::get metódus használatával olvashat. A két operátor egy értéket ad vissza, nem egy hivatkozást. Ezért nem írhat a texture objektumba a texture::operator[] használatával.

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

Az alábbi példakód bemutatja, hogyan tárolhat textúracsatornákat egy rövid vektorban, majd hogyan érheti el az egyes skaláris elemeket a rövid vektor tulajdonságaiként.

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

Az alábbi táblázat az érvényes biteket sorolja fel csatornánként az egyes rendezési vektortípusokhoz.

Textúra adattípusa	Érvényes bitek skaláris elemenként
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
dupla, double_2	64
norma, norm_2, norm_4 unorm, unorm_2, unorm, 4	8, 16

Textúra objektumokra írás

Használja a textúra::set metódust az texture objektumokba való írásra. A textúraobjektum lehet csak olvasható vagy olvasható/írható. Ahhoz, hogy egy textúraobjektum olvasható és írható legyen, a következő feltételeknek kell teljesülniük:

• T csak egy skaláris összetevőt tartalmaz. (A rövid vektorok nem engedélyezettek.)

• T nem double, normvagy unorm.

• A texture::bits_per_scalar_element tulajdonság értéke 32.

Ha egyik sem igaz a háromból, akkor az texture objektum csak olvasható. Az első két feltételt a fordítás során ellenőrzi a rendszer. A fordítási hiba akkor keletkezik, ha olyan kóddal rendelkezik, ami megpróbál írni egy textúraobjektumba readonly. A rendszer futásidőben észleli a feltételt texture::bits_per_scalar_element , és a futtatókörnyezet létrehozza a unsupported_feature kivételt, ha írásvédett texture objektumba próbál írni.

Az alábbi példakód értékeket ír egy textúraobjektumba.

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

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

Textúraobjektumok másolása

A textúraobjektumok közötti másoláshoz használja a másolási függvényt vagy a copy_async függvényt, ahogyan az az alábbi kód példában látható.

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

A textúra::copy_to metódussal egyik textúrából a másikba is másolhat. A két textúra különböző accelerator_view-ken lehetnek. Amikor egy writeonly_texture_view objektumra másol, az adatok át lesznek másolva az alapul szolgáló texture objektumba. A skaláris elemenkénti biteknek és a mértékeknek azonosnak kell lenniük a forrás- és célobjektumokon texture . Ha ezek a követelmények nem teljesülnek, a program futása kivételt dob.

Textúranézet osztályok

A C++ AMP a Visual Studio 2013 texture_view osztályát mutatja be. A textúranézetek ugyanazokat a texeltípusokat támogatják, mint a textúraosztály, de a textúrákkal ellentétben további hardverfunkciókhoz, például a textúra mintavételezéséhez és a mipmapekhez is hozzáférést biztosítanak. A textúranézetek támogatják a csak olvasható, csak írható és olvasás- és írásvédett hozzáférést a mögöttes textúraadatokhoz.

• Az írásvédett hozzáférést a texture_view<const T, N> sablon specializáció biztosítja, amely támogatja az 1, 2 vagy 4 összetevővel rendelkező elemeket, a textúra mintavételezését és a nézet példányosításakor meghatározott mipmap-szintek dinamikus elérését.

• A csak írási hozzáférést a nem specializált sablonosztály texture_view<T, N>biztosítja, amely támogatja a 2 vagy 4 összetevőt tartalmazó elemeket, és a nézet példányosításakor meghatározott mipmap-szintet érheti el. Nem támogatja a mintavételezést.

• Az olvasási-írási hozzáférést a nem specializált sablonosztály texture_view<T, N>biztosítja, amely a textúrákhoz hasonlóan támogatja azokat az elemeket, amelyek csak egy összetevővel rendelkeznek; a nézet egy mipmap-szintet érhet el, amely a példányosításkor lesz meghatározva. Nem támogatja a mintavételezést.

A textúranézetek hasonlóak a tömbnézetekkel, de nem biztosítják a array_view osztály által a tömbosztályon keresztül biztosított automatikus adatkezelési és áthelyezési funkciókat. A texture_view csak a gyorsítónézeten érhető el, ahol a mögöttes textúraadatok találhatók.

writeonly_texture_view megszűnik

A Visual Studio 2013 esetében a C++ AMP jobb támogatást nyújt a hardveres textúra olyan funkcióihoz, mint a mintavételezés és a mipmaps, amelyeket a writeonly_texture_view osztály nem tudott támogatni. Az újonnan bevezetett texture_view osztály támogatja a funkciók writeonly_texture_viewegy szuperhalmazát; ennek következtében writeonly_texture_view elavult.

Javasoljuk – legalábbis új kód esetén –, hogy használja a texture_view-t a korábban a writeonly_texture_view által biztosított funkcionalitás eléréséhez. Hasonlítsa össze az alábbi két kódmintát, amelyek két összetevőt (int_2) tartalmazó textúraobjektumba írnak. Figyelje meg, hogy mindkét esetben a nézetet wo_tv4érték szerint kell rögzíteni a lambda kifejezésben. Az alábbi példa az új texture_view osztályt használja:

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

És itt van az elavult writeonly_texture_view osztály:

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

Mint látható, a két kódpéldának majdnem azonosnak kell lennie, amikor csak az elsődleges mipmap-szintre ír. Ha a meglévő kódban használta writeonly_texture_view , és nem tervezi továbbfejleszteni a kódot, nem kell módosítania. Ha azonban a kód továbbfejlesztésén gondolkodik, javasoljuk, hogy írja át a használatba texture_view , mert a benne lévő fejlesztések támogatják az új hardver-textúrafunkciókat. Olvasson tovább, hogy többet megtudjon ezekről az új képességekről.

Az elavulással writeonly_texture_viewkapcsolatos további információkért tekintse meg a C++ AMP textúranézet-kialakításának áttekintését a natív kód párhuzamos programozásáról szóló blogon.

Textúranézet objektumainak példányosítása

A texture_view deklarálása hasonló egy array_view deklarálásához, amely egy tömbhöz társul. Az alábbi példakód több texture , hozzájuk társított objektumot és texture_view objektumot deklarál.

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

Figyelje meg, hogy egy olyan textúranézet, amelynek elemtípusa nem const, és egy összetevővel rendelkezik, írás-olvasás, de egy olyan textúranézet, amelynek elemtípusa nem const, de több összetevővel rendelkezik, csak írásra. A const elemtípusok textúranézetei mindig írásvédettek, de ha az elemtípus nem const, akkor az elem összetevőinek száma határozza meg, hogy írásvédett (1 összetevő) vagy írásvédett (több összetevő).

A nézet elemtípusa texture_view– a const-ness és a hozzá tartozó összetevők száma – szintén szerepet játszik annak meghatározásában, hogy a nézet támogatja-e a textúra mintavételezését, és hogy a mipmap szintek hogyan érhetők el:

Típus	Összetevők	Olvasás	Írj!	Mintavételezés	Mipmap-hozzáférés
<texture_view const T, N>	1, 2, 4	Igen	Nem (1)	Igen	Igen, indexelhető. A tartomány a példányosításkor lesz meghatározva.
<Texture_view T, N>	1 2, 4	Igen Nem (2)	Igen Igen	Nem (1) Nem (1)	Igen, egy szint. A szint a példányosításkor van meghatározva. Igen, egy szint. A szint a példányosításkor van meghatározva.

Ebből a táblázatból láthatja, hogy az írásvédett textúranézetek teljes mértékben támogatják az új képességeket, cserébe a nézetbe nem tudnak írni. A írható textúranézetek korlátozottak, mivel csak egy mipmap-szinthez férnek hozzá. Az írási-olvasási textúranézetek még a írhatónál is specializáltabbak, mivel hozzáfűzik azt a követelményt, hogy a textúranézet elemtípusa csak egy összetevőből áll. Figyelje meg, hogy a mintavételezés írható textúranézetek esetében nem támogatott, mert ez egy olvasás-orientált művelet.

Olvasás Textúranézet-objektumokból

A nem mintavételezett textúraadatok textúranézeten keresztüli olvasása ugyanúgy működik, mint a textúra önmagából való olvasása, azzal a kivétellel, hogy a textúrákat hivatkozás alapján rögzítik, míg a textúranézeteket érték alapján rögzítik. Az alábbi két példakód bemutatása; elsőként csak a texture használatával:

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

És ugyanez a példa, kivéve, hogy most az osztályt texture_view használja:

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

A lebegőpontos típusokon alapuló textúranézetek — például float, float_2 vagy float_4 — szintén olvashatók textúra mintavételezéssel, ami lehetővé teszi a különböző szűrési és címzési módok hardveres támogatásának kihasználását. A C++ AMP támogatja a számítási forgatókönyvekben leggyakrabban használt két szűrési módot – pontszűrés (legközelebbi szomszéd) és lineáris szűrés (súlyozott átlag) és négy címzési mód – burkolt, tükrözött, befogó és szegélyes. A címzési módokról további információt address_mode Enumerálás című témakörben talál.

A C++ AMP által közvetlenül támogatott módokon kívül az alapul szolgáló platform egyéb szűrési és címzési módjaihoz is hozzáférhet az interop API-k használatával, amellyel közvetlenül a platform API-jaival létrehozott textúra mintavevőt alkalmazhat. A Direct3D például támogatja az egyéb szűrési módokat, például az anizotróp szűrést, és más címzési módot alkalmazhat a textúra minden dimenziójára. Létrehozhat egy textúramintát, amelynek koordinátái függőlegesen burkoltak, vízszintesen tükrözöttek, és anisotróp szűréssel vannak mintavételezve a Direct3D API-k használatával, majd az interop API használatával felhasználhatja a make_sampler C++ AMP kódban. További információ: Textúramintavétel a C++ AMP-ben a Natív kód párhuzamos programozása blogon.

A textúranézetek a mipmapek olvasását is támogatják. Az írásvédett textúranézetek (amelyek const elemtípussal rendelkeznek) a legnagyobb rugalmasságot nyújtják, mivel a példányosításkor meghatározott mip-szintek köre dinamikusan mintavételezhető, és mivel az 1, 2 vagy 4 összetevőt tartalmazó elemek támogatottak. Az olyan olvasási-írási textúranézetek, amelyek elemei egy összetevőt tartalmaznak, szintén támogatják a mipmapokat, de csak a példányosításkor meghatározott szinten. További információ: Textúra és Mipmaps a Natív kód párhuzamos programozása blogon.

Írás textúra megtekintési objektumokba

Használja a texture_view::get metódust az alapul szolgáló texturetexture_view objektumba való íráshoz. A textúranézet lehet csak olvasható, olvasható és írható, vagy csak írható. Ahhoz, hogy a textúra nézet írható legyen, olyan elemtípussal kell rendelkeznie, amely nem const; ahhoz, hogy a textúranézet olvasható és írható legyen, az elemtípusnak is csak egy összetevővel kell rendelkeznie. Ellenkező esetben a textúra nézet írásvédett. A textúra nézetben egyszerre csak egy mipmap-szintet érhet el, a szint pedig a nézet példányosításakor lesz megadva.

Ez a példa bemutatja, hogyan írhat a 4 mipmap-szinttel rendelkező textúra második legrészletesebb mipmap-szintjére. A mipmap legrészletesebb szintje a 0. szint.

// 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ás

A C++ AMP futtatókörnyezet támogatja az interoperabilitást texture<T,1> az ID3D11Texture1D és az texture<T,2>, valamint az texture<T,3> között. A get_texture metódus egy objektumot texture vesz fel, és egy IUnknown felületet ad vissza. A make_texture metódus egy IUnknown felületet és egy accelerator_view objektumot használ, és visszaad egy objektumot texture .

Lásd még

double_2 osztály
double_3 osztály
double_4 osztály
float_2 osztály
float_3 osztály
float_4 osztály
int_2 osztály
int_3 osztály
int_4 osztály
norm_2 osztály
norm_3 osztály
norm_4 osztály
short_vector struktúra
short_vector_traits struktúra
uint_2 osztály
uint_3 osztály
uint_4 osztály
unorm_2 osztály
unorm_3 osztály
unorm_4 osztály