หน้าแรก>การเขียนโปรแกรมที่เกี่ยวข้อง>ซอร์สโค้ดอื่น ๆ
ดาวน์โหลด

FidelityFX สุดยอดความละเอียด 2.2 (FSR 2.2.1)

ลิขสิทธิ์ (c) 2023 Advanced Micro Devices, Inc. สงวนลิขสิทธิ์

อนุญาตให้บุคคลใดก็ตามที่ได้รับสำเนาของซอฟต์แวร์นี้และไฟล์เอกสารที่เกี่ยวข้อง ("ซอฟต์แวร์") อนุญาตโดยไม่เสียค่าใช้จ่าย เพื่อจัดการกับซอฟต์แวร์โดยไม่มีข้อจำกัด รวมถึงแต่ไม่จำกัดเพียงสิทธิ์ในการใช้ คัดลอก ปรับเปลี่ยน ผสาน เผยแพร่ แจกจ่าย ให้อนุญาตช่วง และ/หรือขายสำเนาของซอฟต์แวร์ และอนุญาตให้บุคคลที่ได้รับซอฟต์แวร์นี้ดำเนินการดังกล่าวได้ภายใต้เงื่อนไขต่อไปนี้: ประกาศเกี่ยวกับลิขสิทธิ์ข้างต้นและประกาศการอนุญาตนี้จะรวมอยู่ในสำเนาทั้งหมด หรือส่วนสำคัญของซอฟต์แวร์

ซอฟต์แวร์นี้มีให้ "ตามที่เป็น" โดยไม่มีการรับประกันใดๆ ทั้งโดยชัดแจ้งหรือโดยนัย ซึ่งรวมถึงแต่ไม่จำกัดเพียงการรับประกันความสามารถในการค้าขาย ความเหมาะสมสำหรับวัตถุประสงค์เฉพาะ และการไม่ละเมิด ไม่ว่าในกรณีใดผู้เขียนหรือผู้ถือลิขสิทธิ์จะต้องรับผิดต่อการเรียกร้องค่าเสียหายหรือความรับผิดอื่นใดไม่ว่าในการกระทำของสัญญาการละเมิดหรืออย่างอื่นที่เกิดขึ้นจากหรือเกี่ยวข้องกับซอฟต์แวร์หรือการใช้งานหรือข้อตกลงอื่น ๆ ใน ซอฟต์แวร์.

FSR2 ใช้การตอบสนองชั่วคราวเพื่อสร้างภาพที่มีความละเอียดสูงขึ้นใหม่ ในขณะที่ยังคงรักษาและปรับปรุงคุณภาพของภาพเมื่อเปรียบเทียบกับการเรนเดอร์เนทิฟ

FSR2 สามารถเปิดใช้งาน “ประสิทธิภาพเชิงปฏิบัติ” สำหรับการดำเนินการเรนเดอร์ที่มีค่าใช้จ่ายสูง เช่น การติดตามรังสีของฮาร์ดแวร์

ข้อกำหนดภาษาแรเงา

HLSL CS_6_2 CS_6_6*

* - CS_6_6 ใช้กับฮาร์ดแวร์บางตัวที่รองรับคลื่นหน้ากว้าง 64

รายการตรวจสอบการเริ่มต้นอย่างรวดเร็ว

หากต้องการใช้ FSR2 คุณควรทำตามขั้นตอนด้านล่าง:

  1. ดับเบิลคลิก GenerateSolutions.bat ในไดเร็กทอรี build

  2. เปิดโซลูชันที่ตรงกับ API ของคุณ และสร้างโซลูชัน

  3. คัดลอกไลบรารี API จาก bin/ffx_fsr2_api ลงในโฟลเดอร์ที่มีโฟลเดอร์ในโปรเจ็กต์ของคุณซึ่งมีไลบรารีของบริษัทอื่น

  4. คัดลอกไลบรารีที่ตรงกับแบ็กเอนด์ FSR2 ที่คุณต้องการใช้ เช่น: bin/ffx_fsr2_api/ffx_fsr2_api_dx12_x64.lib สำหรับ DirectX12

  5. คัดลอกไฟล์ส่วนหัว API หลักต่อไปนี้จาก src/ffx-fsr2-api ลงในโปรเจ็กต์ของคุณ: ffx_fsr2.h , ffx_types.h , ffx_error.h , ffx_fsr2_interface.h , ffx_util.h , shaders/ffx_fsr2_common.h และ shaders/ffx_fsr2_resources.h . ควรใช้ความระมัดระวังเพื่อรักษาโครงสร้างไดเร็กทอรีสัมพันธ์ที่ปลายทางของการคัดลอกไฟล์

  6. คัดลอกไฟล์ส่วนหัวสำหรับแบ็กเอนด์ API ที่คุณเลือก เช่น สำหรับ DirectX12 คุณจะต้องคัดลอก dx12/ffx_fsr2_dx12.h และ dx12/shaders/ffx_fsr2_shaders_dx12.h ควรใช้ความระมัดระวังเพื่อรักษาโครงสร้างไดเร็กทอรีสัมพันธ์ที่ปลายทางของการคัดลอกไฟล์

  7. รวมไฟล์ส่วนหัว ffx_fsr2.h ไว้ในโค้ดเบสของคุณที่คุณต้องการโต้ตอบกับ FSR2

  8. สร้างแบ็กเอนด์สำหรับ API เป้าหมายของคุณ เช่นสำหรับ DirectX12 คุณควรเรียก ffxFsr2GetInterfaceDX12 ควรจัดสรรบัฟเฟอร์เริ่มต้นตามขนาดที่ส่งคืนโดยการเรียก ffxFsr2GetScratchMemorySizeDX12 และตัวชี้ไปยังบัฟเฟอร์นั้นส่งผ่านไปยัง ffxFsr2GetInterfaceDX12

  9. สร้างบริบท FSR2 โดยการเรียก ffxFsr2ContextCreate ควรกรอกโครงสร้างพารามิเตอร์ให้ตรงกับการกำหนดค่าแอปพลิเคชันของคุณ ดูเอกสารอ้างอิง API สำหรับรายละเอียดเพิ่มเติม

  10. แต่ละเฟรมที่คุณควรเรียก ffxFsr2ContextDispatch เพื่อเรียกใช้ปริมาณงาน FSR2 ควรกรอกโครงสร้างพารามิเตอร์ให้ตรงกับการกำหนดค่าแอปพลิเคชันของคุณ ดูเอกสารอ้างอิง API สำหรับรายละเอียดเพิ่มเติม และตรวจสอบว่าฟิลด์ frameTimeDelta มีหน่วยเป็นมิลลิวินาที

  11. เมื่อใบสมัครของคุณสิ้นสุดลง (หรือคุณต้องการทำลายบริบทด้วยเหตุผลอื่น) คุณควรเรียก ffxFsr2ContextDestroy GPU ควรไม่ได้ใช้งานก่อนที่จะเรียกใช้ฟังก์ชันนี้

  12. ควรใช้การกระวนกระวายใจของพิกเซลย่อยกับเมทริกซ์การฉายภาพของแอปพลิเคชันของคุณ สิ่งนี้ควรทำเมื่อทำการเรนเดอร์หลักของแอปพลิเคชันของคุณ คุณควรใช้ฟังก์ชัน ffxFsr2GetJitterOffset เพื่อคำนวณค่าชดเชยการกระวนกระวายใจที่แม่นยำ ดูส่วนการกระวนกระวายใจของกล้องสำหรับรายละเอียดเพิ่มเติม

  13. เพื่อคุณภาพการขยายขนาดที่ดีที่สุด ขอแนะนำอย่างยิ่งให้คุณเติม Reactive Mask และ Transparency & Composition Mask ตามหลักเกณฑ์ของเรา คุณยังสามารถใช้ ffxFsr2ContextGenerateReactiveMask เป็นจุดเริ่มต้นได้

  14. แอปพลิเคชันควรแสดงโหมดการปรับขนาดในส่วนติดต่อผู้ใช้ตามลำดับต่อไปนี้: คุณภาพ สมดุล ประสิทธิภาพ และ (เป็นทางเลือก) ประสิทธิภาพขั้นสูง

  15. แอปพลิเคชันควรเปิดแถบเลื่อนเพื่อให้ผู้ใช้ได้รับคุณภาพเพิ่มเติม

แนวทางบูรณาการ

โหมดการปรับขนาด

เพื่อความสะดวกของผู้ใช้ FSR2 API จะจัดเตรียมอัตราส่วนมาตราส่วนที่กำหนดไว้ล่วงหน้าจำนวนหนึ่งซึ่งมีการตั้งชื่อไว้

คุณภาพ ปัจจัยมาตราส่วนต่อมิติ
คุณภาพ 1.5x
สมดุล 1.7x
ผลงาน 2.0x
ประสิทธิภาพสูงสุด 3.0x

เราขอแนะนำอย่างยิ่งให้แอปพลิเคชันใช้อัตราส่วนการตั้งชื่อและมาตราส่วนที่สอดคล้องกันในส่วนต่อประสานผู้ใช้ นี่คือเพื่อให้แน่ใจว่าประสบการณ์ผู้ใช้จะสอดคล้องกันสำหรับผู้ใช้แอปพลิเคชันของคุณซึ่งอาจมีประสบการณ์ของแอปพลิเคชันอื่นที่ใช้ FSR2

ผลงาน

ขึ้นอยู่กับฮาร์ดแวร์เป้าหมายและการกำหนดค่าการทำงานของคุณ FSR2 จะทำงานในระดับประสิทธิภาพที่แตกต่างกัน

ตารางด้านล่างสรุปประสิทธิภาพที่วัดได้ของ FSR2 บนฮาร์ดแวร์ต่างๆ ใน ​​DX12

ความละเอียดเป้าหมาย คุณภาพ RX7900XTX RX6950XT RX6900XT RX6800XT RX6800 RX6700XT RX6650XT RX5700XT RX Vega 56 RX590
3840x2160 คุณภาพ (1.5x) 0.7ms 1.1ms 1.2ms 1.2ms 1.4ms 2.0ms 2.8ms 2.4ms 4.9ms 5.4ms
สมดุล (1.7x) 0.6ms 1.0ms 1.0ms 1.1ms 1.4ms 1.8ms 2.6ms 2.2ms 4.1ms 4.9ms
ประสิทธิภาพ (2x) 0.6ms 0.9ms 1.0ms 1.0ms 1.3ms 1.7ms 2.3ms 2.0ms 3.6ms 4.4ms
อัลตร้าเพอร์เฟค (3x) 0.5ms 0.8ms 0.8ms 0.9ms 1.1ms 1.5ms 1.8ms 1.7ms 2.9ms 3.7ms
2560x1440 คุณภาพ (1.5x) 0.3ms 0.5ms 0.5ms 0.5ms 0.7ms 0.9ms 1.2ms 1.1ms 1.9ms 2.3ms
สมดุล (1.7x) 0.3ms 0.5ms 0.5ms 0.5ms 0.6ms 0.8ms 1.1ms 1.0ms 1.7ms 2.1ms
ประสิทธิภาพ (2x) 0.3ms 0.4ms 0.4ms 0.4ms 0.6ms 0.8ms 0.9ms 0.9ms 1.5ms 1.9ms
อัลตร้าเพอร์เฟค (3x) 0.2ms 0.4ms 0.4ms 0.4ms 0.5ms 0.7ms 0.8ms 0.8ms 1.2ms 1.7ms
1920x1080 คุณภาพ (1.5x) 0.2ms 0.3ms 0.3ms 0.3ms 0.4ms 0.5ms 0.6ms 0.6ms 1.0ms 1.3ms
สมดุล (1.7x) 0.2ms 0.3ms 0.3ms 0.3ms 0.4ms 0.5ms 0.6ms 0.6ms 0.9ms 1.2ms
ประสิทธิภาพ (2x) 0.2ms 0.2ms 0.2ms 0.3ms 0.3ms 0.5ms 0.5ms 0.5ms 0.8ms 1.1ms
อัลตร้าเพอร์เฟค (3x) 0.1ms 0.2ms 0.2ms 0.2ms 0.3ms 0.4ms 0.4ms 0.4ms 0.7ms 0.9ms

ตัวเลขจะถูกปัดเศษเป็น 0.1 มิลลิวินาทีที่ใกล้ที่สุด และไม่มี sharpness เพิ่มเติม และอาจมีการเปลี่ยนแปลงได้

ข้อกำหนดหน่วยความจำ

การใช้ FSR2 ต้องใช้หน่วยความจำภายใน GPU เพิ่มเติมบางส่วนเพื่อจัดสรรให้ GPU ใช้งาน เมื่อใช้ FSR2 API หน่วยความจำนี้จะถูกจัดสรรเมื่อมีการสร้างบริบท FSR2 และดำเนินการดังกล่าวผ่านชุดการโทรกลับซึ่งประกอบด้วยอินเทอร์เฟซแบ็กเอนด์ หน่วยความจำนี้ใช้เพื่อจัดเก็บพื้นผิวระดับกลางซึ่งคำนวณโดยอัลกอริธึม FSR2 รวมถึงพื้นผิวที่คงอยู่ในหลายเฟรมของแอปพลิเคชัน ตารางด้านล่างประกอบด้วยจำนวนหน่วยความจำที่ใช้โดย FSR2 ภายใต้สภาวะการทำงานต่างๆ คอลัมน์ "ชุดการทำงาน" ระบุจำนวนหน่วยความจำทั้งหมดที่ใช้โดย FSR2 ในขณะที่อัลกอริทึมกำลังดำเนินการบน GPU นี่คือจำนวนหน่วยความจำที่ FSR2 ต้องใช้ในการทำงาน คอลัมน์ "หน่วยความจำถาวร" ระบุจำนวนคอลัมน์ "ชุดการทำงาน" ที่ต้องคงเหลือไว้สำหรับเฟรมถัดไปของแอปพลิเคชัน หน่วยความจำนี้จะจัดเก็บข้อมูลชั่วคราวที่ใช้โดย FSR2 คอลัมน์ "หน่วยความจำที่สามารถเปลี่ยนชื่อได้" ระบุว่าคอลัมน์ "ชุดการทำงาน" อาจถูกนามแฝงโดยพื้นผิวหรือทรัพยากรอื่น ๆ ที่ใช้โดยแอปพลิเคชันนอกขอบเขตการปฏิบัติงานของ FSR2 เท่าใด

คุณสามารถควบคุมการสร้างทรัพยากรใน FSR2 ได้โดยการแทนที่ส่วนการสร้างทรัพยากรและการทำลายของอินเทอร์เฟซแบ็กเอนด์ FSR2 และส่งต่อแฟล็กนามแฝง ซึ่งหมายความว่าเพื่อให้สามารถรวม FSR2 ได้อย่างสมบูรณ์แบบ จำเป็นต้องมีหน่วยความจำเพิ่มเติมซึ่งเท่ากับคอลัมน์ "หน่วยความจำถาวร" ของตารางด้านล่าง ทั้งนี้ขึ้นอยู่กับสภาพการทำงานของคุณ

ปณิธาน คุณภาพ ชุดทำงาน (MB) หน่วยความจำถาวร (MB) หน่วยความจำที่สามารถเปลี่ยนชื่อได้ (MB)
3840x2160 คุณภาพ (1.5x) 448MB 354MB 93MB
สมดุล (1.7x) 407MB 330MB 77MB
ประสิทธิภาพ (2x) 376MB 312MB 63MB
ประสิทธิภาพสูงสุด (3x) 323MB 281MB 42MB
2560x1440 คุณภาพ (1.5x) 207MB 164MB 43MB
สมดุล (1.7x) 189MB 153MB 36MB
ประสิทธิภาพ (2x) 172MB 143MB 29MB
ประสิทธิภาพขั้นสูงสุด (3x) 149MB 130MB 19MB
1920x1080 คุณภาพ (1.5x) 115MB 90MB 24MB
สมดุล (1.7x) 105MB 85MB 20MB
ประสิทธิภาพ (2x) 101MB 83MB 18MB
ประสิทธิภาพสูงสุด (3x) 84MB 72MB 11MB

ตัวเลขเป็นการประมาณ โดยปัดเศษขึ้นเป็น MB ที่ใกล้ที่สุดโดยใช้ RX 6700XT GPU ใน DX12 และอาจมีการเปลี่ยนแปลงได้

สำหรับรายละเอียดเกี่ยวกับวิธีจัดการข้อกำหนดหน่วยความจำของ FSR2 โปรดดูในส่วนของเอกสารนี้ที่เกี่ยวข้องกับการจัดการหน่วยความจำ

ทรัพยากรอินพุต

FSR2 เป็นอัลกอริธึมชั่วคราว ดังนั้นจึงต้องเข้าถึงข้อมูลจากทั้งเฟรมปัจจุบันและเฟรมก่อนหน้า ตารางต่อไปนี้ระบุอินพุตภายนอกทั้งหมดที่ FSR2 ต้องการ

คอลัมน์ความละเอียดจะระบุว่าข้อมูลควรมีความละเอียดแบบ 'เรนเดอร์' หรือความละเอียด 'การนำเสนอ' ความละเอียด 'แสดงผล' บ่งชี้ว่าทรัพยากรควรตรงกับความละเอียดที่แอปพลิเคชันกำลังแสดงผล ในทางกลับกัน 'การนำเสนอ' บ่งชี้ว่าความละเอียดของเป้าหมายควรตรงกับที่จะนำเสนอต่อผู้ใช้ ทรัพยากรทั้งหมดมาจากเฟรมที่เรนเดอร์ปัจจุบัน สำหรับแอปพลิเคชัน DirectX(R)12 และ Vulkan(R) ทรัพยากรอินพุตทั้งหมดควรเปลี่ยนเป็น D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE และ VK_ACCESS_SHADER_READ_BIT ตามลำดับก่อนที่จะเรียกใช้ ffxFsr2ContextDispatch

ชื่อ ปณิธาน รูปแบบ พิมพ์ หมายเหตุ
บัฟเฟอร์สี เรนเดอร์ APPLICATION SPECIFIED พื้นผิว บัฟเฟอร์สีความละเอียดของการเรนเดอร์สำหรับเฟรมปัจจุบันที่แอปพลิเคชันจัดเตรียมไว้ให้ หากเนื้อหาของบัฟเฟอร์สีอยู่ในช่วงไดนามิกสูง (HDR) ดังนั้นควรตั้งค่าสถานะ FFX_FSR2_ENABLE_HIGH_DYNAMIC_RANGE ในฟิลด์ flags ของโครงสร้าง FfxFsr2ContextDescription
บัฟเฟอร์ความลึก เรนเดอร์ APPLICATION SPECIFIED (1x FLOAT) พื้นผิว บัฟเฟอร์ความลึกของความละเอียดในการเรนเดอร์สำหรับเฟรมปัจจุบันที่แอปพลิเคชันจัดเตรียมไว้ให้ ข้อมูลควรระบุเป็นค่าจุดลอยตัวเดียว ซึ่งมีความแม่นยำอยู่ภายใต้การควบคุมของแอปพลิเคชัน การกำหนดค่าความลึกควรสื่อสารกับ FSR2 ผ่านฟิลด์ flags ของโครงสร้าง FfxFsr2ContextDescription เมื่อสร้าง FfxFsr2Context คุณควรตั้งค่าสถานะ FFX_FSR2_ENABLE_DEPTH_INVERTED หากบัฟเฟอร์ความลึกของคุณกลับด้าน (นั่นคือช่วง [1..0]) และคุณควรตั้งค่าสถานะ FFX_FSR2_ENABLE_DEPTH_INFINITE หากบัฟเฟอร์ความลึกของคุณมีระนาบที่ไม่มีที่สิ้นสุด หากแอปพลิเคชันจัดเตรียมบัฟเฟอร์ความลึกในรูปแบบ D32S8 ดังนั้น FSR2 จะละเว้นส่วนประกอบสเตนซิลของบัฟเฟอร์ และสร้างทรัพยากร R32_FLOAT เพื่อระบุบัฟเฟอร์ความลึก บนฮาร์ดแวร์ GCN และ RDNA บัฟเฟอร์เชิงลึกจะถูกจัดเก็บแยกต่างหากจากบัฟเฟอร์สเตนซิล
เวกเตอร์การเคลื่อนไหว การเรนเดอร์หรือการนำเสนอ APPLICATION SPECIFIED (2x FLOAT) พื้นผิว เวกเตอร์การเคลื่อนไหว 2 มิติสำหรับเฟรมปัจจุบันที่แอปพลิเคชันจัดทำไว้ในช่วง [ (<-width, -height> .. <width, height> ] หากแอปพลิเคชันของคุณแสดงเวกเตอร์การเคลื่อนไหวด้วยช่วงที่แตกต่างกัน คุณอาจใช้ฟิลด์ motionVectorScale ของ โครงสร้าง FfxFsr2DispatchDescription เพื่อปรับให้ตรงกับช่วงที่คาดหวังสำหรับ FSR2 ภายใน FSR2 ใช้ปริมาณ 16 บิตเพื่อแสดงเวกเตอร์การเคลื่อนที่ในหลายกรณี ซึ่งหมายความว่าในขณะที่เวกเตอร์การเคลื่อนไหวมีค่ามากกว่า สามารถให้ความแม่นยำได้ FSR2 จะไม่ได้รับประโยชน์จากความแม่นยำที่เพิ่มขึ้น ความละเอียดของบัฟเฟอร์เวกเตอร์การเคลื่อนไหวควรเท่ากับความละเอียดของการเรนเดอร์ เว้นแต่ว่าแฟล็ก FFX_FSR2_ENABLE_DISPLAY_RESOLUTION_MOTION_VECTORS จะถูกตั้งค่าในฟิลด์ flags ของโครงสร้าง FfxFsr2ContextDescription เมื่อสร้าง FfxFsr2Context ซึ่ง กรณีควรเท่ากับความละเอียดของการนำเสนอ
หน้ากากปฏิกิริยา เรนเดอร์ R8_UNORM พื้นผิว เนื่องจากบางพื้นที่ของภาพที่เรนเดอร์ไม่ทิ้งรอยเท้าไว้ในบัฟเฟอร์เชิงลึกหรือรวมเวกเตอร์การเคลื่อนไหว FSR2 จึงให้การสนับสนุนสำหรับพื้นผิวมาสก์แบบรีแอกทีฟ ซึ่งสามารถใช้เพื่อระบุ FSR2 ว่าพื้นที่ดังกล่าวอยู่ที่ใด ตัวอย่างที่ดีของสิ่งเหล่านี้คือ อนุภาค หรือวัตถุผสมอัลฟ่าซึ่งไม่ได้เขียนเวกเตอร์ความลึกหรือการเคลื่อนไหว หากไม่ได้ตั้งค่าทรัพยากรนี้ ตรรกะการตรวจจับการเปลี่ยนแปลงแรเงาของ FSR2 จะจัดการกับกรณีเหล่านี้อย่างดีที่สุดเท่าที่จะทำได้ แต่ควรตั้งค่าทรัพยากรนี้เพื่อให้ได้ผลลัพธ์ที่ดีที่สุด สำหรับข้อมูลเพิ่มเติมเกี่ยวกับรีแอคทีฟมาสก์ โปรดดูที่ส่วนรีแอคทีฟมาสก์
การรับสัมผัสเชื้อ 1x1 R32_FLOAT พื้นผิว พื้นผิว 1x1 ที่มีค่าแสงที่คำนวณสำหรับเฟรมปัจจุบัน ทรัพยากรนี้เป็นทางเลือก และอาจละเว้นได้หากมีการตั้งค่าสถานะ FFX_FSR2_ENABLE_AUTO_EXPOSURE ในฟิลด์ flags ของโครงสร้าง FfxFsr2ContextDescription เมื่อสร้าง FfxFsr2Context

อินพุตทั้งหมดที่มีให้ใน Render Resolution ยกเว้นเวกเตอร์การเคลื่อนไหว ควรเรนเดอร์ด้วยความกระวนกระวายใจ เวกเตอร์การเคลื่อนไหวไม่ควรมีการกระวนกระวายใจ เว้นแต่จะมีธง FFX_FSR2_ENABLE_MOTION_VECTORS_JITTER_CANCELLATION ปรากฏอยู่

การกำหนดค่าบัฟเฟอร์ความลึก

ขอแนะนำอย่างยิ่งให้ใช้บัฟเฟอร์ความลึกที่ไม่มีที่สิ้นสุดแบบกลับหัวกับ FSR2 อย่างไรก็ตาม รองรับการกำหนดค่าบัฟเฟอร์ความลึกทางเลือกอื่น แอปพลิเคชันควรแจ้งให้ FSR2 API ทราบถึงการกำหนดค่าบัฟเฟอร์เชิงลึกโดยการตั้งค่าสถานะที่เหมาะสมระหว่างการสร้าง FfxFsr2Context ตารางด้านล่างประกอบด้วยแฟล็กที่เหมาะสม

ธง FSR2 บันทึก
FFX_FSR2_ENABLE_DEPTH_INVERTED บิตที่บ่งชี้ว่าข้อมูลบัฟเฟอร์ความลึกอินพุตที่ให้มากลับด้าน [สูงสุด..0]
FFX_FSR2_ENABLE_DEPTH_INFINITE บิตที่บ่งชี้ว่าข้อมูลบัฟเฟอร์ความลึกอินพุตที่ให้มานั้นใช้ระนาบไกลที่ไม่มีที่สิ้นสุด

ให้เวกเตอร์การเคลื่อนไหว

ช่องว่าง

ส่วนสำคัญของอัลกอริธึมชั่วคราว (ไม่ว่าจะเป็นการลดรอยหยักหรือการลดขนาด) คือการจัดเตรียมเวกเตอร์การเคลื่อนที่ FSR2 ยอมรับเวกเตอร์การเคลื่อนไหวในรูปแบบ 2D ซึ่งเข้ารหัสการเคลื่อนไหวจากพิกเซลในเฟรมปัจจุบันไปยังตำแหน่งของพิกเซลเดียวกันนั้นในเฟรมก่อนหน้า FSR2 คาดว่าแอปพลิเคชันจะจัดเตรียมเวกเตอร์การเคลื่อนที่ไว้ในช่วง [ <-width, -height> .. <width, height> ] สิ่งนี้ตรงกับพื้นที่หน้าจอ ตัวอย่างเช่น เวกเตอร์การเคลื่อนไหวสำหรับพิกเซลที่มุมซ้ายบนของหน้าจอที่มีค่า <ความกว้าง ความสูง> จะแสดงการเคลื่อนไหวที่เคลื่อนที่ผ่านความกว้างและความสูงเต็มของพื้นผิวอินพุต โดยมีต้นกำเนิดจากมุมล่างขวา .

หากแอปพลิเคชันของคุณคำนวณเวกเตอร์การเคลื่อนไหวในพื้นที่อื่น เช่น พื้นที่พิกัดของอุปกรณ์ที่ทำให้เป็นมาตรฐาน คุณอาจใช้ฟิลด์ motionVectorScale ของโครงสร้าง FfxFsr2DispatchDescription เพื่อสั่งให้ FSR2 ปรับให้ตรงกับช่วงที่คาดหวังสำหรับ FSR2 ตัวอย่างโค้ดด้านล่างแสดงให้เห็นว่าเวกเตอร์การเคลื่อนไหวสามารถปรับขนาดตามพื้นที่หน้าจอได้อย่างไร ตัวอย่างโค้ด HLSL และ C++ ด้านล่างแสดงให้เห็นว่าเวกเตอร์การเคลื่อนที่ของ NDC-space สามารถปรับขนาดได้โดยใช้ FSR2 host API อย่างไร 

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

ความแม่นยำและความละเอียด

ภายใน FSR2 ใช้ปริมาณ 16 บิตเพื่อแสดงเวกเตอร์การเคลื่อนที่ในหลายกรณี ซึ่งหมายความว่าในขณะที่สามารถให้เวกเตอร์การเคลื่อนไหวที่มีความแม่นยำมากขึ้นได้ แต่ FSR2 จะไม่ได้รับประโยชน์จากความแม่นยำที่เพิ่มขึ้นในขณะนี้ ความละเอียดของบัฟเฟอร์เวกเตอร์การเคลื่อนไหวควรเท่ากับความละเอียดของการเรนเดอร์ เว้นแต่ว่าแฟล็ก FFX_FSR2_ENABLE_DISPLAY_RESOLUTION_MOTION_VECTORS จะถูกตั้งค่าใน flags กของโครงสร้าง FfxFsr2ContextDescription เมื่อสร้าง FfxFsr2Context ซึ่งในกรณีนี้ควรเท่ากับความละเอียดของการนำเสนอ

ความคุ้มครอง

FSR2 จะดำเนินการลดขนาดคุณภาพให้ดีขึ้นเมื่อมีวัตถุมากขึ้นให้เวกเตอร์การเคลื่อนไหว ดังนั้นจึงแนะนำว่าวัตถุทึบแสง ทดสอบอัลฟ่า และวัตถุผสมอัลฟ่าทั้งหมดควรเขียนเวกเตอร์การเคลื่อนไหวสำหรับพิกเซลที่ครอบคลุมทั้งหมด หากมีการใช้เอฟเฟกต์เชเดอร์จุดยอด เช่น การเลื่อน UV การคำนวณเหล่านี้ควรนำมารวมอยู่ในการคำนวณการเคลื่อนไหวเพื่อให้ได้ผลลัพธ์ที่ดีที่สุด สำหรับออบเจ็กต์แบบผสมอัลฟ่า ขอแนะนำอย่างยิ่งว่าค่าอัลฟ่าของพิกเซลที่ครอบคลุมแต่ละพิกเซลจะถูกจัดเก็บไว้ในพิกเซลที่เกี่ยวข้องในรีแอกทีฟมาสก์ สิ่งนี้จะช่วยให้ FSR2 จัดการอ็อบเจ็กต์แบบผสมอัลฟ่าได้ดีขึ้นในระหว่างการขยายขนาด รีแอคทีฟมาสก์มีความสำคัญอย่างยิ่งสำหรับวัตถุผสมอัลฟ่า ซึ่งการเขียนเวกเตอร์การเคลื่อนไหวอาจเป็นสิ่งต้องห้าม เช่น อนุภาค

หน้ากากปฏิกิริยา

ในบริบทของ FSR2 คำว่า "ปฏิกิริยา" หมายถึงอิทธิพลที่ตัวอย่างที่แสดงผลสำหรับเฟรมปัจจุบันมีอิทธิพลมากน้อยเพียงใดต่อการผลิตภาพที่ขยายสเกลขั้นสุดท้าย โดยทั่วไป ตัวอย่างที่แสดงผลสำหรับเฟรมปัจจุบันมีส่วนช่วยในผลลัพธ์ที่คำนวณโดย FSR2 ในปริมาณที่ค่อนข้างปานกลาง อย่างไรก็ตาม มีข้อยกเว้นอยู่ เพื่อให้ได้ผลลัพธ์ที่ดีที่สุดสำหรับวัตถุที่เคลื่อนที่เร็วและผสมอัลฟ่า FSR2 จำเป็นต้องมีขั้นตอน Reproject & Accumulate เพื่อให้พิกเซลดังกล่าวมีปฏิกิริยามากขึ้น เนื่องจากไม่มีวิธีที่ดีในการระบุจากเวกเตอร์สี ความลึก หรือการเคลื่อนไหวซึ่งพิกเซลได้รับการเรนเดอร์โดยใช้การผสมอัลฟ่า FSR2 จึงทำงานได้ดีที่สุดเมื่อแอปพลิเคชันทำเครื่องหมายพื้นที่ดังกล่าวอย่างชัดเจน

ดังนั้นจึงขอแนะนำอย่างยิ่งให้แอปพลิเคชันจัดเตรียมรีแอกทีฟมาสก์ให้กับ FSR2 รีแอคทีฟมาสก์จะแนะนำ FSR2 ว่าควรลดการพึ่งพาข้อมูลในอดีตเมื่อทำการประกอบพิกเซลปัจจุบัน และอนุญาตให้ตัวอย่างของเฟรมปัจจุบันมีส่วนสนับสนุนผลลัพธ์สุดท้ายมากขึ้นแทน รีแอกทีฟมาสก์อนุญาตให้แอปพลิเคชันระบุค่าตั้งแต่ [0.0..1.0] โดยที่ 0.0 บ่งชี้ว่าพิกเซลไม่มีปฏิกิริยาเลย (และควรใช้กลยุทธ์การจัดองค์ประกอบ FSR2 เริ่มต้น) และค่า 1.0 บ่งชี้ว่าพิกเซลควรเต็ม ปฏิกิริยา นี่คือช่วงจุดลอยตัวและสามารถปรับให้เข้ากับสถานการณ์ต่างๆ ได้

แม้ว่าจะมีแอปพลิเคชันอื่นๆ สำหรับรีแอกทีฟมาสก์ แต่แอปพลิเคชันหลักสำหรับรีแอกทีฟมาสก์จะให้ผลลัพธ์ที่ดีกว่าในการขยายขนาดรูปภาพ ซึ่งรวมถึงวัตถุที่ผสมอัลฟ่าด้วย พร็อกซีที่ดีสำหรับการเกิดปฏิกิริยาจริงๆ แล้วคือค่าอัลฟ่าที่ใช้เมื่อรวมวัตถุที่ผสมอัลฟ่าเข้าไปในฉาก ดังนั้น แอปพลิเคชันควรเขียน alpha ลงในมาสก์ปฏิกิริยา ควรสังเกตว่าไม่น่าเป็นไปได้ที่ค่าปฏิกิริยาที่ใกล้กับ 1 จะให้ผลลัพธ์ที่ดี ดังนั้น เราขอแนะนำให้จับยึดค่าปฏิกิริยาสูงสุดไว้ที่ประมาณ 0.9

หากไม่ได้ระบุ Reactive Mask ให้กับ FSR2 (โดยการตั้งค่าฟิลด์ reactive ของ FfxFsr2DispatchDescription เป็น NULL ) ดังนั้นพื้นผิว 1x1 ที่สร้างขึ้นภายในที่มีค่าปฏิกิริยาที่ล้างจะถูกใช้

สร้างปฏิกิริยาโดยอัตโนมัติ

เพื่อช่วยให้แอปพลิเคชันสร้าง Reactive Mask และ Transparency & Composition Mask FSR2 จึงจัดเตรียม API ตัวช่วยเสริม ภายใต้ประทุน API จะเปิดตัวตัวเชเดอร์การคำนวณซึ่งจะคำนวณค่าเหล่านี้สำหรับแต่ละพิกเซลโดยใช้การวิเคราะห์พฤติกรรมตามความสว่าง

แอปพลิเคชันที่ต้องการทำเช่นนี้สามารถเรียกใช้ฟังก์ชัน ffxFsr2ContextGenerateReactiveMask และควรผ่านบัฟเฟอร์สีสองเวอร์ชัน เวอร์ชันหนึ่งมีเรขาคณิตทึบแสงเท่านั้น และอีกเวอร์ชันมีทั้งวัตถุทึบแสงและผสมอัลฟ่า

หน้ากากความโปร่งใสและองค์ประกอบ

นอกเหนือจาก Reactive Mask แล้ว FSR2 ยังมีแอปพลิเคชันเพื่อแสดงพื้นที่ของการเรนเดอร์โดยผู้เชี่ยวชาญอื่นๆ ซึ่งควรคำนึงถึงในระหว่างกระบวนการอัปสเกล ตัวอย่างของการเรนเดอร์พิเศษดังกล่าวรวมถึงพื้นที่ของการสะท้อนด้วยรังสีหรือพื้นผิวที่เคลื่อนไหวได้

ในขณะที่มาสก์ Reactive จะปรับสมดุลการสะสม ส่วนมาสก์ความโปร่งใสและองค์ประกอบจะปรับกลไกการป้องกันประวัติพิกเซล หน้ากากยังช่วยขจัดผลกระทบของปัจจัยความไม่เสถียรของความสว่างอีกด้วย พิกเซลที่มีค่า 0 ในมาสก์ความโปร่งใสและองค์ประกอบจะไม่ทำการแก้ไขเพิ่มเติมใดๆ กับการล็อกสำหรับพิกเซลนั้น ในทางกลับกัน ค่า 1 แสดงว่าควรถอดการล็อกสำหรับพิกเซลนั้นออกจนหมด

หากไม่ได้ระบุมาสก์ความโปร่งใสและองค์ประกอบให้กับ FSR2 (โดยการตั้งค่าฟิลด์ transparencyAndComposition ของ FfxFsr2DispatchDescription เป็น NULL ) ดังนั้นพื้นผิว 1x1 ที่สร้างขึ้นภายในที่มีความโปร่งใสและค่าองค์ประกอบที่ชัดเจนจะถูกใช้

สร้างมาสก์ความโปร่งใสและองค์ประกอบโดยอัตโนมัติ

FSR2.2 มีคุณลักษณะทดลองเพื่อสร้างมาสก์ปฏิกิริยาและมาสก์ความโปร่งใสและองค์ประกอบโดยอัตโนมัติ หากต้องการเปิดใช้งานสิ่งนี้ ฟิลด์ enableAutoReactive ของ FfxFsr2DispatchDescription จะต้องตั้งค่าเป็น 'TRUE' และจำเป็นต้องระบุสำเนาของส่วนที่ทึบแสงเฉพาะของบัฟเฟอร์แบ็คอัพใน 'colorOpaqueOnly' จากนั้น FSR2 จะสร้างและใช้ Reactive Mask และ Transparency & Composition Mask ภายในโดยอัตโนมัติ มาสก์ถูกสร้างขึ้นในการประมวลผลโดยการวิเคราะห์ความแตกต่างของบัฟเฟอร์สีที่มีและไม่มีรูปทรงโปร่งใส รวมทั้งเปรียบเทียบกับเฟรมก่อนหน้า ขึ้นอยู่กับผลลัพธ์ของการคำนวณเหล่านั้น แต่ละพิกเซลจะได้รับการกำหนดค่ามาสก์แบบโต้ตอบและค่ามาสก์ความโปร่งใสและองค์ประกอบ หากต้องการใช้การสร้างมาสก์อัตโนมัติ จำเป็นต้องระบุค่า 4 ค่าต่อไปนี้เพื่อปรับขนาดและจำกัดความเข้มของมาสก์ด้วย (โปรดทราบว่าค่าเริ่มต้นดังกล่าวเป็นค่าเริ่มต้นที่แนะนำ แต่ควรปรับตามชื่อ):

  • 'autoTcThreshold': การตั้งค่านี้น้อยเกินไปจะทำให้ภาพไม่เสถียร ค่าที่มากขึ้นอาจทำให้เกิดภาพซ้อนได้ ค่าเริ่มต้นที่แนะนำคือ 0.05f
  • 'autoTcScale': ค่าที่น้อยลงจะเพิ่มความเสถียรที่ขอบแข็งของวัตถุโปร่งแสง ค่าเริ่มต้นที่แนะนำคือ 1.0f
  • 'autoReactiveScale': ค่าที่มากขึ้นส่งผลให้พิกเซลมีปฏิกิริยามากขึ้น ค่าเริ่มต้นที่แนะนำคือ 5.00f
  • 'autoReactiveMax': สามารถเข้าถึงค่าปฏิกิริยาสูงสุดได้ ค่าเริ่มต้นที่แนะนำคือ 0.90f

คุณลักษณะนี้มีจุดมุ่งหมายเพื่อช่วยในการรวม FSR2.2 เข้ากับกลไกหรือชื่อใหม่ อย่างไรก็ตาม เพื่อคุณภาพที่ดีที่สุด เรายังคงแนะนำให้เรนเดอร์ Reactive Mask และ Transparency & Composition Mask ด้วยตัวเอง เนื่องจากคาดว่าการสร้างค่าเหล่านั้นตามวัสดุจะมีความน่าเชื่อถือมากกว่าการสร้างอัตโนมัติจากรูปภาพสุดท้าย

โปรดทราบว่าคุณลักษณะนี้ยังอยู่ในขั้นทดลองและอาจมีการเปลี่ยนแปลงอย่างมีนัยสำคัญในอนาคต

การรับสัมผัสเชื้อ

FSR2 มีค่าสองค่าที่ควบคุมการรับแสงที่ใช้เมื่อดำเนินการขยายขนาด มีดังนี้:

  1. เปิดเผยค่าล่วงหน้า โดยที่เราแบ่งสัญญาณอินพุตเพื่อกลับไปยังสัญญาณดั้งเดิมที่เกมสร้างขึ้น ก่อนที่จะรวมเข้ากับเป้าหมายการเรนเดอร์ที่มีความแม่นยำต่ำกว่า
  2. เปิดรับ ค่าซึ่งคูณกับผลลัพธ์ของค่าสีที่เปิดเผยไว้ล่วงหน้า

ค่าการรับแสงควรตรงกับค่าที่แอปพลิเคชันใช้ในระหว่างการแมปโทนที่ตามมาซึ่งดำเนินการโดยแอปพลิเคชัน ซึ่งหมายความว่า FSR2 จะทำงานสอดคล้องกับสิ่งที่น่าจะมองเห็นได้ในภาพที่แมปโทนสุดท้าย

ในขั้นตอนต่างๆ ของอัลกอริทึม FSR2 ที่อธิบายไว้ในเอกสารนี้ FSR2 จะคำนวณค่าการสัมผัสของตัวเองสำหรับการใช้งานภายใน เป็นที่น่าสังเกตว่าเอาต์พุตทั้งหมดจาก FSR2 จะมีการย้อนกลับการปรับโทนเสียงภายในนี้ก่อนที่จะเขียนเอาต์พุตสุดท้าย หมายความว่า FSR2 ส่งคืนผลลัพธ์ในโดเมนเดียวกันกับสัญญาณอินพุตดั้งเดิม

ค่าการรับแสงที่เลือกไม่ดีอาจส่งผลกระทบอย่างมากต่อคุณภาพขั้นสุดท้ายของการลดขนาดของ FSR2 ดังนั้นจึงขอแนะนำให้แอปพลิเคชันใช้ FFX_FSR2_ENABLE_AUTO_EXPOSURE เว้นแต่จะมีเหตุผลเฉพาะที่จะไม่ทำเช่นนั้น เมื่อ FFX_FSR2_ENABLE_AUTO_EXPOSURE ถูกตั้งค่าในช่อง flags ของโครงสร้าง FfxFsr2ContextDescription การคำนวณการรับแสงที่แสดงในโค้ด HLSL ด้านล่างจะถูกนำมาใช้เพื่อคำนวณค่าการรับแสง ซึ่งตรงกับการตอบสนองการรับแสงของสต็อกฟิล์ม 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;
}

ตำแหน่งในกรอบ

เป้าหมายหลักของ FSR2 คือการปรับปรุงประสิทธิภาพการเรนเดอร์แอปพลิเคชันโดยใช้อัลกอริธึมการขยายขนาดชั่วคราวโดยอาศัยอินพุตจำนวนหนึ่ง ดังนั้น การวางตำแหน่งในไปป์ไลน์จึงเป็นกุญแจสำคัญในการสร้างสมดุลที่เหมาะสมระหว่างคุณภาพของภาพสูงสุดและประสิทธิภาพที่ยอดเยี่ยม

ด้วยวิธีการลดขนาดภาพ สิ่งสำคัญคือต้องเข้าใจวิธีวางอัลกอริธึมพื้นที่ภาพอื่นๆ ที่เกี่ยวข้องกับอัลกอริธึมการขยายขนาด การวางเอฟเฟกต์พื้นที่ภาพอื่นๆ เหล่านี้ก่อนการลดขนาดจะมีข้อได้เปรียบตรงที่เอฟเฟกต์จะทำงานที่ความละเอียดต่ำกว่า ซึ่งแน่นอนว่ามอบความได้เปรียบด้านประสิทธิภาพให้กับแอปพลิเคชัน อย่างไรก็ตาม อาจไม่เหมาะสมสำหรับเทคนิคพื้นที่ภาพบางประเภท ตัวอย่างเช่น แอปพลิเคชันจำนวนมากอาจทำให้เกิดสัญญาณรบกวนหรือเกรนในภาพสุดท้าย อาจเป็นการจำลองกล้องจริง การดำเนินการดังกล่าวก่อนที่ตัวอัปสเกลเลอร์อาจทำให้ตัวอัปสเกลขยายสัญญาณรบกวน ทำให้เกิดสิ่งแปลกปลอมที่ไม่พึงประสงค์ในภาพที่ได้รับการอัปสเกล ตารางต่อไปนี้แบ่งเทคนิคพื้นที่รูปภาพแบบเรียลไทม์ทั่วไปออกเป็นสองคอลัมน์ 'หลังการประมวลผล A' มีเทคนิคทั้งหมดที่โดยทั่วไปจะทำงานก่อนการลดขนาดของ FSR2 ซึ่งหมายความว่าเทคนิคทั้งหมดจะทำงานที่ความละเอียดของการเรนเดอร์ ในทางกลับกัน คอลัมน์ 'หลังการประมวลผล B' มีเทคนิคทั้งหมดที่แนะนำให้รันหลังจาก FSR2 ซึ่งหมายความว่าเทคนิคเหล่านั้นจะทำงานที่ความละเอียดการนำเสนอที่ใหญ่กว่า

การประมวลผลภายหลัง A การประมวลผลภายหลัง B
การสะท้อนของพื้นที่หน้าจอ เนื้อฟิล์ม
การบดเคี้ยวโดยรอบของพื้นที่หน้าจอ ความผิดปกติของสี
ตัวดีนอยเซอร์ (เงา, ภาพสะท้อน) บทความสั้น
การเปิดรับแสง (ไม่บังคับ) การทำแผนที่โทน
บลูม
ความชัดลึก
การเคลื่อนไหวเบลอ

โปรดทราบว่าคำแนะนำในที่นี้มีวัตถุประสงค์เพื่อเป็นแนวทางเท่านั้น และขึ้นอยู่กับลักษณะเฉพาะที่ชัดเจนของการใช้งานแอปพลิเคชันของคุณ

โฮสต์ API

แม้ว่าคุณสามารถสร้างทรัพยากรระดับกลางที่เหมาะสม คอมไพล์โค้ดเชเดอร์ ตั้งค่าการเชื่อมโยง และส่งการจัดส่งได้ แต่การใช้ API โฮสต์ FSR2 ที่ให้มานั้นง่ายกว่ามาก

หากต้องการใช้กับ API คุณควรเชื่อมโยงไลบรารี FSR2 (ซึ่งจะเพิ่มเติมในเร็วๆ นี้) และรวมไฟล์ส่วนหัว ffx_fsr2.h ซึ่งจะมีการขึ้นต่อกันของส่วนหัวดังต่อไปนี้: 

 ffx_assert.h
ffx_error.h
ffx_fsr2_interface.h
ffx_types.h
ffx_util.h

หากต้องการใช้ FSR2 API คุณควรลิงก์ ffx_fsr2_api_x64.lib ซึ่งจะจัดเตรียมสัญลักษณ์สำหรับ API ที่เชื่อมต่อกับแอปพลิเคชัน อย่างไรก็ตาม API ของ FSR2 มีแบ็กเอนด์แบบโมดูลาร์ ซึ่งหมายความว่า API กราฟิกและแพลตฟอร์มที่แตกต่างกันอาจถูกกำหนดเป้าหมายผ่านการใช้แบ็กเอนด์ที่ตรงกัน ดังนั้น คุณควรรวม lib แบ็กเอนด์ที่ตรงกับความต้องการของคุณเพิ่มเติม โดยอ้างอิงตารางด้านล่าง

เป้า ชื่อห้องสมุด
DirectX(R)12 ffx_fsr2_dx12_x64.lib
วัลแคน(R) ffx_fsr2_vk_x64.lib

โปรดทราบว่าสถาปัตยกรรมโมดูลาร์ของ FSR2 API ช่วยให้สามารถนำแบ็กเอนด์แบบกำหนดเองไปใช้งาน ดูส่วนแบ็กเอนด์โมดูลาร์สำหรับรายละเอียดเพิ่มเติม

เพื่อเริ่มใช้ API แอปพลิเคชันควรสร้างโครงสร้าง FfxFsr2Context ก่อน โครงสร้างนี้ควรอยู่ในตำแหน่งที่มีอายุการใช้งานประมาณเดียวกับแบ็คบัฟเฟอร์ของคุณ ที่ไหนสักแห่งบนฮีปของแอปพลิเคชันมักจะเป็นตัวเลือกที่ดี โดยการเรียก ffxFsr2ContextCreate โครงสร้าง FfxFsr2Context จะถูกเติมด้วยข้อมูลที่ต้องการ นอกจากนี้ จะมีการโทรจำนวนหนึ่งจาก ffxFsr2ContextCreate ไปยังแบ็กเอนด์ซึ่งจัดเตรียมไว้ให้กับ FfxFsr2Context โดยเป็นส่วนหนึ่งของโครงสร้าง FfxFsr2ContextDescription การเรียกเหล่านี้จะทำงานต่างๆ เช่น การสร้างทรัพยากรระดับกลางที่ FSR2 ต้องการ และการตั้งค่าเชเดอร์และสถานะไปป์ไลน์ที่เกี่ยวข้อง FSR2 API ไม่ได้ทำการจัดสรรหน่วยความจำแบบไดนามิกใดๆ

แต่ละเฟรมของแอปพลิเคชันของคุณที่จำเป็นต้องมีการลดขนาด คุณควรเรียก ffxFsr2ContextDispatch ฟังก์ชันนี้ยอมรับโครงสร้าง FfxFsr2Context ที่สร้างขึ้นก่อนหน้านี้ในช่วงอายุการใช้งานของแอปพลิเคชัน รวมถึงคำอธิบายอย่างชัดเจนว่าควรดำเนินการขยายขนาดอย่างไรและข้อมูลใด คำอธิบายนี้จัดทำโดยแอปพลิเคชันที่กรอกโครงสร้าง FfxFsr2DispatchDescription

การทำลายบริบทจะดำเนินการโดยการเรียก ffxFsr2ContextDestroy โปรดทราบว่า GPU ควรอยู่ในสถานะไม่ได้ใช้งานก่อนที่จะพยายามเรียก ffxFsr2ContextDestroy และฟังก์ชันนี้จะไม่ทำการซิงโครไนซ์โดยนัยเพื่อให้แน่ใจว่าทรัพยากรที่ FSR2 เข้าถึงนั้นไม่ได้อยู่ระหว่างการบิน เหตุผลสำหรับตัวเลือกนี้คือ เพื่อหลีกเลี่ยงไม่ให้ FSR2 แนะนำ GPU ฟลัชเพิ่มเติมสำหรับแอปพลิเคชันที่ดำเนินการซิงโครไนซ์เพียงพอแล้ว ณ จุดที่แอปพลิเคชันอาจต้องการทำลาย FfxFsr2Context ซึ่งจะทำให้แอปพลิเคชันสามารถสร้างและรื้อถอน FSR2 API ได้อย่างมีประสิทธิภาพมากที่สุดเมื่อ ที่จำเป็น.

มีฟังก์ชันตัวช่วยเพิ่มเติมซึ่งเป็นส่วนหนึ่งของ FSR2 API ฟังก์ชันตัวช่วยเหล่านี้ทำงานต่างๆ เช่น การคำนวณออฟเซ็ตการกระวนกระวายใจของพิกเซลย่อย ตลอดจนการคำนวณความละเอียดในการเรนเดอร์ตามความละเอียดในการจัดส่ง และโหมดการปรับขนาดเริ่มต้นที่ FSR2 มอบให้

หากต้องการเอกสารประกอบที่ละเอียดยิ่งขึ้นของ FSR2 API คุณสามารถดูได้จากเอกสารอ้างอิง API ที่ให้ไว้

แบ็กเอนด์แบบโมดูลาร์

การออกแบบ FSR2 API หมายความว่าการใช้งานหลักของอัลกอริธึม FSR2 นั้นไม่ทราบว่า API การเรนเดอร์นั้นอยู่ที่ใด แต่ฟังก์ชันการเรียกใช้ FSR2 ที่จัดให้ผ่านอินเทอร์เฟซ ทำให้สามารถใช้แบ็กเอนด์ที่แตกต่างกันกับ FSR2 ได้ การออกแบบนี้ยังช่วยให้แอปพลิเคชันที่รวม FSR2 เพื่อจัดเตรียมการใช้งานแบ็กเอนด์ของตัวเอง ซึ่งหมายความว่าแพลตฟอร์มที่ FSR2 ไม่รองรับในปัจจุบันอาจถูกกำหนดเป้าหมายโดยการนำฟังก์ชันจำนวนหนึ่งไปใช้ นอกจากนี้ แอปพลิเคชันที่มีการเรนเดอร์นามธรรมของตัวเองยังสามารถใช้แบ็กเอนด์ของตัวเองได้ โดยควบคุมทุกแง่มุมของฟังก์ชันพื้นฐานของ FSR2 รวมถึงการจัดการหน่วยความจำ การสร้างทรัพยากร การรวบรวมเชเดอร์ การเชื่อมโยงทรัพยากรเชเดอร์ และการส่งปริมาณงาน FSR2 ไปยังอุปกรณ์กราฟิก .

เมื่อแกะกล่อง FSR2 API จะคอมไพล์เป็นไลบรารีหลายๆ ไลบรารีตามการแยกที่ร่างไว้แล้วระหว่าง API หลักและแบ็กเอนด์ ซึ่งหมายความว่า หากคุณต้องการใช้แบ็กเอนด์ที่มาพร้อมกับ FSR2 คุณควรเชื่อมโยงทั้ง lib FSR2 API หลัก รวมถึงแบ็กเอนด์ที่ตรงกับความต้องการของคุณ

การเปิดตัว FSR2 ต่อสาธารณะมาพร้อมกับแบ็กเอนด์ DirectX(R)12 และ Vulkan(R) แต่แบ็กเอนด์อื่นๆ มีให้บริการตามคำขอ พูดคุยกับตัวแทน AMD Developer Technology ของคุณเพื่อขอข้อมูลเพิ่มเติม

การจัดการหน่วยความจำ

หากใช้ FSR2 API กับแบ็กเอนด์ที่ให้มา (เช่น DirectX(R)12 หรือ Vulkan(R)) ทรัพยากรทั้งหมดที่ FSR2 ต้องการจะถูกสร้างขึ้นเป็นทรัพยากรที่คอมมิตโดยตรงโดยใช้อุปกรณ์กราฟิกที่แอปพลิเคชันโฮสต์มอบให้ อย่างไรก็ตาม ด้วยการแทนที่กลุ่มฟังก์ชันที่สร้างและทำลายที่มีอยู่ในอินเทอร์เฟซแบ็กเอนด์ จึงเป็นไปได้ที่แอปพลิเคชันจะควบคุมการจัดการหน่วยความจำของ FSR2 ได้แม่นยำยิ่งขึ้น

ในการดำเนินการนี้ คุณสามารถจัดเตรียมแบ็กเอนด์แบบกำหนดเองแบบเต็มให้กับ FSR2 ผ่านโครงสร้าง FfxFsr2ContextDescription ที่ส่งไปยังฟังก์ชัน ffxFsr2ContextCreate หรือคุณสามารถดึงข้อมูลแบ็กเอนด์สำหรับ API ที่คุณต้องการ และแทนที่ฟังก์ชันการสร้างและทำลายทรัพยากรเพื่อจัดการด้วยตนเอง เมื่อต้องการทำเช่นนี้ เพียงเขียนทับตัวชี้ฟังก์ชัน fpCreateResource และ 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);

ข้อได้เปรียบที่น่าสนใจประการหนึ่งสำหรับแอปพลิเคชันที่ควบคุมการจัดการหน่วยความจำที่จำเป็นสำหรับ FSR2 ก็คือ อาจมีการดำเนินการนามแฝงทรัพยากร ซึ่งสามารถส่งผลให้ประหยัดหน่วยความจำได้ ตารางที่แสดงในข้อกำหนดหน่วยความจำแสดงให้เห็นถึงการประหยัดที่มีอยู่ผ่านการใช้เทคนิคนี้ เพื่อให้ทราบถึงการประหยัดที่แสดงในตารางนี้ ควรพบว่าพื้นที่หน่วยความจำที่เหมาะสม - เนื้อหาที่ไม่จำเป็นต้องอยู่รอดผ่านการเรียกไปยังการจัดส่ง FSR2 - ควรถูกพบเพื่อแบ่งปันกับทรัพยากรที่ใช้นามแฝงได้ที่จำเป็นสำหรับ FSR2 การเรียก FfxFsr2CreateResourceFunc แต่ละครั้งที่ทำโดย API หลักของ FSR2 ผ่านอินเทอร์เฟซแบ็กเอนด์ FSR2 จะมีชุดของแฟล็กซึ่งเป็นส่วนหนึ่งของโครงสร้าง FfxCreateResourceDescription หาก FFX_RESOURCE_FLAGS_ALIASABLE ถูกตั้งค่าในฟิลด์ flags แสดงว่าทรัพยากรนั้นอาจมีนามแฝงอย่างปลอดภัยกับทรัพยากรอื่นในเฟรมการเรนเดอร์

การลดรอยหยักชั่วคราว

การลบรอยหยักชั่วคราว (TAA) เป็นเทคนิคที่ใช้เอาต์พุตของเฟรมก่อนหน้าเพื่อสร้างเอาต์พุตคุณภาพสูงขึ้นจากเฟรมปัจจุบัน เนื่องจาก FSR2 มีเป้าหมายที่คล้ายกัน แม้ว่าจะมีเป้าหมายเพิ่มเติมในการเพิ่มความละเอียดของภาพที่เรนเดอร์ด้วย แต่ก็ไม่จำเป็นต้องรวมบัตรผ่าน TAA แยกต่างหากในใบสมัครของคุณอีกต่อไป

กล้องสั่น

FSR2 อาศัยแอปพลิเคชันเพื่อใช้การกระวนกระวายใจของพิกเซลย่อยขณะเรนเดอร์ ซึ่งโดยทั่วไปจะรวมอยู่ในเมทริกซ์การฉายภาพของกล้อง เพื่อให้การประยุกต์ใช้การกระวนกระวายใจของกล้องเป็นเรื่องง่าย FSR2 API จึงมีชุดฟังก์ชันยูทิลิตี้ชุดเล็กๆ ซึ่งคำนวณออฟเซ็ตการกระวนกระวายใจของพิกเซลย่อยสำหรับเฟรมเฉพาะภายในลำดับของการชดเชยการกระวนกระวายใจที่แยกจากกัน 

 int32_t ffxFsr2GetJitterPhaseCount ( int32_t renderWidth, int32_t displayWidth);
FfxErrorCode ffxFsr2GetJitterOffset ( float * outX, float * outY, int32_t jitterPhase, int32_t sequenceLength);

ภายใน ฟังก์ชันเหล่านี้ใช้ลำดับ Halton[2,3] [Halton] เป้าหมายของลำดับ Halton คือการจัดให้มีจุดที่แยกจากกันเชิงพื้นที่ ซึ่งครอบคลุมพื้นที่ว่างที่มีอยู่

สิ่งสำคัญคือต้องเข้าใจว่าค่าที่ส่งคืนจาก ffxFsr2GetJitterOffset อยู่ในพื้นที่พิกเซลของหน่วย และเพื่อที่จะรวมค่านี้ลงในเมทริกซ์การฉายภาพอย่างถูกต้อง เราจะต้องแปลงค่าเหล่านี้เป็นค่าชดเชยการฉายภาพ แผนภาพด้านบนแสดงพิกเซลเดียวในพื้นที่หน่วยพิกเซล และในพื้นที่ฉายภาพ รายการรหัสด้านล่างแสดงวิธีการรวมค่าชดเชยการกระวนกระวายใจของพิกเซลย่อยลงในเมทริกซ์การฉายภาพอย่างถูกต้อง 

 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 กับการแสดงผล ทั้งหมด ซึ่งรวมถึงวัตถุทึบแสง โปร่งใสอัลฟ่า และวัตถุที่มีการติดตามรังสี สำหรับออบเจ็กต์แรสเตอร์ ค่าการกระวนกระวายใจของพิกเซลย่อยที่คำนวณโดยฟังก์ชัน ffxFsr2GetJitterOffset สามารถนำไปใช้กับเมทริกซ์การฉายภาพของกล้อง ซึ่งท้ายที่สุดจะใช้เพื่อทำการแปลงระหว่างการแรเงาจุดยอด สำหรับการเรนเดอร์เรย์ทรัคควรใช้ตัวกระวนกระวายใจพิกเซลย่อยกับแหล่งกำเนิดของเรย์ซึ่งมักจะเป็นตำแหน่งของกล้อง

ไม่ว่าคุณจะเลือกใช้ฟังก์ชั่น ffxFsr2GetJitterOffset ที่แนะนำหรือตัวสร้างลำดับของคุณเองคุณต้องตั้งค่าฟิลด์ jitterOffset ของโครงสร้าง FfxFsr2DispatchDescription เพื่อแจ้ง FSR2 ของการชดเชย Jitter ที่ถูกนำไปใช้เพื่อให้แต่ละเฟรม ยิ่งกว่านั้นหากไม่ได้ใช้ฟังก์ชัน ffxFsr2GetJitterOffset ที่แนะนำควรใช้ความระมัดระวังว่าลำดับการกระวนกระวายใจของคุณไม่เคยสร้างเวกเตอร์โมฆะ นั่นคือค่า 0 ทั้งในมิติ X และ Y

ตารางด้านล่างแสดงความยาวลำดับของกระวนกระวายใจสำหรับแต่ละโหมดคุณภาพเริ่มต้น

โหมดคุณภาพ ปัจจัยการปรับขนาด ความยาวลำดับ
คุณภาพ 1.5x (ต่อมิติ) 18
สมดุล 1.7x (ต่อมิติ) 23
ผลงาน 2.0x (ต่อมิติ) 32
ประสิทธิภาพพิเศษ 3.0x (ต่อมิติ) 72
กำหนดเอง [1..N] x (ต่อมิติ) ceil(8 * n^2)

ตัดกล้องกระโดด

แอปพลิเคชันส่วนใหญ่ที่มีการเรนเดอร์แบบเรียลไทม์มีความสอดคล้องทางโลกในระดับสูงระหว่างสองเฟรมติดต่อกัน อย่างไรก็ตามมีหลายกรณีที่การเปลี่ยนแปลงการเปลี่ยนแปลงของกล้องอาจทำให้เกิดการเปลี่ยนแปลงอย่างฉับพลันในสิ่งที่แสดงผล ในกรณีเช่นนี้ FSR2 ไม่น่าจะสามารถนำข้อมูลใด ๆ ที่สะสมมาจากเฟรมก่อนหน้านี้และควรล้างข้อมูลนี้เพื่อแยกออกจากการพิจารณาในกระบวนการแต่งเพลง เพื่อบ่งบอกถึง FSR2 ว่าการตัดกระโดดเกิดขึ้นกับกล้องคุณควรตั้งค่าฟิลด์ reset ของโครงสร้าง FfxFsr2DispatchDescription เป็น true สำหรับเฟรมแรกของการแปลงกล้องที่ไม่ต่อเนื่อง

ประสิทธิภาพการเรนเดอร์อาจน้อยกว่าการดำเนินการเฟรมต่อเฟรมทั่วไปเล็กน้อยเมื่อใช้ธงรีเซ็ตเนื่องจาก FSR2 จะล้างทรัพยากรภายในเพิ่มเติมบางอย่าง

การให้น้ำหนัก MIPMAP

การใช้อคติ mipmap เชิงลบโดยทั่วไปจะสร้างภาพที่มีขนาดสูงขึ้นพร้อมรายละเอียดพื้นผิวที่ดีขึ้น เราขอแนะนำให้ใช้สูตรต่อไปนี้กับอคติ MIPMAP ของคุณ: 

mipBias = log2(renderResolution/displayResolution) - 1.0 ;

แนะนำว่าแอปพลิเคชันปรับอคติ MIP สำหรับเนื้อหาพื้นผิวความถี่สูงที่เฉพาะเจาะจงซึ่งมีความอ่อนไหวต่อการแสดงปัญหานามแฝงทางโลก

ตารางต่อไปนี้แสดงปัจจัยการให้น้ำหนัก MIPMAP ซึ่งเป็นผลมาจากการประเมิน pseudocode ข้างต้นสำหรับอัตราส่วนการปรับขนาดที่ตรงกับโหมดคุณภาพที่แนะนำซึ่งแอปพลิเคชันควรเปิดเผยต่อผู้ใช้

โหมดคุณภาพ ปัจจัยการปรับขนาด อคติ MIPMAP
คุณภาพ 1.5x (ต่อมิติ) -1.58
สมดุล 1.7x (ต่อมิติ) -1.76
ผลงาน 2.0x (ต่อมิติ) -2.0
ประสิทธิภาพพิเศษ 3.0x (ต่อมิติ) -2.58

อินพุตเฟรมเวลาเดลต้า

FSR2 API ต้องการ frameTimeDelta โดยแอปพลิเคชันผ่านโครงสร้าง FfxFsr2DispatchDescription ค่านี้อยู่ใน มิลลิวินาที : หากทำงานที่ 60fps ค่าที่ผ่านควรอยู่ที่ประมาณ 16.6f

ค่าที่ใช้ภายในส่วนประกอบชั่วคราวของคุณสมบัติการเปิดรับอัตโนมัติ FSR 2 สิ่งนี้ช่วยให้สามารถปรับการสะสมประวัติเพื่อวัตถุประสงค์ด้านคุณภาพ

รองรับ HDR

ภาพช่วงไดนามิกสูงได้รับการสนับสนุนใน FSR2 ในการเปิดใช้งานสิ่งนี้คุณควรตั้งค่า FFX_FSR2_ENABLE_HIGH_DYNAMIC_RANGE บิตในฟิลด์ flags ของโครงสร้าง FfxFsr2ContextDescription ควรให้รูปภาพแก่ FSR2 ในพื้นที่สีเชิงเส้น

การสนับสนุนพื้นที่สีเพิ่มเติมอาจมีให้ในการแก้ไข FSR2 ในอนาคต

ถอยกลับไปที่จุดลอยตัว 32 บิต

FSR2 ได้รับการออกแบบมาเพื่อใช้ประโยชน์จากการเร่งความเร็วฮาร์ดแวร์ครึ่งความแม่นยำ (FP16) เพื่อให้ได้ประสิทธิภาพสูงสุด อย่างไรก็ตามเพื่อให้ระดับความเข้ากันได้และความยืดหยุ่นสูงสุดสำหรับแอปพลิเคชัน FSR2 ยังรวมถึงความสามารถในการรวบรวม shaders โดยใช้การดำเนินงานที่แม่นยำ (FP32) เต็มรูปแบบ

ขอแนะนำให้ใช้ FSR2 เวอร์ชัน FP16 กับฮาร์ดแวร์ทั้งหมดที่รองรับ คุณสามารถสอบถามระดับการรองรับการ์ดกราฟิกของคุณสำหรับ FP16 ได้โดยการสอบถาม D3D12_FEATURE_DATA_SHADER_MIN_PRECISION_SUPPORT ความสามารถใน DirectX (R) 12 - คุณควรตรวจสอบว่า D3D[11/12]_SHADER_MIN_PRECISION_16_BIT FSR2 สำหรับ Vulkan ถ้า VkPhysicalDeviceFloat16Int8FeaturesKHR::shaderFloat16 ไม่ได้ถูกตั้งค่าคุณควรกลับไปที่ FSR2 เวอร์ชัน FP32 ในทำนองเดียวกันถ้า VkPhysicalDevice16BitStorageFeatures::storageBuffer16BitAccess ไม่ได้ตั้งค่าคุณควรกลับไปที่ FSR2 เวอร์ชัน FP32

ในการเปิดใช้งานเส้นทาง FP32 ในซอร์สโค้ด FSR2 Shader คุณควรกำหนด FFX_HALF เป็น 1 ในการแบ่งปันซอร์สโค้ดส่วนใหญ่ของอัลกอริทึมระหว่างทั้ง FP16 และ FP32 (สร้างความมั่นใจว่าการแบ่งปันรหัสระดับสูงเพื่อรองรับการบำรุงรักษาอย่างต่อเนื่อง) คุณจะสังเกตเห็นว่าซอร์สโค้ด FSR2 ใช้ชุดแมโครประเภท ประเภทฐาน 16 บิตและ 32 บิตในแหล่ง Shader

ประเภท fidelityfx FP32 FP16
FFX_MIN16_F float min16float
FFX_MIN16_F2 float2 min16float2
FFX_MIN16_F3 float3 min16float3
FFX_MIN16_F4 float4 min16float4

ตารางด้านบนระบุการแมประหว่างประเภทนามธรรม FidelityFX SDK และประเภทที่อยู่ใต้พื้นซึ่งจะถูกแทนที่ขึ้นอยู่กับการกำหนดค่าของแหล่งที่มาของ shader ในระหว่างการรวบรวม

คลื่นหน้า 64 กว้าง

GPU ที่ทันสมัยดำเนินการคอลเลกชันของเธรด - เรียกว่า Wavefronts - ร่วมกันในแฟชั่น Simt จำนวนเธรดที่แม่นยำซึ่งประกอบด้วยคลื่นเดียวคือปริมาณเฉพาะฮาร์ดแวร์ ฮาร์ดแวร์บางตัวเช่น GPU ที่ใช้ GCN และ RDNA รองรับการรวบรวม 64 เธรดเข้าด้วยกันเป็นคลื่นเดียว ขึ้นอยู่กับลักษณะที่แม่นยำของการดำเนินการของอัลกอริทึมอาจเป็นประโยชน์มากหรือน้อยในการชอบความกว้างของคลื่นที่เฉพาะเจาะจง ด้วยการแนะนำของ Shader Model 6.6 Microsoft ได้เพิ่มความสามารถในการระบุความกว้างของคลื่นผ่าน HLSL สำหรับฮาร์ดแวร์เช่น rDNA ซึ่งรองรับทั้งความกว้างของคลื่นกว้างทั้ง 32 และ 64 นี่เป็นเครื่องมือที่มีประโยชน์มากสำหรับการปรับให้เหมาะสมเนื่องจากมีวิธีที่สะอาดและพกพาในการขอให้ซอฟต์แวร์ไดรเวอร์สแต็กเรียกใช้คลื่นที่มีความกว้างเฉพาะ

สำหรับแอปพลิเคชั่นที่ใช้ DirectX (R) 12 ซึ่งทำงานบน GPU ที่ใช้ RDNA และ RDNA2 และใช้ Microsoft Agility SDK โฮสต์ API FSR2 จะเลือกความกว้างของคลื่นกว้าง 64

ตัวตรวจสอบการดีบัก

โครงสร้างคำอธิบายบริบทสามารถให้ฟังก์ชั่นการโทรกลับสำหรับการผ่านคำเตือนข้อความจากรันไทม์ FSR 2 ไปยังแอปพลิเคชันพื้นฐาน สมาชิก fpMessage ของคำอธิบายเป็นประเภท FfxFsr2Message ซึ่งเป็นตัวชี้ฟังก์ชั่นสำหรับการส่งข้อความสตริงประเภทต่างๆ การกำหนดตัวแปรนี้ให้กับฟังก์ชั่นที่เหมาะสมและผ่าน FFX_FSR2_ENABLE_DEBUG_CHECKING FLAG ภายในสมาชิก FfxFsr2ContextDescription จะเปิดใช้งานคุณสมบัติ ขอแนะนำว่าสิ่งนี้จะเปิดใช้งานเฉพาะในการสร้างการพัฒนาดีบัก

ตัวอย่างของประเภทของเอาต์พุตที่สามารถเกิดขึ้นได้เมื่อตัวตรวจสอบสังเกตปัญหาที่เป็นไปได้อยู่ด้านล่าง: 

 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)

เทคนิค

โครงสร้างอัลกอริทึม

อัลกอริทึม FSR2 ถูกนำไปใช้ในชุดของขั้นตอนซึ่งมีดังนี้:

  1. คำนวณพีระมิดความส่องสว่าง
  2. สร้างใหม่และขยาย
  3. คลิปลึก
  4. สร้างล็อค
  5. การทำซ้ำและสะสม
  6. การปรับความคมชัดของการปรับความคมชัดที่แข็งแกร่ง (RCAs)

แต่ละขั้นตอนการผ่านของอัลกอริทึมจะถูกวางในส่วนที่ตามมา แต่การไหลของข้อมูลสำหรับอัลกอริทึม FSR2 ที่สมบูรณ์จะแสดงในแผนภาพด้านล่าง

คำนวณพีระมิดความส่องสว่าง

ขั้นตอนการคำนวณความส่องสว่างของพีระมิดมีความรับผิดชอบสองประการ:

  1. ในการสร้างความสว่างของความละเอียดต่ำของอินพุตของสี สิ่งนี้ใช้โดยการตรวจจับการเปลี่ยนแปลงการแรเงาในการสะสมผ่าน
  2. ในการผลิตพื้นผิวการเปิดรับแสง 1x1 ซึ่งเป็นทางเลือกในการใช้ tonemapping และขั้นตอนการทำซ้ำและสะสมสำหรับการย้อนกลับ tonemapping ท้องถิ่นก่อนที่จะผลิตผลลัพธ์จาก FSR2

อินพุตทรัพยากร

ตารางต่อไปนี้มีทรัพยากรทั้งหมดที่ใช้โดยขั้นตอนการคำนวณความส่องสว่างพีระมิด

เลเยอร์ชั่วคราวบ่งชี้ว่าเฟรมใดที่ควรมาจากข้อมูล 'เฟรมปัจจุบัน' หมายความว่าข้อมูลควรได้รับจากทรัพยากรที่สร้างขึ้นสำหรับเฟรมที่จะนำเสนอต่อไป 'เฟรมก่อนหน้า' ระบุว่าข้อมูลควรได้รับจากทรัพยากรที่ถูกสร้างขึ้นสำหรับเฟรมที่เพิ่งนำเสนอ คอลัมน์ความละเอียดระบุว่าข้อมูลควรอยู่ที่ความละเอียด 'แสดงผล' หรือความละเอียด 'การนำเสนอ' หรือไม่ ความละเอียด 'การแสดงผล' บ่งชี้ว่าทรัพยากรควรตรงกับความละเอียดที่แอปพลิเคชันกำลังดำเนินการเรนเดอร์ ในทางกลับกัน 'การนำเสนอ' บ่งชี้ว่าความละเอียดของเป้าหมายควรตรงกับสิ่งที่จะนำเสนอให้กับผู้ใช้

ชื่อ ชั้นชั่วคราว ปณิธาน รูปแบบ พิมพ์ หมายเหตุ
บัฟเฟอร์สี กรอบปัจจุบัน เรนเดอร์ APPLICATION SPECIFIED พื้นผิว บัฟเฟอร์สีความละเอียดของเรนเดอร์สำหรับเฟรมปัจจุบันที่จัดทำโดยแอปพลิเคชัน หากเนื้อหาของบัฟเฟอร์สีอยู่ในช่วงไดนามิกสูง (HDR) ดังนั้นควรตั้งค่าสถานะ FFX_FSR2_ENABLE_HIGH_DYNAMIC_RANGE ใน flags FfxFsr2ContextDescription

เอาต์พุตทรัพยากร

ตารางต่อไปนี้มีทรัพยากรทั้งหมดที่ผลิตหรือแก้ไขโดยขั้นตอนการคำนวณ Luminance Pyramid

เลเยอร์ชั่วคราวบ่งชี้ว่าเฟรมใดที่ควรมาจากข้อมูล 'เฟรมปัจจุบัน' หมายความว่าข้อมูลควรได้รับจากทรัพยากรที่สร้างขึ้นสำหรับเฟรมที่จะนำเสนอต่อไป 'เฟรมก่อนหน้า' ระบุว่าข้อมูลควรได้รับจากทรัพยากรที่ถูกสร้างขึ้นสำหรับเฟรมที่เพิ่งนำเสนอ คอลัมน์ความละเอียดระบุว่าข้อมูลควรอยู่ที่ความละเอียด 'แสดงผล' หรือความละเอียด 'การนำเสนอ' หรือไม่ ความละเอียด 'การแสดงผล' บ่งชี้ว่าทรัพยากรควรตรงกับความละเอียดที่แอปพลิเคชันกำลังดำเนินการเรนเดอร์ ในทางกลับกัน 'การนำเสนอ' บ่งชี้ว่าความละเอียดของเป้าหมายควรตรงกับสิ่งที่จะนำเสนอให้กับผู้ใช้

ชื่อ ชั้นชั่วคราว ปณิธาน รูปแบบ พิมพ์ หมายเหตุ
การรับสัมผัสเชื้อ กรอบปัจจุบัน 1x1 R32_FLOAT พื้นผิว พื้นผิว 1x1 ที่มีค่าแสงที่คำนวณสำหรับเฟรมปัจจุบัน ทรัพยากรนี้เป็นทางเลือกและอาจถูกละเว้นหากตั้งค่าสถานะ FFX_FSR2_ENABLE_AUTO_EXPOSURE ถูกตั้งค่าในฟิลด์ flags ของโครงสร้าง FfxFsr2ContextDescription เมื่อสร้าง FfxFsr2Context
ความส่องสว่างปัจจุบัน กรอบปัจจุบัน Render * 0.5 + mipchain R16_FLOAT พื้นผิว พื้นผิวที่ 50% ของพื้นผิวความละเอียดของเรนเดอร์ซึ่งมีความส่องสว่างของเฟรมปัจจุบัน มีการจัดสรรโซ่ MIP เต็มรูปแบบ

คำอธิบาย

ขั้นตอนการคำนวณความส่องสว่างพีระมิดถูกนำมาใช้โดยใช้ FidelityFX Single Pass Downs

ขยาย
ข้อมูลเพิ่มเติม
แอปที่เกี่ยวข้อง
แนะนำสำหรับคุณ
ข้อมูลที่เกี่ยวข้อง ทั้งหมด