Menggunakan DirectX dengan Warna Tingkat Lanjut pada tampilan rentang dinamis tinggi/standar

Topik ini menunjukkan cara menggunakan DirectX dengan skenario Warna Tingkat Lanjut—termasuk rentang dinamis tinggi (HDR), gamut warna lebar (WCG) dengan manajemen warna sistem otomatis, dan kedalaman bit tinggi. Tampilan komputer pribadi premium (PC) dengan setidaknya salah satu peningkatan di atas menjadi tersebar luas, memberikan keakuratan warna yang jauh lebih tinggi daripada tampilan rentang dinamis standar tradisional (SDR).

Dalam topik ini, Anda akan mendapatkan gambaran umum tentang konsep teknis utama di balik dukungan Windows Advanced Color. Anda akan mempelajari persyaratan dan instruksi untuk merender konten HdR, WCG, dan DirectX kedalaman bit tinggi ke salah satu tampilan ini. Jika Anda memiliki aplikasi yang dikelola warna (misalnya, menggunakan profil ICC), maka Anda akan mempelajari bagaimana manajemen warna otomatis memungkinkan akurasi warna yang lebih baik untuk skenario Anda.

Pengantar Warna Tingkat Lanjut di Windows

Advanced Color adalah teknologi payung istilah sistem operasi (OS) untuk tampilan dengan keakuratan warna yang jauh lebih tinggi daripada tampilan standar. Kemampuan yang diperluas dominan dijelaskan di bagian di bawah ini. Kemampuan Warna Tingkat Lanjut pertama kali diperkenalkan untuk tampilan HDR dengan Windows 10, versi 1709 (Pembaruan Fall Creators), dan untuk tampilan SDR yang disediakan secara khusus dengan Windows 11, versi 22H2 (10.0; Rilis Build 22621).

Rentang dinamis tinggi

Rentang dinamis mengacu pada perbedaan antara luminance maksimum dan minimum dalam adegan; ini sering diukur dalam nits (kandela per sentimeter persegi). Adegan dunia nyata, seperti matahari terbenam ini, sering memiliki rentang dinamis 10 urutan besarnya luminance; mata manusia dapat membedakan rentang yang lebih besar setelah adaptasi.

Sejak Direct3D 9, mesin grafis telah mampu merender adegan mereka secara internal dengan tingkat keakuratan fisik ini. Namun, tampilan rentang dinamis standar yang khas hanya dapat mereproduksi sedikit lebih dari 3 pesanan besarnya luminance, dan oleh karena itu konten yang dirender HDR harus ditonemapp (dikompresi) ke dalam rentang terbatas tampilan. Tampilan HDR baru, termasuk yang mematuhi standar HDR10 (BT.2100), menembus batasan ini; misalnya, tampilan emisi mandiri berkualitas tinggi dapat mencapai lebih dari 6 urutan besar.

Gamut warna lebar

Gamut warna mengacu pada rentang dan saturasi rona yang dapat direproduksi oleh tampilan. Warna alami yang paling jenuh yang dapat dirasakan mata manusia terdiri dari cahaya murni dan monokromatik seperti yang diproduksi oleh laser. Namun, tampilan konsumen mainstream sering dapat mereproduksi warna hanya dalam gamut sRGB, yang hanya mewakili sekitar 35% dari semua warna yang dapat dirasakan manusia. Diagram di bawah ini adalah representasi dari "lokus spektral" manusia, atau semua warna yang dapat dirasakan (pada tingkat luminasi tertentu), di mana segitiga yang lebih kecil adalah gamut sRGB.

High end, tampilan PC profesional memiliki gamut warna yang didukung lama yang secara signifikan lebih lebar dari sRGB, seperti Adobe RGB dan DCI-P3 yang mencakup sekitar setengah dari warna yang dapat dirasakan manusia. Dan tampilan gamut lebar ini menjadi lebih umum.

Manajemen warna sistem otomatis

Manajemen warna adalah teknologi dan praktik untuk memastikan reproduksi warna yang akurat dan konsisten di seluruh perangkat. Jika Anda seorang pembuat konten digital, sangat penting untuk warna dalam konten visual Anda—seperti foto, gambar produk, atau logo—agar tampak sama di layar Anda seperti halnya di berbagai perangkat digital audiens Anda.

Windows telah menyediakan API dukungan manajemen warna sejak Windows 2000 dengan API Image Color Management (ICM) dan Windows Color System (WCS) yang lebih baru. Namun, API tersebut hanya pembantu untuk aplikasi yang ingin/diharuskan untuk melakukan manajemen warna; sementara sebagian besar aplikasi dan konten digital hanya mengasumsikan ruang warna sRGB standar industri, dan tidak pernah dikelola warna oleh OS. Itu adalah asumsi yang wajar di masa lalu, tetapi tampilan gamut lebar berkualitas tinggi menjadi jauh lebih umum.

Versi baru Windows mendukung manajemen warna sistem otomatis; yang memastikan bahwa semua warna di setiap aplikasi Windows, baik yang sadar warna maupun tidak, muncul secara akurat dan konsisten pada setiap tampilan yang didukung.

Catatan

Manajemen warna otomatis bukan properti perangkat keras tampilan; sebaliknya, ini adalah fitur Windows untuk mendukung tampilan dengan benar yang memiliki gamut warna yang lebih besar daripada sRGB.

Kedalaman presisi/bit yang mendalam

Presisi numerik, atau kedalaman bit, mengacu pada jumlah informasi yang digunakan untuk mengidentifikasi warna secara unik. Kedalaman bit yang lebih tinggi berarti Anda dapat membedakan antara warna yang sangat mirip tanpa artefak seperti pita. Tampilan PC mainstream mendukung 8 bit per saluran warna, sementara mata manusia membutuhkan setidaknya 10-12 bit presisi untuk menghindari distorsi yang dapat dirasakan.

Sebelum Warna Tingkat Lanjut, aplikasi berjendela terbatas Desktop Window Manager (DWM) untuk menghasilkan konten hanya pada 8 bit per saluran warna, bahkan jika tampilan mendukung kedalaman bit yang lebih tinggi. Ketika Warna Lanjutan diaktifkan, DWM melakukan komposisinya menggunakan titik mengambang setengah presisi IEEE (FP16), menghilangkan hambatan apa pun, dan memungkinkan presisi penuh tampilan untuk digunakan.

Arsitektur sistem Warna Tingkat Lanjut Windows

Info di bagian ini bersifat opsional untuk membangun aplikasi Warna Tingkat Lanjut; tetapi sangat membantu untuk memahami cara kerja teknologi untuk mengoptimalkan penyajian dan perilaku aplikasi Anda.

Di bagian ini, kita akan menggunakan diagram yang disederhanakan untuk menjelaskan komponen tumpukan grafis Windows yang relevan:

Windows yang ada: tampilan 8-bit / sRGB

Selama beberapa dekade, tampilan konsumen dan tumpukan grafis Windows didasarkan sekitar 8 bit per saluran (24 bit per piksel) konten sRGB. Aplikasi yang menggunakan API grafis seperti DirectX dapat melakukan penyajian internal menggunakan kedalaman bit tinggi dan ruang warna yang diperluas; namun, OS hanya mendukung bilangan bulat 8-bit dengan sRGB implisit dan tidak ada manajemen warna sistem:

Itu berarti bahwa data warna tambahan yang dirender oleh aplikasi akan hilang saat ditampilkan; dan bahwa aplikasi harus melakukan manajemen warna itu sendiri untuk memastikan reproduksi yang akurat pada layar.

Windows 10, versi 1703: HDR ditampilkan dengan Warna Tingkat Lanjut

Windows 10, versi 1703 memperkenalkan versi pertama kemampuan Warna Tingkat Lanjut untuk tampilan HDR. Itu membutuhkan beberapa kemajuan signifikan dalam tumpukan grafis OS:

• Dukungan sinyal tampilan HDR
• Komposisi sistem menggunakan ruang warna bit-depth tinggi dan kanonis
• Manajemen warna sistem otomatis

Setiap kemajuan tercakup dalam sub-bagian di bawah ini. Hasil bersihnya adalah bahwa data warna aplikasi yang diperluas sekarang dipertahankan dengan benar oleh OS, dan direproduksi secara akurat pada tampilan HDR.

Dukungan sinyal tampilan HDR

Sinyal HDR melalui konektor tampilan seperti DisplayPort dan HDMI terutama menggunakan 10 bit per presisi saluran (atau lebih besar) dan ruang warna BT.2100 ST.2084. Kernel tampilan, driver tampilan, dan perangkat keras GPU yang mendasar semuanya perlu mendukung deteksi, pemilihan, dan mengemudikan mode sinyal ini.

Komposisi sistem menggunakan ruang warna bit-depth tinggi dan kanonis

Ruang warna BT.2100 ST.2084 adalah standar yang efisien untuk mengodekan warna HDR, tetapi tidak cocok untuk banyak operasi penyajian dan komposisi (campuran). Kami juga ingin membuktikan OS di masa depan untuk mendukung teknologi dan ruang warna jauh di luar BT.2100, yang mencakup kurang dari 2/3 warna yang terlihat manusia. Terakhir, jika memungkinkan, kita ingin meminimalkan konsumsi sumber daya GPU untuk meningkatkan daya dan performa.

Saat dalam mode HDR, Desktop Window Manager (DWM) menggunakan ruang warna komposisi kanonis (CCCS) yang didefinisikan sebagai:

• ruang warna scRGB (BT.709/sRGB utama dengan gamma linier)
• Presisi setengah IEEE (kedalaman bit FP16)

Itu memberikan keseimbangan yang baik antara semua tujuan di atas. CCCS memungkinkan nilai warna di luar rentang numerik [0, 1]; mengingat rentang nilai FP16 yang valid, dapat mewakili urutan besarnya lebih banyak warna daripada rentang visual manusia alami, termasuk nilai luminance lebih dari 5 juta nits. FP16 memiliki presisi yang sangat baik untuk operasi campuran gamma linier, tetapi biaya setengah dari konsumsi memori GPU dan bandwidth presisi tunggal tradisional (FP32) tanpa kehilangan kualitas yang dapat dirasakan.

Manajemen warna sistem otomatis

Windows adalah lingkungan multitugas tempat pengguna dapat menjalankan sejumlah aplikasi SDR dan HDR secara bersamaan dengan jendela yang tumpang tindih. Oleh karena itu, sangat penting bahwa semua jenis konten terlihat benar dan pada kualitas maksimum saat output ke tampilan; misalnya, aplikasi produktivitas sRGB (SDR) dengan jendela video BT.2100 ST.2084 (HDR) yang diputar di atasnya.

Saat dalam mode HDR, Windows melakukan operasi manajemen warna dalam dua tahap:

1. DWM mengonversi setiap aplikasi dari ruang warna aslinya menjadi CCCS sebelum memadukan.
2. Kernel tampilan mengonversi framebuffer OS dari CCCS ke ruang warna format kawat (BT.2100 ST.2084).
   • Secara opsional, kernel tampilan bekerja dengan driver tampilan untuk melakukan kalibrasi warna tampilan tambahan; untuk informasi selengkapnya, lihat Alur kalibrasi warna tampilan perangkat keras Windows.

Catatan

Dalam kedua tahap, operasi manajemen warna terdiri dari konversi ruang warna (matriks dan 1DLUT). Warna yang melebihi gamut warna target tampilan diklip secara numerik.

Windows 11, versi 22H2: Tampilan SDR dengan Warna Tingkat Lanjut

Meskipun prevalensi tampilan HDR berkembang pesat, tampilan SDR akan tetap penting selama bertahun-tahun ke depan. Dukungan HDR di Windows 10, versi 1703 meletakkan sebagian besar dasar yang diperlukan untuk meningkatkan tampilan SDR juga. Windows 11, versi 22H2 memperluas kemampuan manajemen Warna Tingkat Lanjut dan warna otomatis ke tampilan SDR tertentu yang memenuhi syarat. Diagram blok grafis untuk tampilan SDR Warna Tingkat Lanjut terlihat sangat mirip dengan HDR:

Dukungan sinyal tampilan SDR dengan kedalaman bit tinggi

Sinyal yang mendasar untuk tampilan SDR tidak berubah, meskipun rilis Windows 11 versi 22H2 mendukung 10 bit per saluran dan lebih besar, tergantung pada kemampuan tampilan.

Komposisi sistem menggunakan ruang warna bit-depth tinggi dan kanonis

Fungsionalitas DWM Advanced Color termasuk perpaduan dalam CCCS hampir sepenuhnya tidak berubah dari tampilan HDR. Perbedaan utamanya adalah DWM menggunakan luminance yang dirujuk tampilan dengan tampilan SDR, dan luminasi yang dirujuk adegan dengan layar HDR. Ini mengubah cara konten yang dirender Warna Tingkat Lanjut Anda ditafsirkan oleh OS:

Jenis tampilan	Perilaku luminance	Bagaimana 1.0f ditafsirkan
SDR	Tampilan yang dirujuk	Sebagai tingkat putih referensi tampilan
HDR	Adegan yang dirujuk	Sebagai 80 nits (referensi nominal putih)

Manajemen warna sistem otomatis

Kemampuan manajemen warna sistem OS juga sebagian besar tidak berubah dari tampilan HDR. Perbedaan utamanya adalah bahwa kernel tampilan dikonversi ke ruang warna yang dirujuk tampilan seperti yang didefinisikan oleh data colorimetry dan kalibrasi tampilan, alih-alih ruang warna standar BT.2100 ST.2084 untuk tampilan HDR.

Provisi tampilan diperlukan

Data yang akurat dari profil ICC MHC diperlukan untuk menentukan operasi manajemen warna output kernel tampilan. Oleh karena itu, hanya tampilan SDR yang telah disediakan secara khusus oleh produsen atau penyedia kalibrasi tampilan dengan profil yang valid yang memenuhi syarat untuk manajemen warna otomatis. Lihat Perilaku profil ICC dengan Warna Tingkat Lanjut untuk informasi selengkapnya.

Persyaratan sistem dan dukungan sistem operasi

Windows 10, versi 1709 pertama kali mengirimkan dukungan Warna Tingkat Lanjut untuk tampilan HDR. Rilis Windows 11 versi 22H2 menambahkan dukungan Warna Tingkat Lanjut untuk tampilan SDR yang memiliki data provisi yang akurat.

Topik ini mengasumsikan bahwa aplikasi Anda menargetkan Windows 10, versi 2004 (atau yang lebih baru) untuk tampilan HDR, dan Rilis Windows 11 versi 22H2 (atau yang lebih baru) untuk tampilan SDR.

Tampilan

Tampilan rentang dinamis tinggi harus menerapkan HDR10, atau BT.2100 ST.2084, standar. Kualitas tampilan HDR dapat sangat bervariasi, dan kami sangat menyarankan tampilan yang disertifikasi, seperti VESA DisplayHDR. Dimulai dengan rilis Windows 11, versi 22H2, Windows menampilkan status sertifikasi tampilan yang diketahui di aplikasi Pengaturan.

Tampilan rentang dinamis standar harus memiliki data provisi warna yang akurat untuk dukungan Warna Tingkat Lanjut. Dalam rilis Windows 11 versi 22H2, satu-satunya metode yang didukung untuk mengambil alih data ini adalah melalui profil ICC MHC; selain itu, pengguna atau produsen tampilan harus mengaktifkan manajemen warna otomatis. Untuk informasi selengkapnya, lihat Perilaku profil ICC dengan Warna Tingkat Lanjut.

Prosesor grafis (GPU)

Untuk fungsionalitas Warna Tingkat Lanjut penuh pada tampilan SDR dan HDR, GPU terbaru diperlukan:

• AMD Radeon RX seri 400 (Polaris), atau yang lebih baru
• Seri NVIDIA GeForce 10 (Pascal), atau yang lebih baru
• Intel Core generasi ke-10 yang dipilih (Ice Lake), atau yang lebih baru*

Catatan

Chipset nama kode Intel Comet Lake (kode model 5 digit) tidak menyediakan fungsionalitas penuh.

Persyaratan perangkat keras tambahan mungkin berlaku, tergantung pada skenario, termasuk akselerasi codec perangkat keras (HEVC 10 bit, VP9 10 bit, dll.) dan dukungan PlayReady (SL3000). Hubungi vendor GPU Anda untuk informasi yang lebih spesifik.

Driver grafis (WDDM)

Driver grafis terbaru yang tersedia sangat disarankan, baik dari Windows Update atau dari vendor GPU atau situs web produsen PC. Topik ini bergantung pada fungsionalitas driver dari WDDM 2.7 (Windows 10, versi 2004) untuk tampilan HDR, dan WDDM 3.0 (Windows 11, versi 21H2) untuk tampilan SDR.

API penyajian yang didukung

Windows 10 mendukung berbagai API dan kerangka kerja penyajian. Dukungan warna tingkat lanjut pada dasarnya bergantung pada aplikasi Anda yang dapat melakukan presentasi modern menggunakan DXGI atau API Lapisan Visual.

• Infrastruktur Grafis DirectX (DXGI)
• Lapisan Visual (Windows.UI.Composition)

Oleh karena itu, API penyajian apa pun yang dapat menghasilkan salah satu metode presentasi tersebut dapat mendukung Warna Tingkat Lanjut. Itu termasuk (tetapi tidak terbatas pada) di bawah ini.

• Direct3D 11
• Direct3D 12
• Direct2D
• Win2D
  • Memerlukan penggunaan API CanvasSwapChain atau CanvasSwapChainPanel tingkat bawah.
• Windows.UI.Input.Inking
  • Mendukung penyajian tinta kering kustom menggunakan DirectX.
• XAML
  • Mendukung pemutaran video HDR menggunakan MediaPlayerElement.
  • Mendukung dekode gambar JPEG XR menggunakan elemen Gambar .
  • Mendukung interop DirectX menggunakan SwapChainPanel.

Menangani kemampuan tampilan dinamis

Windows 10 mendukung berbagai tampilan berkemampuan Advanced Color, dari panel terintegrasi yang hemat daya hingga monitor game kelas atas dan TV. Pengguna Windows mengharapkan bahwa aplikasi Anda akan menangani semua variasi tersebut dengan mulus, termasuk tampilan SDR yang ada di mana-mana.

Windows 10 menyediakan kontrol atas kemampuan HDR dan Warna Tingkat Lanjut kepada pengguna. Aplikasi Anda harus mendeteksi konfigurasi tampilan saat ini, dan merespons secara dinamis setiap perubahan kemampuan. Itu bisa terjadi karena banyak alasan, misalnya, karena pengguna mengaktifkan atau menonaktifkan fitur, atau memindahkan aplikasi di antara tampilan yang berbeda, atau status daya sistem berubah.

Opsi 1: AdvancedColorInfo

Catatan

AdvancedColorInfo Windows Runtime API dapat digunakan secara independen dari API rendering, mendukung Warna Lanjutan untuk tampilan SDR, dan menggunakan peristiwa untuk memberi sinyal ketika kemampuan berubah. Namun, aplikasi ini hanya tersedia untuk aplikasi Platform Windows Universal (UWP) ; aplikasi desktop (yang tidak memiliki CoreWindow) tidak dapat menggunakannya. Untuk informasi selengkapnya, lihat WINDOWS Runtime API yang tidak didukung di aplikasi desktop.

Pertama, dapatkan instans AdvancedColorInfo dari DisplayInformation::GetAdvancedColorInfo.

Untuk memeriksa jenis Warna Tingkat Lanjut apa yang saat ini aktif, gunakan properti AdvancedColorInfo::CurrentAdvancedColorKind. Itu adalah properti terpenting untuk diperiksa, dan Anda harus mengonfigurasi alur render dan presentasi Anda sebagai respons terhadap jenis aktif:

Jenis warna tingkat lanjut	Menampilkan kapabilitas
SDR	Tampilan SDR tanpa kemampuan Warna Tingkat Lanjut
WCG	Tampilan SDR dengan kedalaman bit tinggi dan manajemen warna otomatis
HDR	Layar HDR dengan semua kemampuan Warna Tingkat Lanjut

Untuk memeriksa jenis Warna Tingkat Lanjut apa yang didukung, tetapi belum tentu aktif, panggil AdvancedColorInfo::IsAdvancedColorKindAvailable. Anda dapat menggunakan informasi tersebut, misalnya, untuk meminta pengguna menavigasi ke aplikasi Windows Pengaturan sehingga mereka dapat mengaktifkan HDR atau manajemen warna otomatis.

Anggota AdvancedColorInfo lainnya memberikan informasi kuantitatif tentang volume warna fisik panel (luminance dan chrominance), sesuai dengan metadata HDR statis SMPTE ST.2086. Meskipun ST.2086 awalnya dirancang untuk tampilan HDR, info tersebut berguna, dan tersedia untuk tampilan HDR dan SDR. Anda harus menggunakan informasi tersebut untuk mengonfigurasi pemetaan nada aplikasi dan pemetaan gamut.

Untuk menangani perubahan dalam kemampuan Warna Tingkat Lanjut, daftar untuk peristiwa DisplayInformation::AdvancedColorInfoChanged. Peristiwa tersebut dimunculkan jika ada parameter kemampuan Warna Tingkat Lanjut tampilan berubah karena alasan apa pun.

Tangani peristiwa tersebut dengan mendapatkan instans baru AdvancedColorInfo, dan periksa nilai mana yang telah berubah.

IDXGIOutput6

Catatan

Antarmuka DirectX Graphics Infrastructure IDXGIOutput6 tersedia untuk aplikasi apa pun yang menggunakan DirectX, baik desktop maupun Platform Windows Universal (UWP). Namun, IDXGIOutput6 tidak mendukung tampilan SDR dengan kemampuan Warna Tingkat Lanjut seperti manajemen warna otomatis; idXGIOutput6hanya dapat mengidentifikasi tampilan HDR.

Jika Anda menulis aplikasi desktop Win32, dan menggunakan DirectX untuk merender, gunakan DXGI_OUTPUT_DESC1 untuk mendapatkan kemampuan tampilan. Dapatkan instans struktur tersebut melalui IDXGIOutput6::GetDesc1.

Untuk memeriksa jenis Warna Tingkat Lanjut yang saat ini aktif, gunakan properti ColorSpace , yang berjenis DXGI_COLOR_SPACE_TYPE, dan berisi salah satu nilai berikut:

DXGI_COLOR_SPACE_TYPE	Menampilkan kapabilitas
DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709	Tampilan SDR tanpa kemampuan Warna Tingkat Lanjut
DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020	Layar HDR dengan semua kemampuan Warna Tingkat Lanjut

Catatan

Tampilan SDR dengan kemampuan Warna Tingkat Lanjut juga dilaporkan sebagai DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709; DXGI tidak memungkinkan Anda membedakan antara kedua jenis tersebut.

Catatan

DXGI tidak memungkinkan Anda memeriksa jenis Warna Tingkat Lanjut apa yang didukung-tetapi-tidak-aktif saat ini.

Sebagian besar anggota lain DXGI_OUTPUT_DESC1 memberikan informasi kuantitatif tentang volume warna fisik panel (luminance dan krominasi), sesuai dengan metadata HDR statis SMPTE ST.2086. Meskipun ST.2086 awalnya dirancang untuk tampilan HDR, info tersebut berguna dan tersedia untuk tampilan HDR dan SDR. Anda harus menggunakan informasi tersebut untuk mengonfigurasi pemetaan nada aplikasi dan pemetaan gamut.

Aplikasi desktop Win32 tidak memiliki mekanisme asli untuk merespons perubahan kemampuan Warna Tingkat Lanjut. Sebagai gantinya, jika aplikasi Anda menggunakan perulangan render, maka Anda harus mengkueri IDXGIFactory1::IsCurrent dengan setiap bingkai. Jika melaporkan FALSE, maka Anda harus mendapatkan DXGI_OUTPUT_DESC1 baru, dan memeriksa nilai mana yang telah berubah.

Selain itu, pompa pesan Win32 Anda harus menangani pesan WM_SIZE , yang menunjukkan bahwa aplikasi Anda mungkin telah berpindah di antara tampilan yang berbeda.

Catatan

Untuk mendapatkan DXGI_OUTPUT_DESC1 baru, Anda harus mendapatkan tampilan saat ini. Namun, Anda tidak boleh memanggil IDXGISwapChain::GetContainingOutput. Itu karena rantai pertukaran mengembalikan output DXGI kedaluarsa setelah DXGIFactory::IsCurrent salah; dan membuat ulang rantai pertukaran untuk mendapatkan hasil output saat ini dalam layar hitam sementara. Sebagai gantinya, kami sarankan Anda menghitung melalui batas semua output DXGI, dan menentukan mana yang memiliki persimpangan terbesar dengan batas jendela aplikasi Anda.

Contoh kode berikut berasal dari aplikasi sampel Direct3D 12 HDR di GitHub.

// Retrieve the current default adapter.
ComPtr<IDXGIAdapter1> dxgiAdapter;
ThrowIfFailed(m_dxgiFactory->EnumAdapters1(0, &dxgiAdapter));

// Iterate through the DXGI outputs associated with the DXGI adapter,
// and find the output whose bounds have the greatest overlap with the
// app window (i.e. the output for which the intersection area is the
// greatest).

UINT i = 0;
ComPtr<IDXGIOutput> currentOutput;
ComPtr<IDXGIOutput> bestOutput;
float bestIntersectArea = -1;

while (dxgiAdapter->EnumOutputs(i, &currentOutput) != DXGI_ERROR_NOT_FOUND)
{
    // Get the retangle bounds of the app window
    int ax1 = m_windowBounds.left;
    int ay1 = m_windowBounds.top;
    int ax2 = m_windowBounds.right;
    int ay2 = m_windowBounds.bottom;

    // Get the rectangle bounds of current output
    DXGI_OUTPUT_DESC desc;
    ThrowIfFailed(currentOutput->GetDesc(&desc));
    RECT r = desc.DesktopCoordinates;
    int bx1 = r.left;
    int by1 = r.top;
    int bx2 = r.right;
    int by2 = r.bottom;

    // Compute the intersection
    int intersectArea = ComputeIntersectionArea(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2);
    if (intersectArea > bestIntersectArea)
    {
        bestOutput = currentOutput;
        bestIntersectArea = static_cast<float>(intersectArea);
    }

    i++;
}

// Having determined the output (display) upon which the app is primarily being 
// rendered, retrieve the HDR capabilities of that display by checking the color space.
ComPtr<IDXGIOutput6> output6;
ThrowIfFailed(bestOutput.As(&output6));

DXGI_OUTPUT_DESC1 desc1;
ThrowIfFailed(output6->GetDesc1(&desc1));

Menyiapkan rantai pertukaran DirectX Anda

Setelah Anda menentukan bahwa tampilan saat ini mendukung kemampuan Warna Tingkat Lanjut, konfigurasikan rantai pertukaran Anda sebagai berikut.

Menggunakan efek model presentasi balik

Saat membuat rantai pertukaran Anda menggunakan salah satu CreateSwapChainFor[Hwnd|Komposisi|Metode CoreWindow] , Anda harus menggunakan model flip DXGI dengan memilih opsi DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL atau DXGI_SWAP_EFFECT_FLIP_DISCARD , yang membuat rantai pertukaran Anda memenuhi syarat untuk pemrosesan Warna Tingkat Lanjut dari DWM dan berbagai pengoptimalan layar penuh. Untuk informasi selengkapnya, lihat Untuk performa terbaik, gunakan model balik DXGI.

Opsi 1. Gunakan format piksel FP16 dan ruang warna scRGB

Windows 10 mendukung dua kombinasi utama format piksel dan ruang warna untuk Warna Tingkat Lanjut. Pilih salah satu berdasarkan persyaratan spesifik aplikasi Anda.

Sebaiknya aplikasi tujuan umum menggunakan Opsi 1. Ini adalah satu-satunya opsi yang berfungsi untuk semua jenis tampilan Warna Tingkat Lanjut, konten, dan API penyajian. Saat membuat rantai pertukaran Anda, tentukan DXGI_FORMAT_R16G16B16A16_FLOAT di DXGI_SWAP_CHAIN_DESC1 Anda. Secara default, rantai pertukaran yang dibuat dengan format piksel floating point diperlakukan seolah-olah menggunakan ruang warna DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709 . Itu adalah format piksel dan ruang warna yang sama yang digunakan oleh DWM.

Kombinasi itu memberi Anda rentang numerik dan presisi untuk menentukan warna yang mungkin secara fisik, dan melakukan pemrosesan segan-segan termasuk pencampukan.

Namun, opsi itu menggunakan 64 bit per piksel, yang menggandakan bandwidth GPU dan konsumsi memori dibandingkan dengan format piksel UINT8 tradisional. Selain itu, scRGB menggunakan nilai numerik yang berada di luar rentang [0, 1] yang dinormalisasi untuk mewakili warna yang berada di luar gamut sRGB dan/atau lebih besar dari 80 nit luminance. Misalnya, scRGB (1.0, 1.0, 1.0) mengodekan D65 putih standar pada 80 nits; tetapi scRGB (12.5, 12.5, 12.5) mengodekan D65 putih yang sama pada 1000 nit yang jauh lebih cerah. Beberapa operasi grafis memerlukan rentang numerik yang dinormalisasi, dan Anda harus mengubah operasi, atau menormalkan ulang nilai warna.

Cara nilai luminance ditafsirkan dengan opsi tersebut berbeda antara tampilan SDR dan HDR; lihat di bawah ini.

Opsi 2: Gunakan format piksel UINT10/RGB10 dan ruang warna HDR10/BT.2100

Opsi 2 adalah pengoptimalan performa yang hanya tersedia jika aplikasi Anda memenuhi semua kondisi berikut:

• Menargetkan tampilan HDR
• Menggunakan Direct3D 12 atau Direct3D 11
• Rantai pertukaran tidak memerlukan perpaduan dengan alfa/transparansi

Jika aplikasi Anda tidak memenuhi semua kondisi tersebut, Maka Anda harus menggunakan Opsi 1.

Tetapi jika aplikasi Anda memenuhi syarat untuk opsi 2, maka itu mungkin memberikan performa yang lebih baik jika aplikasi Anda menggunakan konten yang dikodekan HDR10, seperti pemutar video, atau jika terutama akan digunakan dalam skenario layar penuh, seperti permainan. Saat membuat rantai pertukaran , Anda harus mempertimbangkan untuk menentukan DXGI_FORMAT_R10G10B10A2_UNORM di DXGI_SWAP_CHAIN_DESC1. Secara default, itu diperlakukan sebagai menggunakan ruang warna sRGB; oleh karena itu, Anda harus secara eksplisit memanggil IDXGISwapChain3::SetColorSpace1, dan ditetapkan sebagai ruang warna Anda DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020, juga dikenal sebagai HDR10/BT.2100.

Opsi ini menggunakan 32 bit per piksel yang sama dengan format piksel SDR UINT8 tradisional. Selain itu, pada GPU tertentu ini menghilangkan beberapa pemrosesan yang diperlukan untuk mengonversi konten ke format kawat HDR10.

Menggunakan rantai pertukaran Warna Tingkat Lanjut saat tampilan dalam mode SDR

Anda dapat menggunakan rantai pertukaran Warna Tingkat Lanjut meskipun tampilan tidak mendukung semua kemampuan Warna Tingkat Lanjut. Dalam kasus tersebut, Desktop Window Manager (DWM) akan menurunkankonversi konten Anda agar sesuai dengan kemampuan tampilan dengan melakukan kliping numerik. Misalnya, jika Anda merender ke rantai pertukaran FP16 scRGB, dan menargetkan tampilan standar, maka semuanya di luar rentang numerik [0, 1] diklip.

Perilaku downconversion tersebut juga akan terjadi jika jendela aplikasi Anda mengangsur dua tampilan atau lebih dengan kemampuan Warna Tingkat Lanjut yang berbeda. AdvancedColorInfo dan IDXGIOutput6 diabstraksi untuk hanya melaporkan karakteristik tampilan utama (utama didefinisikan sebagai tampilan yang berisi bagian tengah jendela).

Cocokkan referensi aplikasi Anda dengan tingkat putih referensi OS SDR

Catatan

Referensi putih hanya berlaku untuk tampilan HDR; untuk tampilan Warna Tingkat Lanjut SDR, (1.0, 1.0, 1.0) selalu berarti luminance putih maksimum yang dapat direproduksi oleh layar.

Dalam banyak skenario, aplikasi Anda akan ingin merender konten SDR dan HDR; misalnya, merender subtitel atau kontrol transportasi melalui video HDR, atau UI ke dalam adegan game. Penting untuk memahami konsep tingkat putih referensi SDR untuk memastikan bahwa konten SDR Anda terlihat benar pada tampilan HDR. Putih referensi menunjukkan kecerahan di mana objek putih difus (seperti lembar kertas, atau kadang-kadang UI) muncul dalam adegan HDR. Karena nilai warna HDR memiliki kecerahan yang dirujuk adegan, nilai warna tertentu harus ditampilkan pada tingkat luminance absolut, dan tidak relatif terhadap nilai panel maksimum yang mungkin. Misalnya, scRGB (1.0, 1.0, 1.0) dan HDR10 (497, 497, 497) keduanya mengodekan tepat D65 putih pada luminance 80 nit. Windows memungkinkan pengguna untuk menyesuaikan tingkat putih referensi SDR dengan preferensi mereka; itulah luminansi bahwa Windows akan merender sRGB (1.0, 1.0, 1.0) di. Pada monitor HDR desktop, tingkat putih referensi SDR biasanya diatur ke sekitar 200 nit.

Aplikasi HDR Anda harus memungkinkan pengguna mengatur tingkat putih referensi yang diinginkan, atau membaca nilai yang dikonfigurasi oleh sistem. Anda harus memetakan nilai warna putih difus di adegan Anda ke tingkat putih referensi SDR. Yang memerlukan perkalian framebuffer aplikasi Anda di ruang gamma linier.

Catatan

Pada layar yang mendukung kontrol kecerahan, seperti pada laptop, Windows juga menyesuaikan luminance konten HDR (scene-referred) agar sesuai dengan tingkat kecerahan yang diinginkan pengguna, tetapi tidak terlihat oleh aplikasi. Kecuali Anda mencoba menjamin reproduksi sinyal HDR yang akurat bit, Anda umumnya dapat mengabaikannya.

Jika aplikasi Anda selalu merender SDR dan HDR ke permukaan terpisah, dan bergantung pada komposisi OS, maka Windows akan secara otomatis melakukan penyesuaian yang benar untuk meningkatkan konten SDR ke tingkat putih yang diinginkan. Misalnya, jika aplikasi Anda menggunakan XAML, dan merender konten HDR ke SwapChainPanel sendiri.

Namun, jika aplikasi Anda melakukan komposisi konten SDR dan HDR sendiri ke dalam satu permukaan, maka Anda bertanggung jawab untuk melakukan penyesuaian tingkat putih referensi SDR sendiri. Jika tidak, konten SDR mungkin muncul terlalu redup di bawah kondisi tampilan desktop biasa. Pertama, Anda harus mendapatkan tingkat putih referensi SDR saat ini, lalu Anda harus menyesuaikan nilai warna konten SDR apa pun yang Anda render.

Langkah 1. Mendapatkan tingkat putih referensi SDR saat ini

Anda dapat memperoleh tingkat putih referensi SDR saat ini dengan salah satu cara berikut:

• Di aplikasi desktop. DISPLAYCONFIG_SDR_WHITE_LEVEL dan QueryDisplayConfig.
• Di aplikasi UWP. AdvancedColorInfo.SdrWhiteLevelInNits (menggunakan CoreWindow).

Langkah 2. Menyesuaikan nilai warna konten SDR

Windows mendefinisikan nominal, atau default, mereferensikan tingkat putih pada 80 nits. Oleh karena itu, jika Anda merender sRGB standar (1.0, 1.0, 1.0) putih ke rantai pertukaran FP16, maka akan direproduksi pada luminance 80 nit. Untuk mencocokkan tingkat putih referensi yang ditentukan pengguna yang sebenarnya, Anda harus menyesuaikan konten SDR dari 80 nits ke tingkat yang ditentukan melalui AdvancedColorInfo.SdrWhiteLevelInNits.

Jika Anda merender menggunakan FP16 dan scRGB, atau ruang warna apa pun yang menggunakan gamma linier (1.0), maka Anda cukup mengalikan nilai warna SDR dengan AdvancedColorInfo.SdrWhiteLevelInNits / 80. Jika Anda menggunakan Direct2D, maka ada D2D1_SCENE_REFERRED_SDR_WHITE_LEVEL konstanta yang telah ditentukan sebelumnya, yang memiliki nilai 80.

D2D1_VECTOR_4F inputColor; // Input SDR color value.
D2D1_VECTOR_4F outputColor; // Output color adjusted for SDR white level.
auto acInfo = ...; // Obtain an AdvancedColorInfo.

float sdrAdjust = acInfo->SdrWhiteLevelInNits / D2D1_SCENE_REFERRED_SDR_WHITE_LEVEL;

// Normally in DirectX, color values are manipulated in shaders on GPU textures.
// This example performs scaling on a CPU color value.
outputColor.r = inputColor.r * sdrAdjust; // Assumes linear gamma color values.
outputColor.g = inputColor.g * sdrAdjust;
outputColor.b = inputColor.b * sdrAdjust;
outputColor.a = inputColor.a;

Jika Anda merender menggunakan ruang warna gamma nonlinear seperti HDR10, maka melakukan penyesuaian tingkat putih SDR lebih kompleks. Jika Anda menulis shader piksel Anda sendiri, pertimbangkan untuk mengonversi menjadi gamma linier untuk menerapkan penyesuaian.

Mengadaptasi konten HDR ke kemampuan tampilan menggunakan pemetaan nada

Tampilan HDR dan Warna Tingkat Lanjut sangat bervariasi dalam hal kemampuannya. Misalnya, dalam luminance minimum dan maksimum dan gamut warna yang mampu mereka reproduksi. Dalam banyak kasus, konten HDR Anda akan berisi warna yang melebihi kemampuan tampilan. Untuk kualitas gambar terbaik, penting bagi Anda untuk melakukan pemetaan nada HDR, pada dasarnya mengompresi rentang warna agar sesuai dengan tampilan sambil menjaga niat visual konten dengan sebaik-baiknya.

Parameter tunggal yang paling penting untuk diadaptasi adalah luminance maks, juga dikenal sebagai MaxCLL (tingkat cahaya konten); pemeta nada yang lebih canggih juga akan menyesuaikan min luminance (MinCLL) dan/atau warna utama.

Langkah 1. Mendapatkan kemampuan volume warna tampilan

aplikasi Platform Windows Universal (UWP)

Gunakan AdvancedColorInfo untuk mendapatkan volume warna tampilan.

Aplikasi DirectX Win32 (desktop)

Gunakan DXGI_OUTPUT_DESC1 untuk mendapatkan volume warna tampilan.

Langkah 2. Mendapatkan informasi volume warna konten

Tergantung dari mana konten HDR Anda berasal, ada beberapa cara potensial untuk menentukan luminasi dan informasi gamut warnanya. File video dan gambar HDR tertentu berisi metadata SMPTE ST.2086. Jika konten Anda dirender secara dinamis, maka Anda mungkin dapat mengekstrak informasi adegan dari tahap penyajian internal—misalnya, sumber cahaya paling terang dalam adegan.

Solusi yang lebih umum tetapi mahal secara komputasi adalah menjalankan histogram atau analisis lain yang diteruskan pada bingkai yang dirender. Aplikasi sampel penyajian gambar warna tingkat lanjut Direct2D di GitHub menunjukkan cara melakukannya menggunakan Direct2D; cuplikan kode yang paling relevan disertakan di bawah ini:

// Perform histogram pipeline setup; this should occur as part of image resource creation.
// Histogram results in no visual output but is used to calculate HDR metadata for the image.
void D2DAdvancedColorImagesRenderer::CreateHistogramResources()
{
    auto context = m_deviceResources->GetD2DDeviceContext();

    // We need to preprocess the image data before running the histogram.
    // 1. Spatial downscale to reduce the amount of processing needed.
    DX::ThrowIfFailed(
        context->CreateEffect(CLSID_D2D1Scale, &m_histogramPrescale)
        );

    DX::ThrowIfFailed(
        m_histogramPrescale->SetValue(D2D1_SCALE_PROP_SCALE, D2D1::Vector2F(0.5f, 0.5f))
        );

    // The right place to compute HDR metadata is after color management to the
    // image's native colorspace but before any tonemapping or adjustments for the display.
    m_histogramPrescale->SetInputEffect(0, m_colorManagementEffect.Get());

    // 2. Convert scRGB data into luminance (nits).
    // 3. Normalize color values. Histogram operates on [0-1] numeric range,
    //    while FP16 can go up to 65504 (5+ million nits).
    // Both steps are performed in the same color matrix.
    ComPtr<ID2D1Effect> histogramMatrix;
    DX::ThrowIfFailed(
        context->CreateEffect(CLSID_D2D1ColorMatrix, &histogramMatrix)
        );

    histogramMatrix->SetInputEffect(0, m_histogramPrescale.Get());

    float scale = sc_histMaxNits / sc_nominalRefWhite;

    D2D1_MATRIX_5X4_F rgbtoYnorm = D2D1::Matrix5x4F(
        0.2126f / scale, 0, 0, 0,
        0.7152f / scale, 0, 0, 0,
        0.0722f / scale, 0, 0, 0,
        0              , 0, 0, 1,
        0              , 0, 0, 0);
    // 1st column: [R] output, contains normalized Y (CIEXYZ).
    // 2nd column: [G] output, unused.
    // 3rd column: [B] output, unused.
    // 4th column: [A] output, alpha passthrough.
    // We explicitly calculate Y; this deviates from the CEA 861.3 definition of MaxCLL
    // which approximates luminance with max(R, G, B).

    DX::ThrowIfFailed(histogramMatrix->SetValue(D2D1_COLORMATRIX_PROP_COLOR_MATRIX, rgbtoYnorm));

    // 4. Apply a gamma to allocate more histogram bins to lower luminance levels.
    ComPtr<ID2D1Effect> histogramGamma;
    DX::ThrowIfFailed(
        context->CreateEffect(CLSID_D2D1GammaTransfer, &histogramGamma)
        );

    histogramGamma->SetInputEffect(0, histogramMatrix.Get());

    // Gamma function offers an acceptable tradeoff between simplicity and efficient bin allocation.
    // A more sophisticated pipeline would use a more perceptually linear function than gamma.
    DX::ThrowIfFailed(histogramGamma->SetValue(D2D1_GAMMATRANSFER_PROP_RED_EXPONENT, sc_histGamma));
    // All other channels are passthrough.
    DX::ThrowIfFailed(histogramGamma->SetValue(D2D1_GAMMATRANSFER_PROP_GREEN_DISABLE, TRUE));
    DX::ThrowIfFailed(histogramGamma->SetValue(D2D1_GAMMATRANSFER_PROP_BLUE_DISABLE, TRUE));
    DX::ThrowIfFailed(histogramGamma->SetValue(D2D1_GAMMATRANSFER_PROP_ALPHA_DISABLE, TRUE));

    // 5. Finally, the histogram itself.
    HRESULT hr = context->CreateEffect(CLSID_D2D1Histogram, &m_histogramEffect);
    
    if (hr == D2DERR_INSUFFICIENT_DEVICE_CAPABILITIES)
    {
        // The GPU doesn't support compute shaders and we can't run histogram on it.
        m_isComputeSupported = false;
    }
    else
    {
        DX::ThrowIfFailed(hr);
        m_isComputeSupported = true;

        DX::ThrowIfFailed(m_histogramEffect->SetValue(D2D1_HISTOGRAM_PROP_NUM_BINS, sc_histNumBins));

        m_histogramEffect->SetInputEffect(0, histogramGamma.Get());
    }
}

// Uses a histogram to compute a modified version of MaxCLL (ST.2086 max content light level).
// Performs Begin/EndDraw on the D2D context.
void D2DAdvancedColorImagesRenderer::ComputeHdrMetadata()
{
    // Initialize with a sentinel value.
    m_maxCLL = -1.0f;

    // MaxCLL is not meaningful for SDR or WCG images.
    if ((!m_isComputeSupported) ||
        (m_imageInfo.imageKind != AdvancedColorKind::HighDynamicRange))
    {
        return;
    }

    // MaxCLL is nominally calculated for the single brightest pixel in a frame.
    // But we take a slightly more conservative definition that takes the 99.99th percentile
    // to account for extreme outliers in the image.
    float maxCLLPercent = 0.9999f;

    auto ctx = m_deviceResources->GetD2DDeviceContext();

    ctx->BeginDraw();

    ctx->DrawImage(m_histogramEffect.Get());

    // We ignore D2DERR_RECREATE_TARGET here. This error indicates that the device
    // is lost. It will be handled during the next call to Present.
    HRESULT hr = ctx->EndDraw();
    if (hr != D2DERR_RECREATE_TARGET)
    {
        DX::ThrowIfFailed(hr);
    }

    float *histogramData = new float[sc_histNumBins];
    DX::ThrowIfFailed(
        m_histogramEffect->GetValue(D2D1_HISTOGRAM_PROP_HISTOGRAM_OUTPUT,
            reinterpret_cast<BYTE*>(histogramData),
            sc_histNumBins * sizeof(float)
            )
        );

    unsigned int maxCLLbin = 0;
    float runningSum = 0.0f; // Cumulative sum of values in histogram is 1.0.
    for (int i = sc_histNumBins - 1; i >= 0; i--)
    {
        runningSum += histogramData[i];
        maxCLLbin = i;

        if (runningSum >= 1.0f - maxCLLPercent)
        {
            break;
        }
    }

    float binNorm = static_cast<float>(maxCLLbin) / static_cast<float>(sc_histNumBins);
    m_maxCLL = powf(binNorm, 1 / sc_histGamma) * sc_histMaxNits;

    // Some drivers have a bug where histogram will always return 0. Treat this as unknown.
    m_maxCLL = (m_maxCLL == 0.0f) ? -1.0f : m_maxCLL;
}

Langkah 3. Melakukan operasi tonemapping HDR

Tonemapping secara inheren merupakan proses lossy, dan dapat dioptimalkan untuk sejumlah metrik persepsi atau objektif, sehingga tidak ada algoritma standar tunggal. Windows menyediakan efek tonemapper HDR bawaan sebagai bagian dari Direct2D serta dalam alur pemutaran video HDR Media Foundation. Beberapa algoritma lain yang umum digunakan termasuk ACES Filmic, Reinhard, dan ITU-R BT.2390-3 EETF (fungsi transfer listrik-listrik).

Operator reinhard tonemapper yang disederhanakan ditampilkan dalam contoh kode berikutnya ini.

// This example uses C++. A typical DirectX implementation would port this to HLSL.
D2D1_VECTOR_4F simpleReinhardTonemapper(
    float inputMax, // Content's maximum luminance in scRGB values, e.g. 1.0 = 80 nits.
    float outputMax, // Display's maximum luminance in scRGB values, e.g. 1.0 = 80 nits.
    D2D1_VECTOR_4F input // scRGB color.
)
{
    D2D1_VECTOR_4F output = input;

    // Vanilla Reinhard normalizes color values to [0, 1].
    // This modification scales to the luminance range of the display.
    output.r /= inputMax;
    output.g /= inputMax;
    output.b /= inputMax;

    output.r = output.r / (1 + output.r);
    output.g = output.g / (1 + output.g);
    output.b = output.b / (1 + output.b);

    output.r *= outputMax;
    output.g *= outputMax;
    output.b *= outputMax;

    return output;
}

Menangkap konten layar HDR dan WCG

API yang mendukung penentuan format piksel, seperti yang ada di namespace Layanan Windows.Graphics.Capture, dan metode IDXGIOutput5::D uplicateOutput1, menyediakan kemampuan untuk mengambil konten HDR dan WCG tanpa kehilangan informasi piksel. Perhatikan bahwa setelah memperoleh bingkai konten, diperlukan pemrosesan tambahan. Misalnya, pemetaan nada HDR-ke-SDR (misalnya, salinan cuplikan layar SDR untuk berbagi internet) dan penyimpanan konten dengan format yang tepat (misalnya, JPEG XR).

Perubahan pada manajemen warna warisan dan perilaku profil ICC

Manajemen warna dan warna otomatis tingkat lanjut memastikan warna tampilan yang konsisten dan akurat secara warna untuk semua aplikasi, warisan, dan modern. Namun, beberapa aplikasi dapat melakukan manajemen warna eksplisit mereka sendiri menggunakan profil warna International Color Consortium (ICC).

Saat Warna Tingkat Lanjut aktif pada tampilan SDR atau HDR, perilaku profil ICC tampilan berubah dalam cara yang kompatibel secara non-mundur. Jika aplikasi Anda berfungsi dengan profil ICC tampilan, Windows menawarkan pembantu kompatibilitas untuk memastikan aplikasi Anda terus mendapatkan perilaku yang benar.

Info selengkapnya tentang perubahan perilaku profil ICC dan bagaimana Anda dapat menyesuaikan aplikasi untuk memaksimalkan kompatibilitas dengan Warna Lanjutan, lihat perilaku profil ICC dengan Warna Tingkat Lanjut.

Sumber Daya Tambahan:

• Di GitHub, Menggunakan HdR Rendering dengan DirectX Tool Kit untuk DirectX 11 / DirectX 12. Panduan cara menambahkan dukungan HDR ke aplikasi DirectX menggunakan DirectX Tool Kit (DirectXTK).
• Aplikasi sampel penyajian gambar warna tingkat lanjut Direct2D. Aplikasi sampel UWP SDK yang mengimplementasikan penampil gambar HDR dan WCG sadar Warna Tingkat Lanjut menggunakan Direct2D. Menunjukkan berbagai praktik terbaik untuk aplikasi UWP, termasuk merespons perubahan kemampuan tampilan dan menyesuaikan untuk tingkat putih SDR.
• Aplikasi sampel desktop Direct3D 12 HDR. Sampel SDK desktop yang mengimplementasikan adegan HDR Direct3D 12 dasar.
• Aplikasi sampel Direct3D 12 HDR UWP. UWP setara dengan sampel di atas.
• SimpleHDR_PC. Aplikasi sampel PC Xbox ATG SimpleHDR (aplikasi sampel desktop) yang mengimplementasikan adegan HDR Direct3D 11 dasar.