FidelityFX FSR2
v2.2.1
Hak Cipta (c) 2023 Advanced Micro Devices, Inc. Semua hak dilindungi undang-undang.
Izin dengan ini diberikan, secara gratis, kepada siapa pun yang memperoleh salinan perangkat lunak ini dan file dokumentasi terkait ("Perangkat Lunak"), untuk menggunakan Perangkat Lunak tanpa batasan, termasuk namun tidak terbatas pada hak untuk menggunakan, menyalin, memodifikasi, menggabungkan , mempublikasikan, mendistribusikan, mensublisensikan, dan/atau menjual salinan Perangkat Lunak, dan mengizinkan orang yang menerima Perangkat Lunak untuk melakukan hal tersebut, dengan tunduk pada ketentuan berikut: Pemberitahuan hak cipta di atas dan pemberitahuan izin ini harus disertakan dalam semua salinan atau sebagian besar Perangkat Lunak.
PERANGKAT LUNAK INI DISEDIAKAN "APA ADANYA", TANPA JAMINAN APA PUN, TERSURAT MAUPUN TERSIRAT, TERMASUK NAMUN TIDAK TERBATAS PADA JAMINAN KELAYAKAN UNTUK DIPERDAGANGKAN, KESESUAIAN UNTUK TUJUAN TERTENTU, DAN TIDAK ADA PELANGGARAN. DALAM KEADAAN APA PUN PENULIS ATAU PEMEGANG HAK CIPTA TIDAK BERTANGGUNG JAWAB ATAS KLAIM, KERUSAKAN, ATAU TANGGUNG JAWAB LAINNYA, BAIK DALAM TINDAKAN KONTRAK, HUKUM ATAU LAINNYA, YANG TIMBUL DARI, ATAU SEHUBUNGAN DENGAN PERANGKAT LUNAK ATAU PENGGUNAAN ATAU HAL-HAL LAIN DALAM PERANGKAT LUNAK.
FSR2 menggunakan umpan balik temporal untuk merekonstruksi gambar beresolusi tinggi sambil mempertahankan dan bahkan meningkatkan kualitas gambar dibandingkan dengan rendering asli.
FSR2 dapat mengaktifkan “kinerja praktis” untuk operasi render yang mahal, seperti penelusuran sinar perangkat keras.
HLSL CS_6_2 CS_6_6*
* - CS_6_6 digunakan pada beberapa perangkat keras yang mendukung muka gelombang lebar 64.
Untuk menggunakan FSR2 Anda harus mengikuti langkah-langkah di bawah ini:
Klik dua kali GenerateSolutions.bat di direktori build .
Buka solusi yang cocok dengan API Anda, dan bangun solusinya.
Salin pustaka API dari bin/ffx_fsr2_api ke dalam folder yang berisi folder di proyek Anda yang berisi pustaka pihak ketiga.
Salin perpustakaan yang cocok dengan backend FSR2 yang ingin Anda gunakan, misalnya: bin/ffx_fsr2_api/ffx_fsr2_api_dx12_x64.lib untuk DirectX12.
Salin file header API inti berikut dari src/ffx-fsr2-api ke proyek Anda: ffx_fsr2.h , ffx_types.h , ffx_error.h , ffx_fsr2_interface.h , ffx_util.h , shaders/ffx_fsr2_common.h , dan shaders/ffx_fsr2_resources.h . Perhatian harus diberikan untuk menjaga struktur direktori relatif di tujuan penyalinan file.
Salin file header untuk backend API pilihan Anda, misalnya untuk DirectX12 Anda akan menyalin dx12/ffx_fsr2_dx12.h dan dx12/shaders/ffx_fsr2_shaders_dx12.h . Perhatian harus diberikan untuk menjaga struktur direktori relatif di tujuan penyalinan file.
Sertakan file header ffx_fsr2.h di basis kode tempat Anda ingin berinteraksi dengan FSR2.
Buat backend untuk API target Anda. Misalnya untuk DirectX12 Anda harus menghubungi ffxFsr2GetInterfaceDX12 . Buffer awal harus dialokasikan sesuai ukuran yang dikembalikan dengan memanggil ffxFsr2GetScratchMemorySizeDX12 dan penunjuk ke buffer tersebut diteruskan ke ffxFsr2GetInterfaceDX12 .
Buat konteks FSR2 dengan memanggil ffxFsr2ContextCreate . Struktur parameter harus diisi sesuai dengan konfigurasi aplikasi Anda. Lihat dokumentasi referensi API untuk detail selengkapnya.
Setiap frame harus Anda panggil ffxFsr2ContextDispatch untuk meluncurkan beban kerja FSR2. Struktur parameter harus diisi sesuai dengan konfigurasi aplikasi Anda. Lihat dokumentasi referensi API untuk detail selengkapnya, dan pastikan bidang frameTimeDelta disediakan dalam milidetik.
Saat aplikasi Anda dihentikan (atau Anda ingin menghancurkan konteksnya karena alasan lain), Anda harus memanggil ffxFsr2ContextDestroy . GPU harus dalam keadaan idle sebelum memanggil fungsi ini.
Jittering subpiksel harus diterapkan pada matriks proyeksi aplikasi Anda. Ini harus dilakukan saat melakukan rendering utama aplikasi Anda. Anda harus menggunakan fungsi ffxFsr2GetJitterOffset untuk menghitung offset jitter yang tepat. Lihat bagian Jitter kamera untuk lebih jelasnya.
Untuk kualitas peningkatan terbaik, sangat disarankan agar Anda mengisi masker Reaktif dan masker Transparansi & komposisi sesuai dengan pedoman kami. Anda juga dapat menggunakan ffxFsr2ContextGenerateReactiveMask sebagai titik awal.
Aplikasi harus mengekspos mode penskalaan, di antarmuka penggunanya dengan urutan berikut: Kualitas, Seimbang, Performa, dan (opsional) Performa Ultra.
Aplikasi juga harus menampilkan penggeser penajaman untuk memungkinkan pengguna akhir mencapai kualitas tambahan.
Demi kenyamanan pengguna akhir, API FSR2 menyediakan sejumlah rasio penskalaan preset yang diberi nama.
| Kualitas | Faktor penskalaan per dimensi |
|---|---|
| Kualitas | 1,5x |
| Seimbang | 1,7x |
| Pertunjukan | 2,0x |
| Performa ultra | 3,0x |
Kami sangat menyarankan agar aplikasi mengadopsi rasio penamaan dan penskalaan yang konsisten di antarmuka penggunanya. Hal ini untuk memastikan bahwa pengalaman pengguna konsisten untuk pengguna aplikasi Anda yang mungkin memiliki pengalaman aplikasi lain menggunakan FSR2.
Tergantung pada perangkat keras target Anda dan konfigurasi pengoperasian, FSR2 akan beroperasi pada tingkat kinerja yang berbeda.
Tabel di bawah ini merangkum performa terukur FSR2 pada berbagai perangkat keras di DX12.
| Resolusi sasaran | Kualitas | RX 7900 XTX | RX 6950 XT | RX 6900 XT | RX 6800 XT | RX 6800 | RX 6700 XT | RX 6650 XT | RX 5700 XT | RXVega 56 | RX 590 |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 3840x2160 | Kualitas (1,5x) | 0,7 ms | 1,1 md | 1,2 mdtk | 1,2 mdtk | 1,4 md | 2,0 ms | 2,8 ms | 2,4 ms | 4,9 md | 5,4 md |
| Seimbang (1,7x) | 0,6 ms | 1,0 ms | 1,0 ms | 1,1 md | 1,4 md | 1,8 ms | 2,6 mdtk | 2,2 md | 4,1 md | 4,9 md | |
| Performa (2x) | 0,6 ms | 0,9 ms | 1,0 ms | 1,0 ms | 1,3 md | 1,7 ms | 2,3 md | 2,0 ms | 3,6 mdtk | 4,4 md | |
| Sangat berkinerja. (3x) | 0,5 ms | 0,8 ms | 0,8 ms | 0,9 ms | 1,1 md | 1,5 ms | 1,8 ms | 1,7 ms | 2,9 md | 3,7 ms | |
| 2560x1440 | Kualitas (1,5x) | 0,3 ms | 0,5 ms | 0,5 ms | 0,5 ms | 0,7 ms | 0,9 ms | 1,2 mdtk | 1,1 md | 1,9 md | 2,3 md |
| Seimbang (1,7x) | 0,3 ms | 0,5 ms | 0,5 ms | 0,5 ms | 0,6 ms | 0,8 ms | 1,1 md | 1,0 ms | 1,7 ms | 2,1 md | |
| Performa (2x) | 0,3 ms | 0,4 ms | 0,4 ms | 0,4 ms | 0,6 ms | 0,8 ms | 0,9 ms | 0,9 ms | 1,5 ms | 1,9 md | |
| Sangat berkinerja. (3x) | 0,2 ms | 0,4 ms | 0,4 ms | 0,4 ms | 0,5 ms | 0,7 ms | 0,8 ms | 0,8 ms | 1,2 mdtk | 1,7 ms | |
| 1920x1080 | Kualitas (1,5x) | 0,2 ms | 0,3 ms | 0,3 ms | 0,3 ms | 0,4 ms | 0,5 ms | 0,6 ms | 0,6 ms | 1,0 ms | 1,3 md |
| Seimbang (1,7x) | 0,2 ms | 0,3 ms | 0,3 ms | 0,3 ms | 0,4 ms | 0,5 ms | 0,6 ms | 0,6 ms | 0,9 ms | 1,2 mdtk | |
| Performa (2x) | 0,2 ms | 0,2 ms | 0,2 ms | 0,3 ms | 0,3 ms | 0,5 ms | 0,5 ms | 0,5 ms | 0,8 ms | 1,1 md | |
| Sangat berkinerja. (3x) | 0,1 ms | 0,2 ms | 0,2 ms | 0,2 ms | 0,3 ms | 0,4 ms | 0,4 ms | 0,4 ms | 0,7 ms | 0,9 ms |
Angka dibulatkan ke ketelitian 0,1 md dan tidak memiliki sharpness tambahan serta dapat berubah sewaktu-waktu.
Penggunaan FSR2 memerlukan beberapa memori lokal GPU tambahan untuk dialokasikan untuk dikonsumsi oleh GPU. Saat menggunakan API FSR2, memori ini dialokasikan ketika konteks FSR2 dibuat, dan dilakukan melalui serangkaian callback yang terdiri dari antarmuka backend. Memori ini digunakan untuk menyimpan permukaan perantara yang dihitung dengan algoritma FSR2 serta permukaan yang persisten di banyak frame aplikasi. Tabel di bawah ini mencakup jumlah memori yang digunakan oleh FSR2 dalam berbagai kondisi pengoperasian. Kolom "Working set" menunjukkan jumlah total memori yang digunakan oleh FSR2 saat algoritma dijalankan pada GPU; ini adalah jumlah memori yang dibutuhkan FSR2 untuk dijalankan. Kolom "Memori persisten" menunjukkan berapa banyak kolom "Set kerja" yang perlu dibiarkan utuh untuk frame aplikasi berikutnya; memori ini menyimpan data temporal yang dikonsumsi oleh FSR2. Kolom "Memori Aliasable" menunjukkan seberapa banyak kolom "Working set" yang dapat diberi alias oleh permukaan atau sumber daya lain yang digunakan oleh aplikasi di luar batas operasi FSR2.
Anda dapat mengendalikan pembuatan sumber daya di FSR2 dengan mengganti bagian pembuatan dan penghancuran sumber daya pada antarmuka backend FSR2, dan meneruskan tanda aliasing. Ini berarti bahwa untuk integrasi sempurna FSR2, diperlukan memori tambahan yang setara dengan kolom "Memori persisten" pada tabel di bawah, bergantung pada kondisi pengoperasian Anda.
| Resolusi | Kualitas | Perangkat kerja (MB) | Memori persisten (MB) | Memori alias (MB) |
|---|---|---|---|---|
| 3840x2160 | Kualitas (1,5x) | 448MB | 354MB | 93MB |
| Seimbang (1,7x) | 407MB | 330MB | 77MB | |
| Performa (2x) | 376MB | 312MB | 63MB | |
| Performa ultra (3x) | 323MB | 281MB | 42MB | |
| 2560x1440 | Kualitas (1,5x) | 207MB | 164MB | 43MB |
| Seimbang (1,7x) | 189MB | 153MB | 36MB | |
| Performa (2x) | 172MB | 143MB | 29MB | |
| Performa ultra (3x) | 149MB | 130MB | 19MB | |
| 1920x1080 | Kualitas (1,5x) | 115MB | 90MB | 24MB |
| Seimbang (1,7x) | 105MB | 85MB | 20MB | |
| Performa (2x) | 101MB | 83MB | 18MB | |
| Performa ultra (3x) | 84MB | 72MB | 11MB |
Angka tersebut merupakan perkiraan, dibulatkan ke MB terdekat menggunakan GPU RX 6700XT di DX12, dan dapat berubah.
Untuk detail tentang cara mengelola kebutuhan memori FSR2, silakan merujuk ke bagian dokumen ini yang berhubungan dengan Manajemen memori.
FSR2 adalah algoritma temporal, dan oleh karena itu memerlukan akses ke data dari frame saat ini dan sebelumnya. Tabel berikut mencantumkan semua input eksternal yang diperlukan oleh FSR2.
Kolom resolusi menunjukkan apakah data harus berada pada resolusi 'render' atau resolusi 'presentasi'. Resolusi 'Render' menunjukkan bahwa sumber daya harus sesuai dengan resolusi saat aplikasi melakukan rendering. Sebaliknya, 'presentasi' menunjukkan bahwa resolusi target harus sesuai dengan apa yang ingin disajikan kepada pengguna. Semua sumber daya berasal dari bingkai yang dirender saat ini, untuk aplikasi DirectX(R)12 dan Vulkan(R) semua sumber daya masukan harus dialihkan ke
D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCEdanVK_ACCESS_SHADER_READ_BITmasing-masing sebelum memanggilffxFsr2ContextDispatch.
| Nama | Resolusi | Format | Jenis | Catatan |
|---|---|---|---|---|
| Penyangga warna | Memberikan | APPLICATION SPECIFIED | Tekstur | Buffer warna resolusi render untuk frame saat ini yang disediakan oleh aplikasi. Jika konten buffer warna berada dalam rentang dinamis tinggi (HDR), maka flag FFX_FSR2_ENABLE_HIGH_DYNAMIC_RANGE harus disetel di bidang flags pada struktur FfxFsr2ContextDescription . |
| Penyangga kedalaman | Memberikan | APPLICATION SPECIFIED (1x FLOAT) | Tekstur | Buffer kedalaman resolusi render untuk frame saat ini yang disediakan oleh aplikasi. Data harus disediakan sebagai nilai floating point tunggal, yang presisinya berada di bawah kendali aplikasi. Konfigurasi kedalaman harus dikomunikasikan ke FSR2 melalui bidang flags pada struktur FfxFsr2ContextDescription saat membuat FfxFsr2Context . Anda harus menyetel tanda FFX_FSR2_ENABLE_DEPTH_INVERTED jika buffer kedalaman Anda dibalik (yaitu rentang [1..0]), dan Anda harus menyetel tanda FFX_FSR2_ENABLE_DEPTH_INFINITE jika buffer kedalaman Anda memiliki bidang jauh tak terhingga. Jika aplikasi menyediakan buffer kedalaman dalam format D32S8 , maka FSR2 akan mengabaikan komponen stensil buffer, dan membuat sumber daya R32_FLOAT untuk mengatasi buffer kedalaman. Pada perangkat keras GCN dan RDNA, buffer kedalaman disimpan secara terpisah dari buffer stensil. |
| Vektor gerak | Render atau presentasi | APPLICATION SPECIFIED (2x FLOAT) | Tekstur | Vektor gerakan 2D untuk bingkai saat ini yang disediakan oleh aplikasi dalam rentang [ (<-width, -height> .. <width, height> ]. Jika aplikasi Anda merender vektor gerakan dengan rentang berbeda, Anda dapat menggunakan bidang motionVectorScale dari struktur FfxFsr2DispatchDescription untuk menyesuaikannya agar sesuai dengan rentang yang diharapkan untuk FSR2. Secara internal, FSR2 menggunakan kuantitas 16-bit untuk mewakili vektor gerak dalam banyak kasus, yang berarti sementara Jika vektor gerak dengan presisi lebih tinggi dapat disediakan, FSR2 tidak akan mendapatkan keuntungan dari peningkatan presisi. Resolusi buffer vektor gerakan harus sama dengan resolusi render, kecuali jika flag FFX_FSR2_ENABLE_DISPLAY_RESOLUTION_MOTION_VECTORS disetel di bidang flags pada struktur FfxFsr2ContextDescription saat membuat vektor gerakan. FfxFsr2Context , dalam hal ini harus sama dengan resolusi presentasi. |
| Masker reaktif | Memberikan | R8_UNORM | Tekstur | Karena beberapa area gambar yang dirender tidak meninggalkan jejak di buffer kedalaman atau menyertakan vektor gerakan, FSR2 menyediakan dukungan untuk tekstur masker reaktif yang dapat digunakan untuk menunjukkan ke FSR2 di mana area tersebut berada. Contoh bagusnya adalah partikel, atau objek campuran alfa yang tidak menuliskan vektor kedalaman atau gerak. Jika sumber daya ini tidak disetel, logika deteksi perubahan bayangan FSR2 akan menangani kasus ini sebaik mungkin, namun untuk hasil optimal, sumber daya ini harus disetel. Untuk informasi lebih lanjut mengenai masker reaktif silakan lihat bagian Masker reaktif. |
| Paparan | 1x1 | R32_FLOAT | Tekstur | Tekstur 1x1 berisi nilai eksposur yang dihitung untuk frame saat ini. Sumber daya ini bersifat opsional, dan dapat dihilangkan jika tanda FFX_FSR2_ENABLE_AUTO_EXPOSURE diatur di bidang flags struktur FfxFsr2ContextDescription saat membuat FfxFsr2Context . |
Semua masukan yang disediakan pada Resolusi Render, kecuali vektor gerak, harus dirender dengan jitter. Vektor gerak tidak boleh menerapkan jitter, kecuali tanda FFX_FSR2_ENABLE_MOTION_VECTORS_JITTER_CANCELLATION ada.
Sangat disarankan agar buffer kedalaman terbalik dan tak terbatas digunakan dengan FSR2. Namun, konfigurasi buffer kedalaman alternatif juga didukung. Aplikasi harus memberi tahu FSR2 API tentang konfigurasi buffer kedalamannya dengan menyetel tanda yang sesuai selama pembuatan FfxFsr2Context . Tabel di bawah berisi tanda yang sesuai.
| bendera FSR2 | Catatan |
|---|---|
FFX_FSR2_ENABLE_DEPTH_INVERTED | Sedikit yang menunjukkan bahwa data buffer kedalaman masukan yang diberikan terbalik [maks..0]. |
FFX_FSR2_ENABLE_DEPTH_INFINITE | Sedikit yang menunjukkan bahwa input data buffer kedalaman yang diberikan menggunakan bidang jauh tak terhingga. |
Bagian penting dari algoritma temporal (baik itu antialiasing atau upscaling) adalah penyediaan vektor gerak. FSR2 menerima vektor gerakan dalam 2D yang mengkodekan gerakan dari piksel pada frame saat ini ke posisi piksel yang sama pada frame sebelumnya. FSR2 mengharapkan vektor gerak disediakan oleh aplikasi dalam rentang [ <-width, -height> .. <width, height> ]; ini cocok dengan ruang layar. Misalnya, vektor gerakan untuk piksel di sudut kiri atas layar dengan nilai <width, height> akan mewakili gerakan yang melintasi seluruh lebar dan tinggi permukaan input, yang berasal dari sudut kanan bawah. .
Jika aplikasi Anda menghitung vektor gerakan di ruang lain - misalnya ruang koordinat perangkat yang dinormalisasi - maka Anda dapat menggunakan bidang motionVectorScale dari struktur FfxFsr2DispatchDescription untuk menginstruksikan FSR2 menyesuaikannya agar sesuai dengan rentang yang diharapkan untuk FSR2. Contoh kode di bawah mengilustrasikan bagaimana vektor gerak dapat diskalakan ke ruang layar. Contoh kode HLSL dan C++ di bawah ini mengilustrasikan bagaimana vektor gerak ruang NDC dapat diskalakan menggunakan API host FSR2.
// GPU: Example of application NDC motion vector computation
float2 motionVector = (previousPosition.xy / previousPosition.w) - (currentPosition.xy / currentPosition.w);
// CPU: Matching FSR 2.0 motionVectorScale configuration
dispatchParameters.motionVectorScale.x = ( float )renderWidth;
dispatchParameters.motionVectorScale.y = ( float )renderHeight; Secara internal, FSR2 menggunakan besaran 16bit untuk merepresentasikan vektor gerak dalam banyak kasus, yang berarti bahwa meskipun vektor gerak dengan presisi lebih tinggi dapat disediakan, FSR2 saat ini tidak akan mendapatkan keuntungan dari peningkatan presisi tersebut. Resolusi buffer vektor gerak harus sama dengan resolusi render, kecuali jika flag FFX_FSR2_ENABLE_DISPLAY_RESOLUTION_MOTION_VECTORS disetel di bidang flags pada struktur FfxFsr2ContextDescription saat membuat FfxFsr2Context , yang dalam hal ini harus sama dengan resolusi presentasi.
FSR2 akan melakukan peningkatan kualitas yang lebih baik ketika lebih banyak objek yang menyediakan vektor geraknya. Oleh karena itu disarankan agar semua objek buram, teruji alfa, dan campuran alfa harus menuliskan vektor gerakannya untuk semua piksel yang tercakup. Jika efek vertex shader diterapkan - seperti bergulir UV - perhitungan ini juga harus diperhitungkan dalam perhitungan gerakan untuk hasil terbaik. Untuk objek campuran alfa, sangat disarankan agar nilai alfa setiap piksel yang dicakup disimpan ke piksel yang sesuai dalam masker reaktif. Hal ini akan memungkinkan FSR2 melakukan penanganan yang lebih baik terhadap objek campuran alfa selama peningkatan skala. Masker reaktif sangat penting untuk objek campuran alfa di mana penulisan vektor gerak mungkin menjadi penghalang, seperti partikel.
Dalam konteks FSR2, istilah "reaktivitas" berarti seberapa besar pengaruh sampel yang dirender untuk frame saat ini terhadap produksi gambar akhir yang ditingkatkan. Biasanya, sampel yang dirender untuk frame saat ini memberikan kontribusi yang relatif kecil terhadap hasil yang dihitung oleh FSR2; Namun, ada pengecualian. Untuk menghasilkan hasil terbaik pada objek campuran alfa yang bergerak cepat, FSR2 memerlukan tahap Proyeksi Ulang & Akumulasi agar menjadi lebih reaktif terhadap piksel tersebut. Karena tidak ada cara yang baik untuk menentukan piksel mana yang telah dirender menggunakan pencampuran alfa, baik dari warna, kedalaman, atau vektor gerakan, FSR2 bekerja paling baik ketika aplikasi secara eksplisit menandai area tersebut.
Oleh karena itu, sangat dianjurkan agar aplikasi menyediakan masker reaktif ke FSR2. Masker reaktif memandu FSR2 di mana ia harus mengurangi ketergantungannya pada informasi historis saat menyusun piksel saat ini, dan sebagai gantinya memungkinkan sampel bingkai saat ini berkontribusi lebih banyak pada hasil akhir. Masker reaktif memungkinkan aplikasi memberikan nilai dari [0.0..1.0] di mana 0,0 menunjukkan bahwa piksel sama sekali tidak reaktif (dan harus menggunakan strategi komposisi FSR2 default), dan nilai 1,0 menunjukkan piksel harus sepenuhnya reaktif. Ini adalah rentang floating point dan dapat disesuaikan dengan situasi yang berbeda.
Meskipun ada aplikasi lain untuk masker reaktif, aplikasi utama untuk masker reaktif menghasilkan hasil peningkatan gambar yang lebih baik yang mencakup objek campuran alfa. Proksi yang baik untuk reaktifitas sebenarnya adalah nilai alfa yang digunakan saat menyusun objek campuran alfa ke dalam adegan, oleh karena itu, aplikasi harus menulis alpha ke masker reaktif. Perlu dicatat bahwa nilai reaktif yang mendekati 1 kecil kemungkinannya akan memberikan hasil yang baik. Oleh karena itu, kami merekomendasikan untuk membatasi nilai reaktif maksimum menjadi sekitar 0,9.
Jika masker Reaktif tidak disediakan untuk FSR2 (dengan mengatur bidang reactive FfxFsr2DispatchDescription ke NULL ) maka tekstur 1x1 yang dihasilkan secara internal dengan nilai reaktif yang dihapus akan digunakan.
Untuk membantu aplikasi menghasilkan masker Reaktif dan masker Transparansi & komposisi, FSR2 menyediakan API pembantu opsional. Di balik terpal, API meluncurkan shader komputasi yang menghitung nilai-nilai ini untuk setiap piksel menggunakan heuristik berbasis pencahayaan.
Aplikasi yang ingin melakukan hal ini dapat memanggil fungsi ffxFsr2ContextGenerateReactiveMask dan harus melewati dua versi buffer warna, satu berisi geometri buram saja, dan yang lainnya berisi objek buram dan campuran alfa.
Selain masker Reaktif, FSR2 menyediakan aplikasi untuk menunjukkan area rendering khusus lainnya yang harus diperhitungkan selama proses peningkatan. Contoh rendering khusus tersebut mencakup area pantulan raytracing atau tekstur animasi.
Sementara masker Reaktif menyesuaikan keseimbangan akumulasi, masker Transparansi & komposisi menyesuaikan mekanisme perlindungan riwayat piksel. Masker juga menghilangkan pengaruh faktor ketidakstabilan pencahayaan. Piksel dengan nilai 0 di topeng Transparansi & komposisi tidak melakukan modifikasi tambahan apa pun pada kunci piksel tersebut. Sebaliknya, nilai 1 menunjukkan bahwa kunci untuk piksel tersebut harus dihilangkan seluruhnya.
Jika topeng Transparansi & komposisi tidak disediakan untuk FSR2 (dengan mengatur bidang transparencyAndComposition dari FfxFsr2DispatchDescription ke NULL ) maka tekstur 1x1 yang dihasilkan secara internal dengan nilai transparansi dan komposisi yang dihapus akan digunakan.
FSR2.2 menyertakan fitur eksperimental untuk menghasilkan masker Reaktif dan masker Transparansi & komposisi secara otomatis. Untuk mengaktifkan ini, bidang enableAutoReactive dari FfxFsr2DispatchDescription perlu disetel ke 'TRUE' dan salinan bagian backbuffer yang buram saja perlu disediakan di 'colorOpaqueOnly'. FSR2 kemudian akan secara otomatis membuat dan menggunakan masker Reaktif dan masker Transparansi & komposisi secara internal. Masker dihasilkan dalam lintasan komputasi dengan menganalisis perbedaan buffer warna dengan dan tanpa geometri transparan, serta membandingkannya dengan frame sebelumnya. Berdasarkan hasil komputasi tersebut, setiap piksel diberi nilai masker Reaktif dan masker Transparansi & komposisi. Untuk menggunakan pembuatan otomatis masker, 4 nilai berikut untuk menskalakan dan membatasi intensitas masker juga harus disediakan (Perhatikan bahwa nilai default yang disebutkan adalah nilai awal yang disarankan tetapi harus disesuaikan per judul):
Fitur ini dimaksudkan untuk membantu mengintegrasikan FSR2.2 ke dalam mesin atau judul baru. Namun, untuk kualitas terbaik, kami tetap menyarankan untuk merender sendiri masker Reaktif dan masker Transparansi & komposisi, karena menghasilkan nilai-nilai tersebut berdasarkan material diharapkan lebih dapat diandalkan daripada membuatnya secara otomatis dari gambar akhir.
Harap dicatat bahwa fitur ini masih dalam tahap percobaan dan mungkin berubah secara signifikan di masa mendatang.
FSR2 memberikan dua nilai yang mengontrol eksposur yang digunakan saat melakukan peningkatan. Mereka adalah sebagai berikut:
Nilai eksposur harus sesuai dengan nilai yang digunakan aplikasi selama proses pemetaan nada berikutnya yang dilakukan oleh aplikasi. Ini berarti FSR2 akan beroperasi secara konsisten dengan apa yang mungkin terlihat pada gambar akhir yang dipetakan.
Dalam berbagai tahapan algoritma FSR2 yang dijelaskan dalam dokumen ini, FSR2 akan menghitung nilai eksposurnya sendiri untuk penggunaan internal. Perlu dicatat bahwa semua keluaran dari FSR2 akan memiliki pemetaan nada internal yang dibalik sebelum keluaran akhir ditulis. Artinya FSR2 mengembalikan hasil dalam domain yang sama dengan sinyal masukan asli.
Nilai eksposur yang dipilih dengan buruk dapat berdampak drastis pada kualitas akhir peningkatan FSR2. Oleh karena itu, disarankan agar FFX_FSR2_ENABLE_AUTO_EXPOSURE digunakan oleh aplikasi, kecuali ada alasan tertentu untuk tidak menggunakannya. Ketika FFX_FSR2_ENABLE_AUTO_EXPOSURE diatur di bidang flags pada struktur FfxFsr2ContextDescription , perhitungan eksposur yang ditunjukkan dalam kode HLSL di bawah ini digunakan untuk menghitung nilai eksposur, yang cocok dengan respons eksposur stok film ISO 100.
float ComputeAutoExposureFromAverageLog ( float averageLogLuminance)
{
const float averageLuminance = exp (averageLogLuminance);
const float S = 100.0f ; // ISO arithmetic speed
const float K = 12.5f ;
const float exposureIso100 = log2 ((averageLuminance * S) / K);
const float q = 0.65f ;
const float luminanceMax = ( 78.0f / (q * S)) * pow ( 2.0f , exposureIso100);
return 1 / luminanceMax;
}Tujuan utama FSR2 adalah untuk meningkatkan kinerja rendering aplikasi dengan menggunakan algoritma peningkatan temporal yang mengandalkan sejumlah input. Oleh karena itu, penempatannya di jalur pipa adalah kunci untuk memastikan keseimbangan yang tepat antara kualitas visual kualitas tertinggi dan kinerja hebat.
Dengan pendekatan peningkatan skala gambar apa pun, penting untuk memahami cara menempatkan algoritme ruang gambar lainnya sehubungan dengan algoritme peningkatan tersebut. Menempatkan efek ruang gambar lainnya sebelum peningkatan memiliki keuntungan karena efek tersebut dijalankan pada resolusi yang lebih rendah, yang tentu saja memberikan keunggulan kinerja pada aplikasi. Namun, hal ini mungkin tidak sesuai untuk beberapa kelas teknik ruang gambar. Misalnya, banyak aplikasi yang mungkin memasukkan noise atau butiran ke dalam gambar akhir, mungkin untuk mensimulasikan kamera fisik. Melakukan hal ini sebelum upscaler dapat menyebabkan upscaler memperkuat noise, menyebabkan artefak yang tidak diinginkan pada gambar yang ditingkatkan skalanya. Tabel berikut membagi teknik ruang gambar real-time yang umum menjadi dua kolom. 'Pasca pemrosesan A' berisi semua teknik yang biasanya dijalankan sebelum peningkatan FSR2, artinya semuanya akan dijalankan pada resolusi render. Sebaliknya, kolom 'Pasca pemrosesan B' berisi semua teknik yang direkomendasikan untuk dijalankan setelah FSR2, artinya teknik tersebut akan dijalankan pada resolusi presentasi yang lebih besar.
| Pasca pemrosesan A | Pasca pemrosesanB |
|---|---|
| Refleksi ruang layar | butiran film |
| Oklusi ambien ruang layar | Penyimpangan kromatik |
| Penyangkal (bayangan, pantulan) | Skema |
| Eksposur (opsional) | Pemetaan nada |
| Bunga | |
| Kedalaman bidang | |
| Gerakan kabur |
Harap perhatikan bahwa rekomendasi di sini hanya untuk tujuan panduan dan bergantung pada karakteristik penerapan aplikasi Anda.
Meskipun dimungkinkan untuk menghasilkan sumber daya perantara yang sesuai, mengkompilasi kode shader, mengatur pengikatan, dan mengirimkan kiriman, akan lebih mudah untuk menggunakan API host FSR2 yang disediakan.
Untuk menggunakannya ke API, Anda harus menautkan pustaka FSR2 (segera membahasnya lebih lanjut) dan menyertakan file header ffx_fsr2.h , yang pada gilirannya memiliki dependensi header berikut:
ffx_assert.h
ffx_error.h
ffx_fsr2_interface.h
ffx_types.h
ffx_util.h
Untuk menggunakan API FSR2, Anda harus menautkan ffx_fsr2_api_x64.lib yang akan memberikan simbol untuk API yang menghadap aplikasi. Namun, API FSR2 memiliki backend modular, yang berarti bahwa API grafis dan platform yang berbeda dapat ditargetkan melalui penggunaan backend yang cocok. Oleh karena itu, Anda harus menyertakan lebih lanjut lib backend yang sesuai dengan kebutuhan Anda, dengan merujuk pada tabel di bawah.
| Target | Nama perpustakaan |
|---|---|
| DirectX(R)12 | ffx_fsr2_dx12_x64.lib |
| Vulkan(kanan) | ffx_fsr2_vk_x64.lib |
Harap diperhatikan bahwa arsitektur modular API FSR2 memungkinkan penerapan backend khusus. Lihat bagian Backend modular untuk detail selengkapnya.
Untuk mulai menggunakan API, aplikasi harus terlebih dahulu membuat struktur FfxFsr2Context . Struktur ini harus ditempatkan di suatu tempat dengan masa hidup yang kira-kira sama dengan backbuffer Anda; suatu tempat di tumpukan aplikasi biasanya merupakan pilihan yang baik. Dengan memanggil ffxFsr2ContextCreate struktur FfxFsr2Context akan diisi dengan data yang diperlukan. Selain itu, sejumlah panggilan akan dilakukan dari ffxFsr2ContextCreate ke backend yang disediakan untuk FfxFsr2Context sebagai bagian dari struktur FfxFsr2ContextDescription . Panggilan ini akan melakukan tugas-tugas seperti membuat sumber daya perantara yang diperlukan oleh FSR2 dan menyiapkan shader serta status pipeline terkait. API FSR2 tidak melakukan alokasi memori dinamis apa pun.
Setiap frame aplikasi Anda yang memerlukan peningkatan skala, Anda harus memanggil ffxFsr2ContextDispatch . Fungsi ini menerima struktur FfxFsr2Context yang dibuat sebelumnya dalam masa pakai aplikasi serta deskripsi tentang bagaimana peningkatan harus dilakukan dan pada data apa. Deskripsi ini disediakan oleh aplikasi yang mengisi struktur FfxFsr2DispatchDescription .
Penghancuran konteks dilakukan dengan memanggil ffxFsr2ContextDestroy . Harap dicatat, bahwa GPU harus dalam keadaan idle sebelum mencoba memanggil ffxFsr2ContextDestroy , dan fungsi tersebut tidak melakukan sinkronisasi implisit untuk memastikan bahwa sumber daya yang diakses oleh FSR2 saat ini tidak sedang berjalan. Alasan pilihan ini adalah untuk menghindari FSR2 memperkenalkan pengosongan GPU tambahan untuk aplikasi yang telah melakukan sinkronisasi yang memadai pada titik di mana mereka mungkin ingin menghancurkan FfxFsr2Context , hal ini memungkinkan aplikasi untuk melakukan pembuatan dan pembongkaran API FSR2 seefisien mungkin ketika diperlukan.
Ada fungsi pembantu tambahan yang disediakan sebagai bagian dari API FSR2. Fungsi pembantu ini melakukan tugas seperti penghitungan offset jittering subpiksel, serta penghitungan resolusi rendering berdasarkan resolusi pengiriman dan mode penskalaan default yang disediakan oleh FSR2.
Untuk dokumentasi API FSR2 yang lebih lengkap, Anda dapat merujuk ke dokumentasi referensi API yang disediakan.
Desain API FSR2 berarti bahwa implementasi inti algoritma FSR2 tidak mengetahui di mana API rendering berada. Sebaliknya, FSR2 memanggil fungsi yang disediakan melalui antarmuka, memungkinkan backend berbeda untuk digunakan dengan FSR2. Desain ini juga memungkinkan aplikasi yang mengintegrasikan FSR2 untuk menyediakan implementasi backendnya sendiri, artinya platform yang saat ini tidak didukung FSR2 dapat ditargetkan dengan mengimplementasikan beberapa fungsi. Selain itu, aplikasi yang memiliki abstraksi renderingnya sendiri juga dapat mengimplementasikan backendnya sendiri, mengambil kendali atas semua aspek fungsi dasar FSR2, termasuk manajemen memori, pembuatan sumber daya, kompilasi shader, pengikatan sumber daya shader, dan penyerahan beban kerja FSR2 ke perangkat grafis. .
Secara langsung, API FSR2 akan dikompilasi menjadi beberapa perpustakaan mengikuti pemisahan yang telah diuraikan antara API inti dan backend. Artinya, jika Anda ingin menggunakan backend yang disediakan dengan FSR2, Anda harus menautkan lib API FSR2 inti serta backend yang sesuai dengan kebutuhan Anda.
Rilis publik FSR2 hadir dengan backend DirectX(R)12 dan Vulkan(R), namun backend lainnya tersedia berdasarkan permintaan. Bicaralah dengan perwakilan Teknologi Pengembang AMD Anda untuk informasi lebih lanjut.
Jika API FSR2 digunakan dengan salah satu backend yang disediakan (misalnya: DirectX(R)12 atau Vulkan(R)) maka semua sumber daya yang diperlukan oleh FSR2 dibuat sebagai sumber daya yang dikomit secara langsung menggunakan perangkat grafis yang disediakan oleh aplikasi host. Namun, dengan mengesampingkan rangkaian fungsi buat dan hancurkan yang ada di antarmuka backend, aplikasi dapat mengontrol manajemen memori FSR2 dengan lebih tepat.
Untuk melakukan hal ini, Anda dapat menyediakan backend kustom lengkap ke FSR2 melalui struktur FfxFsr2ContextDescription yang diteruskan ke fungsi ffxFsr2ContextCreate , atau Anda dapat mengambil backend untuk API yang Anda inginkan dan mengganti fungsi pembuatan dan penghancuran sumber daya untuk menanganinya sendiri. Untuk melakukannya, cukup timpa pointer fungsi fpCreateResource dan fpDestroyResource .
// Setup DX12 interface.
const size_t scratchBufferSize = ffxFsr2GetScratchMemorySizeDX12();
void * scratchBuffer = malloc(scratchBufferSize);
FfxErrorCode errorCode = ffxFsr2GetInterfaceDX12(&contextDescription.callbacks, m_pDevice-> GetDevice (), scratchBuffer, scratchBufferSize);
FFX_ASSERT (errorCode == FFX_OK);
// Override the resource creation and destruction.
contextDescription.callbacks.createResource = myCreateResource;
contextDescription.callbacks.destroyResource = myDestroyResource;
// Set up the context description.
contextDescription.device = ffxGetDeviceDX12(m_pDevice-> GetDevice ());
contextDescription.maxRenderSize.width = renderWidth;
contextDescription.maxRenderSize.height = renderHeight;
contextDescription.displaySize.width = displayWidth;
contextDescription.displaySize.height = displayHeight;
contextDescription.flags = FFX_FSR2_ENABLE_HIGH_DYNAMIC_RANGE
| FFX_FSR2_ENABLE_DEPTH_INVERTED
| FFX_FSR2_ENABLE_AUTO_EXPOSURE;
// Create the FSR2 context.
errorCode = ffxFsr2ContextCreate(&context, &contextDescription);
FFX_ASSERT (errorCode == FFX_OK); Salah satu keuntungan menarik dari aplikasi yang mengambil kendali manajemen memori yang diperlukan untuk FSR2 adalah aliasing sumber daya dapat dilakukan, sehingga dapat menghemat memori. Tabel yang ada di Persyaratan memori menunjukkan penghematan yang tersedia melalui penggunaan teknik ini. Untuk mewujudkan penghematan yang ditunjukkan dalam tabel ini, area memori yang sesuai - yang isinya tidak diperlukan untuk bertahan selama panggilan ke pengiriman FSR2 - harus ditemukan untuk dibagikan dengan sumber daya alias yang diperlukan untuk FSR2. Setiap panggilan FfxFsr2CreateResourceFunc yang dilakukan oleh API inti FSR2 melalui antarmuka backend FSR2 akan berisi serangkaian tanda sebagai bagian dari struktur FfxCreateResourceDescription . Jika FFX_RESOURCE_FLAGS_ALIASABLE disetel di bidang flags , hal ini menunjukkan bahwa sumber daya mungkin diberi alias dengan aman dengan sumber daya lain dalam bingkai rendering.
Antialiasing temporal (TAA) adalah teknik yang menggunakan keluaran frame sebelumnya untuk membuat keluaran berkualitas lebih tinggi dari frame saat ini. Karena FSR2 memiliki tujuan serupa - meskipun dengan tujuan tambahan juga untuk meningkatkan resolusi gambar yang dirender - tidak perlu lagi menyertakan pass TAA terpisah dalam aplikasi Anda.
FSR2 mengandalkan aplikasi untuk menerapkan jittering subpiksel saat rendering - ini biasanya disertakan dalam matriks proyeksi kamera. Untuk mempermudah penerapan jitter kamera, API FSR2 menyediakan sekumpulan kecil fungsi utilitas yang menghitung offset jitter subpiksel untuk bingkai tertentu dalam urutan offset jitter terpisah.
int32_t ffxFsr2GetJitterPhaseCount ( int32_t renderWidth, int32_t displayWidth);
FfxErrorCode ffxFsr2GetJitterOffset ( float * outX, float * outY, int32_t jitterPhase, int32_t sequenceLength);Secara internal, fungsi ini mengimplementasikan barisan Halton[2,3] [Halton]. Tujuan dari rangkaian Halton adalah untuk menyediakan titik-titik yang terpisah secara spasial, yang mencakup ruang yang tersedia.
Penting untuk dipahami bahwa nilai yang dikembalikan dari ffxFsr2GetJitterOffset berada dalam ruang satuan piksel, dan untuk menggabungkannya dengan benar ke dalam matriks proyeksi, kita harus mengubahnya menjadi offset proyeksi. Diagram di atas menunjukkan satu piksel dalam ruang satuan piksel, dan dalam ruang proyeksi. Daftar kode di bawah ini menunjukkan cara menggabungkan nilai offset jitter subpiksel dengan benar ke dalam matriks proyeksi.
const int32_t jitterPhaseCount = ffxFsr2GetJitterPhaseCount(renderWidth, displayWidth);
float jitterX = 0 ;
float jitterY = 0 ;
ffxFsr2GetJitterOffset (&jitterX, &jitterY, index, jitterPhaseCount);
// Calculate the jittered projection matrix.
const float jitterX = 2 . 0f * jitterX / ( float )renderWidth;
const float jitterY = - 2 . 0f * jitterY / ( float )renderHeight;
const Matrix4 jitterTranslationMatrix = translateMatrix(Matrix3::identity, Vector3(jitterX, jitterY, 0 ));
const Matrix4 jitteredProjectionMatrix = jitterTranslationMatrix * projectionMatrix; Jitter harus diterapkan ke semua rendering. Ini termasuk objek buram, transparan alfa, dan penelusuran sinar. Untuk objek yang diraster, nilai jittering subpiksel yang dihitung dengan fungsi ffxFsr2GetJitterOffset dapat diterapkan ke matriks proyeksi kamera yang pada akhirnya digunakan untuk melakukan transformasi selama bayangan titik. Untuk rendering raytraced, jitter subpiksel harus diterapkan ke asal sinar - sering kali pada posisi kamera.
Apakah Anda memilih untuk menggunakan fungsi ffxFsr2GetJitterOffset yang disarankan atau generator urutan Anda sendiri, Anda harus mengatur bidang jitterOffset dari struktur FfxFsr2DispatchDescription untuk menginformasikan FSR2 offset jitter yang telah diterapkan untuk membuat setiap frame. Selain itu, jika tidak menggunakan fungsi ffxFsr2GetJitterOffset yang disarankan, harus diperhatikan bahwa urutan jitter Anda tidak pernah menghasilkan vektor nol; Itu adalah nilai 0 di kedua dimensi X dan Y.
Tabel di bawah ini menunjukkan panjang urutan jitter untuk masing -masing mode kualitas default.
| Mode Kualitas | Faktor penskalaan | Panjang urutan |
|---|---|---|
| Kualitas | 1.5x (per dimensi) | 18 |
| Seimbang | 1.7x (per dimensi) | 23 |
| Pertunjukan | 2.0x (per dimensi) | 32 |
| Kinerja ultra | 3.0x (per dimensi) | 72 |
| Kebiasaan | [1..n] x (per dimensi) | ceil(8 * n^2) |
Sebagian besar aplikasi dengan rendering waktu nyata memiliki tingkat konsistensi temporal yang besar antara dua frame berturut-turut. Namun, ada kasus di mana perubahan transformasi kamera dapat menyebabkan perubahan mendadak dalam apa yang diberikan. Dalam kasus seperti itu, FSR2 tidak mungkin dapat menggunakan kembali data apa pun yang telah diakumulasikan dari frame sebelumnya, dan harus menghapus data ini untuk mengecualikannya dari pertimbangan dalam proses pengomposisian. Untuk menunjukkan kepada FSR2 bahwa potongan lompatan telah terjadi dengan kamera, Anda harus mengatur bidang reset dari struktur FfxFsr2DispatchDescription untuk true untuk bingkai pertama transformasi kamera terputus.
Kinerja rendering mungkin sedikit kurang dari operasi bingkai-ke-frame yang khas saat menggunakan bendera reset, karena FSR2 akan menghapus beberapa sumber daya internal tambahan.
Menerapkan biasing mipmap negatif biasanya akan menghasilkan gambar yang ditingkatkan dengan detail tekstur yang lebih baik. Kami sarankan menerapkan formula berikut untuk bias mipmap Anda:
mipBias = log2(renderResolution/displayResolution) - 1.0 ;Disarankan bahwa aplikasi menyesuaikan bias MIP untuk konten tekstur frekuensi tinggi tertentu yang rentan untuk menunjukkan masalah alias temporal.
Tabel berikut menggambarkan faktor biasing MIPMAP yang dihasilkan dari mengevaluasi pseudocode di atas untuk rasio penskalaan yang cocok dengan mode kualitas yang disarankan yang harus diekspos ke pengguna akhir.
| Mode Kualitas | Faktor penskalaan | Bias mipmap |
|---|---|---|
| Kualitas | 1.5x (per dimensi) | -1.58 |
| Seimbang | 1.7x (per dimensi) | -1.76 |
| Pertunjukan | 2.0x (per dimensi) | -2.0 |
| Kinerja ultra | 3.0x (per dimensi) | -2.58 |
API FSR2 membutuhkan frameTimeDelta disediakan oleh aplikasi melalui struktur FfxFsr2DispatchDescription . Nilai ini dalam milidetik : jika berjalan pada 60fps, nilai yang berlalu harus sekitar 16.6F .
Nilai digunakan dalam komponen temporal fitur paparan otomatis FSR 2. Hal ini memungkinkan penyetelan akumulasi sejarah untuk tujuan kualitas.
Gambar rentang dinamis tinggi didukung di FSR2. Untuk mengaktifkan ini, Anda harus mengatur bit FFX_FSR2_ENABLE_HIGH_DYNAMIC_RANGE di bidang flags dari struktur FfxFsr2ContextDescription . Gambar harus disediakan untuk FSR2 dalam ruang warna linier.
Dukungan untuk ruang warna tambahan mungkin disediakan dalam revisi FSR2 di masa mendatang.
FSR2 dirancang untuk memanfaatkan akselerasi perangkat keras setengah presisi (FP16) untuk mencapai kinerja setinggi mungkin. Namun, untuk memberikan tingkat kompatibilitas dan fleksibilitas maksimum untuk aplikasi, FSR2 juga mencakup kemampuan untuk mengkompilasi shader menggunakan operasi presisi penuh (FP32).
Disarankan untuk menggunakan versi FP16 FSR2 pada semua perangkat keras yang mendukungnya. Anda dapat menanyakan tingkat dukungan kartu grafis Anda untuk FP16 dengan menanyakan kemampuan D3D12_FEATURE_DATA_SHADER_MIN_PRECISION_SUPPORT di DirectX (R) 12 - Anda harus memeriksa bahwa D3D[11/12]_SHADER_MIN_PRECISION_16_BIT diatur, dan tidak ada yang diatur, dan tidak ada, dan ITSHADER_MIN_MIN_PRECISIONE_16. FSR2. Untuk Vulkan, jika VkPhysicalDeviceFloat16Int8FeaturesKHR::shaderFloat16 tidak diatur, maka Anda harus mundur ke versi FP32 dari FSR2. Demikian pula, jika VkPhysicalDevice16BitStorageFeatures::storageBuffer16BitAccess tidak diatur, Anda juga harus mundur ke versi FP32 dari FSR2.
Untuk mengaktifkan jalur FP32 dalam kode sumber fsr2 shader, Anda harus mendefinisikan FFX_HALF menjadi 1 . Untuk berbagi sebagian besar kode sumber algoritma antara FP16 dan FP32 (memastikan tingkat berbagi kode yang tinggi untuk mendukung pemeliharaan yang sedang berlangsung), Anda akan melihat bahwa kode sumber shader FSR2 menggunakan satu set jenis makro yang memfasilitasi pengalihan mudah di antara antara antara pengalihan mudah di antara antara antara pengalihan mudah antara antara pengalihan mudah di antara antara pengalihan mudah di antara antara pengalihan mudah di antara antara pengalihan mudah antara pengalihan mudah di antara antara. Jenis dasar 16-bit dan 32-bit di sumber shader.
| Tipe Fidelityfx | FP32 | FP16 |
|---|---|---|
FFX_MIN16_F | float | min16float |
FFX_MIN16_F2 | float2 | min16float2 |
FFX_MIN16_F3 | float3 | min16float3 |
FFX_MIN16_F4 | float4 | min16float4 |
Tabel di atas menyebutkan pemetaan antara tipe SDK Fidelityfx abstrak, dan tipe intrinsik yang mendasar yang akan diganti tergantung pada konfigurasi sumber shader selama kompilasi.
GPU modern mengeksekusi koleksi utas - yang disebut Wavefronts - bersama -sama dengan cara Simt. Jumlah utas yang tepat yang merupakan muka gelombang tunggal adalah kuantitas khusus perangkat keras. Beberapa perangkat keras, seperti Dukungan GPU AMD GCN dan RDNA yang mengumpulkan 64 utas menjadi satu di muka gelombang tunggal. Bergantung pada karakteristik yang tepat dari eksekusi algoritma, mungkin lebih atau kurang menguntungkan untuk lebih memilih lebar gelombang muka tertentu. Dengan diperkenalkannya Shader Model 6.6, Microsoft menambahkan kemampuan untuk spesifik lebar muka gelombang melalui HLSL. Untuk perangkat keras, seperti rDNA yang mendukung lebar 32 dan 64 lebar gelombang lebar, ini adalah alat yang sangat berguna untuk tujuan optimisasi, karena memberikan cara yang bersih dan portabel untuk meminta tumpukan perangkat lunak driver untuk menjalankan muka gelombang dengan lebar tertentu.
Untuk aplikasi berbasis DirectX (R) 12 yang berjalan pada GPU berbasis RDNA dan RDNA2 dan menggunakan Microsoft Agility SDK, API host FSR2 akan memilih lebar muka gelombang 64-lebar.
Struktur deskripsi konteks dapat disediakan dengan fungsi panggilan balik untuk memberikan peringatan tekstual dari runtime FSR 2 ke aplikasi yang mendasarinya. Anggota fpMessage dari deskripsi adalah tipe FfxFsr2Message yang merupakan penunjuk fungsi untuk menyampaikan pesan string dari berbagai jenis. Menetapkan variabel ini ke fungsi yang sesuai, dan meneruskan flag FFX_FSR2_ENABLE_DEBUG_CHECKING di dalam anggota bendera FfxFsr2ContextDescription akan memungkinkan fitur. Direkomendasikan ini hanya diaktifkan dalam pembangunan pengembangan debug.
Contoh jenis output yang dapat terjadi ketika pemeriksa mengamati kemungkinan masalah di bawah ini:
FSR2_API_DEBUG_WARNING: FFX_FSR2_ENABLE_DEPTH_INFINITE and FFX_FSR2_ENABLE_DEPTH_INVERTED present, cameraFar value is very low which may result in depth separation artefacting
FSR2_API_DEBUG_WARNING: frameTimeDelta is less than 1.0f - this value should be milliseconds (~16.6f for 60fps)
Algoritma FSR2 diimplementasikan dalam serangkaian tahapan, yaitu sebagai berikut:
Setiap tahap lulus dari algoritma diletakkan di bagian yang mengikuti yang ini, tetapi aliran data untuk algoritma FSR2 lengkap ditunjukkan dalam diagram di bawah ini.
Tahap piramida compute luminance memiliki dua tanggung jawab:
Tabel berikut berisi semua sumber daya yang dikonsumsi oleh tahap piramida compute luminance.
Lapisan temporal menunjukkan bingkai data mana yang harus dikeluarkan dari. 'Bingkai saat ini' berarti bahwa data harus bersumber dari sumber daya yang dibuat untuk bingkai yang akan disajikan selanjutnya. 'Bingkai sebelumnya' menunjukkan bahwa data harus bersumber dari sumber daya yang dibuat untuk bingkai yang baru saja disajikan. Kolom resolusi menunjukkan apakah data harus pada resolusi 'diberikan' atau resolusi 'presentasi'. Resolusi 'diberikan' menunjukkan bahwa sumber daya harus sesuai dengan resolusi di mana aplikasi melakukan renderingnya. Sebaliknya, 'presentasi' menunjukkan bahwa resolusi target harus sesuai dengan apa yang akan disajikan kepada pengguna.
| Nama | Lapisan temporal | Resolusi | Format | Jenis | Catatan |
|---|---|---|---|---|---|
| Buffer warna | Bingkai saat ini | Memberikan | APPLICATION SPECIFIED | Tekstur | Buffer warna resolusi render untuk bingkai saat ini yang disediakan oleh aplikasi. Jika konten buffer warna berada dalam kisaran dinamis tinggi (HDR), maka bendera FFX_FSR2_ENABLE_HIGH_DYNAMIC_RANGE harus diatur dalam bidang flags dari struktur FfxFsr2ContextDescription . |
Tabel berikut berisi semua sumber daya yang diproduksi atau dimodifikasi oleh tahap piramida compute.
Lapisan temporal menunjukkan bingkai data mana yang harus dikeluarkan dari. 'Bingkai saat ini' berarti bahwa data harus bersumber dari sumber daya yang dibuat untuk bingkai yang akan disajikan selanjutnya. 'Bingkai sebelumnya' menunjukkan bahwa data harus bersumber dari sumber daya yang dibuat untuk bingkai yang baru saja disajikan. Kolom resolusi menunjukkan apakah data harus pada resolusi 'diberikan' atau resolusi 'presentasi'. Resolusi 'diberikan' menunjukkan bahwa sumber daya harus sesuai dengan resolusi di mana aplikasi melakukan renderingnya. Sebaliknya, 'presentasi' menunjukkan bahwa resolusi target harus sesuai dengan apa yang akan disajikan kepada pengguna.
| Nama | Lapisan temporal | Resolusi | Format | Jenis | Catatan |
|---|---|---|---|---|---|
| Paparan | Bingkai saat ini | 1x1 | R32_FLOAT | Tekstur | Tekstur 1x1 yang berisi nilai paparan yang dihitung untuk bingkai saat ini. Sumber daya ini opsional, dan dapat dihilangkan jika bendera FFX_FSR2_ENABLE_AUTO_EXPOSURE diatur dalam bidang flags dari struktur FfxFsr2ContextDescription saat membuat FfxFsr2Context . |
| Pencahayaan saat ini | Bingkai saat ini | Render * 0.5 + Mipchain | R16_FLOAT | Tekstur | Tekstur pada 50% dari tekstur resolusi render yang berisi pencahayaan bingkai saat ini. Rantai MIP penuh dialokasikan. |
Tahap piramida compute luminance diimplementasikan menggunakan fidelityfx lewat tunggal
