Kompresi Blok (Direct3D 10)

  • Artikel

Kompresi blok adalah teknik kompresi tekstur untuk mengurangi ukuran tekstur. Jika dibandingkan dengan tekstur dengan 32-bit per warna, tekstur terkompresi blok bisa hingga 75 persen lebih kecil. Aplikasi biasanya melihat peningkatan performa saat menggunakan kompresi blok karena jejak memori yang lebih kecil.

Meskipun lossy, kompresi blok bekerja dengan baik dan direkomendasikan untuk semua tekstur yang diubah dan difilter oleh alur. Tekstur yang langsung dipetakan ke layar (elemen UI seperti ikon dan teks) bukanlah pilihan yang baik untuk pemadatan karena artefak lebih terlihat.

Tekstur terkompresi blok harus dibuat sebagai kelipatan ukuran 4 di semua dimensi dan tidak dapat digunakan sebagai output dari alur.

Bagaimana Cara Kerja Kompresi Blok?

Kompresi blok adalah teknik untuk mengurangi jumlah memori yang diperlukan untuk menyimpan data warna. Dengan menyimpan beberapa warna dalam ukuran aslinya, dan warna lain menggunakan skema pengodean, Anda dapat secara dramatis mengurangi jumlah memori yang diperlukan untuk menyimpan gambar. Karena perangkat keras secara otomatis mendekode data terkompresi, tidak ada penalti performa untuk menggunakan tekstur terkompresi.

Untuk melihat cara kerja pemadatan, lihat dua contoh berikut. Contoh pertama menjelaskan jumlah memori yang digunakan saat menyimpan data yang tidak dikompresi; contoh kedua menjelaskan jumlah memori yang digunakan saat menyimpan data terkompresi.

Menyimpan Data Yang Tidak Dikompresi

Ilustrasi berikut mewakili tekstur 4×4 yang tidak dikompresi. Asumsikan bahwa setiap warna berisi komponen warna tunggal (merah misalnya) dan disimpan dalam satu byte memori.

ilustrasi tekstur 4x4 yang tidak dikompresi

Data yang tidak dikompresi ditata dalam memori secara berurutan dan memerlukan 16 byte, seperti yang ditunjukkan dalam ilustrasi berikut.

ilustrasi data yang tidak dikompresi dalam memori berurutan

Menyimpan Data Terkompresi

Sekarang setelah Anda melihat berapa banyak memori yang digunakan gambar yang tidak dikompresi, lihat berapa banyak memori yang disimpan gambar terkompresi. Format kompresi BC4 menyimpan 2 warna (masing-masing 1 byte) dan indeks 16 3-bit (48 bit, atau 6 byte) yang digunakan untuk menginterpolasi warna asli dalam tekstur, seperti yang ditunjukkan dalam ilustrasi berikut.

ilustrasi format kompresi bc4

Total ruang yang diperlukan untuk menyimpan data terkompresi adalah 8 byte yang merupakan penghematan memori 50 persen atas contoh yang tidak dikompresi. Penghematan bahkan lebih besar ketika lebih dari satu komponen warna digunakan.

Penghematan memori substansial yang disediakan oleh kompresi blok dapat menyebabkan peningkatan performa. Performa ini datang dengan biaya kualitas gambar (karena interpolasi warna); namun, kualitas yang lebih rendah sering tidak terlihat.

Bagian berikutnya menunjukkan kepada Anda bagaimana Direct3D 10 memudahkan Anda untuk menggunakan kompresi blok di aplikasi Anda.

Menggunakan Kompresi Blok

Buat tekstur terkompresi blok sama seperti tekstur yang tidak dikompresi (lihat Membuat Tekstur dari File) kecuali Anda menentukan format terkompresi blok.

loadInfo.Format = DXGI_FORMAT_BC1_UNORM;
D3DX10CreateTextureFromFile(...);

Selanjutnya, buat tampilan untuk mengikat tekstur ke alur. Karena tekstur terkompresi blok hanya dapat digunakan sebagai input ke tahap shader, Anda ingin membuat tampilan sumber daya shader dengan memanggil CreateShaderResourceView.

Gunakan tekstur terkompresi blok dengan cara yang sama seperti Anda akan menggunakan tekstur yang tidak dikompresi. Jika aplikasi Anda akan mendapatkan penunjuk memori ke data yang dikompresi blok, Anda perlu memperhitungkan padding memori dalam mipmap yang menyebabkan ukuran yang dinyatakan berbeda dari ukuran aktual.

Ukuran Virtual versus Ukuran Fisik

Jika Anda memiliki kode aplikasi yang menggunakan penunjuk memori untuk memandu memori tekstur terkompresi blok, ada satu pertimbangan penting yang mungkin memerlukan modifikasi dalam kode aplikasi Anda. Tekstur terkompresi blok harus kelipatan 4 di semua dimensi karena algoritma kompresi blok beroperasi pada blok texel 4x4. Ini akan menjadi masalah untuk mipmap yang dimensi awalnya dapat dibagi 4, tetapi tingkat yang dibagi tidak. Diagram berikut menunjukkan perbedaan area antara ukuran virtual (dideklarasikan) dan ukuran fisik (aktual) dari setiap tingkat mipmap.

diagram tingkat mipmap yang tidak dikompresi dan dikompresi

Sisi kiri diagram menunjukkan ukuran tingkat mipmap yang dihasilkan untuk tekstur 60×40 yang tidak dikompresi. Ukuran tingkat atas diambil dari panggilan API yang menghasilkan tekstur; setiap tingkat berikutnya adalah setengah dari ukuran tingkat sebelumnya. Untuk tekstur yang tidak dikompresi, tidak ada perbedaan antara ukuran virtual (dideklarasikan) dan ukuran fisik (aktual).

Sisi kanan diagram menunjukkan ukuran tingkat mipmap yang dihasilkan untuk tekstur 60×40 yang sama dengan kompresi. Perhatikan bahwa tingkat kedua dan ketiga memiliki padding memori untuk membuat faktor ukuran 4 pada setiap tingkat. Hal ini diperlukan agar algoritma dapat beroperasi pada blok texel 4×4. Ini terbukti secara eksplisit jika Anda mempertimbangkan tingkat mipmap yang lebih kecil dari 4×4; ukuran tingkat mipmap yang sangat kecil ini akan dibulatkan ke faktor terdekat 4 ketika memori tekstur dialokasikan.

Perangkat keras pengambilan sampel menggunakan ukuran virtual; saat tekstur diambil sampelnya, padding memori diabaikan. Untuk tingkat mipmap yang lebih kecil dari 4×4, hanya empat texel pertama yang akan digunakan untuk peta 2×2, dan hanya texel pertama yang akan digunakan oleh blok 1×1. Namun, tidak ada struktur API yang mengekspos ukuran fisik (termasuk padding memori).

Singkatnya, berhati-hatilah untuk menggunakan blok memori yang selaras saat menyalin wilayah yang berisi data terkompresi blok. Untuk melakukan ini dalam aplikasi yang mendapatkan penunjuk memori, pastikan bahwa pointer menggunakan permukaan pitch untuk memperkirakan ukuran memori fisik.

Algoritma Kompresi

Teknik kompresi blok di Direct3D memecah data tekstur yang tidak dikompresi menjadi 4×4 blok, memadatkan setiap blok, lalu menyimpan data. Untuk alasan ini, tekstur yang diharapkan dikompresi harus memiliki dimensi tekstur yang kelipatan 4.

diagram kompresi blok

Diagram sebelumnya menunjukkan tekstur yang dipartisi menjadi blok texel. Blok pertama memperlihatkan tata letak 16 texel berlabel a-p, tetapi setiap blok memiliki organisasi data yang sama.

Direct3D menerapkan beberapa skema kompresi, masing-masing menerapkan tradeoff yang berbeda antara jumlah komponen yang disimpan, jumlah bit per komponen, dan jumlah memori yang dikonsumsi. Gunakan tabel ini untuk membantu memilih format yang paling sesuai dengan jenis data dan resolusi data yang paling sesuai dengan aplikasi Anda.

Data Sumber Resolusi Kompresi Data (dalam bit) Pilih format kompresi ini
Warna tiga komponen dan alfa Warna (5:6:5), Alfa (1) atau tanpa alfa BC1
Warna tiga komponen dan alfa Warna (5:6:5), Alfa (4) BC2
Warna tiga komponen dan alfa Warna (5:6:5), Alfa (8) BC3
Warna satu komponen Satu komponen (8) BC4
Warna dua komponen Dua komponen (8:8) BC5

 

BC1

Gunakan format kompresi blok pertama (BC1) (baik DXGI_FORMAT_BC1_TYPELESS, DXGI_FORMAT_BC1_UNORM, atau DXGI_BC1_UNORM_SRGB) untuk menyimpan data warna tiga komponen menggunakan warna 5:6:5 (merah 5 bit, hijau 6 bit, biru 5 bit). Ini benar bahkan jika data juga berisi alfa 1-bit. Dengan asumsi tekstur 4×4 menggunakan format data terbesar yang mungkin, format BC1 mengurangi memori yang diperlukan dari 48 byte (16 warna × 3 komponen/warna × 1 byte/komponen) menjadi 8 byte memori.

Algoritma bekerja pada 4×4 blok texel. Alih-alih menyimpan 16 warna, algoritma menyimpan 2 warna referensi (color_0 dan color_1) dan indeks warna 16 2-bit (memblokir a–p), seperti yang ditunjukkan dalam diagram berikut.

diagram tata letak untuk pemadatan bc1

Indeks warna (a–p) digunakan untuk mencari warna asli dari tabel warna. Tabel warna berisi 4 warna. Dua warna pertama—color_0 dan color_1—adalah warna minimum dan maksimum. Dua warna lainnya, color_2 dan color_3, adalah warna perantara yang dihitung dengan interpolasi linier.

color_2 = 2/3*color_0 + 1/3*color_1
color_3 = 1/3*color_0 + 2/3*color_1

Empat warna diberi nilai indeks 2-bit yang akan disimpan dalam blok a–p.

color_0 = 00
color_1 = 01
color_2 = 10
color_3 = 11

Akhirnya, masing-masing warna dalam blok a–p dibandingkan dengan empat warna dalam tabel warna, dan indeks untuk warna terdekat disimpan dalam blok 2-bit.

Algoritma ini meminjamkan dirinya ke data yang juga berisi alfa 1-bit. Satu-satunya perbedaan adalah bahwa color_3 diatur ke 0 (yang mewakili warna transparan) dan color_2 adalah campuran linier color_0 dan color_1.

color_2 = 1/2*color_0 + 1/2*color_1;
color_3 = 0;

Perbedaan antara Direct3D 9 dan Direct3D 10:

Format ini ada dalam Direct3D 9 dan 10.

  • Dalam Direct3D 9, format BC1 disebut D3DFMT_DXT1.
  • Dalam Direct3D 10, format BC1 diwakili oleh DXGI_FORMAT_BC1_UNORM atau DXGI_FORMAT_BC1_UNORM_SRGB.

BC2

Gunakan format BC2 (baik DXGI_FORMAT_BC2_TYPELESS, DXGI_FORMAT_BC2_UNORM, atau DXGI_BC2_UNORM_SRGB) untuk menyimpan data yang berisi data warna dan alfa dengan koherensi rendah (gunakan BC3 untuk data alfa yang sangat koheren). Format BC2 menyimpan data RGB sebagai warna 5:6:5 (merah 5 bit, hijau 6 bit, biru 5 bit) dan alfa sebagai nilai 4-bit terpisah. Dengan asumsi tekstur 4×4 menggunakan format data terbesar yang mungkin, teknik pemadatan ini mengurangi memori yang diperlukan dari 64 byte (16 warna × 4 komponen/warna × 1 byte/komponen) menjadi 16 byte memori.

Format BC2 menyimpan warna dengan jumlah bit dan tata letak data yang sama dengan format BC1 ; namun, BC2 memerlukan memori tambahan 64-bit untuk menyimpan data alfa, seperti yang ditunjukkan dalam diagram berikut.

diagram tata letak untuk pemadatan bc2

Perbedaan antara Direct3D 9 dan Direct3D 10:

Format ini ada dalam Direct3D 9 dan 10.

  • Dalam Direct3D 9, format BC2 disebut D3DFMT_DXT2 dan D3DFMT_DXT3.

  • Dalam Direct3D 10, format BC2 diwakili oleh DXGI_FORMAT_BC2_UNORM atau DXGI_FORMAT_BC2_UNORM_SRGB

BC3

Gunakan format BC3 (baik DXGI_FORMAT_BC3_TYPELESS, DXGI_FORMAT_BC3_UNORM, atau DXGI_BC3_UNORM_SRGB) untuk menyimpan data warna yang sangat koheren (gunakan BC2 dengan data alfa yang kurang koheren). Format BC3 menyimpan data warna menggunakan warna 5:6:5 (merah 5 bit, hijau 6 bit, biru 5 bit) dan data alfa menggunakan satu byte. Dengan asumsi tekstur 4×4 menggunakan format data terbesar yang mungkin, teknik pemadatan ini mengurangi memori yang diperlukan dari 64 byte (16 warna × 4 komponen/warna × 1 byte/komponen) menjadi 16 byte memori.

Format BC3 menyimpan warna dengan jumlah bit dan tata letak data yang sama dengan format BC1 ; namun, BC3 memerlukan memori tambahan 64-bit untuk menyimpan data alfa. Format BC3 menangani alfa dengan menyimpan dua nilai referensi dan menginterpolasi di antaranya (mirip dengan bagaimana BC1 menyimpan warna RGB).

Algoritma bekerja pada 4×4 blok texel. Alih-alih menyimpan nilai alfa 16, algoritma menyimpan 2 alfa referensi (alpha_0 dan alpha_1) dan indeks warna 16 3-bit (alfa a sampai p), seperti yang ditunjukkan dalam diagram berikut.

diagram tata letak untuk pemadatan bc3

Format BC3 menggunakan indeks alfa (a–p) untuk mencari warna asli dari tabel pencarian yang berisi 8 nilai. Dua nilai pertama—alpha_0 dan alpha_1—adalah nilai minimum dan maksimum; enam nilai perantara lainnya dihitung menggunakan interpolasi linier.

Algoritma menentukan jumlah nilai alfa terinterpolasi dengan memeriksa dua nilai alfa referensi. Jika alpha_0 lebih besar dari alpha_1, maka BC3 menginterpolasi 6 nilai alfa; jika tidak, itu menginterpolasi 4. Ketika BC3 hanya menginterpolasi 4 nilai alfa, BC3 menetapkan dua nilai alfa tambahan (0 untuk transparan sepenuhnya dan 255 untuk buram sepenuhnya). BC3 memadatkan nilai alfa di area texel 4×4 dengan menyimpan kode bit yang sesuai dengan nilai alfa terinterpolasi yang paling cocok dengan alfa asli untuk texel tertentu.

if( alpha_0 > alpha_1 )
{
  // 6 interpolated alpha values.
  alpha_2 = 6/7*alpha_0 + 1/7*alpha_1; // bit code 010
  alpha_3 = 5/7*alpha_0 + 2/7*alpha_1; // bit code 011
  alpha_4 = 4/7*alpha_0 + 3/7*alpha_1; // bit code 100
  alpha_5 = 3/7*alpha_0 + 4/7*alpha_1; // bit code 101
  alpha_6 = 2/7*alpha_0 + 5/7*alpha_1; // bit code 110
  alpha_7 = 1/7*alpha_0 + 6/7*alpha_1; // bit code 111
}
else
{
  // 4 interpolated alpha values.
  alpha_2 = 4/5*alpha_0 + 1/5*alpha_1; // bit code 010
  alpha_3 = 3/5*alpha_0 + 2/5*alpha_1; // bit code 011
  alpha_4 = 2/5*alpha_0 + 3/5*alpha_1; // bit code 100
  alpha_5 = 1/5*alpha_0 + 4/5*alpha_1; // bit code 101
  alpha_6 = 0;                         // bit code 110
  alpha_7 = 255;                       // bit code 111
}

Perbedaan antara Direct3D 9 dan Direct3D 10:

  • Dalam Direct3D 9, format BC3 disebut D3DFMT_DXT4 dan D3DFMT_DXT5.

  • Dalam Direct3D 10, format BC3 diwakili oleh DXGI_FORMAT_BC3_UNORM atau DXGI_FORMAT_BC3_UNORM_SRGB.

BC4

Gunakan format BC4 untuk menyimpan data warna satu komponen menggunakan 8 bit untuk setiap warna. Sebagai hasil dari peningkatan akurasi (dibandingkan dengan BC1), BC4 sangat ideal untuk menyimpan data floating-point dalam kisaran [0 hingga 1] menggunakan format DXGI_FORMAT_BC4_UNORM dan [-1 hingga +1] menggunakan format DXGI_FORMAT_BC4_SNORM. Dengan asumsi tekstur 4×4 menggunakan format data terbesar yang mungkin, teknik pemadatan ini mengurangi memori yang diperlukan dari 16 byte (16 warna × 1 komponen/warna × 1 byte/komponen) menjadi 8 byte.

Algoritma bekerja pada 4×4 blok texel. Alih-alih menyimpan 16 warna, algoritma menyimpan 2 warna referensi (red_0 dan red_1) dan indeks warna 16 3-bit (merah a hingga merah p), seperti yang ditunjukkan dalam diagram berikut.

diagram tata letak untuk pemadatan bc4

Algoritma menggunakan indeks 3-bit untuk mencari warna dari tabel warna yang berisi 8 warna. Dua warna pertama—red_0 dan red_1—adalah warna minimum dan maksimum. Algoritma menghitung warna yang tersisa menggunakan interpolasi linier.

Algoritma menentukan jumlah nilai warna terinterpolasi dengan memeriksa dua nilai referensi. Jika red_0 lebih besar dari red_1, maka BC4 menginterpolasi 6 nilai warna; jika tidak, itu menginterpolasi 4. Ketika BC4 hanya menginterpolasi 4 nilai warna, BC4 menetapkan dua nilai warna tambahan (0,0f untuk transparan sepenuhnya dan 1,0f untuk buram sepenuhnya). BC4 memadatkan nilai alfa di area texel 4×4 dengan menyimpan kode bit yang sesuai dengan nilai alfa terinterpolasi yang paling cocok dengan alfa asli untuk texel tertentu.

BC4_UNORM

Interpolasi data komponen tunggal dilakukan seperti dalam sampel kode berikut.

unsigned word red_0, red_1;

if( red_0 > red_1 )
{
  // 6 interpolated color values
  red_2 = (6*red_0 + 1*red_1)/7.0f; // bit code 010
  red_3 = (5*red_0 + 2*red_1)/7.0f; // bit code 011
  red_4 = (4*red_0 + 3*red_1)/7.0f; // bit code 100
  red_5 = (3*red_0 + 4*red_1)/7.0f; // bit code 101
  red_6 = (2*red_0 + 5*red_1)/7.0f; // bit code 110
  red_7 = (1*red_0 + 6*red_1)/7.0f; // bit code 111
}
else
{
  // 4 interpolated color values
  red_2 = (4*red_0 + 1*red_1)/5.0f; // bit code 010
  red_3 = (3*red_0 + 2*red_1)/5.0f; // bit code 011
  red_4 = (2*red_0 + 3*red_1)/5.0f; // bit code 100
  red_5 = (1*red_0 + 4*red_1)/5.0f; // bit code 101
  red_6 = 0.0f;                     // bit code 110
  red_7 = 1.0f;                     // bit code 111
}

Warna referensi diberi indeks 3-bit (000–111 karena ada 8 nilai), yang akan disimpan dalam blok merah a hingga merah p selama pemadatan.

BC4_SNORM

DXGI_FORMAT_BC4_SNORM persis sama, kecuali bahwa data dikodekan dalam rentang SNORM dan ketika 4 nilai warna diinterpolasi. Interpolasi data komponen tunggal dilakukan seperti dalam sampel kode berikut.

signed word red_0, red_1;

if( red_0 > red_1 )
{
  // 6 interpolated color values
  red_2 = (6*red_0 + 1*red_1)/7.0f; // bit code 010
  red_3 = (5*red_0 + 2*red_1)/7.0f; // bit code 011
  red_4 = (4*red_0 + 3*red_1)/7.0f; // bit code 100
  red_5 = (3*red_0 + 4*red_1)/7.0f; // bit code 101
  red_6 = (2*red_0 + 5*red_1)/7.0f; // bit code 110
  red_7 = (1*red_0 + 6*red_1)/7.0f; // bit code 111
}
else
{
  // 4 interpolated color values
  red_2 = (4*red_0 + 1*red_1)/5.0f; // bit code 010
  red_3 = (3*red_0 + 2*red_1)/5.0f; // bit code 011
  red_4 = (2*red_0 + 3*red_1)/5.0f; // bit code 100
  red_5 = (1*red_0 + 4*red_1)/5.0f; // bit code 101
  red_6 = -1.0f;                     // bit code 110
  red_7 =  1.0f;                     // bit code 111
}

Warna referensi diberi indeks 3-bit (000–111 karena ada 8 nilai), yang akan disimpan dalam blok merah a hingga merah p selama pemadatan.

BC5

Gunakan format BC5 untuk menyimpan data warna dua komponen menggunakan 8 bit untuk setiap warna. Sebagai hasil dari peningkatan akurasi (dibandingkan dengan BC1), BC5 sangat ideal untuk menyimpan data floating-point dalam rentang [0 hingga 1] menggunakan format DXGI_FORMAT_BC5_UNORM dan [-1 hingga +1] menggunakan format DXGI_FORMAT_BC5_SNORM. Dengan asumsi tekstur 4×4 menggunakan format data terbesar yang mungkin, teknik kompresi ini mengurangi memori yang diperlukan dari 32 byte (16 warna × 2 komponen/warna × 1 byte/komponen) menjadi 16 byte.

Algoritma bekerja pada 4×4 blok texel. Alih-alih menyimpan 16 warna untuk kedua komponen, algoritma menyimpan 2 warna referensi untuk setiap komponen (red_0, red_1, green_0, dan green_1) dan indeks warna 16 3-bit untuk setiap komponen (merah a hingga merah p dan hijau a hingga hijau p), seperti yang ditunjukkan dalam diagram berikut.

diagram tata letak untuk pemadatan bc5

Algoritma menggunakan indeks 3-bit untuk mencari warna dari tabel warna yang berisi 8 warna. Dua warna pertama—red_0 dan red_1 (atau green_0 dan green_1)—adalah warna minimum dan maksimum. Algoritma menghitung warna yang tersisa menggunakan interpolasi linier.

Algoritma menentukan jumlah nilai warna terinterpolasi dengan memeriksa dua nilai referensi. Jika red_0 lebih besar dari red_1, maka BC5 menginterpolasi 6 nilai warna; jika tidak, itu menginterpolasi 4. Ketika BC5 hanya menginterpolasi 4 nilai warna, BC5 mengatur dua nilai warna yang tersisa pada 0,0f dan 1,0f.

BC5_UNORM

Interpolasi data komponen tunggal dilakukan seperti dalam sampel kode berikut. Perhitungan untuk komponen hijau serupa.

unsigned word red_0, red_1;

if( red_0 > red_1 )
{
  // 6 interpolated color values
  red_2 = (6*red_0 + 1*red_1)/7.0f; // bit code 010
  red_3 = (5*red_0 + 2*red_1)/7.0f; // bit code 011
  red_4 = (4*red_0 + 3*red_1)/7.0f; // bit code 100
  red_5 = (3*red_0 + 4*red_1)/7.0f; // bit code 101
  red_6 = (2*red_0 + 5*red_1)/7.0f; // bit code 110
  red_7 = (1*red_0 + 6*red_1)/7.0f; // bit code 111
}
else
{
  // 4 interpolated color values
  red_2 = (4*red_0 + 1*red_1)/5.0f; // bit code 010
  red_3 = (3*red_0 + 2*red_1)/5.0f; // bit code 011
  red_4 = (2*red_0 + 3*red_1)/5.0f; // bit code 100
  red_5 = (1*red_0 + 4*red_1)/5.0f; // bit code 101
  red_6 = 0.0f;                     // bit code 110
  red_7 = 1.0f;                     // bit code 111
}

Warna referensi diberi indeks 3-bit (000–111 karena ada 8 nilai), yang akan disimpan dalam blok merah a hingga merah p selama pemadatan.

BC5_SNORM

DXGI_FORMAT_BC5_SNORM sama persis, kecuali bahwa data dikodekan dalam rentang SNORM dan ketika 4 nilai data diinterpolasi, dua nilai tambahan adalah -1,0f dan 1,0f. Interpolasi data komponen tunggal dilakukan seperti dalam sampel kode berikut. Perhitungan untuk komponen hijau serupa.

signed word red_0, red_1;

if( red_0 > red_1 )
{
  // 6 interpolated color values
  red_2 = (6*red_0 + 1*red_1)/7.0f; // bit code 010
  red_3 = (5*red_0 + 2*red_1)/7.0f; // bit code 011
  red_4 = (4*red_0 + 3*red_1)/7.0f; // bit code 100
  red_5 = (3*red_0 + 4*red_1)/7.0f; // bit code 101
  red_6 = (2*red_0 + 5*red_1)/7.0f; // bit code 110
  red_7 = (1*red_0 + 6*red_1)/7.0f; // bit code 111
}
else
{
  // 4 interpolated color values
  red_2 = (4*red_0 + 1*red_1)/5.0f; // bit code 010
  red_3 = (3*red_0 + 2*red_1)/5.0f; // bit code 011
  red_4 = (2*red_0 + 3*red_1)/5.0f; // bit code 100
  red_5 = (1*red_0 + 4*red_1)/5.0f; // bit code 101
  red_6 = -1.0f;                    // bit code 110
  red_7 =  1.0f;                    // bit code 111
}

Warna referensi diberi indeks 3-bit (000–111 karena ada 8 nilai), yang akan disimpan dalam blok merah a hingga merah p selama pemadatan.

Konversi Format menggunakan Direct3D 10.1

Direct3D 10.1 memungkinkan salinan antara tekstur berjenis terstruktur dan tekstur terkompresi blok dengan lebar bit yang sama. Fungsi yang dapat menyelesaikan ini adalah CopyResource dan CopySubresourceRegion.

Dimulai dengan Direct3D 10.1, Anda dapat menggunakan CopyResource dan CopySubresourceRegion untuk menyalin di antara beberapa jenis format. Jenis operasi salin ini melakukan jenis konversi format yang menginterpretasikan ulang data sumber daya sebagai jenis format yang berbeda. Pertimbangkan contoh ini yang menunjukkan perbedaan antara menginterpretasikan ulang data dengan cara jenis konversi yang lebih khas bertingkah:

    FLOAT32 f = 1.0f;
    UINT32 u;

Untuk menginterpretasikan ulang 'f' sebagai jenis 'u', gunakan memcpy:

    memcpy( &u, &f, sizeof( f ) ); // ‘u’ becomes equal to 0x3F800000.

Dalam reinterpretasi sebelumnya, nilai data yang mendasarinya tidak berubah; memcpy menginterpretasikan kembali float sebagai bilangan bulat yang tidak ditandatangani.

Untuk melakukan jenis konversi yang lebih umum, gunakan penugasan:

    u = f; // ‘u’ becomes 1.

Dalam konversi sebelumnya, nilai yang mendasari data berubah.

Tabel berikut mencantumkan format sumber dan tujuan yang diizinkan yang bisa Anda gunakan dalam jenis konversi format reinterpretasi ini. Anda harus mengodekan nilai dengan benar agar reinterpretasi berfungsi seperti yang diharapkan.

Lebar Bit Sumber Daya Tidak Terkompresi Sumber Daya Block-Compressed
32 DXGI_FORMAT_R32_UINT
DXGI_FORMAT_R32_SINT
 DXGI_FORMAT_R9G9B9E5_SHAREDEXP
64 DXGI_FORMAT_R16G16B16A16_UINT
DXGI_FORMAT_R16G16B16A16_SINT
DXGI_FORMAT_R32G32_UINT
DXGI_FORMAT_R32G32_SINT
 DXGI_FORMAT_BC1_UNORM[_SRGB]
DXGI_FORMAT_BC4_UNORM
DXGI_FORMAT_BC4_SNORM
128 DXGI_FORMAT_R32G32B32A32_UINT
DXGI_FORMAT_R32G32B32A32_SINT
 DXGI_FORMAT_BC2_UNORM[_SRGB]
DXGI_FORMAT_BC3_UNORM[_SRGB]
DXGI_FORMAT_BC5_UNORM
DXGI_FORMAT_BC5_SNORM

 

Sumber daya (Direct3D 10)