Grafikler (C++ AMP)

C++ AMP, GPU'lardaki Concurrency::graphics doku desteğine erişmek için kullanabileceğiniz ad alanında birkaç API içerir. Bazı yaygın senaryolar şunlardır:

• sınıfını texture hesaplama için bir veri kapsayıcısı olarak kullanabilir ve doku önbelleğinin uzamsal yerelliğinden ve GPU donanımının düzenlerinden yararlanabilirsiniz. Uzamsal yerellik, fiziksel olarak birbirine yakın olan veri öğelerinin özelliğidir.

• Çalışma zamanı, işlem dışı gölgelendiricilerle verimli birlikte çalışabilirlik sağlar. Piksel, köşe, mozaik ve gövde gölgelendiricileri C++ AMP hesaplamalarınızda kullanabileceğiniz dokuları sık sık tüketir veya üretir.

• C++ AMP'deki grafik API'leri, alt sözcük paketlenmiş arabelleklere erişmek için alternatif yollar sağlar. 8 bit veya 16 bit skalerlerden oluşan texel'leri (doku öğeleri) temsil eden biçimlere sahip dokular, bu tür paketlenmiş veri depolamaya erişim sağlar.

Norm ve unorm Türleri

norm ve unorm türleri, değer aralığını float sınırlayan skaler türlerdir; bu, sıkıştırma olarak bilinir. Bu türler, diğer skaler türlerden açıkça oluşturulabilir. Atamada değer önce veya float tarafından norm [-1.0, 1.0] unorm [0.0, 1.0]izin verilen ilgili bölgeye atılır ve ardından bu bölgeye sıkıştırılır. +/- sonsuzdan atama +/-1 döndürür. NaN'den atama tanımlanmamıştır. ' norm den unorm örtük olarak oluşturulabilir ve veri kaybı olmaz. örtük dönüştürme işleci float bu türlerde tanımlanır. İkili işleçler, bu türler ile ve gibi float diğer yerleşik skaler türler arasında tanımlanır: +, -, *, /, ==, !=, ><>=. <=int Bileşik atama işleçleri de desteklenir: +=, -=, *=, /=. Tekli olumsuzlama işleci (-), türler için norm tanımlanır.

Kısa Vektör Kitaplığı

Kısa Vektör Kitaplığı, HLSL'de tanımlanan ve genellikle texel'leri tanımlamak için kullanılan Vektör Türünün bazı işlevlerini sağlar. Kısa vektör, aynı türde bir ile dört arasında değer tutan bir veri yapısıdır. Desteklenen türler , , float, , , uintve unorm'lerdirdouble. normint Tür adları aşağıdaki tabloda gösterilmiştir. Her tür için, adında alt çizgi olmayan karşılık gelen typedef bir de vardır. Alt çizgi içeren türler Concurrency::graphics Ad Alanındadır. Alt çizgiye sahip olmayan türler Concurrency::graphics::d irect3d Ad Alanındadır, böylece ve __int16gibi __int8 benzer şekilde adlandırılmış temel türlerden açıkça ayrılırlar.

İşleçler

Bir işleç iki kısa vektör arasında tanımlanmışsa, kısa vektör ile skaler arasında da tanımlanır. Ayrıca, bunlardan biri doğru olmalıdır:

• Skaler türü, kısa vektör öğe türüyle aynı olmalıdır.

• Skaler türü, yalnızca bir kullanıcı tanımlı dönüştürme kullanılarak örtük olarak vektörün öğe türüne dönüştürülebilir.

İşlem, kısa vektör ve skaler her bileşen arasında bileşene göre taşınır. Geçerli işleçler şunlardır:

İfadeleri Kaydırma

Kısa Vektör Kitaplığı, kısa vektör bileşenlerine vector_type.identifier erişmek için erişimci yapısını destekler. identifierbir kaydırma ifadesi olarak bilinen , vektör bileşenlerini belirtir. İfade bir l-değeri veya r-değeri olabilir. Tanımlayıcıdaki tek tek karakterler: x, y, z ve w; veya r, g, b ve a. "x" ve "r", sıfırıncı bileşen, "y" ve "g" ilk bileşen anlamına gelir ve bu şekilde devam eder. (Aynı tanımlayıcıda "x" ve "r" kullanılamaz.) Bu nedenle, "rgba" ve "xyzw" aynı sonucu döndürür. "x" ve "y" gibi tek bileşenli erişimciler skaler değer türleridir. Çok bileşenli erişimciler kısa vektör türleridir. Örneğin, adlı fourInts ve 2, 4, 6 ve 8 değerlerine sahip bir int_4 vektör oluşturursanız, fourInts.y 4 tamsayısını döndürür ve 2 ve fourInts.rg 4 değerlerine sahip bir int_2 nesne döndürür.

Doku Sınıfları

Birçok GPU'da pikselleri ve ifadeleri getirmek ve görüntüleri ve dokuları işlemek için iyileştirilmiş donanım ve önbellekler vardır. texel texture<T,N> nesneleri için bir kapsayıcı sınıfı olan sınıfı, bu GPU'ların doku işlevselliğini kullanıma sunar. Bir ifade şu olabilir:

• Bir int, uint, float, double, , normveya unorm skaler.

• İki veya dört bileşeni olan kısa bir vektör. Tek özel durum, double_4izin verilmeyen şeklindedir.

texture Nesne 1, 2 veya 3 derecesine sahip olabilir. texture Nesnesi yalnızca çağrısının parallel_for_eachlambda'sında başvuruyla yakalanabilir. Doku, GPU'da Direct3D doku nesneleri olarak depolanır. Direct3D'deki dokular ve ifadeler hakkında daha fazla bilgi için bkz . Direct3D 11'de Dokulara Giriş.

Kullandığınız texel türü, grafik programlamada kullanılan birçok doku biçiminden biri olabilir. Örneğin RGBA biçimi R, G, B ve A skaler öğeleri için her biri 8 bit olmak üzere 32 bit kullanabilir. Grafik kartının doku donanımı, biçime göre tek tek öğelere erişebilir. Örneğin RGBA biçimini kullanıyorsanız doku donanımı her 8 bit öğeyi 32 bit biçiminde ayıklayabilir. C++ AMP'de, bit kaydırma kullanmadan koddaki tek tek skaler öğelere otomatik olarak erişebilmek için texel'inizin skaler öğesi başına bitleri ayarlayabilirsiniz.

Doku Nesnelerinin Örneğini Oluşturma

Bir doku nesnesini başlatmadan bildirebilirsiniz. Aşağıdaki kod örneği birkaç doku nesnesi bildirir.

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

Bir nesneyi bildirmek ve başlatmak için bir texture oluşturucu da kullanabilirsiniz. Aşağıdaki kod örneği, nesne texture vektörünün bir nesnesinin örneğini float_4 oluşturur. Skaler öğe başına bitler varsayılan olarak ayarlanır. Skaler öğe başına varsayılan bitleri olmadığından, bu oluşturucuyu norm, unormveya ve unorm'nin norm kısa vektörleriyle kullanamazsınız.

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

Ayrıca, kaynak texture verilere işaretçi alan bir oluşturucu aşırı yüklemesini, kaynak verilerin bayt cinsinden boyutunu ve skaler öğe başına bitleri kullanarak da bir nesne bildirebilir ve başlatabilirsiniz.

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

Bu örneklerdeki dokular, varsayılan hızlandırıcının varsayılan görünümünde oluşturulur. Bir accelerator_view nesne belirtmek istiyorsanız oluşturucunun diğer aşırı yüklemelerini kullanabilirsiniz. CPU hızlandırıcısı üzerinde doku nesnesi oluşturamazsınız.

Aşağıdaki tabloda gösterildiği gibi, nesnenin texture her boyutunun boyutuyla ilgili sınırlar vardır. Sınırları aşarsanız bir çalışma zamanı hatası oluşturulur.

Doku Nesnelerinden Okuma

Bir nesneden texture doku::operator[], texture::operator() İşleci veya doku::get Yöntemi kullanarak okuyabilirsiniz. İki işleç başvuru değil değer döndürür. Bu nedenle, kullanarak texture::operator\[\]bir texture nesneye yazamazsınız.

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

Aşağıdaki kod örneği, doku kanallarının kısa bir vektörde nasıl depolanacağını ve ardından kısa vektör özellikleri olarak tek tek skaler öğelere nasıl erişeceklerini gösterir.

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

Aşağıdaki tabloda, her sıralama vektör türü için kanal başına geçerli bitler listelenir.

Doku Nesnelerine Yazma

Nesnelere yazmak texture için texture::set yöntemini kullanın. Doku nesnesi salt okunur veya okunabilir/yazılabilir. Doku nesnesinin okunabilir ve yazılabilir olması için aşağıdaki koşulların doğru olması gerekir:

• T yalnızca bir skaler bileşene sahiptir. (Kısa vektörlere izin verilmez.)

• T , veya normunormdeğildirdouble.

• Özelliği texture::bits_per_scalar_element 32'dir.

Üçü de doğru değilse, texture nesne salt okunur olur. derleme sırasında ilk iki koşul denetleniyor. Doku nesnesine yazmaya çalışan kodunuz varsa bir readonly derleme hatası oluşturulur. koşulu texture::bits_per_scalar_element çalışma zamanında algılanır ve salt okunur texture bir nesneye yazmaya çalışırsanız çalışma zamanı unsupported_feature özel durumunu oluşturur.

Aşağıdaki kod örneği, değerleri bir doku nesnesine yazar.

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

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

Doku Nesnelerini Kopyalama

Aşağıdaki kod örneğinde gösterildiği gibi copy işlevini veya copy_async işlevini kullanarak doku nesneleri arasında kopyalama yapabilirsiniz.

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

Doku::copy_to yöntemini kullanarak da bir dokudan diğerine kopyalayabilirsiniz. İki doku farklı accelerator_views olabilir. Bir writeonly_texture_view nesneye kopyaladığınızda, veriler temel alınan texture nesneye kopyalanır. Skaler öğe başına bit sayısı ve kapsam, kaynak ve hedef texture nesnelerde aynı olmalıdır. Bu gereksinimler karşılanmazsa, çalışma zamanı bir özel durum oluşturur.

Doku Görünümü Sınıfları

C++ AMP, Visual Studio 2013'te texture_view Sınıfını tanıtır. Doku görünümleri doku Sınıfı ile aynı texel türlerini ve derecelerini destekler, ancak dokulardan farklı olarak doku örnekleme ve mipmap'ler gibi ek donanım özelliklerine erişim sağlar. Doku görünümleri, temel alınan doku verilerine salt okunur, salt yazma ve okuma-yazma erişimini destekler.

• Salt okunur erişim, 1, 2 veya 4 bileşeni olan öğeleri, doku örneklemesini ve görünüm örneği oluşturulduğunda belirlenen bir dizi mipmap düzeyine dinamik erişimi destekleyen şablon özelleştirmesi tarafından texture_view<const T, N> sağlanır.

• Yalnızca yazma erişimi, 2 veya 4 bileşeni olan öğeleri destekleyen ve görünüm örneği oluşturulurken belirlenen bir mipmap düzeyine erişebilen özel olmayan şablon sınıfı texture_view<T, N>tarafından sağlanır. Örneklemeyi desteklemez.

• Okuma-yazma erişimi, dokular gibi tek bir bileşene sahip öğeleri destekleyen özel olmayan şablon sınıfı texture_view<T, N>tarafından sağlanır; görünüm, örneklendiğinde belirlenen tek bir mipmap düzeyine erişebilir. Örneklemeyi desteklemez.

Doku görünümleri dizi görünümlerine benzer, ancak array_view Sınıfının dizi sınıfı üzerinden sağladığı otomatik veri yönetimi ve taşıma işlevselliğini sağlamaz. öğesine texture_view yalnızca temel doku verilerinin bulunduğu hızlandırıcı görünümünde erişilebilir.

writeonly_texture_view Kullanım Dışı

Visual Studio 2013 için C++ AMP, örnekleme ve mipmap'ler gibi writeonly_texture_view Sınıfı tarafından desteklenmeyen donanım dokusu özellikleri için daha iyi destek sunar. Yeni tanıtılan texture_view sınıf içindeki işlevselliğin writeonly_texture_viewbir üst kümesini destekler; sonuç olarak kullanım writeonly_texture_view dışıdır.

En azından yeni kod için, daha önce tarafından writeonly_texture_viewsağlanan işlevlere erişmek için kullanmanızı texture_view öneririz. İki bileşeni olan bir doku nesnesine yazan aşağıdaki iki kod örneğini karşılaştırın (int_2). Her iki durumda da görünümün, wo_tv4lambda ifadesindeki değere göre yakalanması gerektiğine dikkat edin. Yeni texture_view sınıfı kullanan örnek aşağıda verilmiştir:

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

Kullanım dışı bırakılan writeonly_texture_view sınıf da şu şekildedir:

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

Gördüğünüz gibi, yaptığınız tek şey birincil mipmap düzeyine yazmak olduğunda iki kod örneği neredeyse aynıdır. Mevcut kodda kullandıysanız writeonly_texture_view ve bu kodu geliştirmeyi planlamıyorsanız, bunu değiştirmeniz gerekmez. Ancak, bu kodu öne getirmeyi düşünüyorsanız, içindeki geliştirmeler yeni donanım dokusu özelliklerini desteklediğinden kullanmak texture_view üzere yeniden yazmanızı öneririz. Bu yeni özellikler hakkında daha fazla bilgi için okumaya devam edin.

'nin writeonly_texture_viewkullanımdan kaldırılması hakkında daha fazla bilgi için Yerel Kodda Paralel Programlama blogunda C++ AMP'de Doku Görünümü Tasarımına Genel Bakış bölümüne bakın.

Doku Görünümü Nesnelerinin Örneğini Oluşturma

texture_view bir bildirimi, bir diziyle ilişkili bir array_view bildirimini bildirmeye benzer. Aşağıdaki kod örneği, bunlarla ilişkilendirilmiş birkaç texture nesne ve texture_view nesne bildirir.

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

Öğe türü const olmayan ve bir bileşeni olan bir doku görünümünün okuma-yazma olduğuna, ancak öğe türü const olmayan ancak birden fazla componenent içeren doku görünümünün salt okunur olduğuna dikkat edin. Const öğe türlerinin doku görünümleri her zaman salt okunurdur, ancak öğe türü const değilse, öğedeki bileşenlerin sayısı bunun okuma-yazma (1 bileşen) veya salt yazma (birden çok bileşen) olup olmadığını belirler.

Bir texture_viewöğesinin öğe türü (sabitliği ve sahip olduğu bileşen sayısı), görünümün doku örneklemeyi destekleyip desteklemediğini ve mipmap düzeylerine nasıl erişilebileceğini belirlemede de rol oynar:

Bu tabloda, salt okunur doku görünümlerinin görünüme yazamama karşılığında yeni özellikleri tam olarak desteklediğini görebilirsiniz. Yazılabilir doku görünümleri, yalnızca bir mipmap düzeyine erişebilecekleri için sınırlıdır. Doku görünümünün öğe türünün yalnızca bir bileşene sahip olması gereksinimini eklediklerinden, okuma-yazma doku görünümleri yazılabilir görünümlerden daha özeldir. Okuma odaklı bir işlem olduğundan, yazılabilir doku görünümleri için örneklemenin desteklenmediğini fark edin.

Doku Görünümü Nesnelerinden Okuma

Doku görünümü aracılığıyla örneklenmemiş doku verilerini okumak, dokuların başvuruyla yakalanması dışında doku görünümlerinin değere göre yakalanması dışında dokudan okumak gibidir. Aşağıdaki iki kod örneği gösterilmiştir; öncelikle, yalnızca şunu kullanarak 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));
    });
}

Ve şimdi sınıfını kullanması dışında aynı örnek aşağıda verilmiştir 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));
    });
}

Öğeleri kayan nokta türlerine (örneğin, kayan, float_2 veya float_4) dayanan doku görünümleri, çeşitli filtreleme modları ve adresleme modları için donanım desteğinden yararlanmak üzere doku örneklemesi kullanılarak da okunabilir. C++ AMP, işlem senaryolarında en yaygın olan iki filtreleme modunu (nokta filtreleme (en yakın komşu) ve doğrusal filtreleme (ağırlıklı ortalama) ve sarmalanmış, yansıtılmış, kelepçelenmiş ve kenarlıklı dört adresleme modunu destekler. Adresleme modları hakkında daha fazla bilgi için bkz . address_mode Numaralandırması.

C++ AMP'nin doğrudan desteklediği modlara ek olarak, platform API'leri kullanılarak oluşturulan doku örnekleyiciyi doğrudan benimsemek için birlikte çalışma API'lerini kullanarak temel platformun diğer filtreleme modlarına ve adresleme modlarına erişebilirsiniz. Örneğin Direct3D, anisotropik filtreleme gibi diğer filtreleme modlarını destekler ve bir dokunun her boyutuna farklı bir adresleme modu uygulayabilir. Koordinatları dikey olarak sarmalanan, yatay olarak yansıtılan ve Direct3D API'lerini kullanarak anizotropik filtreleme ile örneklenen bir doku örnekleyici oluşturabilir ve ardından birlikte çalışma API'sini kullanarak C++ AMP kodunuzda örnekleyiciden make_sampler yararlanabilirsiniz. Daha fazla bilgi için Yerel Kodda Paralel Programlama blogunda C++ AMP'de Doku Örnekleme bölümüne bakın.

Doku görünümleri mipmap'lerin okunmasını da destekler. Örnekleme sırasında belirlenen bir mip düzeyi aralığı dinamik olarak örneklenebildiği ve 1, 2 veya 4 bileşeni olan öğeler desteklendiğinden, salt okunur doku görünümleri (const öğe türüne sahip olanlar) en fazla esnekliği sunar. Tek bir bileşene sahip öğeleri olan okuma-yazma doku görünümleri de mipmap'leri destekler, ancak yalnızca örnekleme sırasında belirlenen bir düzeyi destekler. Daha fazla bilgi için Yerel Kodda Paralel Programlama blogunda Mipmap'ler ile doku bölümüne bakın.

Doku Görünümü Nesnelerine Yazma

nesnesi aracılığıyla texture_view temel alınana texture yazmak için texture_view::get Yöntemini kullanın. Doku görünümü salt okunur, salt okunur veya salt okunur olabilir. Doku görünümünün yazılabilir olması için sabit olmayan bir öğe türüne sahip olması gerekir; Doku görünümünün okunabilir ve yazılabilir olması için, öğe türünün de yalnızca bir bileşeni olmalıdır. Aksi takdirde doku görünümü salt okunur olur. Doku görünümü aracılığıyla aynı anda bir dokunun yalnızca bir mipmap düzeyine erişebilirsiniz ve görünüm örneği oluşturulurken düzey belirtilir.

Bu örnekte, 4 mipmap düzeyine sahip bir dokunun ikinci en ayrıntılı mipmap düzeyine nasıl yazıldığını gösterir. En ayrıntılı mipmap düzeyi düzey 0'dır.

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

Birlikte çalışabilirlik

C++ AMP çalışma zamanı, ID3D11Texture1D arabirimi ile texture<T,1> ID3D11Texture2D arabirimi arasında texture<T,2> ve ID3D11Texture3D arabirimi arasında texture<T,3> birlikte çalışabilirliği destekler. get_texture yöntemi bir texture nesnesi alır ve bir IUnknown arabirim döndürür. make_texture yöntemi bir IUnknown arabirim ve accelerator_view nesne alır ve bir texture nesne döndürür.

Ayrıca bkz.

double_2 Sınıfı
double_3 Sınıfı
double_4 Sınıfı
float_2 Sınıfı
float_3 Sınıfı
float_4 Sınıfı
int_2 Sınıfı
int_3 Sınıfı
int_4 Sınıfı
norm_2 Sınıfı
norm_3 Sınıfı
norm_4 Sınıfı
short_vector Yapısı
short_vector_traits Yapısı
uint_2 Sınıfı
uint_3 Sınıfı
uint_4 Sınıfı
unorm_2 Sınıfı
unorm_3 Sınıfı
unorm_4 Sınıfı