FidelityFX FSR2
v2.2.1
Авторское право (c) 2023 Advanced Micro Devices, Inc. Все права защищены.
Настоящим разрешение бесплатно предоставляется любому лицу, получившему копию этого программного обеспечения и связанных с ним файлов документации («Программное обеспечение»), на использование Программного обеспечения без ограничений, включая, помимо прочего, права на использование, копирование, изменение, объединение. публиковать, распространять, сублицензировать и/или продавать копии Программного обеспечения, а также разрешать лицам, которым предоставлено Программное обеспечение, делать это при соблюдении следующих условий: Приведенное выше уведомление об авторских правах и настоящее уведомление о разрешении должны быть включены во все копии. или существенные части Программного обеспечения.
ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ, ЯВНЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ, НО НЕ ОГРАНИЧИВАЯСЬ, ГАРАНТИЯМИ ТОВАРНОЙ ЦЕННОСТИ, ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЕННОЙ ЦЕЛИ И НЕНАРУШЕНИЯ ПРАВ. НИ ПРИ КАКИХ ОБСТОЯТЕЛЬСТВАХ АВТОРЫ ИЛИ ОБЛАДАТЕЛИ АВТОРСКИХ ПРАВ НЕ НЕСУТ ОТВЕТСТВЕННОСТИ ЗА ЛЮБЫЕ ПРЕТЕНЗИИ, УБЫТКИ ИЛИ ДРУГУЮ ОТВЕТСТВЕННОСТЬ, БУДЬ В ДЕЙСТВИЯХ ПО КОНТРАКТУ, ПРАВОНАРУШЕНИЮ ИЛИ ДРУГИМ ОБРАЗОМ, ВОЗНИКАЮЩИЕ ОТ, ИЗ ИЛИ В СВЯЗИ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ ИЛИ ИСПОЛЬЗОВАНИЕМ ИЛИ ДРУГИМИ СДЕЛКАМИ, ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ.
FSR2 использует временную обратную связь для восстановления изображений с высоким разрешением, сохраняя и даже улучшая качество изображения по сравнению с собственным рендерингом.
FSR2 может обеспечить «практическую производительность» для дорогостоящих операций рендеринга, таких как аппаратная трассировка лучей.
HLSL CS_6_2 CS_6_6*
* - CS_6_6 используется на некотором оборудовании, поддерживающем волновые фронты шириной 64.
Чтобы использовать FSR2, вам необходимо выполнить следующие действия:
Дважды щелкните GenerateSolutions.bat в каталоге build .
Откройте решение, соответствующее вашему API, и создайте его.
Скопируйте библиотеку API из bin/ffx_fsr2_api в папку, содержащую папку вашего проекта, содержащую сторонние библиотеки.
Скопируйте библиотеку, соответствующую серверной части FSR2, которую вы хотите использовать, например: bin/ffx_fsr2_api/ffx_fsr2_api_dx12_x64.lib для DirectX12.
Скопируйте следующие файлы заголовков основного 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 . Следует позаботиться о сохранении относительной структуры каталогов в месте назначения копирования файла.
Скопируйте файлы заголовков для выбранного вами бэкэнда API, например, для DirectX12 вы должны скопировать dx12/ffx_fsr2_dx12.h и dx12/shaders/ffx_fsr2_shaders_dx12.h . Следует позаботиться о сохранении относительной структуры каталогов в месте назначения копирования файла.
Включите заголовочный файл ffx_fsr2.h в свою кодовую базу, где вы хотите взаимодействовать с FSR2.
Создайте бэкэнд для вашего целевого API. Например, для DirectX12 вам следует вызвать ffxFsr2GetInterfaceDX12 . Необходимо выделить рабочий буфер размера, возвращаемого вызовом ffxFsr2GetScratchMemorySizeDX12 , и указатель на этот буфер передается в ffxFsr2GetInterfaceDX12 .
Создайте контекст FSR2, вызвав ffxFsr2ContextCreate . Структура параметров должна быть заполнена в соответствии с конфигурацией вашего приложения. Дополнительные сведения см. в справочной документации API.
Каждый кадр вы должны вызывать ffxFsr2ContextDispatch для запуска рабочих нагрузок FSR2. Структура параметров должна быть заполнена в соответствии с конфигурацией вашего приложения. Дополнительные сведения см. в справочной документации API и убедитесь, что frameTimeDelta указано в миллисекундах.
Когда ваше приложение завершается (или вы хотите уничтожить контекст по другой причине), вам следует вызвать ffxFsr2ContextDestroy . Перед вызовом этой функции графический процессор должен простаивать.
Субпиксельное дрожание должно быть применено к матрице проекции вашего приложения. Это следует сделать при выполнении основного рендеринга вашего приложения. Вам следует использовать функцию ffxFsr2GetJitterOffset для вычисления точных смещений джиттера. Дополнительную информацию см. в разделе «Дрожание камеры».
Для достижения наилучшего качества масштабирования настоятельно рекомендуется заполнить Реактивную маску и Маску прозрачности и композиции в соответствии с нашими рекомендациями. Вы также можете использовать ffxFsr2ContextGenerateReactiveMask в качестве отправной точки.
Приложения должны предоставлять режимы масштабирования в своем пользовательском интерфейсе в следующем порядке: «Качество», «Сбалансированный», «Производительность» и (необязательно) «Сверхпроизводительность».
Приложения также должны иметь ползунок повышения резкости, чтобы конечные пользователи могли добиться дополнительного качества.
Для удобства конечных пользователей API FSR2 предоставляет ряд предустановленных коэффициентов масштабирования, которые имеют названия.
| Качество | Коэффициент масштабирования по измерению |
|---|---|
| Качество | 1,5x |
| Сбалансированный | 1,7x |
| Производительность | 2,0x |
| Ультра производительность | 3,0x |
Мы настоятельно рекомендуем приложениям использовать в пользовательском интерфейсе единообразные соотношения имен и масштабирования. Это необходимо для обеспечения единообразия взаимодействия с пользователями вашего приложения, которые могут иметь опыт работы с другими приложениями, использующими FSR2.
В зависимости от вашего целевого оборудования и операционной конфигурации FSR2 будет работать на разных уровнях производительности.
В таблице ниже приведены измеренные показатели производительности FSR2 на различном оборудовании в DX12.
| Целевое разрешение | Качество | RX 7900 ХТХ | RX 6950 XT | RX 6900 XT | RX 6800 XT | РХ 6800 | RX 6700 XT | RX 6650 XT | RX 5700 XT | RX Вега 56 | РХ 590 |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 3840x2160 | Качество (1,5x) | 0,7 мс | 1,1 мс | 1,2 мс | 1,2 мс | 1,4 мс | 2,0 мс | 2,8 мс | 2,4 мс | 4,9 мс | 5,4 мс |
| Сбалансированный (1,7x) | 0,6 мс | 1,0 мс | 1,0 мс | 1,1 мс | 1,4 мс | 1,8 мс | 2,6 мс | 2,2 мс | 4,1 мс | 4,9 мс | |
| Производительность (2x) | 0,6 мс | 0,9 мс | 1,0 мс | 1,0 мс | 1,3 мс | 1,7 мс | 2,3 мс | 2,0 мс | 3,6 мс | 4,4 мс | |
| Ультра перф. (3x) | 0,5 мс | 0,8 мс | 0,8 мс | 0,9 мс | 1,1 мс | 1,5 мс | 1,8 мс | 1,7 мс | 2,9 мс | 3,7 мс | |
| 2560x1440 | Качество (1,5x) | 0,3 мс | 0,5 мс | 0,5 мс | 0,5 мс | 0,7 мс | 0,9 мс | 1,2 мс | 1,1 мс | 1,9 мс | 2,3 мс |
| Сбалансированный (1,7x) | 0,3 мс | 0,5 мс | 0,5 мс | 0,5 мс | 0,6 мс | 0,8 мс | 1,1 мс | 1,0 мс | 1,7 мс | 2,1 мс | |
| Производительность (2x) | 0,3 мс | 0,4 мс | 0,4 мс | 0,4 мс | 0,6 мс | 0,8 мс | 0,9 мс | 0,9 мс | 1,5 мс | 1,9 мс | |
| Ультра перф. (3x) | 0,2 мс | 0,4 мс | 0,4 мс | 0,4 мс | 0,5 мс | 0,7 мс | 0,8 мс | 0,8 мс | 1,2 мс | 1,7 мс | |
| 1920x1080 | Качество (1,5x) | 0,2 мс | 0,3 мс | 0,3 мс | 0,3 мс | 0,4 мс | 0,5 мс | 0,6 мс | 0,6 мс | 1,0 мс | 1,3 мс |
| Сбалансированный (1,7x) | 0,2 мс | 0,3 мс | 0,3 мс | 0,3 мс | 0,4 мс | 0,5 мс | 0,6 мс | 0,6 мс | 0,9 мс | 1,2 мс | |
| Производительность (2x) | 0,2 мс | 0,2 мс | 0,2 мс | 0,3 мс | 0,3 мс | 0,5 мс | 0,5 мс | 0,5 мс | 0,8 мс | 1,1 мс | |
| Ультра перф. (3x) | 0,1 мс | 0,2 мс | 0,2 мс | 0,2 мс | 0,3 мс | 0,4 мс | 0,4 мс | 0,4 мс | 0,7 мс | 0,9 мс |
Цифры округлены до ближайших 0,1 мс, не имеют дополнительной sharpness и могут быть изменены.
Использование FSR2 требует выделения некоторой дополнительной локальной памяти графического процессора для использования графическим процессором. При использовании API FSR2 эта память выделяется при создании контекста FSR2 и делается это посредством серии обратных вызовов, которые составляют внутренний интерфейс. Эта память используется для хранения промежуточных поверхностей, вычисляемых алгоритмом FSR2, а также поверхностей, которые сохраняются во многих кадрах приложения. В таблице ниже указан объем памяти, используемый FSR2 в различных условиях эксплуатации. В столбце «Рабочий набор» указан общий объем памяти, используемый FSR2 при выполнении алгоритма на графическом процессоре; это объем памяти, который потребуется для работы FSR2. В столбце «Постоянная память» указано, какую часть столбца «Рабочий набор» необходимо оставить нетронутой для последующих кадров приложения; в этой памяти хранятся временные данные, используемые FSR2. Столбец «Псевдонимная память» указывает, какая часть столбца «Рабочий набор» может быть псевдонимом поверхностей или других ресурсов, используемых приложением за пределами рабочих границ FSR2.
Вы можете взять под свой контроль создание ресурсов в FSR2, переопределив части создания и уничтожения ресурсов внутреннего интерфейса FSR2 и перенаправив флаги псевдонимов. Это означает, что для идеальной интеграции FSR2 требуется дополнительная память, равная столбцу «Постоянная память» таблицы ниже, в зависимости от ваших условий эксплуатации.
| Разрешение | Качество | Рабочий набор (МБ) | Постоянная память (МБ) | Альтернативная память (МБ) |
|---|---|---|---|---|
| 3840x2160 | Качество (1,5x) | 448 МБ | 354 МБ | 93 МБ |
| Сбалансированный (1,7x) | 407 МБ | 330 МБ | 77 МБ | |
| Производительность (2x) | 376 МБ | 312 МБ | 63 МБ | |
| Ультра производительность (3x) | 323 МБ | 281 МБ | 42 МБ | |
| 2560x1440 | Качество (1,5x) | 207 МБ | 164 МБ | 43 МБ |
| Сбалансированный (1,7x) | 189 МБ | 153 МБ | 36 МБ | |
| Производительность (2x) | 172 МБ | 143 МБ | 29 МБ | |
| Ультра производительность (3x) | 149 МБ | 130 МБ | 19 МБ | |
| 1920x1080 | Качество (1,5x) | 115 МБ | 90 МБ | 24 МБ |
| Сбалансированный (1,7x) | 105 МБ | 85 МБ | 20 МБ | |
| Производительность (2x) | 101 МБ | 83 МБ | 18 МБ | |
| Ультра производительность (3x) | 84 МБ | 72 МБ | 11 МБ |
Цифры являются приблизительными и округлены до ближайшего МБ с использованием графического процессора RX 6700XT в 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) | Текстура | Векторы 2D-движения для текущего кадра, предоставленные приложением в диапазоне [ (<-width, -height> .. <width, height> ]. Если ваше приложение отображает векторы движения с другим диапазоном, вы можете использовать поле motionVectorScale структуру FfxFsr2DispatchDescription , чтобы настроить их в соответствии с ожидаемым диапазоном для FSR2. Внутренне FSR2 во многих случаях использует 16-битные величины для представления векторов движения, что означает. что, хотя векторы движения могут быть предоставлены с большей точностью, FSR2 не выиграет от повышенной точности. Разрешение буфера векторов движения должно быть равно разрешению рендеринга, если только в поле flags структуры FfxFsr2ContextDescription не установлен флаг FFX_FSR2_ENABLE_DISPLAY_RESOLUTION_MOTION_VECTORS . создание FfxFsr2Context , и в этом случае оно должно быть равно разрешению презентации. |
| Реактивная маска | Оказывать | R8_UNORM | Текстура | Поскольку некоторые области визуализированного изображения не оставляют следов в буфере глубины и не содержат векторов движения, FSR2 обеспечивает поддержку текстуры реактивной маски, которую можно использовать для указания FSR2, где находятся такие области. Хорошими примерами являются частицы или объекты с альфа-смешением, которые не записывают глубину или векторы движения. Если этот ресурс не установлен, то логика обнаружения изменения затенения FSR2 будет обрабатывать эти случаи как можно лучше, но для достижения оптимальных результатов этот ресурс должен быть установлен. Более подробную информацию о реактивной маске можно найти в разделе «Реактивная маска». |
| Контакт | 1х1 | R32_FLOAT | Текстура | Текстура 1x1, содержащая значение экспозиции, вычисленное для текущего кадра. Этот ресурс является необязательным и может быть опущен, если флаг FFX_FSR2_ENABLE_AUTO_EXPOSURE установлен в поле flags структуры FfxFsr2ContextDescription при создании FfxFsr2Context . |
Все входные данные, предоставляемые с разрешением рендеринга, за исключением векторов движения, должны визуализироваться с джиттером. К векторам движения не должно применяться дрожание, если не присутствует флаг FFX_FSR2_ENABLE_MOTION_VECTORS_JITTER_CANCELLATION .
Настоятельно рекомендуется использовать инвертированный буфер бесконечной глубины с FSR2. Однако поддерживаются альтернативные конфигурации буфера глубины. Приложение должно сообщить FSR2 API о конфигурации своего буфера глубины, установив соответствующие флаги во время создания FfxFsr2Context . В таблице ниже приведены соответствующие флаги.
| Флаг ФСР2 | Примечание |
|---|---|
FFX_FSR2_ENABLE_DEPTH_INVERTED | Бит, указывающий, что предоставленные входные данные буфера глубины инвертированы [макс..0]. |
FFX_FSR2_ENABLE_DEPTH_INFINITE | Бит, указывающий, что предоставленные входные данные буфера глубины используют бесконечную дальнюю плоскость. |
Ключевой частью временного алгоритма (будь то сглаживание или масштабирование) является предоставление векторов движения. FSR2 принимает векторы движения в 2D, которые кодируют движение от пикселя текущего кадра до положения того же пикселя в предыдущем кадре. FSR2 ожидает, что векторы движения предоставляются приложением в диапазоне [ <-width, -height> .. <width, height> ]; это соответствует экранному пространству. Например, вектор движения для пикселя в верхнем левом углу экрана со значением <width, height> будет представлять собой движение, которое пересекает всю ширину и высоту входных поверхностей, начиная с правого нижнего угла. .
Если ваше приложение вычисляет векторы движения в другом пространстве — например, в нормализованном пространстве координат устройства — тогда вы можете использовать поле motionVectorScale структуры FfxFsr2DispatchDescription , чтобы дать указание FSR2 настроить их в соответствии с ожидаемым диапазоном для FSR2. Приведенные ниже примеры кода иллюстрируют, как векторы движения можно масштабировать в пространстве экрана. В приведенном ниже примере кода HLSL и C++ показано, как можно масштабировать векторы движения в пространстве NDC с помощью API хоста 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; Внутренне FSR2 во многих случаях использует 16-битные величины для представления векторов движения, а это означает, что, хотя векторы движения могут быть предоставлены с большей точностью, FSR2 в настоящее время не получит выгоды от повышенной точности. Разрешение буфера вектора движения должно быть равно разрешению рендеринга, если только флаг FFX_FSR2_ENABLE_DISPLAY_RESOLUTION_MOTION_VECTORS не установлен в поле flags структуры FfxFsr2ContextDescription при создании FfxFsr2Context , и в этом случае оно должно быть равно разрешению представления.
FSR2 будет выполнять более качественное масштабирование, когда больше объектов предоставит свои векторы движения. Поэтому рекомендуется, чтобы все непрозрачные, альфа-тестированные и альфа-смешенные объекты записывали свои векторы движения для всех закрытых пикселей. Если применяются эффекты вершинного шейдера, такие как прокрутка UV, эти расчеты также следует учитывать при расчете движения для достижения наилучших результатов. Для объектов с альфа-смешением также настоятельно рекомендуется сохранять значение альфа каждого закрытого пикселя в соответствующем пикселе в реактивной маске. Это позволит FSR2 лучше обрабатывать объекты с альфа-смешением во время масштабирования. Реактивная маска особенно важна для объектов с альфа-смешением, где запись векторов движения может быть невозможна, например, для частиц.
В контексте FSR2 термин «реактивность» означает, какое влияние оказывают образцы, визуализированные для текущего кадра, на создание окончательного увеличенного изображения. Обычно образцы, визуализированные для текущего кадра, вносят относительно небольшой вклад в результат, вычисленный FSR2; однако есть исключения. Чтобы получить наилучшие результаты для быстро движущихся объектов с альфа-смешением, FSR2 требует, чтобы этап «Перепроектирование и накопление» стал более реактивным для таких пикселей. Поскольку не существует хорошего способа определить по цвету, глубине или векторам движения, какие пиксели были визуализированы с использованием альфа-смешивания, FSR2 работает лучше всего, когда приложения явно отмечают такие области.
Поэтому настоятельно рекомендуется, чтобы приложения предоставляли реактивную маску для FSR2. Реактивная маска указывает FSR2, где ему следует уменьшить зависимость от исторической информации при компоновке текущего пикселя и вместо этого позволить выборкам текущего кадра вносить больший вклад в конечный результат. Реактивная маска позволяет приложению предоставлять значение от [0.0..1.0], где 0,0 указывает, что пиксель вообще не является реактивным (и должен использовать стратегию композиции FSR2 по умолчанию), а значение 1,0 указывает, что пиксель должен быть полностью реактивный. Это диапазон с плавающей запятой, который можно адаптировать к различным ситуациям.
Хотя существуют и другие приложения для реактивной маски, основное применение реактивной маски дает лучшие результаты при масштабировании изображений, которые включают объекты с альфа-смешением. Хорошим показателем реактивности на самом деле является значение альфа, используемое при компоновке объекта с альфа-смешением в сцену, поэтому приложения должны записывать alpha в реактивную маску. Следует отметить, что маловероятно, что реактивное значение, близкое к 1, когда-либо даст хорошие результаты. Поэтому мы рекомендуем ограничить максимальное реактивное значение примерно до 0,9.
Если реактивная маска не предоставлена FSR2 (путем установки reactive поля FfxFsr2DispatchDescription в NULL ), тогда будет использоваться внутренне сгенерированная текстура 1x1 с очищенным реактивным значением.
Чтобы помочь приложениям генерировать реактивную маску и маску прозрачности и композиции, FSR2 предоставляет дополнительный вспомогательный API. Под капотом API запускает вычислительный шейдер, который вычисляет эти значения для каждого пикселя, используя эвристику на основе яркости.
Приложения, желающие сделать это, могут вызвать функцию ffxFsr2ContextGenerateReactiveMask и должны передать две версии цветового буфера: одна содержит только непрозрачную геометрию, а другая содержит как непрозрачные объекты, так и объекты с альфа-смешением.
Помимо реактивной маски, FSR2 позволяет приложению обозначать области другого специального рендеринга, которые следует учитывать в процессе масштабирования. Примеры такого специального рендеринга включают области отражений с трассировкой лучей или анимированные текстуры.
В то время как маска «Реактивная» регулирует баланс накопления, маска «Прозрачность и композиция» регулирует механизмы защиты истории пикселей. Маска также устраняет влияние фактора нестабильности яркости. Пиксель со значением 0 в маске «Прозрачность и композиция» не вносит никаких дополнительных изменений в блокировку этого пикселя. И наоборот, значение 1 означает, что блокировку этого пикселя следует полностью снять.
Если маска прозрачности и композиции не предоставлена FSR2 (путем установки для поля transparencyAndComposition FfxFsr2DispatchDescription значения NULL ), тогда будет использоваться внутренне сгенерированная текстура 1x1 с очищенными значениями прозрачности и композиции.
FSR2.2 включает экспериментальную функцию автоматического создания реактивной маски и маски прозрачности и композиции. Чтобы включить это, поле enableAutoReactive в FfxFsr2DispatchDescription должно быть установлено в значение «TRUE», а копия непрозрачных частей обратного буфера должна быть предоставлена в «colorOpaqueOnly». Затем FSR2 автоматически сгенерирует и будет использовать внутри себя реактивную маску, а также маску прозрачности и композиции. Маски генерируются в ходе вычисления путем анализа разницы цветового буфера с прозрачной геометрией и без нее, а также сравнения ее с предыдущим кадром. На основе результатов этих вычислений каждому пикселю присваиваются значения реактивной маски и маски прозрачности и композиции. Чтобы использовать автоматическое создание масок, необходимо также указать следующие 4 значения для масштабирования и ограничения интенсивности масок (обратите внимание, что упомянутые значения по умолчанию являются рекомендуемыми стартовыми значениями, но их следует настраивать для каждого заголовка):
Эта функция предназначена для помощи в интеграции FSR2.2 в новый движок или игру. Однако для достижения наилучшего качества мы по-прежнему рекомендуем самостоятельно визуализировать маску «Реактивная маска» и маску «Прозрачность и композиция», поскольку ожидается, что создание этих значений на основе материала будет более надежным, чем автоматическое создание их из окончательного изображения.
Обратите внимание, что эта функция все еще находится на экспериментальной стадии и может существенно измениться в будущем.
FSR2 предоставляет два значения, которые управляют экспозицией, используемой при выполнении масштабирования. Они заключаются в следующем:
Значение экспозиции должно совпадать с тем, которое приложение использует во время любых последующих проходов тональной компрессии, выполняемых приложением. Это означает, что 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 — повысить производительность рендеринга приложений за счет использования алгоритма временного масштабирования, основанного на ряде входных данных. Поэтому его размещение в конвейере является ключом к обеспечению правильного баланса между высочайшим качеством изображения и отличной производительностью.
При любом подходе к масштабированию изображения важно понимать, как разместить другие алгоритмы пространства изображения относительно алгоритма масштабирования. Размещение этих других эффектов пространства изображения до масштабирования имеет то преимущество, что они выполняются с более низким разрешением, что, конечно, дает приложению преимущество в производительности. Однако это может быть неприемлемо для некоторых классов методов пространства изображений. Например, многие приложения могут вносить в конечное изображение шум или зернистость, возможно, для имитации физической камеры. Если сделать это до того, как программа масштабирования увеличит масштаб, это может привести к усилению шума, что приведет к нежелательным артефактам в результирующем увеличенном изображении. В следующей таблице распространенные методы работы с пространством изображений в реальном времени разделены на два столбца. «Постобработка А» содержит все методы, которые обычно выполняются до масштабирования FSR2, то есть все они выполняются с разрешением рендеринга. И наоборот, столбец «Постобработка B» содержит все методы, которые рекомендуется использовать после FSR2, то есть они будут работать с более высоким разрешением представления.
| Постобработка А | Постобработка Б |
|---|---|
| Отражения в экранном пространстве | Зерно пленки |
| Окружающая окклюзия экранного пространства | Хроматическая аберрация |
| Денойзеры (тени, отражения) | Виньетка |
| Экспозиция (необязательно) | Тональное отображение |
| Цвести | |
| Глубина резкости | |
| Размытие в движении |
Обратите внимание, что приведенные здесь рекомендации предназначены только для ознакомительных целей и зависят от точных характеристик реализации вашего приложения.
Хотя можно сгенерировать соответствующие промежуточные ресурсы, скомпилировать код шейдера, установить привязки и отправить отправки, гораздо проще использовать предоставляемый API хоста FSR2.
Чтобы использовать API, вам следует связать библиотеки FSR2 (подробнее о том, какие именно) и включить заголовочный файл ffx_fsr2.h , который, в свою очередь, имеет следующие зависимости заголовков:
ffx_assert.h
ffx_error.h
ffx_fsr2_interface.h
ffx_types.h
ffx_util.h
Чтобы использовать API FSR2, вам следует связать файл ffx_fsr2_api_x64.lib , который предоставит символы для API, ориентированных на приложение. Однако API FSR2 имеет модульную серверную часть, а это означает, что различные графические API и платформы могут быть ориентированы на использование соответствующего серверной части. Поэтому вам следует дополнительно включить серверную библиотеку, соответствующую вашим требованиям, согласно таблице ниже.
| Цель | Название библиотеки |
|---|---|
| DirectX(R)12 | ffx_fsr2_dx12_x64.lib |
| Вулкан(R) | ffx_fsr2_vk_x64.lib |
Обратите внимание, что модульная архитектура API FSR2 позволяет реализовать собственные серверные части. Более подробную информацию см. в разделе Модульный бэкэнд.
Чтобы начать использовать API, приложение должно сначала создать структуру FfxFsr2Context . Эта структура должна располагаться где-то со временем жизни, примерно совпадающим со временем жизни вашего обратного буфера; место в куче приложения обычно является хорошим выбором. При вызове ffxFsr2ContextCreate структура FfxFsr2Context будет заполнена необходимыми данными. Более того, из ffxFsr2ContextCreate будет выполнено несколько вызовов к серверной части, которая предоставляется FfxFsr2Context как часть структуры FfxFsr2ContextDescription . Эти вызовы будут выполнять такие задачи, как создание промежуточных ресурсов, необходимых для FSR2, а также настройка шейдеров и связанного с ними состояния конвейера. API FSR2 не выполняет динамическое распределение памяти.
В каждом кадре вашего приложения, где требуется масштабирование, вы должны вызывать ffxFsr2ContextDispatch . Эта функция принимает структуру FfxFsr2Context , созданную ранее во время существования приложения, а также описание того, как именно следует выполнять масштабирование и для каких данных. Это описание предоставляется приложением, заполняющим структуру FfxFsr2DispatchDescription .
Уничтожение контекста выполняется вызовом ffxFsr2ContextDestroy . Обратите внимание, что перед попыткой вызова ffxFsr2ContextDestroy графический процессор должен простаивать, а функция не выполняет неявную синхронизацию, чтобы гарантировать, что ресурсы, к которым обращается FSR2, в данный момент не находятся в работе. Причина этого выбора заключается в том, чтобы избежать введения FSR2 дополнительных сбросов графического процессора для приложений, которые уже выполняют адекватную синхронизацию в тот момент, когда они могут захотеть уничтожить FfxFsr2Context . Это позволяет приложению выполнять наиболее эффективное создание и удаление API FSR2, когда необходимый.
Существуют дополнительные вспомогательные функции, предоставляемые как часть API FSR2. Эти вспомогательные функции выполняют такие задачи, как вычисление смещений субпиксельного дрожания, а также расчет разрешения рендеринга на основе разрешения диспетчеризации и режимов масштабирования по умолчанию, предоставляемых FSR2.
Более подробную документацию по API FSR2 можно найти в предоставленной справочной документации по API.
Конструкция API FSR2 означает, что базовая реализация алгоритма FSR2 не знает, на каком API рендеринга она работает. Вместо этого FSR2 вызывает функции, предоставленные ему через интерфейс, что позволяет использовать различные серверные части с FSR2. Эта конструкция также позволяет приложениям, интегрирующим FSR2, обеспечивать собственную реализацию серверной части, а это означает, что платформы, которые FSR2 в настоящее время не поддерживает, могут быть нацелены на реализацию нескольких функций. Более того, приложения, которые имеют свои собственные абстракции рендеринга, также могут реализовать свою собственную серверную часть, взяв под контроль все аспекты базовой функции FSR2, включая управление памятью, создание ресурсов, компиляцию шейдеров, привязку ресурсов шейдеров и отправку рабочих нагрузок FSR2 на графическое устройство. .
Изначально API FSR2 будет компилироваться в несколько библиотек, следуя уже описанному разделению между основным API и серверными модулями. Это означает, что если вы хотите использовать серверные части, поставляемые с FSR2, вам следует связать как основную библиотеку API FSR2, так и серверную часть, соответствующую вашим требованиям.
Публичная версия FSR2 поставляется с серверными модулями DirectX(R)12 и Vulkan(R), но другие серверные части доступны по запросу. Для получения дополнительной информации обратитесь к представителю AMD Developer Technology.
Если API FSR2 используется с одним из поставляемых серверных модулей (например, 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 . Если в поле flags установлено FFX_RESOURCE_FLAGS_ALIASABLE это указывает на то, что ресурс может быть безопасно сопоставлен с другими ресурсами в кадре рендеринга.
Временное сглаживание (TAA) — это метод, который использует выходные данные предыдущих кадров для создания выходных данных более высокого качества из текущего кадра. Поскольку FSR2 преследует аналогичную цель – хотя и с дополнительной целью увеличения разрешения визуализированного изображения – больше нет необходимости включать в ваше приложение отдельный проход TAA.
FSR2 использует приложение для применения субпиксельного дрожания во время рендеринга — оно обычно включается в матрицу проекции камеры. Чтобы упростить применение джиттера камеры, API FSR2 предоставляет небольшой набор служебных функций, которые вычислят смещение субпиксельного дрожания для конкретного кадра в последовательности отдельных смещений дрожания.
int32_t ffxFsr2GetJitterPhaseCount ( int32_t renderWidth, int32_t displayWidth);
FfxErrorCode ffxFsr2GetJitterOffset ( float * outX, float * outY, int32_t jitterPhase, int32_t sequenceLength);Внутри эти функции реализуют последовательность Холтона[2,3] [Халтон]. Цель последовательности Холтона — предоставить пространственно разделенные точки, покрывающие доступное пространство.
Важно понимать, что значения, возвращаемые из 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; Джиттер должен применяться ко всему рендерингу. Сюда входят непрозрачные, альфа-прозрачные объекты и объекты с трассировкой лучей. Для растеризованных объектов значения субпиксельного дрожания, рассчитанные с помощью функции ffxFsr2GetJitterOffset могут быть применены к матрице проекции камеры, которая в конечном итоге используется для выполнения преобразований во время затенения вершин. Для рендеринга с трассировкой лучей субпиксельное дрожание должно применяться к началу луча — часто к положению камеры.
Независимо от того, используете ли вы рекомендованную функцию ffxFsr2GetJitterOffset или свой собственный генератор последовательностей, необходимо установить поле jitterOffset в структуре FfxFsr2DispatchDescription , чтобы информировать FSR2 о смещении дрожания, которая была применена для отображения каждого кадра. Более того, если не использование рекомендуемой функции 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:
mipBias = log2(renderResolution/displayResolution) - 1.0 ;Предполагается, что приложения корректируют смещение MIP для конкретного высокочастотного содержания текстуры, которое подвержено демонстрации вопросов временного псевдонима.
Следующая таблица иллюстрирует коэффициент смещения MIPMAP, который является результатом оценки вышеуказанного псевдокода для коэффициентов масштабирования, соответствующих рекомендуемым режимам качества, которые приложения должны подвергать конечным пользователям.
| Качественный режим | Масштабирование коэффициента | MIPMAP смещение |
|---|---|---|
| Качество | 1,5x (за измерение) | -1,58 |
| Сбалансированный | 1,7x (за измерение) | -1,76 |
| Производительность | 2.0x (за измерение) | -2,0 |
| Ультрапроизводительность | 3,0x (за измерение) | -2,58 |
API FSR2 требует, чтобы frameTimeDelta была предоставлена применением через структуру FfxFsr2DispatchDescription . Это значение находится в миллисекундах : при запуске со скоростью 60 кадров в секунду, пройденное значение должно составлять около 16,6F .
Значение используется в височном компоненте функции автоэкспозиции FSR 2. Это позволяет настраивать накопление истории в целях качества.
Изображения высокого динамического диапазона поддерживаются в FSR2. Чтобы включить это, вы должны установить бит FFX_FSR2_ENABLE_HIGH_DYNAMIC_RANGE в поле flags структуры FfxFsr2ContextDescription . Изображения должны быть предоставлены FSR2 в линейном цветовом пространстве.
Поддержка дополнительных цветных пространств может быть предоставлена в будущем пересмотре FSR2.
FSR2 был разработан, чтобы воспользоваться преимуществами аппаратного ускорения половины точности (FP16) для достижения максимально возможной производительности. Однако, чтобы обеспечить максимальный уровень совместимости и гибкости для приложений, FSR2 также включает в себя возможность компилировать шейдеры с использованием операций полной точной (FP32).
Рекомендуется использовать версию FS16 FSR2 на All Adplaware, которая поддерживает его. Вы можете запросить уровень поддержки вашей видеокарты для FP16, запросив возможность D3D12_FEATURE_DATA_SHADER_MIN_PRECISION_SUPPORT в DirectX (R) 12 - Вы должны проверить, что D3D[11/12]_SHADER_MIN_PRECISION_16_BIT установлен, и если это не так, что это не так, что не так, что это не так, что не так. FSR2. Для Vulkan, если VkPhysicalDeviceFloat16Int8FeaturesKHR::shaderFloat16 не установлен, то вам следует задействовать на версию FP32 FSR2. Точно так же, если VkPhysicalDevice16BitStorageFeatures::storageBuffer16BitAccess не установлен, вы также должны отступить на версию FP32 FSR2.
Чтобы включить путь FP32 в исходном коде FSR2 Шейдера, вы должны определить FFX_HALF как 1 . Чтобы поделиться большинством исходного кода алгоритма между FP16 и FP32 (обеспечивая высокий уровень обмена кодами для поддержки постоянного обслуживания), вы заметите, что исходный код шейдера FSR2 использует набор макросов типов, который облегчает простые переключения между переключением между FSR2. 16-битные и 32-разрядные базовые типы в источнике шейдера.
| Тип fidelityfx | FP32 | РП16 |
|---|---|---|
FFX_MIN16_F | float | min16float |
FFX_MIN16_F2 | float2 | min16float2 |
FFX_MIN16_F3 | float3 | min16float3 |
FFX_MIN16_F4 | float4 | min16float4 |
Таблица выше перечисляет отображения между абстрактными типами SDK FidelityFX, и подложенным внутренним типом, который будет заменен в зависимости от конфигурации источника шейдера во время компиляции.
Современные графические процессоры выполняют коллекции потоков - называемые волновыми фронтами - вместе в стиле. Точное количество потоков, которые составляют единый волновый фронт, является специфичным для оборудования. Некоторое аппаратное обеспечение, такое как графические процессоры AMD и графические процессоры на основе RDNA, собирающие 64 потока вместе в один волновой фронт. В зависимости от точных характеристик выполнения алгоритма, может быть более или менее выгодно предпочесть определенную ширину волнового фронта. С введением Shader Model 6.6 Microsoft добавила возможность определить ширину волнового фронта через HLSL. Для оборудования, такого как RDNA, которая поддерживает ширину 32 и 64 широких волновых фронтов, это очень полезный инструмент для целей оптимизации, поскольку он обеспечивает чистый и портативный способ попросить программный стек драйвера выполнить волновой фронт с определенной шириной.
Для приложений на основе DirectX (R), которые работают на графических процессорах на основе RDNA и RDNA2, и используют Microsoft Agility SDK, API хоста FSR2 выберет ширину волнового фронта 64.
Структура описания контекста может быть предоставлена функцией обратного вызова для передачи текстовых предупреждений из среды выполнения FSR 2 в базовое приложение. Член fpMessage описания имеет тип FfxFsr2Message , который является указателем функции для передачи строковых сообщений различных типов. Присвоение этой переменной подходящей функции и передача флага FFX_FSR2_ENABLE_DEBUG_CHECKING в элементе флагов 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 реализован в серии этапов, которые следующие:
Каждая стадия прохода алгоритма выложена в разделах, следующих за этим, но поток данных для полного алгоритма FSR2 показан на диаграмме ниже.
Стадия пирамиды вычислительной светительности имеет две обязанности:
Следующая таблица содержит все ресурсы, потребляемые на стадии вычислительной яркости пирамиды.
Временный слой указывает, из какого кадра данные должны быть получены. «Текущий кадр» означает, что данные должны быть получены из ресурсов, созданных для кадры, который должен быть представлен дальше. «Предыдущий кадр» указывает на то, что данные должны быть получены из ресурсов, которые были созданы для только что представленного кадра. Столбец разрешения указывает, должны ли данные быть в разрешении «выведены» или разрешением «презентации». Резолюция «рендера» указывает на то, что ресурс должен соответствовать разрешению, в которой приложение выполняет его рендеринг. И наоборот, «презентация» указывает на то, что разрешение цели должно соответствовать тому, что должно быть представлено пользователю.
| Имя | Временный слой | Разрешение | Формат | Тип | Примечания |
|---|---|---|---|---|---|
| Цветовой буфер | Текущий кадр | Оказывать | APPLICATION SPECIFIED | Текстура | Цветовой буфер разрешения рендеринга для текущей кадры, предоставленной приложением. Если содержимое цветового буфера находится в высоком динамическом диапазоне (HDR), то флаг FFX_FSR2_ENABLE_HIGH_DYNAMIC_RANGE должен быть установлен в поле flags структуры FfxFsr2ContextDescription . |
Следующая таблица содержит все ресурсы, произведенные или модифицированные на стадии вычислительной яркости пирамиды.
Временный слой указывает, из какого кадра данные должны быть получены. «Текущий кадр» означает, что данные должны быть получены из ресурсов, созданных для кадры, который должен быть представлен дальше. «Предыдущий кадр» указывает на то, что данные должны быть получены из ресурсов, которые были созданы для только что представленного кадра. Столбец разрешения указывает, должны ли данные быть в разрешении «выведены» или разрешением «презентации». Резолюция «рендера» указывает на то, что ресурс должен соответствовать разрешению, в которой приложение выполняет его рендеринг. И наоборот, «презентация» указывает на то, что разрешение цели должно соответствовать тому, что должно быть представлено пользователю.
| Имя | Временный слой | Разрешение | Формат | Тип | Примечания |
|---|---|---|---|---|---|
| Контакт | Текущий кадр | 1х1 | R32_FLOAT | Текстура | Текстура 1x1, содержащая значение экспозиции, рассчитанное для текущего кадра. Этот ресурс не является обязательным и может быть опущен, если флаг FFX_FSR2_ENABLE_AUTO_EXPOSURE устанавливается в поле flags в структуре FfxFsr2ContextDescription при создании FfxFsr2Context . |
| Текущая яркости | Текущий кадр | Render * 0.5 + mipchain | R16_FLOAT | Текстура | Текстура при 50% текстуры разрешения рендеринга, которая содержит яркости текущего кадра. Полная цепь MIP выделяется. |
Стадия вычислительной светильной пирамиды реализована с использованием единого прохода FidelityFX
