Yüksek/standart dinamik aralıklı ekranlarda Gelişmiş Renk ile DirectX kullanma

Bu konuda, yüksek dinamik aralık (HDR), otomatik sistem renk yönetimine sahip geniş renk gamı (WCG) ve yüksek bit derinliği gibi Gelişmiş Renk senaryolarıyla DirectX'in nasıl kullanılacağı gösterilmektedir. Yukarıdaki iyileştirmelerden en az birine sahip premium kişisel bilgisayar (PC) monitörler yaygınlaşarak geleneksel standart dinamik aralık (SDR) ekranlara göre önemli ölçüde daha yüksek renk doğruluğu sağlar.

Bu konu başlığında, Windows Gelişmiş Renk desteğinin arkasındaki temel teknik kavramlara genel bir bakış elde edersiniz. HDR, WCG ve yüksek bit derinliğindeki DirectX içeriğini bu ekranlardan birinde işlemeye yönelik gereksinimleri ve yönergeleri öğreneceksiniz. Renkle yönetilen bir uygulamanız varsa (örneğin, ICC profillerini kullanarak), otomatik renk yönetiminin senaryolarınız için daha iyi renk doğruluğuna nasıl olanak sağladığını öğreneceksiniz.

Windows'ta Gelişmiş Renge Giriş

Gelişmiş Renk, standart ekranlara göre önemli ölçüde daha yüksek renk doğruluğuna sahip ekranlar için işletim sistemi (OS) teknolojilerinin bir şemsiye terimidir. Öne çıkan genişletilmiş yetenekler aşağıdaki bölümlerde açıklanmıştır. Gelişmiş Renk özellikleri ilk olarak Windows 10, sürüm 1709 (Fall Creators Update) ile HDR ekranlar için ve özel olarak yapılandırılmış SDR ekranlar için Windows 11, sürüm 22H2 (10.0; Derleme 22621) sürümünde tanıtıldı.

Yüksek dinamik aralık

Dinamik aralık, bir sahnedeki maksimum ve minimum parlaklık arasındaki farkı ifade eder; bu genellikle nit cinsinden ölçülür (santimetre kare başına candelas). Bu gün batımı gibi gerçek dünya sahneleri genellikle 10 parlaklık büyüklüğüne sahip dinamik aralıklara sahiptir; insan gözü, adaptasyondan sonra daha da geniş bir aralığı ayırt edebilir.

olarak etiketlenmiş.

Direct3D 9'dan bu yana grafik altyapıları bu fiziksel doğruluk düzeyiyle sahnelerini dahili olarak işleyebildi. Ancak, tipik bir standart dinamik aralık ekranı, parlaklık seviyelerinde yalnızca biraz daha fazla 3 mertebe üretebilir ve bu nedenle HDR ile işlenmiş içeriğin sınırlı ekran aralığına ton eşleştirmesi (sıkıştırılması) gerekir. HDR10 (BT.2100) standardına uyanlar da dahil olmak üzere yeni HDR ekranlar bu sınırlamayı aşıyor; örneğin, yüksek kaliteli kendi ışığını yayabilen ekranlar 6 büyüklük derecesinden fazla bir başarıya ulaşabiliyor.

Geniş renk gamı

Renk gamı, bir ekranın yeniden üretebileceği tonların aralığını ve doygunluğunu ifade eder. İnsan gözünün algıladığı en doygun doğal renkler, lazerler tarafından üretilen gibi saf, tek renkli ışıklardan oluşur. Ancak, temel tüketici ekranları genellikle renkleri yalnızca sRGB gamut içinde yeniden üretebilir ve bu da insan tarafından algılanabilir tüm renklerin yalnızca 35% temsil eder. Aşağıdaki diyagram, insan "spektral locus" veya tüm algılanabilir renklerin (belirli bir parlaklık düzeyinde) bir gösterimidir ve burada küçük üçgen sRGB gamutudur.

İnsan spektral lokusu ve sRGB gamutu diyagramı

Yüksek uçlu, profesyonel bilgisayar ekranları Adobe RGB ve DCI-P3 gibi insan tarafından algılanabilir renklerin yaklaşık yarısını kapsayan sRGB'den önemli ölçüde daha geniş olan, uzun zamandır desteklenen renk gamlarına sahiptir. Ve bu geniş gamut ekranlar daha yaygın hale geliyor.

Otomatik sistem renk yönetimi

Renk yönetimi, cihazlar arasında doğru ve tutarlı renk üretimi sağlama teknolojisi ve uygulamasıdır. Dijital içerik oluşturucuysanız, görsel içeriğinizdeki renkler (fotoğraf, ürün resmi veya logo gibi) izleyicilerinizin çok çeşitli dijital cihazlarında olduğu gibi ekranınızda da aynı şekilde görünmesi çok önemlidir.

Windows, Windows 2000'den bu yana Görüntü Rengi Yönetimi (ICM) ve sonraki Windows Renk Sistemi (WCS) API'leri ile renk yönetimi desteği API'leri sağlamıştır. Ancak bu API'ler yalnızca renk yönetimi yapmak isteyen/gereken uygulamalar için yardımcıydı; çoğu uygulama ve dijital içerik yalnızca endüstri standardı sRGB renk alanını varsayıyordu ve hiçbir zaman işletim sistemi tarafından renkle yönetilmedi. Bu geçmişte makul bir varsayımdı, ancak yüksek kaliteli geniş gamut ekranlar çok daha yaygın hale geliyor.

Windows'un yeni sürümleri otomatik sistem renk yönetimini destekler; bu, renk farkında olsun veya olmasın, her Windows uygulamasındaki tüm renklerin desteklenen her ekranda doğru ve tutarlı bir şekilde görünmesini sağlar.

Derin hassasiyet/bit derinliği

Sayısal duyarlık veya bit derinliği, renkleri benzersiz olarak tanımlamak için kullanılan bilgi miktarını ifade eder. Daha yüksek bit derinliği, bant oluşturma gibi yapıtlar olmadan çok benzer renkleri ayırt edebilirsiniz anlamına gelir. Ana bilgisayar ekranları renk kanalı başına 8 biti desteklerken, algılanabilir bozulmaları önlemek için insan gözü için en az 10-12 bit hassasiyet gerekir.

Gelişmiş Renk'in öncesinde Masaüstü Pencere Yöneticisi (DWM), ekran daha yüksek bit derinliğini desteklese bile pencerelenmiş uygulamaları renk kanalı başına yalnızca 8 bit içerik çıkışıyla kısıtladı. Gelişmiş Renk etkinleştirildiğinde, DWM bileşimini IEEE yarı hassasiyetli kayan nokta (FP16) kullanarak gerçekleştirir, böylece herhangi bir darboğazı ortadan kaldırır ve ekranın tüm duyarlığını kullanmaya olanak tanır.

Windows Gelişmiş Renk sistemi mimarisi

Bu bölümdeki bilgiler Gelişmiş Renk uygulamaları oluşturmak için isteğe bağlıdır; ancak uygulamanızın işlemesini ve davranışını iyileştirmek için teknolojinin nasıl çalıştığını anlamak yararlı olur.

Bu bölümde, Windows grafik yığınının ilgili bileşenlerini açıklamak için basitleştirilmiş bir diyagram kullanacağız:

Windows grafik yığınının görüntülemek için DWM'ye uygulama

Mevcut Windows: 8 bit / sRGB ekranlar

Onlarca yıldır tüketici ekranları ve Windows grafik yığını kanal başına yaklaşık 8 bit (piksel başına 24 bit) sRGB içeriğine dayanıyordu. DirectX gibi grafik API'leri kullanan uygulamalar, yüksek bit derinlikleri ve genişletilmiş renk alanları kullanarak iç işleme gerçekleştirebilir; ancak işletim sistemi örtük sRGB ile yalnızca 8 bitlik tamsayıyı destekler ve sistem renk yönetimi yoktur:

SDR görüntü yığınının olmadan sRGB, 8 bit ile sınırlıdır

Bu, bir uygulama tarafından işlenen ek renk verilerinin görüntülendiğinde kaybolacağı anlamına geliyordu; ve bir ekranda doğru çoğaltma sağlamak için uygulamanın renk yönetimi gerçekleştirmesi gerekiyordu.

Windows 10, sürüm 1703: Gelişmiş Renkli HDR ekranlar

Windows 10, sürüm 1703, HDR ekranlar için Gelişmiş Renk özelliklerinin ilk sürümünü tanıttı. Bu, işletim sistemi grafik yığınında birkaç önemli ilerleme gerektiriyor:

• HDR ekran sinyal desteği
• Yüksek bit derinliği, kurallı renk alanı kullanan sistem bileşimi
• Otomatik sistem renk yönetimi

HDR ekran yığınının

Her ilerleme aşağıdaki alt bölümlerde ele alınmıştır. Net sonuç, genişletilmiş uygulama renk verilerinin artık işletim sistemi tarafından doğru bir şekilde korunması ve HDR ekranlarda doğru şekilde yeniden üretiliyor olmasıdır.

HDR ekran sinyal desteği

DisplayPort ve HDMI gibi ekran bağlayıcıları üzerinden HDR sinyali, öncelikli olarak kanal duyarlığı (veya üstü) başına 10 bit ve BT.2100 ST.2084 renk alanını kullanır. Ekran çekirdeği, görüntü sürücüsü ve temel gpu donanımlarının tümünün bu sinyal modunu algılamayı, seçmeyi ve yönlendirmeyi desteklemesi gerekir.

Yüksek bit derinliği, kurallı renk alanı kullanan sistem bileşimi

BT.2100 ST.2084 renk alanı HDR renkleri kodlamak için verimli bir standarttır, ancak birçok işleme ve oluşturma (karıştırma) işlemi için uygun değildir. Ayrıca, bt.2100'ün ötesindeki teknolojileri ve renk alanlarını desteklemek için işletim sisteminin gelecekte kanıtlanmasını istiyoruz. Bu, insan tarafından görülebilen renklerin 2/3'ünden azını kapsar. Son olarak, mümkün olduğunca güç ve performansı geliştirmek için GPU kaynak tüketimini en aza indirmek istiyoruz.

HDR modundayken, Masaüstü Pencere Yöneticisi (DWM) şu şekilde tanımlanan kurallı bir bileşim renk alanı (CCCS) kullanır:

• scRGB renk alanı (doğrusal gama ile BT.709/sRGB birincilleri)
• IEEE yarı kesinlik (FP16 bit derinlik)

Bu, yukarıdaki hedeflerin tümü arasında iyi bir denge sağlar. CCCS, [0, 1] sayısal aralığın dışındaki renk değerlerine izin verir; geçerli FP16 değerleri aralığı göz önünde bulundurulduğunda, 5 milyon nitti aşan ışık değerleri de dahil olmak üzere, doğal insan görsel aralığından çok daha fazla büyüklük derecesinde renkleri temsil edebilir. FP16, doğrusal gama karışımı işlemleri için mükemmel hassasiyete sahiptir, ancak geleneksel tek hassasiyetli (FP32) işlemle karşılaştırıldığında, algılanabilir bir kalite kaybı olmadan GPU'nun bellek tüketimi ve bant genişliğinin yarısına mal olur.

Otomatik sistem renk yönetimi

Windows, kullanıcının çakışan pencerelerle aynı anda istediğiniz sayıda SDR ve HDR uygulaması çalıştırabildiği çok görevli bir ortamdır. Bu nedenle, bir ekrana çıkış yapıldığında tüm içerik türlerinin doğru ve maksimum kalitede görünmesi çok önemlidir; örneğin, BT.2100 ST.2084 (HDR) video penceresi üzerinde oynatılan bir sRGB (SDR) üretkenlik uygulaması.

HDR modundayken Windows, renk yönetimi işlemlerini iki aşamada gerçekleştirir:

1. DWM, karıştırmadan önce her uygulamayı kendi yerel renk alanından CCCS'ye dönüştürür.
2. Ekran çekirdeği, CCCS'den kablo formatı renk uzayına (BT.2100 ST.2084) işletim sistemi framebuffer'ını dönüştürür.
   • İsteğe bağlı olarak, görüntü çekirdeği ek görüntü rengi ayarı gerçekleştirmek için görüntü sürücüsüyle birlikte çalışır; Daha fazla bilgi için bkz. Windows donanım ekran renk ayarı işlem hattı.

DWM'de otomatik renk yönetiminin

Windows 11, sürüm 22H2: Gelişmiş Renk ile SDR ekranlar

HDR ekranların yaygınlığı hızla artsa da, SDR ekranlar gelecek yıllar için önemli olmaya devam edecektir. Windows 10, sürüm 1703'teki HDR desteği, SDR ekranlarını geliştirmek için gereken temel çalışmaların çoğunu ortaya koydu. Windows 11, sürüm 22H2, Gelişmiş Renk ve otomatik renk yönetimi özelliklerini belirli uygun SDR ekranlara genişletir. Gelişmiş Renkli SDR ekranlar için grafik bloğu diyagramı HDR'ye çok benzer:

SDR AC görüntü yığınının

Yüksek bit derinliği ile SDR ekran sinyal desteği

Windows 11, sürüm 22H2 sürümü, ekranın özelliklerine bağlı olarak kanal başına 10 bit ve üzerini desteklese de, SDR ekranları için temel alınan sinyaller değişmemiştir.

Yüksek bit derinliği, kurallı renk alanı kullanan sistem bileşimi

CCCS'de karıştırma dahil olmak üzere DWM Gelişmiş Renk işlevselliği HDR ekranlardan neredeyse tamamen değişmemiştir. En önemli fark, DWM'nin SDR ekranlarla ekran referanslı parlaklığı ve HDR ekranlarla sahne referanslı parlaklığı kullanmasıdır. Bu, Gelişmiş Renk işlenmiş içeriğinizin işletim sistemi tarafından yorumlandığı şekli değiştirir:

Ekran türü	Parlaklık davranışı	1.0f nasıl yorumlanır?
SDR	Ekranla ilişkili	Ekranın beyaz referans düzeyi olarak
HDR	Sahneye atıfta bulunan	80 nit olarak (nominal referans beyaz)

Otomatik sistem renk yönetimi

İşletim sistemi renk yönetimi özellikleri de çoğunlukla HDR ekranlardan değişmez. Ana fark, ekran çekirdeğinin HDR ekranlar için standart BT.2100 ST.2084 renk alanı yerine ekranın renk birimi ve kalibrasyon verileri tarafından tanımlanan ekran başvurulu renk alanına dönüştürülmesidir.

Ekran sağlama gerekli

Görüntü çekirdeğinin çıkış renk yönetimi işlemini tanımlamak için bir MHC ICC profilinden doğru veriler gerekir. Bu nedenle, yalnızca üretici veya geçerli bir profili olan bir ekran ayarı sağlayıcısı tarafından özel olarak sağlanan SDR ekranlar otomatik renk yönetimi için uygundur. ICC profil davranışını Gelişmiş Renk ile ilgili daha fazla bilgi için bkz.

Sistem gereksinimleri ve işletim sistemi desteği

Windows 10, sürüm 1709 ilk olarak HDR ekranlar için Gelişmiş Renk desteği gönderdi. Windows 11, sürüm 22H2 sürümü, doğru sağlama verilerine sahip SDR ekranları için Gelişmiş Renk desteği ekler.

Bu konu başlığında, uygulamanızın HDR ekranlar için Windows 10, sürüm 2004 (veya üzeri) ve SDR ekranları için Windows 11, sürüm 22H2 sürümünü (veya üzeri) hedeflediği varsayılır.

Ekran

Yüksek dinamik aralıklı bir ekranın HDR10 veya BT.2100 ST.2084 standardını uygulaması gerekir. HDR ekran kalitesi büyük ölçüde farklılık gösterebilir ve VESA DisplayHDRgibi sertifikalı ekranları kesinlikle öneririz. Windows 11, sürüm 22H2 sürümünden itibaren Windows, Ayarlar uygulamasında bilinen ekranların sertifika durumunu görüntüler.

Standart bir dinamik aralık ekranı, Gelişmiş Renk desteği için doğru renk sağlama verilerine sahip olmalıdır. Windows 11, sürüm 22H2 sürümünde, bu verileri geçersiz kılmak için desteklenen tek yöntem bir MHC ICC profili üzerindendir; ayrıca, kullanıcı veya görüntü üreticisi otomatik renk yönetimini etkinleştirmiş olmalıdır. Daha fazla bilgi için bkz. ICC profil davranışı Gelişmiş Renkile.

Grafik işlemcisi (GPU)

Hem SDR hem de HDR ekranlarda tam Gelişmiş Renk işlevselliği için yeni bir GPU gereklidir:

• AMD Radeon RX 400 serisi (Polaris) veya daha yenisi
• NVIDIA GeForce 10 serisi (Pascal) veya daha yenisi
• Seçilen Intel Core 10. nesil (Ice Lake) veya daha yenisi*

Donanım codec hızlandırma (10 bit HEVC, 10 bit VP9 vb.) ve PlayReady desteği (SL3000) gibi senaryolara bağlı olarak ek donanım gereksinimleri uygulanabilir. Daha ayrıntılı bilgi için GPU satıcınıza başvurun.

Grafik sürücüsü (WDDM)

Windows Update'ten veya GPU satıcısının veya bilgisayar üreticisinin web sitesinden en son kullanılabilir grafik sürücüsü kesinlikle önerilir. Bu konu başlığı, HDR ekranlar için WDDM 2.7 (Windows 10, sürüm 2004) ve SDR ekranlar için WDDM 3.0 (Windows 11, sürüm 21H2) sürücü işlevselliğine dayanır.

Desteklenen işleme API'leri

Windows 10 çok çeşitli işleme API'lerini ve çerçevelerini destekler. Gelişmiş renk desteği temel olarak uygulamanızın DXGI veya Görsel Katman API'lerini kullanarak modern sunu gerçekleştirebilmesini temel alır.

• DirectX Grafik Altyapısı (DXGI)
• Görsel Katmanı (Windows.UI.Composition)

Bu nedenle, bu sunu yöntemlerinden birine çıkış yapabilecek tüm işleme API'leri Gelişmiş Renk'i destekleyebilir. Buna aşağıdakiler dahildir (ancak bunlarla sınırlı değildir).

• Direct3D 11
• Direct3D 12
• Direct2D
• Win2D
  • alt düzey CanvasSwapChain veya CanvasSwapChainPanel API'lerinin kullanılması gerekir.
• Windows.UI.Input.Inking
  • DirectX kullanarak özel kuru mürekkep işlemeyi destekler.
• XAML
  • MediaPlayerElementkullanarak HDR videolarının oynatılmasını destekler.
  • Image öğesini kullanarak JPEG XR görüntülerinin kodunu çözmeyi destekler.
  • SwapChainPanelkullanarak DirectX için birlikte çalışabilirlik desteği sunar.

Dinamik görüntüleme özelliklerini işleme

Windows 10, güç açısından verimli tümleşik panellerden üst düzey oyun monitörlerine ve TV'lere kadar çok çeşitli Gelişmiş Renk özellikli ekranları destekler. Windows kullanıcıları, uygulamanızın mevcut SDR ekranları da dahil olmak üzere tüm bu varyasyonları sorunsuz bir şekilde işlemesini bekler.

Windows 10, kullanıcıya HDR ve Gelişmiş Renk özellikleri üzerinde denetim sağlar. Uygulamanız geçerli ekranın yapılandırmasını algılamalı ve yetenekteki değişikliklere dinamik olarak yanıt vermelidir. Bunun birçok nedeni olabilir, örneğin kullanıcı bir özelliği etkinleştirdiği veya devre dışı bırakdığı ya da uygulamayı farklı ekranlar arasında taşıdığı veya sistemin güç durumu değiştiği için.

Seçenek 1: AdvancedColorInfo

İlk olarak, AdvancedColorInfo örneğini DisplayInformation::GetAdvancedColorInfoaracılığıyla edinin.

Hangi Gelişmiş Renk türünün etkin olduğunu denetlemek için AdvancedColorInfo::CurrentAdvancedColorKind özelliğini kullanın. Denetlenecek en önemli özellik bu ve işleme ve sunu işlem hattınızı etkin türe yanıt olarak yapılandırmanız gerekir:

Gelişmiş renk türü	Görüntüleme özellikleri
SDR	Gelişmiş Renk özellikleri olmayan SDR ekran
WCG	Yüksek bit derinliği ve otomatik renk yönetimi ile SDR ekran
HDR	Tüm Gelişmiş Renk özelliklerine sahip HDR ekran

Hangi Gelişmiş Renk türlerinin desteklenip desteklenmediğini, fakat mutlaka aktif olmadığını denetlemek için AdvancedColorInfo::IsAdvancedColorKindAvailableçağrısı yapın. Örneğin bu bilgileri kullanarak kullanıcıdan HDR veya otomatik renk yönetimini etkinleştirebilmesi için Windows Ayarları uygulamasına gitmelerini isteyebilirsiniz.

AdvancedColorInfo diğer üyeleri, SMPTE ST.2086 statik HDR meta verilerine karşılık gelen panelin fiziksel renk hacmi (parlaklık ve kromans) hakkında nicel bilgiler sağlar. ST.2086 başlangıçta HDR ekranlar için tasarlanmış olsa da, bu bilgiler kullanışlıdır ve hem HDR hem de SDR ekranlar için kullanılabilir. Bu bilgileri uygulamanızın ton eşlemesini ve gamut eşlemesini yapılandırmak için kullanmalısınız.

Gelişmiş Renk özelliklerindeki değişiklikleri işlemek için DisplayInformation::AdvancedColorInfoChanged olayına kaydolun. Bu olay, herhangi bir nedenle ekranın Gelişmiş Renk özelliklerinin herhangi bir parametresi değişirse oluşturulur.

yeni bir AdvancedColorInfoörneği alarak ve hangi değerlerin değiştiğini denetleyerek bu olayı işleyebilir.

IDXGIOutput6

Win32 masaüstü uygulaması yazıyorsanız ve işlemek için DirectX kullanıyorsanız görüntü özelliklerini almak için DXGI_OUTPUT_DESC1 kullanın. IDXGIOutput6::GetDesc1aracılığıyla bu yapının bir örneğini alın.

Hangi Gelişmiş Renk türünün şu anda etkin olduğunu denetlemek için DXGI_COLOR_SPACE_TYPEtüründe olan ve aşağıdaki değerlerden birini içeren ColorSpace özelliğini kullanın:

DXGI_COLOR_SPACE_TYPE	Görüntüleme özellikleri
DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709	Gelişmiş Renk özellikleri olmayan SDR ekran
DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020	Tüm Gelişmiş Renk özelliklerine sahip HDR ekran

DXGI_OUTPUT_DESC1 diğer üyelerinin çoğu SMPTE ST.2086 statik HDR meta verilerine karşılık gelen panelin fiziksel renk hacmi (parlaklık ve kromans) hakkında nicel bilgiler sağlar. ST.2086 başlangıçta HDR ekranlar için tasarlanmış olsa da, bu bilgiler kullanışlıdır ve hem HDR hem de SDR ekranlar için kullanılabilir. Bu bilgileri uygulamanızın ton eşlemesini ve gamut eşlemesini yapılandırmak için kullanmalısınız.

Win32 masaüstü uygulamalarının Gelişmiş Renk özelliği değişikliklerine yanıt vermek için yerel bir mekanizması yoktur. Bunun yerine, uygulamanız bir işleme döngüsü kullanıyorsa, her çerçeveyle IDXGIFactory1::IsCurrent sorgulamanız gerekir. "FALSEbildiriyorsa, yeni bir DXGI_OUTPUT_DESC1edinmeli ve hangi değerlerin değiştiğini kontrol etmelisiniz."

Ayrıca, Win32 ileti pompanız uygulamanızın farklı ekranlar arasında taşınmış olabileceğini gösteren WM_SIZE iletisini işlemelidir.

Aşağıdaki örnek kod, GitHub'da Direct3D 12 HDR örnek uygulamasından gelir.

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

DirectX takas zincirinizi ayarlama

Ekranın şu anda Gelişmiş Renk özelliklerini desteklediğini belirledikten sonra, takas zincirinizi aşağıdaki gibi yapılandırın.

Sunu modelini ters çevirme efekti kullanma

CreateSwapChainFor[Hwnd| birini kullanarak takas zincirinizi oluştururkenKompozisyon|CoreWindow] yöntemlerinde DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL veya DXGI_SWAP_EFFECT_FLIP_DISCARD seçeneğini belirleyerek DXGI flip modelini kullanmanız gerekir. Bu seçenek, değiştirme zincirinizi DWM'den Gelişmiş Renk işleme ve çeşitli tam ekran iyileştirmeleri için uygun hale getirir. Daha fazla bilgi için bkz. En iyi performans içinDXGI flip modelini kullanma.

Seçenek 1. FP16 piksel biçimini ve scRGB renk alanını kullanma

Windows 10, Gelişmiş Renk için piksel biçimi ve renk alanının iki ana bileşimini destekler. Uygulamanızın belirli gereksinimlerine göre birini seçin.

Genel amaçlı uygulamaların Seçenek 1'i kullanmasını öneririz. Tüm Gelişmiş Renk görüntüleme, içerik ve işleme API'leri için çalışan tek seçenek bu seçenektir. Takas zincirinizi oluştururken, DXGI_FORMAT_R16G16B16A16_FLOAT değerlerini DXGI_SWAP_CHAIN_DESC1içinde belirtin. Varsayılan olarak, kayan nokta piksel biçimiyle oluşturulan bir takas zinciri, DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709 renk alanını kullanıyormuş gibi değerlendirilir. Bu, DWM tarafından kullanılan piksel biçimi ve renk alanıdır.

Bu birleşim, fiziksel olarak mümkün olan herhangi bir rengi belirtmek ve karıştırma da dahil olmak üzere isteğe bağlı işlemleri gerçekleştirmek için sayısal aralık ve hassasiyet sağlar.

Ancak bu seçenek, geleneksel UINT8 piksel biçimlerine kıyasla GPU bant genişliğini ve bellek tüketimini ikiye katlayan piksel başına 64 bit tüketir. Ayrıca scRGB, sRGB gamutunun dışındaki ve/veya 80 nit'ten fazla parlaklığı olan renkleri göstermek için normalleştirilmiş [0, 1] aralığının dışında olan sayısal değerler kullanır. Örneğin scRGB (1.0, 1.0, 1.0) standart D65 beyazını 80 nit'te kodlar; ancak scRGB (12.5, 12.5, 12.5) çok daha parlak bir 1000 nit'te aynı D65 beyazını kodlar. Bazı grafik işlemleri normalleştirilmiş bir sayısal aralık gerektirir ve işlemi değiştirmeniz veya renk değerlerini yeniden normalleştirmeniz gerekir.

Parlaklık değerlerinin bu seçenekle yorumlanışı SDR ve HDR ekranlar arasında farklılık gösterir; aşağıya bakın.

Seçenek 2: UINT10/RGB10 piksel biçimini ve HDR10/BT.2100 renk alanını kullanın

Seçenek 2, yalnızca uygulamanız aşağıdaki koşulların tümünü karşılıyorsa kullanılabilen bir performans iyileştirmesidir:

• HDR ekranı hedefler
• Direct3D 12 veya Direct3D 11 kullanır
• Takas zinciri alfa/saydamlık ile karıştırma gerektirmez

Uygulamanız bu koşulların tümünü karşılamıyorsa Seçenek 1'i kullanmanız gerekir.

Ancak uygulamanız 2. seçenek için uygunsa, uygulamanız video oynatıcı gibi HDR10 ile kodlanmış içerik kullanıyorsa veya esas olarak oyun gibi tam ekran senaryolarda kullanılacaksa bu daha iyi bir performans sağlayabilir. Takas zincirinizi oluştururken DXGI_SWAP_CHAIN_DESC1'de DXGI_FORMAT_R10G10B10A2_UNORM belirtmeyi göz önünde bulundurmanız gerekir. Varsayılan olarak, bu sRGB renk alanını kullanıyor olarak değerlendirilir; bu nedenle, IDXGISwapChain3::SetColorSpace1açıkça çağırmanız ve HDR10/BT.2100 olarak da bilinen DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020renk alanı olarak ayarlamanız gerekir.

Bu seçenek, geleneksel UINT8 SDR piksel biçimleriyle piksel başına aynı 32 bit tüketir. Buna ek olarak, bazı GPU'larda bu, içeriği HDR10 kablo biçimine dönüştürmek için gereken bazı işlemleri ortadan kaldırır.

Ekran SDR modundayken Gelişmiş Renk değiştirme zinciri kullanma

Ekran tüm Gelişmiş Renk özelliklerini desteklemese bile Gelişmiş Renk değiştirme zinciri kullanabilirsiniz. Bu gibi durumlarda, Masaüstü Pencere Yöneticisi (DWM), sayısal kırpma gerçekleştirerek içeriğinizi ekranın özelliklerine uyacak şekilde küçültür. Örneğin, FP16 scRGB takas zincirine işleme yaparsanız ve standart bir ekran hedeflerseniz, [0, 1] sayısal aralığın dışındaki her şey kırpılır.

Uygulama pencereniz farklı Gelişmiş Renk özelliklerine sahip iki veya daha fazla ekran kaplarsa bu downconversion davranışı da ortaya çıkar. AdvancedColorInfo ve IDXGIOutput6, yalnızca ana ekranının özelliklerini (pencerenin merkezini içeren ekran olarak tanımlanan ana) raporlamak için soyutlanır.

Uygulamanızın referans beyazını işletim sistemi SDR referans beyaz düzeyiyle eşleştirin

Birçok senaryoda uygulamanız hem SDR hem de HDR içeriği işlemek isteyecektir; örneğin, HDR video veya kullanıcı arabirimi üzerinden alt yazıları veya aktarım denetimlerini bir oyun sahnesine işleme. SDR içeriğinizin HDR ekranda doğru göründüğünden emin olmak için SDR başvuru beyaz düzeyi kavramını anlamak önemlidir. Referans beyazı, HDR sahnesinde dağınık beyaz bir nesnenin (bir kağıt sayfası veya bazen kullanıcı arabirimi gibi) göründüğü parlaklığı gösterir. HDR renk değerleri, sahneye atıfta bulunulanparlaklığa sahip olduğundan, mümkün olan maksimum panel değerine göre değil, mutlak parlaklık düzeyinde belirli bir renk değeri görüntülenmelidir. Örneğin scRGB (1.0, 1.0, 1.0) ve HDR10 (497, 497, 497, 497) her ikisi de 80 nit parlaklıkta tam olarak D65 beyaz kodlar. Windows, kullanıcının SDR referans beyaz seviyesini kendi tercihine göre ayarlamasına izin verir; bu, Windows'un sRGB (1.0, 1.0, 1.0) olarak işleyeceği parlaklık seviyesidir. Masaüstü HDR monitörlerde SDR referans beyaz düzeyleri genellikle yaklaşık 200 nit olarak ayarlanır.

HDR uygulamanız, kullanıcının istediği başvuru beyaz düzeyini ayarlamasına veya sistem tarafından yapılandırılan değeri okumasına izin vermelidir. Sahnenizdeki dağınık beyaz renk değerlerinizi SDR başvuru beyaz düzeyine eşlemeniz gerekir. Bu, uygulama çerçeve kutunuzu doğrusal gama alanında çarpmayı gerektirir.

Uygulamanız her zaman SDR ve HDR'yi ayrı yüzeylere işlerse ve işletim sistemi bileşimine dayanırsa Windows, SDR içeriğini istenen beyaz düzeye yükseltmek için otomatik olarak doğru ayarlamayı yapar. Örneğin, uygulamanız XAML kullanıyorsa ve HDR içeriğini kendi SwapChainPaneliçinde işliyorsa.

Ancak uygulamanız kendi SDR ve HDR içeriği bileşimini tek bir yüzeyde gerçekleştiriyorsa, SDR başvuru beyaz düzeyi ayarlamasını kendiniz gerçekleştirmek sizin sorumluluğunuzdadır. Aksi takdirde SDR içeriği tipik masaüstü görüntüleme koşullarında çok soluk görünebilir. İlk olarak geçerli SDR başvuru beyaz düzeyini edinmeniz ve ardından işlemekte olduğunuz SDR içeriğinin renk değerlerini ayarlamanız gerekir.

Adım 1. Geçerli SDR referans beyaz seviyesini elde et

Mevcut SDR referans beyaz düzeyini şu yollardan biriyle elde edebilirsiniz:

• Bir masaüstü uygulamasında. DISPLAYCONFIG_SDR_WHITE_LEVEL ve QueryDisplayConfig.
• UWP uygulamasında. AdvancedColorInfo.SdrWhiteLevelInNits (CoreWindowkullanarak).

Adım 2. SDR içeriğinin renk değerlerini ayarlama

Windows 80 nit cinsinden nominal veya varsayılan başvuru beyaz düzeyini tanımlar. Bu nedenle standart bir sRGB (1.0, 1.0, 1.0) beyazını FP16 takas zincirine işlerseniz, 80 nit parlaklıkta yeniden oluşturulur. Gerçek kullanıcı tanımlı başvuru beyaz düzeyiyle eşleşmesi için, SDR içeriğini 80 nit'ten AdvancedColorInfo.SdrWhiteLevelInNitsaracılığıyla belirtilen düzeye ayarlamanız gerekir.

FP16 ve scRGB veya doğrusal (1,0) gama kullanan herhangi bir renk alanı kullanarak işleniyorsanız, SDR renk değerini AdvancedColorInfo.SdrWhiteLevelInNits / 80ile çarpmanız yeterlidir. Direct2D kullanıyorsanız, değeri 80 olan önceden tanımlanmış bir sabit D2D1_SCENE_REFERRED_SDR_WHITE_LEVELvardır.

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;

HDR10 gibi doğrusal olmayan bir gama renk alanı kullanarak işleme yapıyorsanız, SDR beyaz düzeyi ayarlaması yapmak daha karmaşıktır. Piksel gölgelendiricinizi kendiniz yazıyorsanız, ayarlamayı uygulamak için lineer gamaya dönüştürmeyi göz önünde bulundurun.

Ton eşlemesini kullanarak HDR içeriğini ekranın özelliklerine uyarlama

HDR ve Gelişmiş Renkli ekranlar, özellikleri açısından büyük ölçüde farklılık gösterir. Örneğin, minimum ve maksimum parlaklıkta ve yeniden üretebilecekleri renk gamında. Çoğu durumda HDR içeriğiniz, ekranın özelliklerini aşan renkler içerir. En iyi görüntü kalitesi için HDR ton eşlemesi yapmanız, temelde içeriğin görsel amacını en iyi şekilde korurken ekrana sığacak şekilde renk aralığını sıkıştırmanız önemlidir.

Uyarlanabilen en önemli tek parametre MaxCLL (içerik ışığı düzeyi) olarak da bilinen maksimum parlaklıktır; daha gelişmiş ton eşleştiriciler de en düşük parlaklık (MinCLL) ve/veya renk öncelikli değerleri uyarlar.

Adım 1. Ekranın renk hacmi özelliklerini alma

Evrensel Windows Platformu (UWP) uygulamaları

Ekranın renk hacmini almak için AdvancedColorInfo kullanın.

Win32 (masaüstü) DirectX uygulamaları

Ekranın renk düzeyini almak için DXGI_OUTPUT_DESC1 kullanın.

Adım 2. İçeriğin renk hacmi bilgilerini alma

HDR içeriğinizin nereden geldiğine bağlı olarak, parlaklık ve renk gamı bilgilerini belirlemenin birden çok olası yolu vardır. Bazı HDR video ve görüntü dosyaları SMPTE ST.2086 meta verilerini içerir. İçeriğiniz dinamik olarak işlendiyse, iç işleme aşamalarından sahne bilgilerini ayıklayabilirsiniz( örneğin, bir sahnedeki en parlak ışık kaynağı).

Daha genel ama hesaplama açısından pahalı bir çözüm, işlenen çerçevede bir histogram veya başka bir analiz geçişi çalıştırmaktır. GitHub'daki Direct2D gelişmiş renkli görüntü işleme örnek uygulaması Direct2D kullanarak bunun nasıl yapılacağını gösterir; en ilgili kod parçacıkları aşağıda verilmişti:

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

Adım 3. HDR tonemapping işlemini gerçekleştirme

Tonlama doğal olarak kayıplı bir süreçtir ve bir dizi algısal veya hedef ölçüm için iyileştirilebilir, bu nedenle tek bir standart algoritma yoktur. Windows, Direct2D'nin yanı sıra Media Foundation HDR video kayıttan yürütme işlem hattında yerleşik HDR tonemapper efekti sağlar. Yaygın olarak kullanılan algoritmalardan bazıları arasında ACES Filmic, Reinhard ve ITU-R BT.2390-3 EETF (elektrik-elektrik aktarım işlevi) yer alır.

Bu sonraki kod örneğinde basitleştirilmiş bir Reinhard tonemapper işleci gösterilir.

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

HDR ve WCG ekran içeriğini yakalama

Windows.Graphics.Capture ad alanındaki ve IDXGIOutput5::DuplicateOutput1 yöntemindeki piksel biçimlerini belirtmeyi destekleyen API'ler, piksel bilgilerini kaybetmeden HDR ve WCG içeriğini yakalama olanağı sağlar. İçerik çerçeveleri alındıktan sonra ek işlem yapılması gerektiğini unutmayın. Örneğin, HDR-SDR ton eşlemesi (örneğin, İnternet paylaşımı için SDR ekran görüntüsü kopyası) ve uygun biçimde içerik kaydetme (örneğin, JPEG XR).

Eski renk yönetimi ve ICC profili davranışındaki değişiklikler

Gelişmiş renk ve otomatik renk yönetimi, eski ve modern tüm uygulamalar için tutarlı ve renkölçer olarak doğru görüntü rengi sağlar. Ancak, bazı uygulamalar Uluslararası Renk Konsorsiyumu (ICC) renk profillerini kullanarak kendi açık renk yönetimini gerçekleştirebilir.

Gelişmiş Renk SDR veya HDR ekranlarda etkin olduğunda, ekran ICC profillerinin davranışı geriye dönük olmayan uyumlu şekillerde değişir. Uygulamanız görünen ICC profilleriyle çalışıyorsa Windows, uygulamanızın doğru davranışa devam ettiğinden emin olmak için uyumluluk yardımcıları sunar.

ICC profil davranışındaki değişiklikler ve Gelişmiş Renk ile uyumluluğu en üst düzeye çıkarmak için uygulamanızı nasıl uyarlayabileceğiniz hakkında daha fazla bilgi için ICC profil davranışı ile Gelişmiş Renk'e bakın.

Ek kaynaklar

• GitHub'da DirectX 11 / DirectX 12için DirectX Araç Seti ile HDR İşleme kullanma. DirectX Tool Kit (DirectXTK) kullanarak bir DirectX uygulamasına HDR desteği ekleme adımları.
• Direct2D gelişmiş renkli görüntü işleme örnek uygulaması. Direct2D kullanarak Gelişmiş Renk Algılayan HDR ve WCG görüntü görüntüleyici uygulayan UWP SDK örnek uygulaması. Görüntüleme özelliği değişikliklerine yanıt verme ve SDR beyaz düzeyi için ayarlama da dahil olmak üzere UWP uygulamaları için en iyi yöntemlerin tamamını gösterir.
• Direct3D 12 HDR masaüstü örnek uygulaması. Temel bir Direct3D 12 HDR sahnesi uygulayan Masaüstü SDK örneği.
• Direct3D 12 HDR UWP örnek uygulaması. Yukarıdaki örneğin UWP eşdeğeri.
• SimpleHDR_PC. Temel bir Direct3D 11 HDR sahnesi uygulayan bir Xbox ATG SimpleHDR bilgisayar örnek uygulaması (masaüstü örnek uygulaması).