FidelityFX FSR2
v2.2.1
Copyright (c) 2023 Advanced Micro Devices, Inc. Todos los derechos reservados.
Por el presente se otorga permiso, sin cargo, a cualquier persona que obtenga una copia de este software y los archivos de documentación asociados (el "Software"), para operar con el Software sin restricciones, incluidos, entre otros, los derechos de uso, copia, modificación, fusión. , publicar, distribuir, sublicenciar y/o vender copias del Software, y permitir que las personas a quienes se les proporciona el Software lo hagan, sujeto a las siguientes condiciones: El aviso de derechos de autor anterior y este aviso de permiso se incluirán en todas las copias. o partes sustanciales del Software.
EL SOFTWARE SE PROPORCIONA "TAL CUAL", SIN GARANTÍA DE NINGÚN TIPO, EXPRESA O IMPLÍCITA, INCLUYENDO PERO NO LIMITADO A LAS GARANTÍAS DE COMERCIABILIDAD, IDONEIDAD PARA UN PROPÓSITO PARTICULAR Y NO INFRACCIÓN. EN NINGÚN CASO LOS AUTORES O TITULARES DE DERECHOS DE AUTOR SERÁN RESPONSABLES DE NINGÚN RECLAMO, DAÑO U OTRA RESPONSABILIDAD, YA SEA EN UNA ACCIÓN CONTRACTUAL, AGRAVIO O DE OTRA MANERA, QUE SURJA DE, FUERA DE O EN RELACIÓN CON EL SOFTWARE O EL USO U OTRAS NEGOCIOS EN EL SOFTWARE.
FSR2 utiliza retroalimentación temporal para reconstruir imágenes de alta resolución mientras mantiene e incluso mejora la calidad de la imagen en comparación con la renderización nativa.
FSR2 puede permitir un "rendimiento práctico" para operaciones de renderizado costosas, como el trazado de rayos por hardware.
HLSL CS_6_2 CS_6_6*
* - CS_6_6 se utiliza en algunos hardware que admiten frentes de onda de 64 anchos.
Para utilizar FSR2 debes seguir los pasos a continuación:
Haga doble clic en GenerateSolutions.bat en el directorio build .
Abra la solución que coincida con su API y cree la solución.
Copie la biblioteca API de bin/ffx_fsr2_api en la carpeta que contiene una carpeta en su proyecto que contiene bibliotecas de terceros.
Copie la biblioteca que coincida con el backend FSR2 que desea usar, por ejemplo: bin/ffx_fsr2_api/ffx_fsr2_api_dx12_x64.lib para DirectX12.
Copie los siguientes archivos de encabezado de API principales de src/ffx-fsr2-api en su proyecto: ffx_fsr2.h , ffx_types.h , ffx_error.h , ffx_fsr2_interface.h , ffx_util.h , shaders/ffx_fsr2_common.h y shaders/ffx_fsr2_resources.h . Se debe tener cuidado de mantener la estructura de directorio relativa en el destino de la copia del archivo.
Copie los archivos de encabezado para el backend API de su elección, por ejemplo, para DirectX12 copiaría dx12/ffx_fsr2_dx12.h y dx12/shaders/ffx_fsr2_shaders_dx12.h . Se debe tener cuidado de mantener la estructura de directorio relativa en el destino de la copia del archivo.
Incluya el archivo de encabezado ffx_fsr2.h en su código base donde desea interactuar con FSR2.
Cree un backend para su API de destino. Por ejemplo, para DirectX12 deberías llamar ffxFsr2GetInterfaceDX12 . Se debe asignar un búfer temporal del tamaño devuelto llamando ffxFsr2GetScratchMemorySizeDX12 y pasando el puntero a ese búfer a ffxFsr2GetInterfaceDX12 .
Cree un contexto FSR2 llamando ffxFsr2ContextCreate . La estructura de parámetros debe completarse de acuerdo con la configuración de su aplicación. Consulte la documentación de referencia de API para obtener más detalles.
En cada cuadro debe llamar ffxFsr2ContextDispatch para iniciar cargas de trabajo FSR2. La estructura de parámetros debe completarse de acuerdo con la configuración de su aplicación. Consulte la documentación de referencia de la API para obtener más detalles y asegúrese de que el campo frameTimeDelta se proporcione en milisegundos.
Cuando su aplicación esté finalizando (o desee destruir el contexto por otro motivo), debe llamar ffxFsr2ContextDestroy . La GPU debe estar inactiva antes de llamar a esta función.
Se debe aplicar fluctuación de subpíxeles a la matriz de proyección de su aplicación. Esto debe hacerse al realizar la representación principal de su aplicación. Debe utilizar la función ffxFsr2GetJitterOffset para calcular las compensaciones de fluctuación precisas. Consulte la sección Jitter de la cámara para obtener más detalles.
Para obtener la mejor calidad de mejora, se recomienda encarecidamente que complete la máscara Reactiva y la máscara de Transparencia y composición de acuerdo con nuestras pautas. También puede utilizar ffxFsr2ContextGenerateReactiveMask como punto de partida.
Las aplicaciones deben exponer los modos de escala en su interfaz de usuario en el siguiente orden: Calidad, Equilibrado, Rendimiento y (opcionalmente) Ultra rendimiento.
Las aplicaciones también deben exponer un control deslizante de nitidez para permitir a los usuarios finales lograr una calidad adicional.
Para comodidad de los usuarios finales, la API FSR2 proporciona una serie de proporciones de escala preestablecidas que reciben un nombre.
| Calidad | Factor de escala por dimensión |
|---|---|
| Calidad | 1,5x |
| Equilibrado | 1,7x |
| Actuación | 2.0x |
| Ultrarendimiento | 3.0x |
Recomendamos encarecidamente que las aplicaciones adopten proporciones consistentes de nombres y escalas en su interfaz de usuario. Esto es para garantizar que la experiencia del usuario sea consistente para los usuarios de su aplicación que pueden tener experiencia con otras aplicaciones que usan FSR2.
Dependiendo del hardware de destino y de la configuración operativa, FSR2 funcionará en diferentes niveles de rendimiento.
La siguiente tabla resume el rendimiento medido de FSR2 en una variedad de hardware en DX12.
| Resolución objetivo | Calidad | 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 | Calidad (1,5x) | 0,7 ms | 1,1 ms | 1,2 ms | 1,2 ms | 1,4 ms | 2,0 ms | 2,8 ms | 2,4 ms | 4,9 ms | 5,4 ms |
| Equilibrado (1,7x) | 0,6 ms | 1,0 ms | 1,0 ms | 1,1 ms | 1,4 ms | 1,8 ms | 2,6 ms | 2,2 ms | 4,1 ms | 4,9 ms | |
| Rendimiento (2x) | 0,6 ms | 0,9 ms | 1,0 ms | 1,0 ms | 1,3 ms | 1,7 ms | 2,3 ms | 2,0 ms | 3,6 ms | 4,4 ms | |
| Ultraperf. (3x) | 0,5 ms | 0,8 ms | 0,8 ms | 0,9 ms | 1,1 ms | 1,5 ms | 1,8 ms | 1,7 ms | 2,9 ms | 3,7 ms | |
| 2560x1440 | Calidad (1,5x) | 0,3 ms | 0,5 ms | 0,5 ms | 0,5 ms | 0,7 ms | 0,9 ms | 1,2 ms | 1,1 ms | 1,9 ms | 2,3 ms |
| Equilibrado (1,7x) | 0,3 ms | 0,5 ms | 0,5 ms | 0,5 ms | 0,6 ms | 0,8 ms | 1,1 ms | 1,0 ms | 1,7 ms | 2,1 ms | |
| Rendimiento (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 ms | |
| Ultraperf. (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 ms | 1,7 ms | |
| 1920x1080 | Calidad (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 ms |
| Equilibrado (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 ms | |
| Rendimiento (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 ms | |
| Ultraperf. (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 |
Las cifras están redondeadas al 0,1 ms más cercano, no tienen sharpness adicional y están sujetas a cambios.
El uso de FSR2 requiere que se asigne algo de memoria local de GPU adicional para el consumo de la GPU. Cuando se utiliza la API FSR2, esta memoria se asigna cuando se crea el contexto FSR2 y se hace a través de una serie de devoluciones de llamada que componen la interfaz backend. Esta memoria se utiliza para almacenar superficies intermedias que se calculan mediante el algoritmo FSR2, así como superficies que son persistentes en muchos fotogramas de la aplicación. La siguiente tabla incluye la cantidad de memoria utilizada por FSR2 en diversas condiciones operativas. La columna "Conjunto de trabajo" indica la cantidad total de memoria utilizada por FSR2 mientras el algoritmo se ejecuta en la GPU; esta es la cantidad de memoria que FSR2 necesitará para ejecutarse. La columna "Memoria persistente" indica qué parte de la columna "Conjunto de trabajo" se debe dejar intacta para fotogramas posteriores de la aplicación; esta memoria almacena los datos temporales consumidos por FSR2. La columna "Memoria con alias" indica qué parte de la columna "Conjunto de trabajo" puede tener alias mediante superficies u otros recursos utilizados por la aplicación fuera de los límites operativos de FSR2.
Puede tomar el control de la creación de recursos en FSR2 anulando las partes de creación y destrucción de recursos de la interfaz backend de FSR2 y reenviando los indicadores de alias. Esto significa que para una perfecta integración de FSR2, se requiere memoria adicional equivalente a la columna "Memoria persistente" de la siguiente tabla dependiendo de sus condiciones de funcionamiento.
| Resolución | Calidad | Conjunto de trabajo (MB) | Memoria persistente (MB) | Memoria con alias (MB) |
|---|---|---|---|---|
| 3840x2160 | Calidad (1,5x) | 448MB | 354MB | 93MB |
| Equilibrado (1,7x) | 407MB | 330MB | 77MB | |
| Rendimiento (2x) | 376 MB | 312MB | 63MB | |
| Ultrarendimiento (3x) | 323 MB | 281MB | 42MB | |
| 2560x1440 | Calidad (1,5x) | 207MB | 164MB | 43MB |
| Equilibrado (1,7x) | 189MB | 153MB | 36MB | |
| Rendimiento (2x) | 172MB | 143MB | 29MB | |
| Ultrarendimiento (3x) | 149MB | 130MB | 19MB | |
| 1920x1080 | Calidad (1,5x) | 115MB | 90MB | 24MB |
| Equilibrado (1,7x) | 105MB | 85MB | 20MB | |
| Rendimiento (2x) | 101 MB | 83MB | 18MB | |
| Ultrarendimiento (3x) | 84MB | 72MB | 11MB |
Las cifras son aproximaciones, redondeadas al MB más cercano utilizando una GPU RX 6700XT en DX12 y están sujetas a cambios.
Para obtener detalles sobre cómo administrar los requisitos de memoria de FSR2, consulte la sección de este documento que trata sobre la administración de memoria.
FSR2 es un algoritmo temporal y, por lo tanto, requiere acceso a los datos tanto del cuadro actual como del anterior. La siguiente tabla enumera todas las entradas externas requeridas por FSR2.
La columna de resolución indica si los datos deben tener una resolución de "representación" o de "presentación". La resolución 'renderizada' indica que el recurso debe coincidir con la resolución a la que la aplicación realiza su renderización. Por el contrario, 'presentación' indica que la resolución del objetivo debe coincidir con la que se presentará al usuario. Todos los recursos provienen del marco renderizado actual; para aplicaciones DirectX(R)12 y Vulkan(R), todos los recursos de entrada deben pasar a
D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCEyVK_ACCESS_SHADER_READ_BITrespectivamente antes de llamarffxFsr2ContextDispatch.
| Nombre | Resolución | Formato | Tipo | Notas |
|---|---|---|---|---|
| Búfer de color | Prestar | APPLICATION SPECIFIED | Textura | El búfer de color de resolución de renderizado para el fotograma actual proporcionado por la aplicación. Si el contenido del búfer de color está en un rango dinámico alto (HDR), entonces el indicador FFX_FSR2_ENABLE_HIGH_DYNAMIC_RANGE debe establecerse en el campo flags de la estructura FfxFsr2ContextDescription . |
| Amortiguador de profundidad | Prestar | APPLICATION SPECIFIED (1x FLOAT) | Textura | El búfer de profundidad de resolución de renderizado para el fotograma actual proporcionado por la aplicación. Los datos deben proporcionarse como un único valor de punto flotante, cuya precisión está bajo el control de la aplicación. La configuración de la profundidad debe comunicarse a FSR2 a través del campo flags de la estructura FfxFsr2ContextDescription al crear FfxFsr2Context . Debe configurar el indicador FFX_FSR2_ENABLE_DEPTH_INVERTED si su búfer de profundidad está invertido (es decir, el rango [1..0]), y debe configurar el indicador FFX_FSR2_ENABLE_DEPTH_INFINITE si su búfer de profundidad tiene un plano lejano infinito. Si la aplicación proporciona el búfer de profundidad en formato D32S8 , entonces FSR2 ignorará el componente de plantilla del búfer y creará un recurso R32_FLOAT para abordar el búfer de profundidad. En el hardware GCN y RDNA, los búferes de profundidad se almacenan por separado de los búferes de plantilla. |
| Vectores de movimiento | Render o presentación | APPLICATION SPECIFIED (2x FLOAT) | Textura | Los vectores de movimiento 2D para el cuadro actual proporcionados por la aplicación en el rango [ (<-width, -height> .. <width, height> ]. Si su aplicación representa vectores de movimiento con un rango diferente, puede usar el campo motionVectorScale de la estructura FfxFsr2DispatchDescription para ajustarlos para que coincidan con el rango esperado para FSR2. Internamente, FSR2 usa cantidades de 16 bits para representar vectores de movimiento en muchos casos, lo que significa que mientras. Se pueden proporcionar vectores de movimiento con mayor precisión, FSR2 no se beneficiará de la mayor precisión. La resolución del buffer del vector de movimiento debe ser igual a la resolución de renderizado, a menos que el indicador FFX_FSR2_ENABLE_DISPLAY_RESOLUTION_MOTION_VECTORS esté configurado en el campo de flags de la estructura FfxFsr2ContextDescription al crear el. FfxFsr2Context , en cuyo caso debería ser igual a la resolución de presentación. |
| Máscara reactiva | Prestar | R8_UNORM | Textura | Como algunas áreas de una imagen renderizada no dejan una huella en el búfer de profundidad ni incluyen vectores de movimiento, FSR2 proporciona soporte para una textura de máscara reactiva que puede usarse para indicarle a FSR2 dónde están dichas áreas. Buenos ejemplos de esto son las partículas u objetos combinados alfa que no escriben vectores de profundidad o movimiento. Si este recurso no está configurado, entonces la lógica de detección de cambios de sombreado de FSR2 manejará estos casos lo mejor que pueda, pero para obtener resultados óptimos, se debe configurar este recurso. Para obtener más información sobre la máscara reactiva, consulte la sección Máscara reactiva. |
| Exposición | 1x1 | R32_FLOAT | Textura | Una textura de 1x1 que contiene el valor de exposición calculado para el fotograma actual. Este recurso es opcional y se puede omitir si el indicador FFX_FSR2_ENABLE_AUTO_EXPOSURE está configurado en el campo flags de la estructura FfxFsr2ContextDescription al crear FfxFsr2Context . |
Todas las entradas que se proporcionan con resolución de renderizado, excepto los vectores de movimiento, deben renderizarse con fluctuación. A los vectores de movimiento no se les debe aplicar fluctuación, a menos que el indicador FFX_FSR2_ENABLE_MOTION_VECTORS_JITTER_CANCELLATION esté presente.
Se recomienda encarecidamente utilizar un búfer de profundidad infinita e invertido con FSR2. Sin embargo, se admiten configuraciones de búfer de profundidad alternativas. Una aplicación debe informar a la API FSR2 de su configuración de búfer de profundidad configurando los indicadores apropiados durante la creación de FfxFsr2Context . La siguiente tabla contiene las banderas apropiadas.
| Bandera FSR2 | Nota |
|---|---|
FFX_FSR2_ENABLE_DEPTH_INVERTED | Un bit que indica que los datos del búfer de profundidad de entrada proporcionados están invertidos [max..0]. |
FFX_FSR2_ENABLE_DEPTH_INFINITE | Un bit que indica que los datos del búfer de profundidad de entrada proporcionados utilizan un plano lejano infinito. |
Una parte clave de un algoritmo temporal (ya sea antialiasing o upscaling) es la provisión de vectores de movimiento. FSR2 acepta vectores de movimiento en 2D que codifican el movimiento desde un píxel en el cuadro actual hasta la posición de ese mismo píxel en el cuadro anterior. FSR2 espera que la aplicación proporcione vectores de movimiento en el rango [ <-width, -height> .. <width, height> ]; esto coincide con el espacio de pantalla. Por ejemplo, un vector de movimiento para un píxel en la esquina superior izquierda de la pantalla con un valor de <ancho, alto> representaría un movimiento que atravesó todo el ancho y alto de las superficies de entrada, originándose en la esquina inferior derecha. .
Si su aplicación calcula vectores de movimiento en otro espacio (por ejemplo, espacio de coordenadas de dispositivo normalizado), puede usar el campo motionVectorScale de la estructura FfxFsr2DispatchDescription para indicarle a FSR2 que los ajuste para que coincidan con el rango esperado para FSR2. Los ejemplos de código siguientes ilustran cómo los vectores de movimiento se pueden escalar al espacio de la pantalla. El siguiente código HLSL y C++ de ejemplo ilustra cómo se pueden escalar los vectores de movimiento del espacio NDC utilizando la API de 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; Internamente, FSR2 utiliza cantidades de 16 bits para representar vectores de movimiento en muchos casos, lo que significa que si bien se pueden proporcionar vectores de movimiento con mayor precisión, FSR2 actualmente no se beneficiará de la mayor precisión. La resolución del búfer de vector de movimiento debe ser igual a la resolución de representación, a menos que el indicador FFX_FSR2_ENABLE_DISPLAY_RESOLUTION_MOTION_VECTORS esté configurado en el campo flags de la estructura FfxFsr2ContextDescription al crear FfxFsr2Context , en cuyo caso debe ser igual a la resolución de presentación.
FSR2 realizará una mejora de mejor calidad cuando más objetos proporcionen sus vectores de movimiento. Por lo tanto, se recomienda que todos los objetos opacos, probados alfa y mezclados alfa escriban sus vectores de movimiento para todos los píxeles cubiertos. Si se aplican efectos de sombreado de vértices, como desplazamiento de rayos UV, estos cálculos también deben tenerse en cuenta en el cálculo del movimiento para obtener mejores resultados. Para objetos con combinación alfa, también se recomienda encarecidamente que el valor alfa de cada píxel cubierto se almacene en el píxel correspondiente en la máscara reactiva. Esto permitirá que FSR2 realice un mejor manejo de objetos combinados alfa durante el escalado. La máscara reactiva es especialmente importante para objetos combinados alfa donde escribir vectores de movimiento puede resultar prohibitivo, como las partículas.
En el contexto de FSR2, el término "reactividad" significa cuánta influencia tienen las muestras renderizadas para el fotograma actual sobre la producción de la imagen final mejorada. Normalmente, las muestras renderizadas para el fotograma actual contribuyen en una cantidad relativamente modesta al resultado calculado por FSR2; sin embargo, hay excepciones. Para producir los mejores resultados para objetos combinados alfa que se mueven rápidamente, FSR2 requiere que la etapa Reproyectar y acumular sea más reactiva para dichos píxeles. Como no existe una buena manera de determinar a partir de vectores de color, profundidad o movimiento qué píxeles se han renderizado mediante combinación alfa, FSR2 funciona mejor cuando las aplicaciones marcan explícitamente dichas áreas.
Por lo tanto, se recomienda encarecidamente que las aplicaciones proporcionen una máscara reactiva para FSR2. La máscara reactiva guía al FSR2 sobre dónde debe reducir su dependencia de la información histórica al componer el píxel actual y, en cambio, permitir que las muestras del cuadro actual contribuyan más al resultado final. La máscara reactiva permite que la aplicación proporcione un valor de [0.0...1.0] donde 0.0 indica que el píxel no es reactivo en absoluto (y debe usar la estrategia de composición FSR2 predeterminada) y un valor de 1.0 indica que el píxel debe ser completamente reactivo. reactivo. Este es un rango de coma flotante y se puede adaptar a diferentes situaciones.
Si bien existen otras aplicaciones para la máscara reactiva, la aplicación principal de la máscara reactiva es producir mejores resultados al mejorar la escala de imágenes que incluyen objetos mezclados alfa. Un buen indicador de la reactividad es en realidad el valor alfa utilizado al componer un objeto combinado con alfa en la escena; por lo tanto, las aplicaciones deben escribir alpha en la máscara reactiva. Cabe señalar que es poco probable que un valor reactivo cercano a 1 produzca buenos resultados. Por lo tanto, recomendamos fijar el valor reactivo máximo en aproximadamente 0,9.
Si no se proporciona una máscara reactiva a FSR2 (estableciendo el campo reactive de FfxFsr2DispatchDescription en NULL ), se utilizará una textura 1x1 generada internamente con un valor reactivo borrado.
Para ayudar a las aplicaciones a generar la máscara reactiva y la máscara de transparencia y composición, FSR2 proporciona una API auxiliar opcional. Debajo del capó, la API lanza un sombreador de cálculo que calcula estos valores para cada píxel utilizando una heurística basada en la luminancia.
Las aplicaciones que deseen hacer esto pueden llamar a la función ffxFsr2ContextGenerateReactiveMask y deben pasar dos versiones del búfer de color, una que contenga solo geometría opaca y la otra que contenga objetos opacos y combinados alfa.
Además de la máscara reactiva, FSR2 permite que la aplicación indique áreas de otros renderizados especializados que deben tenerse en cuenta durante el proceso de ampliación. Ejemplos de este tipo de renderizado especial incluyen áreas de reflejos con trazado de rayos o texturas animadas.
Mientras que la máscara Reactiva ajusta el equilibrio de acumulación, la máscara de Transparencia y composición ajusta los mecanismos de protección del historial de píxeles. La máscara también elimina el efecto del factor de inestabilidad de la luminancia. Un píxel con un valor de 0 en la máscara de Transparencia y composición no realiza ninguna modificación adicional al bloqueo de ese píxel. Por el contrario, un valor de 1 indica que el bloqueo de ese píxel debe eliminarse por completo.
Si no se proporciona una máscara de Transparencia y composición a FSR2 (estableciendo el campo transparencyAndComposition de FfxFsr2DispatchDescription en NULL ), se utilizará una textura 1x1 generada internamente con un valor de transparencia y composición borrado.
FSR2.2 incluye una función experimental para generar máscara reactiva y máscara de transparencia y composición automáticamente. Para habilitar esto, el campo enableAutoReactive de FfxFsr2DispatchDescription debe establecerse en 'TRUE' y se debe proporcionar una copia de las partes opacas del backbuffer en 'colorOpaqueOnly'. Luego, FSR2 generará y utilizará automáticamente la máscara reactiva y la máscara de transparencia y composición internamente. Las máscaras se generan en una pasada de cálculo analizando la diferencia del buffer de color con y sin geometría transparente, así como comparándolo con el fotograma anterior. Según el resultado de esos cálculos, a cada píxel se le asignan valores de máscara reactiva y máscara de transparencia y composición. Para utilizar la generación automática de máscaras, también se deben proporcionar los siguientes 4 valores para escalar y limitar la intensidad de las máscaras (tenga en cuenta que los valores predeterminados mencionados son valores iniciales sugeridos, pero deben ajustarse por título):
Esta característica está destinada a ayudar con la integración de FSR2.2 en un nuevo motor o título. Sin embargo, para obtener la mejor calidad, recomendamos renderizar la máscara reactiva y la máscara de transparencia y composición usted mismo, ya que se espera que generar esos valores basados en el material sea más confiable que generarlos automáticamente a partir de la imagen final.
Tenga en cuenta que esta función aún se encuentra en etapa experimental y puede cambiar significativamente en el futuro.
FSR2 proporciona dos valores que controlan la exposición utilizada al realizar la ampliación. Son los siguientes:
El valor de exposición debe coincidir con el que utiliza la aplicación durante cualquier paso posterior de mapeo de tonos realizado por la aplicación. Esto significa que FSR2 funcionará de manera consistente con lo que probablemente será visible en la imagen final del mapa de tonos.
En varias etapas del algoritmo FSR2 descrito en este documento, FSR2 calculará su propio valor de exposición para uso interno. Vale la pena señalar que todas las salidas de FSR2 tendrán este mapeo de tonos interno invertido antes de que se escriba la salida final. Lo que significa que FSR2 devuelve resultados en el mismo dominio que la señal de entrada original.
Los valores de exposición mal seleccionados pueden tener un impacto drástico en la calidad final de la ampliación de FSR2. Por lo tanto, se recomienda que la aplicación utilice FFX_FSR2_ENABLE_AUTO_EXPOSURE , a menos que exista una razón particular para no hacerlo. Cuando se establece FFX_FSR2_ENABLE_AUTO_EXPOSURE en el campo flags de la estructura FfxFsr2ContextDescription , el cálculo de exposición que se muestra en el código HLSL a continuación se utiliza para calcular el valor de exposición, que coincide con la respuesta de exposición de la película 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;
}El objetivo principal de FSR2 es mejorar el rendimiento de renderizado de las aplicaciones mediante el uso de un algoritmo de escalamiento temporal que depende de varias entradas. Por lo tanto, su ubicación en el mercado es clave para garantizar el equilibrio adecuado entre la más alta calidad visual y un excelente rendimiento.
Con cualquier enfoque de mejora de escala de imágenes, es importante comprender cómo colocar otros algoritmos de espacio de imagen con respecto al algoritmo de mejora de escala. Colocar estos otros efectos de espacio de imagen antes del escalado tiene la ventaja de que se ejecutan a una resolución más baja, lo que por supuesto confiere una ventaja de rendimiento a la aplicación. Sin embargo, puede que no sea apropiado para algunas clases de técnicas de espacio de imágenes. Por ejemplo, muchas aplicaciones pueden introducir ruido o granulado en la imagen final, tal vez para simular una cámara física. Hacerlo antes de que un escalador amplifique el ruido, provocando artefactos no deseados en la imagen mejorada resultante. La siguiente tabla divide las técnicas comunes de espacio de imágenes en tiempo real en dos columnas. El 'Postprocesamiento A' contiene todas las técnicas que normalmente se ejecutarían antes del escalado de FSR2, lo que significa que todas se ejecutarían con resolución de renderizado. Por el contrario, la columna 'Postprocesamiento B' contiene todas las técnicas que se recomienda ejecutar después de FSR2, lo que significa que se ejecutarían con una resolución de presentación mayor.
| Postprocesamiento A | Postprocesamiento B |
|---|---|
| Reflexiones del espacio de pantalla | Grano de película |
| Oclusión ambiental del espacio de pantalla | aberración cromática |
| Denoisers (sombras, reflejos) | Viñeta |
| Exposición (opcional) | Mapeo de tonos |
| Floración | |
| Profundidad de campo | |
| Desenfoque de movimiento |
Tenga en cuenta que las recomendaciones aquí son solo para fines orientativos y dependen de las características precisas de la implementación de su aplicación.
Si bien es posible generar los recursos intermedios apropiados, compilar el código de sombreado, configurar los enlaces y enviar los envíos, es mucho más fácil usar la API de host FSR2 que se proporciona.
Para usar la API, debe vincular las bibliotecas FSR2 (más sobre cuáles en breve) e incluir el archivo de encabezado ffx_fsr2.h , que a su vez tiene las siguientes dependencias de encabezado:
ffx_assert.h
ffx_error.h
ffx_fsr2_interface.h
ffx_types.h
ffx_util.h
Para utilizar la API FSR2, debe vincular ffx_fsr2_api_x64.lib , que proporcionará los símbolos para las API orientadas a la aplicación. Sin embargo, la API de FSR2 tiene un backend modular, lo que significa que se pueden apuntar a diferentes API y plataformas de gráficos mediante el uso de un backend coincidente. Por lo tanto, debe incluir además la biblioteca de backend que coincida con sus requisitos, haciendo referencia a la siguiente tabla.
| Objetivo | Nombre de la biblioteca |
|---|---|
| DirectX(R)12 | ffx_fsr2_dx12_x64.lib |
| Vulcano(R) | ffx_fsr2_vk_x64.lib |
Tenga en cuenta que la arquitectura modular de la API FSR2 permite implementar backends personalizados. Consulte la sección Backend modular para obtener más detalles.
Para comenzar a utilizar la API, la aplicación primero debe crear una estructura FfxFsr2Context . Esta estructura debe ubicarse en algún lugar con una vida útil aproximadamente igual a la de su backbuffer; algún lugar en el montón de la aplicación suele ser una buena opción. Al llamar ffxFsr2ContextCreate la estructura FfxFsr2Context se completará con los datos que requiere. Además, se realizarán varias llamadas desde ffxFsr2ContextCreate al backend que se proporciona a FfxFsr2Context como parte de la estructura FfxFsr2ContextDescription . Estas llamadas realizarán tareas como la creación de recursos intermedios requeridos por FSR2 y la configuración de sombreadores y su estado de canalización asociado. La API FSR2 no realiza ninguna asignación de memoria dinámica.
Cada cuadro de su aplicación donde se requiere ampliación, debe llamar ffxFsr2ContextDispatch . Esta función acepta la estructura FfxFsr2Context que se creó anteriormente en la vida útil de la aplicación, así como una descripción precisa de cómo se debe realizar la ampliación y en qué datos. Esta descripción la proporciona la aplicación al completar una estructura FfxFsr2DispatchDescription .
La destrucción del contexto se realiza llamando ffxFsr2ContextDestroy . Tenga en cuenta que la GPU debe estar inactiva antes de intentar llamar ffxFsr2ContextDestroy y que la función no realiza una sincronización implícita para garantizar que los recursos a los que accede FSR2 no estén actualmente en funcionamiento. El motivo de esta elección es evitar que FSR2 introduzca vaciados de GPU adicionales para aplicaciones que ya realizan una sincronización adecuada en el punto en el que podrían desear destruir FfxFsr2Context , esto permite que una aplicación realice la creación y desmontaje más eficiente posible de la API de FSR2 cuando requerido.
Hay funciones auxiliares adicionales que se proporcionan como parte de la API FSR2. Estas funciones auxiliares realizan tareas como el cálculo de compensaciones de fluctuación de subpíxeles, así como el cálculo de resoluciones de renderizado basadas en resoluciones de despacho y los modos de escala predeterminados proporcionados por FSR2.
Para obtener documentación más exhaustiva de la API FSR2, puede consultar la documentación de referencia de la API proporcionada.
El diseño de la API FSR2 significa que la implementación central del algoritmo FSR2 desconoce en qué API de renderizado se encuentra. En cambio, FSR2 llama a funciones que se le proporcionan a través de una interfaz, lo que permite utilizar diferentes backends con FSR2. Este diseño también permite que las aplicaciones que integran FSR2 proporcionen su propia implementación de backend, lo que significa que las plataformas que FSR2 no admite actualmente pueden ser objetivo mediante la implementación de un puñado de funciones. Además, las aplicaciones que tienen sus propias abstracciones de renderizado también pueden implementar su propio backend, tomando el control de todos los aspectos de la función subyacente de FSR2, incluida la gestión de memoria, la creación de recursos, la compilación de sombreadores, la vinculación de recursos de sombreadores y el envío de cargas de trabajo de FSR2 al dispositivo gráfico. .
De fábrica, la API FSR2 se compilará en múltiples bibliotecas siguiendo la separación ya descrita entre la API principal y los backends. Esto significa que si desea utilizar los backends proporcionados con FSR2, debe vincular tanto la biblioteca API principal de FSR2 como el backend que coincida con sus requisitos.
El lanzamiento público de FSR2 viene con backends DirectX(R)12 y Vulkan(R), pero hay otros backends disponibles a pedido. Hable con su representante de AMD Developer Technology para obtener más información.
Si la API de FSR2 se utiliza con uno de los backends suministrados (por ejemplo: DirectX(R)12 o Vulkan(R)), entonces todos los recursos requeridos por FSR2 se crean como recursos comprometidos directamente utilizando el dispositivo gráfico proporcionado por la aplicación host. Sin embargo, al anular la familia de funciones de creación y destrucción presentes en la interfaz de backend, es posible que una aplicación controle con mayor precisión la gestión de memoria de FSR2.
Para hacer esto, puede proporcionar un backend personalizado completo a FSR2 a través de la estructura FfxFsr2ContextDescription pasada a la función ffxFsr2ContextCreate , o puede recuperar el backend de la API que desee y anular las funciones de creación y destrucción de recursos para manejarlos usted mismo. Para hacer esto, simplemente sobrescriba los punteros de función fpCreateResource y 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); Una ventaja interesante de que una aplicación tome el control de la gestión de memoria requerida para FSR2 es que se puede realizar un alias de recursos, lo que puede generar un ahorro de memoria. La tabla presente en Requisitos de memoria demuestra los ahorros disponibles mediante el uso de esta técnica. Para lograr los ahorros que se muestran en esta tabla, se debe encontrar un área apropiada de memoria (cuyo contenido no es necesario para sobrevivir a través de una llamada a los despachos de FSR2) para compartir con los recursos alias necesarios para FSR2. Cada llamada FfxFsr2CreateResourceFunc realizada por la API principal de FSR2 a través de la interfaz de backend de FSR2 contendrá un conjunto de indicadores como parte de la estructura FfxCreateResourceDescription . Si FFX_RESOURCE_FLAGS_ALIASABLE está configurado en el campo flags , esto indica que el recurso puede tener un alias seguro con otros recursos en el marco de representación.
El antialiasing temporal (TAA) es una técnica que utiliza la salida de fotogramas anteriores para construir una salida de mayor calidad a partir del fotograma actual. Como FSR2 tiene un objetivo similar, aunque con el objetivo adicional de aumentar también la resolución de la imagen renderizada, ya no es necesario incluir un pase TAA separado en su aplicación.
FSR2 se basa en la aplicación para aplicar fluctuaciones de subpíxeles durante el renderizado; esto generalmente se incluye en la matriz de proyección de la cámara. Para simplificar la aplicación de la fluctuación de la cámara, la API FSR2 proporciona un pequeño conjunto de funciones de utilidad que calcula la compensación de la fluctuación de subpíxeles para un cuadro particular dentro de una secuencia de compensaciones de fluctuación separadas.
int32_t ffxFsr2GetJitterPhaseCount ( int32_t renderWidth, int32_t displayWidth);
FfxErrorCode ffxFsr2GetJitterOffset ( float * outX, float * outY, int32_t jitterPhase, int32_t sequenceLength);Internamente, estas funciones implementan una secuencia Halton[2,3] [Halton]. El objetivo de la secuencia de Halton es proporcionar puntos espacialmente separados que cubran el espacio disponible.
Es importante comprender que los valores devueltos por ffxFsr2GetJitterOffset están en unidades de espacio de píxeles y, para poder componerlos correctamente en una matriz de proyección, debemos convertirlos en desplazamientos de proyección. El diagrama anterior muestra un solo píxel en el espacio unitario de píxeles y en el espacio de proyección. El siguiente código muestra cómo componer correctamente el valor de compensación de fluctuación de subpíxeles en una matriz de proyección.
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; Se debe aplicar fluctuación a todos los renderizados. Esto incluye objetos opacos, alfa transparentes y con trazado de rayos. Para objetos rasterizados, los valores de fluctuación de subpíxeles calculados por la función ffxFsr2GetJitterOffset se pueden aplicar a la matriz de proyección de la cámara que, en última instancia, se utiliza para realizar transformaciones durante el sombreado de vértices. Para la renderización con trazado de rayos, la fluctuación de subpíxeles debe aplicarse al origen del rayo, a menudo la posición de la cámara.
Ya sea que elija utilizar la función ffxFsr2GetJitterOffset recomendada o su propio generador de secuencia, debe establecer el campo jitterOffset de la estructura FfxFsr2DispatchDescription para informar FSR2 del desplazamiento de jitter que se ha aplicado para representar cada cuadro. Además, si no se usa la función ffxFsr2GetJitterOffset recomendada, se debe tener cuidado de que su secuencia de fluctuación nunca genera un vector nulo; Eso es un valor de 0 en las dimensiones x e y.
La siguiente tabla muestra la longitud de la secuencia de jitter para cada uno de los modos de calidad predeterminados.
| Modo de calidad | Factor de escala | Longitud de secuencia |
|---|---|---|
| Calidad | 1.5x (por dimensión) | 18 |
| Equilibrado | 1.7x (por dimensión) | 23 |
| Actuación | 2.0x (por dimensión) | 32 |
| Ultra rendimiento | 3.0x (por dimensión) | 72 |
| Costumbre | [1..n] x (por dimensión) | ceil(8 * n^2) |
La mayoría de las aplicaciones con representación en tiempo real tienen un gran grado de consistencia temporal entre dos cuadros consecutivos. Sin embargo, hay casos en los que un cambio en la transformación de una cámara podría causar un cambio abrupto en lo que se representa. En tales casos, es poco probable que FSR2 pueda reutilizar cualquier datos que haya acumulado de marcos anteriores, y debería borrar estos datos para excluirlos de la consideración en el proceso de composición. Para indicar a FSR2 que se ha producido un corte de salto con la cámara, debe establecer el campo reset de la estructura FfxFsr2DispatchDescription en true para el primer cuadro de la transformación discontinua de la cámara.
El rendimiento de representación puede ser un poco menor que la operación típica de marco a marco cuando se usa el indicador de reinicio, ya que FSR2 borrará algunos recursos internos adicionales.
Aplicar un sesgo negativo de MIPMAP típicamente generará una imagen elevada con mejores detalles de textura. Recomendamos aplicar la siguiente fórmula a su sesgo MIPMAP:
mipBias = log2(renderResolution/displayResolution) - 1.0 ;Se sugiere que las aplicaciones ajusten el sesgo MIP para un contenido específico de textura de alta frecuencia que es susceptible a mostrar problemas de alias temporales.
La siguiente tabla ilustra el factor de polarización MIPMAP que resulta de evaluar el pseudocódigo anterior para las relaciones de escala que coinciden con los modos de calidad sugeridos que las aplicaciones deben exponer a los usuarios finales.
| Modo de calidad | Factor de escala | Sesgo de mipmap |
|---|---|---|
| Calidad | 1.5x (por dimensión) | -1,58 |
| Equilibrado | 1.7x (por dimensión) | -1.76 |
| Actuación | 2.0x (por dimensión) | -2.0 |
| Ultra rendimiento | 3.0x (por dimensión) | -2.58 |
La API FSR2 requiere que la aplicación se proporcione frameTimeDelta a través de la estructura FfxFsr2DispatchDescription . Este valor está en milisegundos : si se ejecuta a 60 fps, el valor aprobado debe ser de alrededor de 16.6F .
El valor se utiliza dentro del componente temporal de la función FSR 2 de exposición automática. Esto permite la sintonización de la acumulación de historial para fines de calidad.
Las imágenes de rango dinámico de alto se admiten en FSR2. Para habilitar esto, debe establecer el bit FFX_FSR2_ENABLE_HIGH_DYNAMIC_RANGE en el campo flags de la estructura FfxFsr2ContextDescription . Se deben proporcionar imágenes a FSR2 en un espacio de color lineal.
Se podría proporcionar soporte para espacios de color adicionales en una revisión futura de FSR2.
FSR2 fue diseñado para aprovechar la aceleración de hardware de mitad de precisión (FP16) para lograr el mayor rendimiento posible. Sin embargo, para proporcionar el nivel máximo de compatibilidad y flexibilidad para las aplicaciones, FSR2 también incluye la capacidad de compilar los sombreadores utilizando operaciones de precisión completa (FP32).
Se recomienda usar la versión FP16 de FSR2 en todo el hardware que lo admite. Puede consultar el nivel de soporte de su tarjeta gráfica para FP16 consultando la capacidad D3D12_FEATURE_DATA_SHADER_MIN_PRECISION_SUPPORT en DirectX (R) 12: puede verificar que el D3D[11/12]_SHADER_MIN_PRECISION_16_BIT esté establecido, y si no es, Fallback a la versión FP32 FP32 de FP32 de FP32 de FP3 FSR2. Para Vulkan, si VkPhysicalDeviceFloat16Int8FeaturesKHR::shaderFloat16 no está configurado, entonces debe caer a la versión FP32 de FSR2. Del mismo modo, si VkPhysicalDevice16BitStorageFeatures::storageBuffer16BitAccess no está configurado, también debe caer a la versión FP32 de FSR2.
Para habilitar la ruta FP32 en el código fuente del sombreador FSR2, debe definir FFX_HALF como 1 . Para compartir la mayoría del código fuente del algoritmo entre FP16 y FP32 (asegurando un alto nivel de intercambio de código para admitir el mantenimiento continuo), notará que el código fuente del sombreador FSR2 usa un conjunto de macros de tipo que facilita el cambio fácil entre Tipos de base de 16 y 32 bits en la fuente del sombreador.
| Tipo de fidelityfx | FP32 | FP16 |
|---|---|---|
FFX_MIN16_F | float | min16float |
FFX_MIN16_F2 | float2 | min16float2 |
FFX_MIN16_F3 | float3 | min16float3 |
FFX_MIN16_F4 | float4 | min16float4 |
La tabla anterior enumera las asignaciones entre los tipos abstractos de FidelityFX SDK y el tipo intrínseco de subestimación que se sustituirá dependiendo de la configuración de la fuente del sombreador durante la compilación.
Las GPU modernas ejecutan colecciones de hilos, llamadas frente de onda, juntas de manera simt. El número preciso de hilos que constituyen un solo frente de onda es una cantidad específica de hardware. Algunos hardware, como GCN de AMD y GPU basado en ADNc, admiten que la recolección de 64 hilos en un solo frente de onda. Dependiendo de las características precisas de la ejecución de un algoritmo, puede ser más o menos ventajoso preferir un ancho de frente de onda específico. Con la introducción del Modelo 6.6 de Shader, Microsoft agregó la capacidad de especificar el ancho de un frente de onda a través de HLSL. Para el hardware, como el RDNA que admite los anchos de frente de onda de 32 y 64 anchos, esta es una herramienta muy útil para fines de optimización, ya que proporciona una forma limpia y portátil de pedirle al software del controlador que ejecute un frente de onda con un ancho específico.
Para las aplicaciones basadas en DirectX (R) 12 que se ejecutan en GPU basadas en RDNA y RDNA2 y utilizando el SDK de Microsoft Agility SDK, la API host FSR2 seleccionará un ancho de frente de onda de 64 ancho.
La estructura de descripción de contexto se puede proporcionar con una función de devolución de llamada para pasar advertencias textuales del tiempo de ejecución FSR 2 a la aplicación subyacente. El miembro fpMessage de la descripción es de tipo FfxFsr2Message , que es un puntero de función para pasar mensajes de cadena de varios tipos. Asignando esta variable a una función adecuada, y pasar el indicador FFX_FSR2_ENABLE_DEBUG_CHECKING dentro del miembro de los banderas de FfxFsr2ContextDescription habilitará la función. Se recomienda que esto esté habilitado solo en construcciones de desarrollo de depuración.
Un ejemplo del tipo de salida que puede ocurrir cuando el verificador observa posibles problemas está a continuación:
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)
El algoritmo FSR2 se implementa en una serie de etapas, que son los siguientes:
Cada etapa de pase del algoritmo se establece en las secciones después de esta, pero el flujo de datos para el algoritmo FSR2 completo se muestra en el diagrama a continuación.
La etapa piramidal de luminancia de cómputo tiene dos responsabilidades:
La siguiente tabla contiene todos los recursos consumidos por la etapa de pirámide de luminancia de cálculo.
La capa temporal indica de qué marco deben obtener los datos. El "marco actual" significa que los datos deben obtenerse de los recursos creados para el marco que se presentará a continuación. 'Frame anterior' indica que los datos deben obtenerse de los recursos que se crearon para el marco que acaba de presentar. La columna de resolución indica si los datos deben estar en resolución de 'presentación' o 'presentación'. La resolución 'renderizada' indica que el recurso debe coincidir con la resolución en la que la aplicación está realizando su representación. Por el contrario, la 'presentación' indica que la resolución del objetivo debe coincidir con lo que se presentará al usuario.
| Nombre | Capa temporal | Resolución | Formato | Tipo | Notas |
|---|---|---|---|---|---|
| Amortiguador de color | Marco actual | Prestar | APPLICATION SPECIFIED | Textura | El búfer de color de resolución de renderizado para el marco actual proporcionado por la aplicación. Si el contenido del búfer de color está en un rango dinámico de alto (HDR), entonces el indicador FFX_FSR2_ENABLE_HIGH_DYNAMIC_RANGE debe establecerse en el campo flags de la estructura FfxFsr2ContextDescription . |
La siguiente tabla contiene todos los recursos producidos o modificados por la etapa de pirámide de luminancia de cálculo.
La capa temporal indica de qué marco deben obtener los datos. El "marco actual" significa que los datos deben obtenerse de los recursos creados para el marco que se presentará a continuación. 'Frame anterior' indica que los datos deben obtenerse de los recursos que se crearon para el marco que acaba de presentar. La columna de resolución indica si los datos deben estar en resolución de 'presentación' o 'presentación'. La resolución 'renderizada' indica que el recurso debe coincidir con la resolución en la que la aplicación está realizando su representación. Por el contrario, la 'presentación' indica que la resolución del objetivo debe coincidir con lo que se presentará al usuario.
| Nombre | Capa temporal | Resolución | Formato | Tipo | Notas |
|---|---|---|---|---|---|
| Exposición | Marco actual | 1x1 | R32_FLOAT | Textura | Una textura 1x1 que contiene el valor de exposición calculado para el marco actual. Este recurso es opcional, y puede omitirse si el indicador FFX_FSR2_ENABLE_AUTO_EXPOSURE está configurado en el campo flags de la estructura FfxFsr2ContextDescription al crear el FfxFsr2Context . |
| Luminancia actual | Marco actual | Render * 0.5 + mipchain | R16_FLOAT | Textura | Una textura al 50% de la textura de resolución de renderizado que contiene la luminancia del marco actual. Se asigna una cadena MIP completa. |
La etapa de pirámide de luminancia de cómputo se implementa utilizando FidelityFX Single Pass Downs
