From d0f6ddf0196488c94deaeea8ffd13070a070b939 Mon Sep 17 00:00:00 2001 From: Nico de Poel Date: Sat, 20 Jul 2024 18:53:14 +0200 Subject: [PATCH] Added FSR3 optical flow and frame interpolation shaders and headers, directly from the FidelityFX SDK. --- ..._vector_field_inpainting_pyramid_pass.hlsl | 71 ++ ...or_field_inpainting_pyramid_pass.hlsl.meta | 7 + ...ation_compute_inpainting_pyramid_pass.hlsl | 70 ++ ..._compute_inpainting_pyramid_pass.hlsl.meta | 7 + ...fx_frameinterpolation_debug_view_pass.hlsl | 57 ++ ...ameinterpolation_debug_view_pass.hlsl.meta | 7 + ...einterpolation_disocclusion_mask_pass.hlsl | 55 ++ ...rpolation_disocclusion_mask_pass.hlsl.meta | 7 + ...olation_game_motion_vector_field_pass.hlsl | 54 ++ ...on_game_motion_vector_field_pass.hlsl.meta | 7 + ...fx_frameinterpolation_inpainting_pass.hlsl | 53 ++ ...ameinterpolation_inpainting_pass.hlsl.meta | 7 + ...lation_optical_flow_vector_field_pass.hlsl | 55 ++ ...n_optical_flow_vector_field_pass.hlsl.meta | 7 + .../shaders/ffx_frameinterpolation_pass.hlsl | 58 ++ .../ffx_frameinterpolation_pass.hlsl.meta | 7 + ...rpolation_reconstruct_and_dilate_pass.hlsl | 58 ++ ...tion_reconstruct_and_dilate_pass.hlsl.meta | 7 + ...ation_reconstruct_previous_depth_pass.hlsl | 52 ++ ..._reconstruct_previous_depth_pass.hlsl.meta | 7 + .../ffx_frameinterpolation_setup_pass.hlsl | 55 ++ ...fx_frameinterpolation_setup_pass.hlsl.meta | 7 + ...alflow_compute_luminance_pyramid_pass.hlsl | 57 ++ ...w_compute_luminance_pyramid_pass.hlsl.meta | 7 + ...compute_optical_flow_advanced_pass_v5.hlsl | 63 ++ ...te_optical_flow_advanced_pass_v5.hlsl.meta | 7 + ...ticalflow_compute_scd_divergence_pass.hlsl | 56 ++ ...flow_compute_scd_divergence_pass.hlsl.meta | 7 + ...ticalflow_filter_optical_flow_pass_v5.hlsl | 56 ++ ...flow_filter_optical_flow_pass_v5.hlsl.meta | 7 + ...ticalflow_generate_scd_histogram_pass.hlsl | 54 ++ ...flow_generate_scd_histogram_pass.hlsl.meta | 7 + .../ffx_opticalflow_prepare_luma_pass.hlsl | 50 ++ ...fx_opticalflow_prepare_luma_pass.hlsl.meta | 7 + ...w_scale_optical_flow_advanced_pass_v5.hlsl | 62 ++ ...le_optical_flow_advanced_pass_v5.hlsl.meta | 7 + Shaders/shaders/frameinterpolation.meta | 8 + .../ffx_frameinterpolation.h | 192 +++++ .../ffx_frameinterpolation.h.meta | 60 ++ .../ffx_frameinterpolation_callbacks_hlsl.h | 778 ++++++++++++++++++ ...x_frameinterpolation_callbacks_hlsl.h.meta | 60 ++ .../ffx_frameinterpolation_common.h | 445 ++++++++++ .../ffx_frameinterpolation_common.h.meta | 60 ++ ...ute_game_vector_field_inpainting_pyramid.h | 121 +++ ...ame_vector_field_inpainting_pyramid.h.meta | 60 ++ ...interpolation_compute_inpainting_pyramid.h | 120 +++ ...polation_compute_inpainting_pyramid.h.meta | 60 ++ .../ffx_frameinterpolation_debug_view.h | 163 ++++ .../ffx_frameinterpolation_debug_view.h.meta | 60 ++ ...ffx_frameinterpolation_disocclusion_mask.h | 142 ++++ ...rameinterpolation_disocclusion_mask.h.meta | 60 ++ ...meinterpolation_game_motion_vector_field.h | 118 +++ ...erpolation_game_motion_vector_field.h.meta | 60 ++ .../ffx_frameinterpolation_inpainting.h | 150 ++++ .../ffx_frameinterpolation_inpainting.h.meta | 60 ++ ...einterpolation_optical_flow_vector_field.h | 124 +++ ...rpolation_optical_flow_vector_field.h.meta | 60 ++ ...ruct_dilated_velocity_and_previous_depth.h | 123 +++ ...dilated_velocity_and_previous_depth.h.meta | 60 ++ ...interpolation_reconstruct_previous_depth.h | 59 ++ ...polation_reconstruct_previous_depth.h.meta | 60 ++ .../ffx_frameinterpolation_resources.h | 99 +++ .../ffx_frameinterpolation_resources.h.meta | 60 ++ .../ffx_frameinterpolation_setup.h | 50 ++ .../ffx_frameinterpolation_setup.h.meta | 60 ++ Shaders/shaders/fsr3.meta | 8 + .../shaders/fsr3/ffx_fsr3_callbacks_hlsl.h | 24 + .../fsr3/ffx_fsr3_callbacks_hlsl.h.meta | 60 ++ Shaders/shaders/fsr3/ffx_fsr3_common.h | 25 + Shaders/shaders/fsr3/ffx_fsr3_common.h.meta | 60 ++ Shaders/shaders/fsr3/ffx_fsr3_resources.h | 37 + .../shaders/fsr3/ffx_fsr3_resources.h.meta | 60 ++ Shaders/shaders/opticalflow.meta | 8 + .../ffx_opticalflow_callbacks_hlsl.h | 634 ++++++++++++++ .../ffx_opticalflow_callbacks_hlsl.h.meta | 60 ++ .../opticalflow/ffx_opticalflow_common.h | 99 +++ .../opticalflow/ffx_opticalflow_common.h.meta | 60 ++ ...fx_opticalflow_compute_luminance_pyramid.h | 107 +++ ...ticalflow_compute_luminance_pyramid.h.meta | 60 ++ .../ffx_opticalflow_compute_optical_flow_v5.h | 279 +++++++ ...opticalflow_compute_optical_flow_v5.h.meta | 60 ++ .../ffx_opticalflow_compute_scd_divergence.h | 159 ++++ ..._opticalflow_compute_scd_divergence.h.meta | 60 ++ .../ffx_opticalflow_filter_optical_flow_v5.h | 58 ++ ..._opticalflow_filter_optical_flow_v5.h.meta | 60 ++ .../ffx_opticalflow_generate_scd_histogram.h | 92 +++ ..._opticalflow_generate_scd_histogram.h.meta | 60 ++ .../ffx_opticalflow_prepare_luma.h | 106 +++ .../ffx_opticalflow_prepare_luma.h.meta | 60 ++ .../opticalflow/ffx_opticalflow_resources.h | 74 ++ .../ffx_opticalflow_resources.h.meta | 60 ++ ...ticalflow_scale_optical_flow_advanced_v5.h | 99 +++ ...flow_scale_optical_flow_advanced_v5.h.meta | 60 ++ 93 files changed, 7283 insertions(+) create mode 100644 Shaders/shaders/ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid_pass.hlsl create mode 100644 Shaders/shaders/ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid_pass.hlsl.meta create mode 100644 Shaders/shaders/ffx_frameinterpolation_compute_inpainting_pyramid_pass.hlsl create mode 100644 Shaders/shaders/ffx_frameinterpolation_compute_inpainting_pyramid_pass.hlsl.meta create mode 100644 Shaders/shaders/ffx_frameinterpolation_debug_view_pass.hlsl create mode 100644 Shaders/shaders/ffx_frameinterpolation_debug_view_pass.hlsl.meta create mode 100644 Shaders/shaders/ffx_frameinterpolation_disocclusion_mask_pass.hlsl create mode 100644 Shaders/shaders/ffx_frameinterpolation_disocclusion_mask_pass.hlsl.meta create mode 100644 Shaders/shaders/ffx_frameinterpolation_game_motion_vector_field_pass.hlsl create mode 100644 Shaders/shaders/ffx_frameinterpolation_game_motion_vector_field_pass.hlsl.meta create mode 100644 Shaders/shaders/ffx_frameinterpolation_inpainting_pass.hlsl create mode 100644 Shaders/shaders/ffx_frameinterpolation_inpainting_pass.hlsl.meta create mode 100644 Shaders/shaders/ffx_frameinterpolation_optical_flow_vector_field_pass.hlsl create mode 100644 Shaders/shaders/ffx_frameinterpolation_optical_flow_vector_field_pass.hlsl.meta create mode 100644 Shaders/shaders/ffx_frameinterpolation_pass.hlsl create mode 100644 Shaders/shaders/ffx_frameinterpolation_pass.hlsl.meta create mode 100644 Shaders/shaders/ffx_frameinterpolation_reconstruct_and_dilate_pass.hlsl create mode 100644 Shaders/shaders/ffx_frameinterpolation_reconstruct_and_dilate_pass.hlsl.meta create mode 100644 Shaders/shaders/ffx_frameinterpolation_reconstruct_previous_depth_pass.hlsl create mode 100644 Shaders/shaders/ffx_frameinterpolation_reconstruct_previous_depth_pass.hlsl.meta create mode 100644 Shaders/shaders/ffx_frameinterpolation_setup_pass.hlsl create mode 100644 Shaders/shaders/ffx_frameinterpolation_setup_pass.hlsl.meta create mode 100644 Shaders/shaders/ffx_opticalflow_compute_luminance_pyramid_pass.hlsl create mode 100644 Shaders/shaders/ffx_opticalflow_compute_luminance_pyramid_pass.hlsl.meta create mode 100644 Shaders/shaders/ffx_opticalflow_compute_optical_flow_advanced_pass_v5.hlsl create mode 100644 Shaders/shaders/ffx_opticalflow_compute_optical_flow_advanced_pass_v5.hlsl.meta create mode 100644 Shaders/shaders/ffx_opticalflow_compute_scd_divergence_pass.hlsl create mode 100644 Shaders/shaders/ffx_opticalflow_compute_scd_divergence_pass.hlsl.meta create mode 100644 Shaders/shaders/ffx_opticalflow_filter_optical_flow_pass_v5.hlsl create mode 100644 Shaders/shaders/ffx_opticalflow_filter_optical_flow_pass_v5.hlsl.meta create mode 100644 Shaders/shaders/ffx_opticalflow_generate_scd_histogram_pass.hlsl create mode 100644 Shaders/shaders/ffx_opticalflow_generate_scd_histogram_pass.hlsl.meta create mode 100644 Shaders/shaders/ffx_opticalflow_prepare_luma_pass.hlsl create mode 100644 Shaders/shaders/ffx_opticalflow_prepare_luma_pass.hlsl.meta create mode 100644 Shaders/shaders/ffx_opticalflow_scale_optical_flow_advanced_pass_v5.hlsl create mode 100644 Shaders/shaders/ffx_opticalflow_scale_optical_flow_advanced_pass_v5.hlsl.meta create mode 100644 Shaders/shaders/frameinterpolation.meta create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation.h create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation.h.meta create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h.meta create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_common.h create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_common.h.meta create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid.h create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid.h.meta create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_compute_inpainting_pyramid.h create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_compute_inpainting_pyramid.h.meta create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_debug_view.h create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_debug_view.h.meta create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_disocclusion_mask.h create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_disocclusion_mask.h.meta create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_game_motion_vector_field.h create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_game_motion_vector_field.h.meta create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_inpainting.h create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_inpainting.h.meta create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_optical_flow_vector_field.h create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_optical_flow_vector_field.h.meta create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_reconstruct_dilated_velocity_and_previous_depth.h create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_reconstruct_dilated_velocity_and_previous_depth.h.meta create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_reconstruct_previous_depth.h create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_reconstruct_previous_depth.h.meta create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_resources.h create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_resources.h.meta create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_setup.h create mode 100644 Shaders/shaders/frameinterpolation/ffx_frameinterpolation_setup.h.meta create mode 100644 Shaders/shaders/fsr3.meta create mode 100644 Shaders/shaders/fsr3/ffx_fsr3_callbacks_hlsl.h create mode 100644 Shaders/shaders/fsr3/ffx_fsr3_callbacks_hlsl.h.meta create mode 100644 Shaders/shaders/fsr3/ffx_fsr3_common.h create mode 100644 Shaders/shaders/fsr3/ffx_fsr3_common.h.meta create mode 100644 Shaders/shaders/fsr3/ffx_fsr3_resources.h create mode 100644 Shaders/shaders/fsr3/ffx_fsr3_resources.h.meta create mode 100644 Shaders/shaders/opticalflow.meta create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_callbacks_hlsl.h create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_callbacks_hlsl.h.meta create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_common.h create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_common.h.meta create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_compute_luminance_pyramid.h create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_compute_luminance_pyramid.h.meta create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_compute_optical_flow_v5.h create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_compute_optical_flow_v5.h.meta create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_compute_scd_divergence.h create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_compute_scd_divergence.h.meta create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_filter_optical_flow_v5.h create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_filter_optical_flow_v5.h.meta create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_generate_scd_histogram.h create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_generate_scd_histogram.h.meta create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_prepare_luma.h create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_prepare_luma.h.meta create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_resources.h create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_resources.h.meta create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_scale_optical_flow_advanced_v5.h create mode 100644 Shaders/shaders/opticalflow/ffx_opticalflow_scale_optical_flow_advanced_v5.h.meta diff --git a/Shaders/shaders/ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid_pass.hlsl b/Shaders/shaders/ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid_pass.hlsl new file mode 100644 index 0000000..8f75361 --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid_pass.hlsl @@ -0,0 +1,71 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define FFX_FRAMEINTERPOLATION_BIND_SRV_GAME_MOTION_VECTOR_FIELD_X 0 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_GAME_MOTION_VECTOR_FIELD_Y 1 + +#define FFX_FRAMEINTERPOLATION_BIND_UAV_COUNTERS 0 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_0 1 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_1 2 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_2 3 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_3 4 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_4 5 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_5 6 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_6 7 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_7 8 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_8 9 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_9 10 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_10 11 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_11 12 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_12 13 + +#define FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION 0 + +#ifdef FFX_HALF + #undef FFX_HALF + #define FFX_HALF 0 +#endif + +#define FFX_FRAMEINTERPOLATION_BIND_CB_INPAINTING_PYRAMID 1 + +#include "frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h" +#include "frameinterpolation/ffx_frameinterpolation_common.h" +#include "frameinterpolation/ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid.h" + +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH 256 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT 1 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS +#define FFX_FRAMEINTERPOLATION_NUM_THREADS [numthreads(FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH, FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT, FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH)] +#endif // #ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS + +FFX_FRAMEINTERPOLATION_NUM_THREADS +void CS(FfxUInt32x3 WorkGroupId : SV_GroupID, FfxUInt32 LocalThreadIndex : SV_GroupIndex) +{ + computeFrameinterpolationGameVectorFieldInpaintingPyramid(WorkGroupId, LocalThreadIndex); +} diff --git a/Shaders/shaders/ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid_pass.hlsl.meta b/Shaders/shaders/ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid_pass.hlsl.meta new file mode 100644 index 0000000..b6dcce1 --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid_pass.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 3cd4562d24383ce4fa00eadf5d122cd9 +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/ffx_frameinterpolation_compute_inpainting_pyramid_pass.hlsl b/Shaders/shaders/ffx_frameinterpolation_compute_inpainting_pyramid_pass.hlsl new file mode 100644 index 0000000..d2686d7 --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_compute_inpainting_pyramid_pass.hlsl @@ -0,0 +1,70 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define FFX_FRAMEINTERPOLATION_BIND_SRV_OUTPUT 0 + +#define FFX_FRAMEINTERPOLATION_BIND_UAV_COUNTERS 0 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_0 1 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_1 2 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_2 3 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_3 4 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_4 5 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_5 6 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_6 7 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_7 8 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_8 9 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_9 10 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_10 11 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_11 12 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_12 13 + +#define FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION 0 + +#ifdef FFX_HALF + #undef FFX_HALF + #define FFX_HALF 0 +#endif + +#define FFX_FRAMEINTERPOLATION_BIND_CB_INPAINTING_PYRAMID 1 + +#include "frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h" +#include "frameinterpolation/ffx_frameinterpolation_common.h" +#include "frameinterpolation/ffx_frameinterpolation_compute_inpainting_pyramid.h" + +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH 256 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT 1 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS +#define FFX_FRAMEINTERPOLATION_NUM_THREADS [numthreads(FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH, FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT, FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH)] +#endif // #ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS + +FFX_FRAMEINTERPOLATION_NUM_THREADS +void CS(FfxUInt32x3 WorkGroupId : SV_GroupID, FfxUInt32 LocalThreadIndex : SV_GroupIndex) +{ + computeFrameinterpolationInpaintingPyramid(WorkGroupId, LocalThreadIndex); +} diff --git a/Shaders/shaders/ffx_frameinterpolation_compute_inpainting_pyramid_pass.hlsl.meta b/Shaders/shaders/ffx_frameinterpolation_compute_inpainting_pyramid_pass.hlsl.meta new file mode 100644 index 0000000..515b485 --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_compute_inpainting_pyramid_pass.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 37d572f0b28b6f645a923b6590f12efb +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/ffx_frameinterpolation_debug_view_pass.hlsl b/Shaders/shaders/ffx_frameinterpolation_debug_view_pass.hlsl new file mode 100644 index 0000000..e844728 --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_debug_view_pass.hlsl @@ -0,0 +1,57 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define FFX_FRAMEINTERPOLATION_BIND_SRV_GAME_MOTION_VECTOR_FIELD_X 0 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_GAME_MOTION_VECTOR_FIELD_Y 1 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_X 2 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_Y 3 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_DISOCCLUSION_MASK 4 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_PRESENT_BACKBUFFER 5 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_INPAINTING_PYRAMID 6 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_CURRENT_INTERPOLATION_SOURCE 7 + +#define FFX_FRAMEINTERPOLATION_BIND_UAV_OUTPUT 0 + +#define FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION 0 + +#include "frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h" +#include "frameinterpolation/ffx_frameinterpolation_common.h" +#include "frameinterpolation/ffx_frameinterpolation_debug_view.h" + +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH 8 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT 8 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS +#define FFX_FRAMEINTERPOLATION_NUM_THREADS [numthreads(FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH, FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT, FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH)] +#endif // #ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS + +FFX_FRAMEINTERPOLATION_NUM_THREADS +void CS(FfxInt32x2 iPxPos : SV_DispatchThreadID) +{ + computeDebugView(iPxPos); +} diff --git a/Shaders/shaders/ffx_frameinterpolation_debug_view_pass.hlsl.meta b/Shaders/shaders/ffx_frameinterpolation_debug_view_pass.hlsl.meta new file mode 100644 index 0000000..7dab4f6 --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_debug_view_pass.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 354e05e22a936934089e2c7bfb157e9e +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/ffx_frameinterpolation_disocclusion_mask_pass.hlsl b/Shaders/shaders/ffx_frameinterpolation_disocclusion_mask_pass.hlsl new file mode 100644 index 0000000..b26f432 --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_disocclusion_mask_pass.hlsl @@ -0,0 +1,55 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define FFX_FRAMEINTERPOLATION_BIND_SRV_GAME_MOTION_VECTOR_FIELD_X 0 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_GAME_MOTION_VECTOR_FIELD_Y 1 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_RECONSTRUCTED_DEPTH_PREVIOUS_FRAME 2 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_DILATED_DEPTH 3 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_RECONSTRUCTED_DEPTH_INTERPOLATED_FRAME 4 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_INPAINTING_PYRAMID 5 + +#define FFX_FRAMEINTERPOLATION_BIND_UAV_DISOCCLUSION_MASK 0 + +#define FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION 0 + +#include "frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h" +#include "frameinterpolation/ffx_frameinterpolation_common.h" +#include "frameinterpolation/ffx_frameinterpolation_disocclusion_mask.h" + +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH 8 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT 8 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS +#define FFX_FRAMEINTERPOLATION_NUM_THREADS [numthreads(FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH, FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT, FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH)] +#endif // #ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS + +FFX_FRAMEINTERPOLATION_NUM_THREADS +void CS(FfxInt32x2 iPxPos : SV_DispatchThreadID) +{ + computeDisocclusionMask(iPxPos); +} diff --git a/Shaders/shaders/ffx_frameinterpolation_disocclusion_mask_pass.hlsl.meta b/Shaders/shaders/ffx_frameinterpolation_disocclusion_mask_pass.hlsl.meta new file mode 100644 index 0000000..9e81d49 --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_disocclusion_mask_pass.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: f8740ba66c4b7624ea1abc8b3e6c35b1 +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/ffx_frameinterpolation_game_motion_vector_field_pass.hlsl b/Shaders/shaders/ffx_frameinterpolation_game_motion_vector_field_pass.hlsl new file mode 100644 index 0000000..20f87b5 --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_game_motion_vector_field_pass.hlsl @@ -0,0 +1,54 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define FFX_FRAMEINTERPOLATION_BIND_SRV_DILATED_MOTION_VECTORS 0 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_DILATED_DEPTH 1 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_PREVIOUS_INTERPOLATION_SOURCE 2 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_CURRENT_INTERPOLATION_SOURCE 3 + +#define FFX_FRAMEINTERPOLATION_BIND_UAV_GAME_MOTION_VECTOR_FIELD_X 0 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_GAME_MOTION_VECTOR_FIELD_Y 1 + +#define FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION 0 + +#include "frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h" +#include "frameinterpolation/ffx_frameinterpolation_common.h" +#include "frameinterpolation/ffx_frameinterpolation_game_motion_vector_field.h" + +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH 8 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT 8 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS +#define FFX_FRAMEINTERPOLATION_NUM_THREADS [numthreads(FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH, FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT, FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH)] +#endif // #ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS + +FFX_FRAMEINTERPOLATION_NUM_THREADS +void CS(FfxInt32x2 iPxPos : SV_DispatchThreadID) +{ + computeGameFieldMvs(iPxPos); +} diff --git a/Shaders/shaders/ffx_frameinterpolation_game_motion_vector_field_pass.hlsl.meta b/Shaders/shaders/ffx_frameinterpolation_game_motion_vector_field_pass.hlsl.meta new file mode 100644 index 0000000..853dbc4 --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_game_motion_vector_field_pass.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 60cde4822dd54e6499101ea385167618 +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/ffx_frameinterpolation_inpainting_pass.hlsl b/Shaders/shaders/ffx_frameinterpolation_inpainting_pass.hlsl new file mode 100644 index 0000000..858498c --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_inpainting_pass.hlsl @@ -0,0 +1,53 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_SCENE_CHANGE_DETECTION 0 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_INPAINTING_PYRAMID 1 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_PRESENT_BACKBUFFER 2 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_CURRENT_INTERPOLATION_SOURCE 3 + +#define FFX_FRAMEINTERPOLATION_BIND_UAV_OUTPUT 0 + +#define FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION 0 + +#include "frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h" +#include "frameinterpolation/ffx_frameinterpolation_common.h" +#include "frameinterpolation/ffx_frameinterpolation_inpainting.h" + +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH 8 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT 8 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS +#define FFX_FRAMEINTERPOLATION_NUM_THREADS [numthreads(FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH, FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT, FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH)] +#endif // #ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS + +FFX_FRAMEINTERPOLATION_NUM_THREADS +void CS(FfxInt32x2 iPxPos : SV_DispatchThreadID) +{ + computeInpainting(iPxPos); +} diff --git a/Shaders/shaders/ffx_frameinterpolation_inpainting_pass.hlsl.meta b/Shaders/shaders/ffx_frameinterpolation_inpainting_pass.hlsl.meta new file mode 100644 index 0000000..b21924b --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_inpainting_pass.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 1296628e84d82b442955b313b553aa73 +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/ffx_frameinterpolation_optical_flow_vector_field_pass.hlsl b/Shaders/shaders/ffx_frameinterpolation_optical_flow_vector_field_pass.hlsl new file mode 100644 index 0000000..f9e204c --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_optical_flow_vector_field_pass.hlsl @@ -0,0 +1,55 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW 0 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_CONFIDENCE 1 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_DILATED_DEPTH 2 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_PREVIOUS_INTERPOLATION_SOURCE 3 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_CURRENT_INTERPOLATION_SOURCE 4 + +#define FFX_FRAMEINTERPOLATION_BIND_UAV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_X 0 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_Y 1 + +#define FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION 0 + +#include "frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h" +#include "frameinterpolation/ffx_frameinterpolation_common.h" +#include "frameinterpolation/ffx_frameinterpolation_optical_flow_vector_field.h" + +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH 8 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT 8 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS +#define FFX_FRAMEINTERPOLATION_NUM_THREADS [numthreads(FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH, FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT, FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH)] +#endif // #ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS + +FFX_FRAMEINTERPOLATION_NUM_THREADS +void CS(FfxInt32x2 iPxPos : SV_DispatchThreadID) +{ + computeOpticalFlowVectorField(iPxPos); +} diff --git a/Shaders/shaders/ffx_frameinterpolation_optical_flow_vector_field_pass.hlsl.meta b/Shaders/shaders/ffx_frameinterpolation_optical_flow_vector_field_pass.hlsl.meta new file mode 100644 index 0000000..4b44131 --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_optical_flow_vector_field_pass.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 274f931fd4682ac46995bfd8d55957d9 +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/ffx_frameinterpolation_pass.hlsl b/Shaders/shaders/ffx_frameinterpolation_pass.hlsl new file mode 100644 index 0000000..ea74540 --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_pass.hlsl @@ -0,0 +1,58 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define FFX_FRAMEINTERPOLATION_BIND_SRV_GAME_MOTION_VECTOR_FIELD_X 0 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_GAME_MOTION_VECTOR_FIELD_Y 1 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_X 2 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_Y 3 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_PREVIOUS_INTERPOLATION_SOURCE 4 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_CURRENT_INTERPOLATION_SOURCE 5 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_DISOCCLUSION_MASK 6 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_INPAINTING_PYRAMID 7 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_COUNTERS 8 + +#define FFX_FRAMEINTERPOLATION_BIND_UAV_OUTPUT 0 + +#define FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION 0 + +#include "frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h" +#include "frameinterpolation/ffx_frameinterpolation_common.h" +#include "frameinterpolation/ffx_frameinterpolation.h" + +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH 8 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT 8 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS +#define FFX_FRAMEINTERPOLATION_NUM_THREADS [numthreads(FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH, FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT, FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH)] +#endif // #ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS + +FFX_FRAMEINTERPOLATION_NUM_THREADS +void CS(FfxInt32x2 iPxPos : SV_DispatchThreadID) +{ + computeFrameinterpolation(iPxPos); +} diff --git a/Shaders/shaders/ffx_frameinterpolation_pass.hlsl.meta b/Shaders/shaders/ffx_frameinterpolation_pass.hlsl.meta new file mode 100644 index 0000000..086709d --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_pass.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: f5a24abc414175245b30414b90c737f7 +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/ffx_frameinterpolation_reconstruct_and_dilate_pass.hlsl b/Shaders/shaders/ffx_frameinterpolation_reconstruct_and_dilate_pass.hlsl new file mode 100644 index 0000000..431d1bf --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_reconstruct_and_dilate_pass.hlsl @@ -0,0 +1,58 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define FFX_FRAMEINTERPOLATION_BIND_SRV_INPUT_MOTION_VECTORS 0 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_INPUT_DEPTH 1 + +#define FFX_FRAMEINTERPOLATION_BIND_UAV_RECONSTRUCTED_DEPTH_PREVIOUS_FRAME 0 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_DILATED_MOTION_VECTORS 1 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_DILATED_DEPTH 2 + +#define FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION 0 + +#include "frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h" +#include "frameinterpolation/ffx_frameinterpolation_common.h" +#include "frameinterpolation/ffx_frameinterpolation_reconstruct_dilated_velocity_and_previous_depth.h" + +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH 8 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_WIDTH +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT 8 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_HEIGHT +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FSR3UPSCALER_THREAD_GROUP_DEPTH +#ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS +#define FFX_FRAMEINTERPOLATION_NUM_THREADS [numthreads(FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH, FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT, FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH)] +#endif // #ifndef FFX_FSR3UPSCALER_NUM_THREADS + +FFX_FRAMEINTERPOLATION_NUM_THREADS +void CS( + int2 iGroupId : SV_GroupID, + int2 iDispatchThreadId : SV_DispatchThreadID, + int2 iGroupThreadId : SV_GroupThreadID, + int iGroupIndex : SV_GroupIndex +) +{ + ReconstructAndDilate(iDispatchThreadId); +} diff --git a/Shaders/shaders/ffx_frameinterpolation_reconstruct_and_dilate_pass.hlsl.meta b/Shaders/shaders/ffx_frameinterpolation_reconstruct_and_dilate_pass.hlsl.meta new file mode 100644 index 0000000..99ffa44 --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_reconstruct_and_dilate_pass.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 9ab74cb734203714c82850108dd09b66 +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/ffx_frameinterpolation_reconstruct_previous_depth_pass.hlsl b/Shaders/shaders/ffx_frameinterpolation_reconstruct_previous_depth_pass.hlsl new file mode 100644 index 0000000..3aed49d --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_reconstruct_previous_depth_pass.hlsl @@ -0,0 +1,52 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define FFX_FRAMEINTERPOLATION_BIND_SRV_DILATED_MOTION_VECTORS 0 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_DILATED_DEPTH 1 +#define FFX_FRAMEINTERPOLATION_BIND_SRV_CURRENT_INTERPOLATION_SOURCE 2 + +#define FFX_FRAMEINTERPOLATION_BIND_UAV_RECONSTRUCTED_DEPTH_INTERPOLATED_FRAME 0 + +#define FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION 0 + +#include "frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h" +#include "frameinterpolation/ffx_frameinterpolation_common.h" +#include "frameinterpolation/ffx_frameinterpolation_reconstruct_previous_depth.h" + +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH 8 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT 8 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS +#define FFX_FRAMEINTERPOLATION_NUM_THREADS [numthreads(FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH, FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT, FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH)] +#endif // #ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS + +FFX_FRAMEINTERPOLATION_NUM_THREADS +void CS(FfxInt32x2 iPxPos : SV_DispatchThreadID) +{ + reconstructPreviousDepth(iPxPos); +} diff --git a/Shaders/shaders/ffx_frameinterpolation_reconstruct_previous_depth_pass.hlsl.meta b/Shaders/shaders/ffx_frameinterpolation_reconstruct_previous_depth_pass.hlsl.meta new file mode 100644 index 0000000..4ed4d02 --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_reconstruct_previous_depth_pass.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: c18054d765fcf0f4499305fa7accdf27 +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/ffx_frameinterpolation_setup_pass.hlsl b/Shaders/shaders/ffx_frameinterpolation_setup_pass.hlsl new file mode 100644 index 0000000..7c16fcc --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_setup_pass.hlsl @@ -0,0 +1,55 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_SCENE_CHANGE_DETECTION 0 + +#define FFX_FRAMEINTERPOLATION_BIND_UAV_GAME_MOTION_VECTOR_FIELD_X 0 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_GAME_MOTION_VECTOR_FIELD_Y 1 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_X 2 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_Y 3 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_DISOCCLUSION_MASK 4 +#define FFX_FRAMEINTERPOLATION_BIND_UAV_COUNTERS 5 + +#define FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION 0 + +#include "frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h" +#include "frameinterpolation/ffx_frameinterpolation_common.h" +#include "frameinterpolation/ffx_frameinterpolation_setup.h" + +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH 8 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT 8 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT +#ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#define FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH +#ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS +#define FFX_FRAMEINTERPOLATION_NUM_THREADS [numthreads(FFX_FRAMEINTERPOLATION_THREAD_GROUP_WIDTH, FFX_FRAMEINTERPOLATION_THREAD_GROUP_HEIGHT, FFX_FRAMEINTERPOLATION_THREAD_GROUP_DEPTH)] +#endif // #ifndef FFX_FRAMEINTERPOLATION_NUM_THREADS + +FFX_FRAMEINTERPOLATION_NUM_THREADS +void CS(FfxInt32x2 iPxPos : SV_DispatchThreadID) +{ + setupFrameinterpolationResources(iPxPos); +} diff --git a/Shaders/shaders/ffx_frameinterpolation_setup_pass.hlsl.meta b/Shaders/shaders/ffx_frameinterpolation_setup_pass.hlsl.meta new file mode 100644 index 0000000..6a2b9d6 --- /dev/null +++ b/Shaders/shaders/ffx_frameinterpolation_setup_pass.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 12f0653f1cdae7f4ca75c41024576f2f +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/ffx_opticalflow_compute_luminance_pyramid_pass.hlsl b/Shaders/shaders/ffx_opticalflow_compute_luminance_pyramid_pass.hlsl new file mode 100644 index 0000000..1c62a53 --- /dev/null +++ b/Shaders/shaders/ffx_opticalflow_compute_luminance_pyramid_pass.hlsl @@ -0,0 +1,57 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT 0 +#define FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_1 1 +#define FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_2 2 +#define FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_3 3 +#define FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_4 4 +#define FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_5 5 +#define FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_6 6 + +#define FFX_OPTICALFLOW_BIND_CB_COMMON 0 +#define FFX_OPTICALFLOW_BIND_CB_SPD 1 + +#include "opticalflow/ffx_opticalflow_callbacks_hlsl.h" +#include "opticalflow/ffx_opticalflow_compute_luminance_pyramid.h" + +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_WIDTH +#define FFX_OPTICALFLOW_THREAD_GROUP_WIDTH 256 +#endif // #ifndef FFX_OPTICALFLOW_THREAD_GROUP_WIDTH +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT +#define FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT 1 +#endif // #ifndef FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_DEPTH +#define FFX_OPTICALFLOW_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_OPTICALFLOW_THREAD_GROUP_DEPTH +#ifndef FFX_OPTICALFLOW_NUM_THREADS +#define FFX_OPTICALFLOW_NUM_THREADS [numthreads(FFX_OPTICALFLOW_THREAD_GROUP_WIDTH, FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT, FFX_OPTICALFLOW_THREAD_GROUP_DEPTH)] +#endif // #ifndef FFX_OPTICALFLOW_NUM_THREADS + +FFX_OPTICALFLOW_NUM_THREADS +FFX_OPTICALFLOW_EMBED_CB2_ROOTSIG_CONTENT +void CS(int2 iGlobalId : SV_DispatchThreadID, + int2 iGroupId : SV_GroupID, + int iLocalIndex : SV_GroupIndex) +{ + ComputeOpticalFlowInputPyramid(iGroupId, iLocalIndex); +} diff --git a/Shaders/shaders/ffx_opticalflow_compute_luminance_pyramid_pass.hlsl.meta b/Shaders/shaders/ffx_opticalflow_compute_luminance_pyramid_pass.hlsl.meta new file mode 100644 index 0000000..1ed8105 --- /dev/null +++ b/Shaders/shaders/ffx_opticalflow_compute_luminance_pyramid_pass.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 7752434668a56bb4a9a44893de0e30c0 +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/ffx_opticalflow_compute_optical_flow_advanced_pass_v5.hlsl b/Shaders/shaders/ffx_opticalflow_compute_optical_flow_advanced_pass_v5.hlsl new file mode 100644 index 0000000..a34c99d --- /dev/null +++ b/Shaders/shaders/ffx_opticalflow_compute_optical_flow_advanced_pass_v5.hlsl @@ -0,0 +1,63 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define FFX_WAVE 1 + +#define FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_INPUT 0 +#define FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_PREVIOUS_INPUT 1 + +#define FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW 0 +#define FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_OUTPUT 1 + +#define FFX_OPTICALFLOW_BIND_CB_COMMON 0 + +#include "opticalflow/ffx_opticalflow_callbacks_hlsl.h" + +#ifndef FFX_OPTICALFLOW_BLOCK_SIZE +#define FFX_OPTICALFLOW_BLOCK_SIZE 8 +#endif +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_WIDTH +#define FFX_OPTICALFLOW_THREAD_GROUP_WIDTH 64 +#endif // #ifndef FFX_OPTICALFLOW_THREAD_GROUP_WIDTH +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT +#define FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT 1 +#endif // #ifndef FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_DEPTH +#define FFX_OPTICALFLOW_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_OPTICALFLOW_THREAD_GROUP_DEPTH + +#include "opticalflow/ffx_opticalflow_compute_optical_flow_v5.h" + +#ifndef FFX_OPTICALFLOW_NUM_THREADS +#define FFX_OPTICALFLOW_NUM_THREADS [numthreads(FFX_OPTICALFLOW_THREAD_GROUP_WIDTH, FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT, FFX_OPTICALFLOW_THREAD_GROUP_DEPTH)] +#endif // #ifndef FFX_OPTICALFLOW_NUM_THREADS + +FFX_OPTICALFLOW_NUM_THREADS +FFX_OPTICALFLOW_EMBED_ROOTSIG_CONTENT +FFX_PREFER_WAVE64 +void CS(int2 iGlobalId : SV_DispatchThreadID, + int2 iLocalId : SV_GroupThreadID, + int2 iGroupId : SV_GroupID, + int iLocalIndex : SV_GroupIndex) +{ + ComputeOpticalFlowAdvanced(iGlobalId, iLocalId, iGroupId, iLocalIndex); +} diff --git a/Shaders/shaders/ffx_opticalflow_compute_optical_flow_advanced_pass_v5.hlsl.meta b/Shaders/shaders/ffx_opticalflow_compute_optical_flow_advanced_pass_v5.hlsl.meta new file mode 100644 index 0000000..5d8ab2a --- /dev/null +++ b/Shaders/shaders/ffx_opticalflow_compute_optical_flow_advanced_pass_v5.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 147318f7f0a12f34ea3afcb41cfcdb9b +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/ffx_opticalflow_compute_scd_divergence_pass.hlsl b/Shaders/shaders/ffx_opticalflow_compute_scd_divergence_pass.hlsl new file mode 100644 index 0000000..7b01816 --- /dev/null +++ b/Shaders/shaders/ffx_opticalflow_compute_scd_divergence_pass.hlsl @@ -0,0 +1,56 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_HISTOGRAM 0 +#define FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_PREVIOUS_HISTOGRAM 1 +#define FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_TEMP 2 +#define FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_OUTPUT 3 + +#define FFX_OPTICALFLOW_BIND_CB_COMMON 0 + +#include "opticalflow/ffx_opticalflow_callbacks_hlsl.h" +#include "opticalflow/ffx_opticalflow_compute_scd_divergence.h" + +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_WIDTH +#define FFX_OPTICALFLOW_THREAD_GROUP_WIDTH 256 +#endif // #ifndef FFX_OPTICALFLOW_THREAD_GROUP_WIDTH +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT +#define FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT 1 +#endif // #ifndef FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_DEPTH +#define FFX_OPTICALFLOW_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_OPTICALFLOW_THREAD_GROUP_DEPTH +#ifndef FFX_OPTICALFLOW_NUM_THREADS +#define FFX_OPTICALFLOW_NUM_THREADS [numthreads(FFX_OPTICALFLOW_THREAD_GROUP_WIDTH, FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT, FFX_OPTICALFLOW_THREAD_GROUP_DEPTH)] +#endif // #ifndef FFX_OPTICALFLOW_NUM_THREADS + +FFX_OPTICALFLOW_NUM_THREADS +FFX_OPTICALFLOW_EMBED_ROOTSIG_CONTENT +FFX_PREFER_WAVE64 +void CS(int3 iGlobalId : SV_DispatchThreadID, + int2 iLocalId : SV_GroupThreadID, + int2 iGroupId : SV_GroupID, + int iLocalIndex : SV_GroupIndex) +{ + int2 iGroupSize = int2(FFX_OPTICALFLOW_THREAD_GROUP_WIDTH, FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT); + ComputeSCDHistogramsDivergence(iGlobalId, iLocalId, iLocalIndex, iGroupId, iGroupSize); +} diff --git a/Shaders/shaders/ffx_opticalflow_compute_scd_divergence_pass.hlsl.meta b/Shaders/shaders/ffx_opticalflow_compute_scd_divergence_pass.hlsl.meta new file mode 100644 index 0000000..15de4e9 --- /dev/null +++ b/Shaders/shaders/ffx_opticalflow_compute_scd_divergence_pass.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 5ca6afef1cf3c134498a709d2a6d4d54 +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/ffx_opticalflow_filter_optical_flow_pass_v5.hlsl b/Shaders/shaders/ffx_opticalflow_filter_optical_flow_pass_v5.hlsl new file mode 100644 index 0000000..f220307 --- /dev/null +++ b/Shaders/shaders/ffx_opticalflow_filter_optical_flow_pass_v5.hlsl @@ -0,0 +1,56 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_PREVIOUS 0 + +#define FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW 0 + +#define FFX_OPTICALFLOW_BIND_CB_COMMON 0 + +#include "opticalflow/ffx_opticalflow_callbacks_hlsl.h" + +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_WIDTH +#define FFX_OPTICALFLOW_THREAD_GROUP_WIDTH 16 +#endif // #ifndef FFX_OPTICALFLOW_THREAD_GROUP_WIDTH +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT +#define FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT 4 +#endif // #ifndef FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_DEPTH +#define FFX_OPTICALFLOW_THREAD_GROUP_DEPTH 1 +#endif // #ifndef FFX_OPTICALFLOW_THREAD_GROUP_DEPTH + +#include "opticalflow/ffx_opticalflow_filter_optical_flow_v5.h" + +#ifndef FFX_OPTICALFLOW_NUM_THREADS +#define FFX_OPTICALFLOW_NUM_THREADS [numthreads(FFX_OPTICALFLOW_THREAD_GROUP_WIDTH, FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT, FFX_OPTICALFLOW_THREAD_GROUP_DEPTH)] +#endif // #ifndef FFX_OPTICALFLOW_NUM_THREADS + +FFX_OPTICALFLOW_NUM_THREADS +FFX_OPTICALFLOW_EMBED_ROOTSIG_CONTENT +FFX_PREFER_WAVE64 +void CS(int2 iGlobalId : SV_DispatchThreadID, + int2 iLocalId : SV_GroupThreadID, + int2 iGroupId : SV_GroupID, + int iLocalIndex : SV_GroupIndex) +{ + FilterOpticalFlow(iGlobalId, iLocalId, iGroupId, iLocalIndex); +} diff --git a/Shaders/shaders/ffx_opticalflow_filter_optical_flow_pass_v5.hlsl.meta b/Shaders/shaders/ffx_opticalflow_filter_optical_flow_pass_v5.hlsl.meta new file mode 100644 index 0000000..0fa0bcc --- /dev/null +++ b/Shaders/shaders/ffx_opticalflow_filter_optical_flow_pass_v5.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 59903e151d8d6594d97a989a7dd21df1 +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/ffx_opticalflow_generate_scd_histogram_pass.hlsl b/Shaders/shaders/ffx_opticalflow_generate_scd_histogram_pass.hlsl new file mode 100644 index 0000000..5350dcc --- /dev/null +++ b/Shaders/shaders/ffx_opticalflow_generate_scd_histogram_pass.hlsl @@ -0,0 +1,54 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_INPUT 0 +#define FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_HISTOGRAM 0 + +#define FFX_OPTICALFLOW_BIND_CB_COMMON 0 + +#include "opticalflow/ffx_opticalflow_callbacks_hlsl.h" +#include "opticalflow/ffx_opticalflow_generate_scd_histogram.h" + +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_WIDTH +#define FFX_OPTICALFLOW_THREAD_GROUP_WIDTH 32 +#endif +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT +#define FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT 8 +#endif +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_DEPTH +#define FFX_OPTICALFLOW_THREAD_GROUP_DEPTH 1 +#endif +#ifndef FFX_OPTICALFLOW_NUM_THREADS +#define FFX_OPTICALFLOW_NUM_THREADS [numthreads(FFX_OPTICALFLOW_THREAD_GROUP_WIDTH, FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT, FFX_OPTICALFLOW_THREAD_GROUP_DEPTH)] +#endif + +FFX_OPTICALFLOW_NUM_THREADS +FFX_OPTICALFLOW_EMBED_ROOTSIG_CONTENT +FFX_PREFER_WAVE64 +void CS(int3 iGlobalId : SV_DispatchThreadID, + int2 iLocalId : SV_GroupThreadID, + int2 iGroupId : SV_GroupID, + int iLocalIndex : SV_GroupIndex) +{ + int2 iGroupSize = int2(FFX_OPTICALFLOW_THREAD_GROUP_WIDTH, FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT); + GenerateSceneChangeDetectionHistogram(iGlobalId, iLocalId, iLocalIndex, iGroupId, iGroupSize); +} diff --git a/Shaders/shaders/ffx_opticalflow_generate_scd_histogram_pass.hlsl.meta b/Shaders/shaders/ffx_opticalflow_generate_scd_histogram_pass.hlsl.meta new file mode 100644 index 0000000..c907229 --- /dev/null +++ b/Shaders/shaders/ffx_opticalflow_generate_scd_histogram_pass.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 9f4290c7d6c15f641a115e39b7ec5342 +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/ffx_opticalflow_prepare_luma_pass.hlsl b/Shaders/shaders/ffx_opticalflow_prepare_luma_pass.hlsl new file mode 100644 index 0000000..0cc4592 --- /dev/null +++ b/Shaders/shaders/ffx_opticalflow_prepare_luma_pass.hlsl @@ -0,0 +1,50 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define FFX_OPTICALFLOW_BIND_SRV_INPUT_COLOR 0 +#define FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT 0 + +#define FFX_OPTICALFLOW_BIND_CB_COMMON 0 + +#include "opticalflow/ffx_opticalflow_callbacks_hlsl.h" + +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_WIDTH +#define FFX_OPTICALFLOW_THREAD_GROUP_WIDTH 16 +#endif +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT +#define FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT 16 +#endif +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_DEPTH +#define FFX_OPTICALFLOW_THREAD_GROUP_DEPTH 1 +#endif +#ifndef FFX_OPTICALFLOW_NUM_THREADS +#define FFX_OPTICALFLOW_NUM_THREADS [numthreads(FFX_OPTICALFLOW_THREAD_GROUP_WIDTH, FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT, FFX_OPTICALFLOW_THREAD_GROUP_DEPTH)] +#endif + +#include "opticalflow/ffx_opticalflow_prepare_luma.h" + +FFX_OPTICALFLOW_NUM_THREADS +FFX_OPTICALFLOW_EMBED_ROOTSIG_CONTENT +void CS(int2 iGlobalId : SV_DispatchThreadID, int iLocalIndex : SV_GroupIndex) +{ + PrepareLuma(iGlobalId, iLocalIndex); +} diff --git a/Shaders/shaders/ffx_opticalflow_prepare_luma_pass.hlsl.meta b/Shaders/shaders/ffx_opticalflow_prepare_luma_pass.hlsl.meta new file mode 100644 index 0000000..1070744 --- /dev/null +++ b/Shaders/shaders/ffx_opticalflow_prepare_luma_pass.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 455ee99394fc6a04e94c113d68e72241 +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/ffx_opticalflow_scale_optical_flow_advanced_pass_v5.hlsl b/Shaders/shaders/ffx_opticalflow_scale_optical_flow_advanced_pass_v5.hlsl new file mode 100644 index 0000000..d846741 --- /dev/null +++ b/Shaders/shaders/ffx_opticalflow_scale_optical_flow_advanced_pass_v5.hlsl @@ -0,0 +1,62 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#define FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_INPUT 0 +#define FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_PREVIOUS_INPUT 1 +#define FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW 2 + +#define FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_NEXT_LEVEL 0 +#define FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_OUTPUT 1 + +#define FFX_OPTICALFLOW_BIND_CB_COMMON 0 + +#include "opticalflow/ffx_opticalflow_callbacks_hlsl.h" + +#ifndef FFX_OPTICALFLOW_BLOCK_SIZE +#define FFX_OPTICALFLOW_BLOCK_SIZE 8 +#endif + +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_WIDTH +#define FFX_OPTICALFLOW_THREAD_GROUP_WIDTH 4 +#endif + +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT +#define FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT 4 +#endif + +#ifndef FFX_OPTICALFLOW_THREAD_GROUP_DEPTH +#define FFX_OPTICALFLOW_THREAD_GROUP_DEPTH 4 +#endif + +#include "opticalflow/ffx_opticalflow_scale_optical_flow_advanced_v5.h" + +#ifndef FFX_OPTICALFLOW_NUM_THREADS +#define FFX_OPTICALFLOW_NUM_THREADS [numthreads(FFX_OPTICALFLOW_THREAD_GROUP_WIDTH, FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT, FFX_OPTICALFLOW_THREAD_GROUP_DEPTH)] +#endif + +FFX_OPTICALFLOW_NUM_THREADS +FFX_OPTICALFLOW_EMBED_ROOTSIG_CONTENT +FFX_PREFER_WAVE64 +void CS(int3 iGlobalId : SV_DispatchThreadID, int3 iLocalId : SV_GroupThreadID) +{ + ScaleOpticalFlowAdvanced(iGlobalId, iLocalId); +} diff --git a/Shaders/shaders/ffx_opticalflow_scale_optical_flow_advanced_pass_v5.hlsl.meta b/Shaders/shaders/ffx_opticalflow_scale_optical_flow_advanced_pass_v5.hlsl.meta new file mode 100644 index 0000000..d9d1977 --- /dev/null +++ b/Shaders/shaders/ffx_opticalflow_scale_optical_flow_advanced_pass_v5.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: c1132c214a4b8244280127c25ba743b0 +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/frameinterpolation.meta b/Shaders/shaders/frameinterpolation.meta new file mode 100644 index 0000000..c95c7a4 --- /dev/null +++ b/Shaders/shaders/frameinterpolation.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: b8f9d950634cf174fa36dc607959997a +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation.h b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation.h new file mode 100644 index 0000000..8f84b9c --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation.h @@ -0,0 +1,192 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_FRAMEINTERPOLATION_H +#define FFX_FRAMEINTERPOLATION_H + +struct InterpolationSourceColor +{ + FfxFloat32x3 fRaw; + FfxFloat32x3 fLinear; + FfxFloat32 fBilinearWeightSum; +}; + +InterpolationSourceColor NewInterpolationSourceColor() +{ + InterpolationSourceColor c; + c.fRaw = FfxFloat32x3(0.0, 0.0, 0.0); + c.fLinear = FfxFloat32x3(0.0, 0.0, 0.0); + c.fBilinearWeightSum = 0.0; + return c; +} + +InterpolationSourceColor SampleTextureBilinear(FfxBoolean isCurrent, FfxFloat32x2 fUv, FfxFloat32x2 fMotionVector, FfxInt32x2 texSize) +{ + InterpolationSourceColor result = NewInterpolationSourceColor(); + + FfxFloat32x2 fReprojectedUv = fUv + fMotionVector; + BilinearSamplingData bilinearInfo = GetBilinearSamplingData(fReprojectedUv, texSize); + + FfxFloat32x3 fColor = FfxFloat32x3(0.0, 0.0, 0.0); + FfxFloat32 fWeightSum = 0.0f; + for (FfxInt32 iSampleIndex = 0; iSampleIndex < 4; iSampleIndex++) { + + const FfxInt32x2 iOffset = bilinearInfo.iOffsets[iSampleIndex]; + const FfxInt32x2 iSamplePos = bilinearInfo.iBasePos + iOffset; + + if (IsInRect(iSamplePos, InterpolationRectBase(), InterpolationRectSize())) + { + FfxFloat32 fWeight = bilinearInfo.fWeights[iSampleIndex]; + + if (isCurrent) + fColor += LoadCurrentBackbuffer(iSamplePos).rgb * fWeight; + else + fColor += LoadPreviousBackbuffer(iSamplePos).rgb * fWeight; + fWeightSum += fWeight; + } + } + + //normalize colors + fColor = (fWeightSum != 0.0f) ? fColor / fWeightSum : FfxFloat32x3(0.0f, 0.0f, 0.0f); + + result.fRaw = fColor; + result.fLinear = RawRGBToLinear(fColor); + result.fBilinearWeightSum = fWeightSum; + + return result; +} + +void updateInPaintingWeight(inout FfxFloat32 fInPaintingWeight, FfxFloat32 fFactor) +{ + fInPaintingWeight = ffxSaturate(ffxMax(fInPaintingWeight, fFactor)); +} + +void computeInterpolatedColor(FfxUInt32x2 iPxPos, out FfxFloat32x3 fInterpolatedColor, inout FfxFloat32 fInPaintingWeight) +{ + const FfxFloat32x2 fUvInInterpolationRect = (FfxFloat32x2(iPxPos - InterpolationRectBase()) + 0.5f) / InterpolationRectSize(); + const FfxFloat32x2 fUvInScreenSpace = (FfxFloat32x2(iPxPos) + 0.5f) / DisplaySize(); + const FfxFloat32x2 fLrUvInInterpolationRect = fUvInInterpolationRect * (FfxFloat32x2(RenderSize()) / GetMaxRenderSize()); + + const FfxFloat32x2 fUvLetterBoxScale = FfxFloat32x2(InterpolationRectSize()) / DisplaySize(); + + // game MV are top left aligned, the function scales them to render res UV + VectorFieldEntry gameMv; + LoadInpaintedGameFieldMv(fUvInInterpolationRect, gameMv); + + // OF is done on the back buffers which already have black bars + VectorFieldEntry ofMv; + SampleOpticalFlowMotionVectorField(fUvInScreenSpace, ofMv); + + // Binarize disucclusion factor + FfxFloat32x2 fDisocclusionFactor = FfxFloat32x2(FFX_EQUAL(ffxSaturate(SampleDisocclusionMask(fLrUvInInterpolationRect).xy), FfxFloat32x2(1.0, 1.0))); + + InterpolationSourceColor fPrevColorGame = SampleTextureBilinear(false, fUvInScreenSpace, +gameMv.fMotionVector * fUvLetterBoxScale, DisplaySize()); + InterpolationSourceColor fCurrColorGame = SampleTextureBilinear(true, fUvInScreenSpace, -gameMv.fMotionVector * fUvLetterBoxScale, DisplaySize()); + + InterpolationSourceColor fPrevColorOF = SampleTextureBilinear(false, fUvInScreenSpace, +ofMv.fMotionVector * fUvLetterBoxScale, DisplaySize()); + InterpolationSourceColor fCurrColorOF = SampleTextureBilinear(true, fUvInScreenSpace, -ofMv.fMotionVector * fUvLetterBoxScale, DisplaySize()); + + FfxFloat32 fBilinearWeightSum = 0.0f; + FfxFloat32 fDisoccludedFactor = 0.0f; + + // Disocclusion logic + { + fDisocclusionFactor.x *= FfxFloat32(!gameMv.bNegOutside); + fDisocclusionFactor.y *= FfxFloat32(!gameMv.bPosOutside); + + // Inpaint in bi-directional disocclusion areas + updateInPaintingWeight(fInPaintingWeight, FfxFloat32(length(fDisocclusionFactor) <= FFX_FRAMEINTERPOLATION_EPSILON)); + + FfxFloat32 t = 0.5f; + t += 0.5f * (1 - (fDisocclusionFactor.x)); + t -= 0.5f * (1 - (fDisocclusionFactor.y)); + + fInterpolatedColor = ffxLerp(fPrevColorGame.fRaw, fCurrColorGame.fRaw, ffxSaturate(t)); + fBilinearWeightSum = ffxLerp(fPrevColorGame.fBilinearWeightSum, fCurrColorGame.fBilinearWeightSum, ffxSaturate(t)); + + fDisoccludedFactor = ffxSaturate(1 - ffxMin(fDisocclusionFactor.x, fDisocclusionFactor.y)); + + if (fPrevColorGame.fBilinearWeightSum == 0.0f) + { + fInterpolatedColor = fCurrColorGame.fRaw; + fBilinearWeightSum = fCurrColorGame.fBilinearWeightSum; + } + else if (fCurrColorGame.fBilinearWeightSum == 0.0f) + { + fInterpolatedColor = fPrevColorGame.fRaw; + fBilinearWeightSum = fPrevColorGame.fBilinearWeightSum; + } + if (fPrevColorGame.fBilinearWeightSum == 0 && fCurrColorGame.fBilinearWeightSum == 0) + { + fInPaintingWeight = 1.0f; + } + } + + { + + FfxFloat32 ofT = 0.5f; + + if (fPrevColorOF.fBilinearWeightSum > 0 && fCurrColorOF.fBilinearWeightSum > 0) + { + ofT = 0.5f; + } + else if (fPrevColorOF.fBilinearWeightSum > 0) + { + ofT = 0; + } else { + ofT = 1; + } + + const FfxFloat32x3 ofColor = ffxLerp(fPrevColorOF.fRaw, fCurrColorOF.fRaw, ofT); + + FfxFloat32 fOF_Sim = NormalizedDot3(fPrevColorOF.fRaw, fCurrColorOF.fRaw); + FfxFloat32 fGame_Sim = NormalizedDot3(fPrevColorGame.fRaw, fCurrColorGame.fRaw); + + fGame_Sim = ffxLerp(ffxMax(FFX_FRAMEINTERPOLATION_EPSILON, fGame_Sim), 1.0f, ffxSaturate(fDisoccludedFactor)); + FfxFloat32 fGameMvBias = ffxPow(ffxSaturate(fGame_Sim / ffxMax(FFX_FRAMEINTERPOLATION_EPSILON, fOF_Sim)), 1.0f); + + const FfxFloat32 fFrameIndexFactor = FfxFloat32(FrameIndexSinceLastReset() < 10); + fGameMvBias = ffxLerp(fGameMvBias, 1.0f, fFrameIndexFactor); + + fInterpolatedColor = ffxLerp(ofColor, fInterpolatedColor, ffxSaturate(fGameMvBias)); + } +} + +void computeFrameinterpolation(FfxInt32x2 iPxPos) +{ + FfxFloat32x3 fColor = FfxFloat32x3(0, 0, 0); + FfxFloat32 fInPaintingWeight = 0.0f; + + if (IsInRect(iPxPos, InterpolationRectBase(), InterpolationRectSize()) == false || FrameIndexSinceLastReset() == 0) + { + // if we just reset or we are out of the interpolation rect, copy the current back buffer and don't interpolate + fColor = LoadCurrentBackbuffer(iPxPos); + } + else + { + computeInterpolatedColor(iPxPos, fColor, fInPaintingWeight); + } + + StoreFrameinterpolationOutput(FfxInt32x2(iPxPos), FfxFloat32x4(fColor, fInPaintingWeight)); +} + +#endif // FFX_FRAMEINTERPOLATION_H diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation.h.meta b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation.h.meta new file mode 100644 index 0000000..0db9a92 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: df35e42a01c1c3b4dbfd823e9aec076c +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h new file mode 100644 index 0000000..470708c --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h @@ -0,0 +1,778 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#include "ffx_frameinterpolation_resources.h" + +#if defined(FFX_GPU) +#ifdef __hlsl_dx_compiler +#pragma dxc diagnostic push +#pragma dxc diagnostic ignored "-Wambig-lit-shift" +#endif //__hlsl_dx_compiler +#include "ffx_core.h" +#ifdef __hlsl_dx_compiler +#pragma dxc diagnostic pop +#endif //__hlsl_dx_compiler +#endif // #if defined(FFX_GPU) + +#if defined(FFX_GPU) + +#define COUNTER_SPD 0 +#define COUNTER_FRAME_INDEX_SINCE_LAST_RESET 1 + + /////////////////////////////////////////////// + // declare CBs and CB accessors +/////////////////////////////////////////////// +#if defined(FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION) + cbuffer cbFI : FFX_DECLARE_CB(FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION) + { + FfxInt32x2 renderSize; + FfxInt32x2 displaySize; + + FfxFloat32x2 displaySizeRcp; + FfxFloat32 cameraNear; + FfxFloat32 cameraFar; + + FfxInt32x2 upscalerTargetSize; + FfxInt32 Mode; + FfxInt32 reset; + + FfxFloat32x4 fDeviceToViewDepth; + + FfxFloat32 deltaTime; + FfxInt32 HUDLessAttachedFactor; + FfxFloat32x2 UNUSED; + + FfxFloat32x2 opticalFlowScale; + FfxInt32 opticalFlowBlockSize; + FfxUInt32 dispatchFlags; + + FfxInt32x2 maxRenderSize; + FfxInt32 opticalFlowHalfResMode; + FfxInt32 NumInstances; + + FfxInt32x2 interpolationRectBase; + FfxInt32x2 interpolationRectSize; + + FfxFloat32x3 debugBarColor; + FfxUInt32 backBufferTransferFunction; + + FfxFloat32x2 minMaxLuminance; + FfxFloat32 fTanHalfFOV; + FfxInt32 _pad1; + + FfxFloat32x2 fJitter; + FfxFloat32x2 fMotionVectorScale; + } + + const FfxFloat32x2 Jitter() + { + return fJitter; + } + + const FfxFloat32x2 MotionVectorScale() + { + return fMotionVectorScale; + } + + const FfxInt32x2 InterpolationRectBase() + { + return interpolationRectBase; + } + + const FfxInt32x2 InterpolationRectSize() + { + return interpolationRectSize; + } + + const FfxInt32x2 RenderSize() + { + return renderSize; + } + + const FfxInt32x2 DisplaySize() + { + return displaySize; + } + + const FfxBoolean Reset() + { + return reset == 1; + } + + FfxFloat32x4 DeviceToViewSpaceTransformFactors() + { + return fDeviceToViewDepth; + } + + FfxInt32x2 GetOpticalFlowSize() + { + FfxInt32x2 iOpticalFlowSize = (1.0f / opticalFlowScale) / FfxFloat32x2(opticalFlowBlockSize.xx); + + return iOpticalFlowSize; + } + + FfxInt32x2 GetOpticalFlowSize2() + { + return GetOpticalFlowSize() * 1; + } + + FfxFloat32x2 GetOpticalFlowScale() + { + return opticalFlowScale; + } + + FfxInt32 GetOpticalFlowBlockSize() + { + return opticalFlowBlockSize; + } + + FfxInt32 GetHUDLessAttachedFactor() + { + return HUDLessAttachedFactor; + } + + FfxUInt32 GetDispatchFlags() + { + return dispatchFlags; + } + + FfxInt32x2 GetMaxRenderSize() + { + return maxRenderSize; + } + + FfxInt32 GetOpticalFlowHalfResMode() + { + return opticalFlowHalfResMode; + } + + FfxFloat32x3 GetDebugBarColor() + { + return debugBarColor; + } + + FfxFloat32 TanHalfFoV() + { + return fTanHalfFOV; + } + + FfxUInt32 BackBufferTransferFunction() + { + return backBufferTransferFunction; + } + + FfxFloat32 MinLuminance() + { + return minMaxLuminance[0]; + } + + FfxFloat32 MaxLuminance() + { + return minMaxLuminance[1]; + } + +#endif // #if defined(FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION) + +#if defined(FFX_FRAMEINTERPOLATION_BIND_CB_INPAINTING_PYRAMID) + cbuffer cbInpaintingPyramid : FFX_DECLARE_CB(FFX_FRAMEINTERPOLATION_BIND_CB_INPAINTING_PYRAMID) + { + FfxUInt32 mips; + FfxUInt32 numWorkGroups; + FfxUInt32x2 workGroupOffset; + } + + FfxUInt32 NumMips() + { + return mips; + } + FfxUInt32 NumWorkGroups() + { + return numWorkGroups; + } + FfxUInt32x2 WorkGroupOffset() + { + return workGroupOffset; + } +#endif // #if defined(FFX_FRAMEINTERPOLATION_BIND_CB_INPAINTING_PYRAMID) + +#define FFX_FRAMEINTERPOLATION_ROOTSIG_STRINGIFY(p) FFX_FRAMEINTERPOLATION_ROOTSIG_STR(p) +#define FFX_FRAMEINTERPOLATION_ROOTSIG_STR(p) #p +#define FFX_FRAMEINTERPOLATION_ROOTSIG [RootSignature( "DescriptorTable(UAV(u0, numDescriptors = " FFX_FRAMEINTERPOLATION_ROOTSIG_STRINGIFY(FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_COUNT) ")), " \ + "DescriptorTable(SRV(t0, numDescriptors = " FFX_FRAMEINTERPOLATION_ROOTSIG_STRINGIFY(FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_COUNT) ")), " \ + "CBV(b0), " \ + "StaticSampler(s0, filter = FILTER_MIN_MAG_MIP_LINEAR, " \ + "addressU = TEXTURE_ADDRESS_CLAMP, " \ + "addressV = TEXTURE_ADDRESS_CLAMP, " \ + "addressW = TEXTURE_ADDRESS_CLAMP, " \ + "comparisonFunc = COMPARISON_NEVER, " \ + "borderColor = STATIC_BORDER_COLOR_TRANSPARENT_BLACK)" )] + +#define FFX_FRAMEINTERPOLATION_INPAINTING_ROOTSIG [RootSignature( "DescriptorTable(UAV(u0, numDescriptors = " FFX_FRAMEINTERPOLATION_ROOTSIG_STRINGIFY(FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_COUNT) ")), " \ + "DescriptorTable(SRV(t0, numDescriptors = " FFX_FRAMEINTERPOLATION_ROOTSIG_STRINGIFY(FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_COUNT) ")), " \ + "CBV(b0), " \ + "CBV(b1), " \ + "StaticSampler(s0, filter = FILTER_MIN_MAG_MIP_LINEAR, " \ + "addressU = TEXTURE_ADDRESS_CLAMP, " \ + "addressV = TEXTURE_ADDRESS_CLAMP, " \ + "addressW = TEXTURE_ADDRESS_CLAMP, " \ + "comparisonFunc = COMPARISON_NEVER, " \ + "borderColor = STATIC_BORDER_COLOR_TRANSPARENT_BLACK)" )] + +#if defined(FFX_FRAMEINTERPOLATION_EMBED_ROOTSIG) +#define FFX_FRAMEINTERPOLATION_EMBED_ROOTSIG_CONTENT FFX_FRAMEINTERPOLATION_ROOTSIG +#define FFX_FRAMEINTERPOLATION_EMBED_INPAINTING_ROOTSIG_CONTENT FFX_FRAMEINTERPOLATION_INPAINTING_ROOTSIG +#else +#define FFX_FRAMEINTERPOLATION_EMBED_ROOTSIG_CONTENT +#define FFX_FRAMEINTERPOLATION_EMBED_INPAINTING_ROOTSIG_CONTENT +#endif // #if FFX_FRAMEINTERPOLATION_EMBED_ROOTSIG + +/////////////////////////////////////////////// +// declare samplers +/////////////////////////////////////////////// + +SamplerState s_LinearClamp : register(s0); + +/////////////////////////////////////////////// +// declare SRVs and SRV accessors +/////////////////////////////////////////////// + +#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_PREVIOUS_INTERPOLATION_SOURCE + Texture2D r_previous_interpolation_source : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_PREVIOUS_INTERPOLATION_SOURCE); + + FfxFloat32x3 LoadPreviousBackbuffer(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return r_previous_interpolation_source[iPxPos].rgb; + } + FfxFloat32x3 SamplePreviousBackbuffer(FFX_PARAMETER_IN FfxFloat32x2 fUv) + { + return r_previous_interpolation_source.SampleLevel(s_LinearClamp, fUv, 0).xyz; + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_CURRENT_INTERPOLATION_SOURCE + Texture2D r_current_interpolation_source : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_CURRENT_INTERPOLATION_SOURCE); + + FfxFloat32x3 LoadCurrentBackbuffer(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return r_current_interpolation_source[iPxPos].rgb; + } + FfxFloat32x3 SampleCurrentBackbuffer(FFX_PARAMETER_IN FfxFloat32x2 fUv) + { + return r_current_interpolation_source.SampleLevel(s_LinearClamp, fUv, 0).xyz; + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_DILATED_MOTION_VECTORS + Texture2D r_dilated_motion_vectors : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_DILATED_MOTION_VECTORS); + + FfxFloat32x2 LoadDilatedMotionVector(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return r_dilated_motion_vectors[iPxPos].xy; + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_DILATED_DEPTH + Texture2D r_dilated_depth : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_DILATED_DEPTH); + + FfxFloat32 LoadDilatedDepth(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return r_dilated_depth[iPxPos].x; + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_RECONSTRUCTED_DEPTH_PREVIOUS_FRAME + Texture2D r_reconstructed_depth_previous_frame : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_RECONSTRUCTED_DEPTH_PREVIOUS_FRAME); + + FfxFloat32 LoadReconstructedDepthPreviousFrame(FFX_PARAMETER_IN FfxInt32x2 iPxInput) + { + return asfloat(r_reconstructed_depth_previous_frame[iPxInput]); + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_RECONSTRUCTED_DEPTH_INTERPOLATED_FRAME + Texture2D r_reconstructed_depth_interpolated_frame : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_RECONSTRUCTED_DEPTH_INTERPOLATED_FRAME); + + FfxFloat32 LoadEstimatedInterpolationFrameDepth(FFX_PARAMETER_IN FfxInt32x2 iPxInput) + { + return asfloat(r_reconstructed_depth_interpolated_frame[iPxInput]); + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_DISOCCLUSION_MASK + Texture2D r_disocclusion_mask : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_DISOCCLUSION_MASK); + + FfxFloat32x4 LoadDisocclusionMask(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return r_disocclusion_mask[iPxPos]; + } + FfxFloat32x4 SampleDisocclusionMask(FFX_PARAMETER_IN FfxFloat32x2 fUv) + { + return r_disocclusion_mask.SampleLevel(s_LinearClamp, fUv, 0); + } +#endif + +#if defined(FFX_FRAMEINTERPOLATION_BIND_SRV_GAME_MOTION_VECTOR_FIELD_X) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_SRV_GAME_MOTION_VECTOR_FIELD_Y) + Texture2D r_game_motion_vector_field_x : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_GAME_MOTION_VECTOR_FIELD_X); + Texture2D r_game_motion_vector_field_y : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_GAME_MOTION_VECTOR_FIELD_Y); + + FfxUInt32x2 LoadGameFieldMv(FFX_PARAMETER_IN FfxInt32x2 iPxSample) + { + FfxUInt32 packedX = r_game_motion_vector_field_x[iPxSample]; + FfxUInt32 packedY = r_game_motion_vector_field_y[iPxSample]; + + return FfxUInt32x2(packedX, packedY); + } +#endif + +#if defined(FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_X) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_Y) + Texture2D r_optical_flow_motion_vector_field_x : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_X); + Texture2D r_optical_flow_motion_vector_field_y : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_Y); + + FfxUInt32x2 LoadOpticalFlowFieldMv(FFX_PARAMETER_IN FfxInt32x2 iPxSample) + { + FfxUInt32 packedX = r_optical_flow_motion_vector_field_x[iPxSample]; + FfxUInt32 packedY = r_optical_flow_motion_vector_field_y[iPxSample]; + + return FfxUInt32x2(packedX, packedY); + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW + Texture2D r_optical_flow : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW); + + #if defined(FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION) + FfxFloat32x2 LoadOpticalFlow(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return r_optical_flow[iPxPos] * GetOpticalFlowScale(); + } + #endif +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_UPSAMPLED + Texture2D r_optical_flow_upsampled : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_UPSAMPLED); + + FfxFloat32x2 LoadOpticalFlowUpsampled(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return r_optical_flow_upsampled[iPxPos]; + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_CONFIDENCE + Texture2D r_optical_flow_confidence : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_CONFIDENCE); + + FfxFloat32 LoadOpticalFlowConfidence(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return r_optical_flow_confidence[iPxPos].y; + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_GLOBAL_MOTION + Texture2D r_optical_flow_global_motion : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_GLOBAL_MOTION); + + FfxUInt32 LoadOpticalFlowGlobalMotion(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return r_optical_flow_global_motion[iPxPos]; + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_SCENE_CHANGE_DETECTION + Texture2D r_optical_flow_scd : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_SCENE_CHANGE_DETECTION); + + FfxUInt32 LoadOpticalFlowSceneChangeDetection(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return r_optical_flow_scd[iPxPos]; + } + + FfxBoolean HasSceneChanged() + { + #define SCD_OUTPUT_HISTORY_BITS_SLOT 1 + //if (FrameIndex() <= 5) // threshold according to original OpenCL code + //{ + // return 1.0; + //} + //else + { + // Report that the scene is changed if the change was detected in any of the + // 4 previous frames (0xfu - covers 4 history bits). + return (r_optical_flow_scd[FfxInt32x2(SCD_OUTPUT_HISTORY_BITS_SLOT, 0)] & 0xfu) != 0; + } + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_DEBUG + Texture2D r_optical_flow_debug : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_DEBUG); + + FfxFloat32x4 LoadOpticalFlowDebug(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return r_optical_flow_debug[iPxPos]; + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_OUTPUT + Texture2D r_output : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_OUTPUT); + + FfxFloat32x4 LoadFrameInterpolationOutput(FFX_PARAMETER_IN FfxInt32x2 iPxInput) + { + return r_output[iPxInput]; + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_INPAINTING_PYRAMID + Texture2D r_inpainting_pyramid : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_INPAINTING_PYRAMID); + + FfxFloat32x4 LoadInpaintingPyramid(FFX_PARAMETER_IN FfxInt32 mipLevel, FFX_PARAMETER_IN FfxUInt32x2 iPxInput) + { + return r_inpainting_pyramid.mips[mipLevel][iPxInput]; + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_PRESENT_BACKBUFFER + Texture2D r_present_backbuffer : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_PRESENT_BACKBUFFER); + + FfxFloat32x4 LoadPresentBackbuffer(FFX_PARAMETER_IN FfxInt32x2 iPxInput) + { + return r_present_backbuffer[iPxInput]; + } + FfxFloat32x4 SamplePresentBackbuffer(FFX_PARAMETER_IN FfxFloat32x2 fUv) + { + return r_present_backbuffer.SampleLevel(s_LinearClamp, fUv, 0); + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_COUNTERS + StructuredBuffer r_counters : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_COUNTERS); + + FfxUInt32 LoadCounter(FFX_PARAMETER_IN FfxInt32 iPxPos) + { + return r_counters[iPxPos]; + } + + const FfxUInt32 FrameIndexSinceLastReset() + { + return LoadCounter(COUNTER_FRAME_INDEX_SINCE_LAST_RESET); + } +#endif + +#if defined(FFX_FRAMEINTERPOLATION_BIND_SRV_INPUT_DEPTH) +Texture2D r_input_depth : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_INPUT_DEPTH); +FfxFloat32 LoadInputDepth(FfxInt32x2 iPxPos) +{ + return r_input_depth[iPxPos]; +} +#endif + +#if defined(FFX_FRAMEINTERPOLATION_BIND_SRV_INPUT_MOTION_VECTORS) +Texture2D r_input_motion_vectors : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_INPUT_MOTION_VECTORS); +FfxFloat32x2 LoadInputMotionVector(FfxInt32x2 iPxDilatedMotionVectorPos) +{ + FfxFloat32x2 fSrcMotionVector = r_input_motion_vectors[iPxDilatedMotionVectorPos].xy; + + FfxFloat32x2 fUvMotionVector = fSrcMotionVector * MotionVectorScale(); + +#if FFX_FRAMEINTERPOLATION_OPTION_JITTERED_MOTION_VECTORS + fUvMotionVector -= MotionVectorJitterCancellation(); +#endif + + return fUvMotionVector; +} +#endif +/////////////////////////////////////////////// +// declare UAVs and UAV accessors +/////////////////////////////////////////////// +#ifdef FFX_FRAMEINTERPOLATION_BIND_UAV_OUTPUT + RWTexture2D rw_output : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_OUTPUT); + + FfxFloat32x4 RWLoadFrameinterpolationOutput(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return rw_output[iPxPos]; + } + + void StoreFrameinterpolationOutput(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x4 val) + { + rw_output[iPxPos] = val; + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_UAV_DILATED_MOTION_VECTORS + RWTexture2D rw_dilated_motion_vectors : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_DILATED_MOTION_VECTORS); + + FfxFloat32x2 RWLoadDilatedMotionVectors(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return rw_dilated_motion_vectors[iPxPos]; + } + + void StoreDilatedMotionVectors(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x2 val) + { + rw_dilated_motion_vectors[iPxPos] = val; + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_UAV_DILATED_DEPTH + RWTexture2D rw_dilated_depth : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_DILATED_DEPTH); + + FfxFloat32 RWLoadDilatedDepth(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return rw_dilated_depth[iPxPos]; + } + + void StoreDilatedDepth(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32 val) + { + rw_dilated_depth[iPxPos] = val; + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_UAV_RECONSTRUCTED_DEPTH_PREVIOUS_FRAME + RWTexture2D rw_reconstructed_depth_previous_frame : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_RECONSTRUCTED_DEPTH_PREVIOUS_FRAME); + + FfxFloat32 RWLoadReconstructedDepthPreviousFrame(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return ffxAsFloat(rw_reconstructed_depth_previous_frame[iPxPos]); + } + + void UpdateReconstructedDepthPreviousFrame(FfxInt32x2 iPxSample, FfxFloat32 fDepth) + { + FfxUInt32 uDepth = ffxAsUInt32(fDepth); + +#if FFX_FRAMEINTERPOLATION_OPTION_INVERTED_DEPTH + InterlockedMax(rw_reconstructed_depth_previous_frame[iPxSample], uDepth); +#else + InterlockedMin(rw_reconstructed_depth_previous_frame[iPxSample], uDepth); // min for standard, max for inverted depth +#endif + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_UAV_RECONSTRUCTED_DEPTH_INTERPOLATED_FRAME + RWTexture2D rw_reconstructed_depth_interpolated_frame : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_RECONSTRUCTED_DEPTH_INTERPOLATED_FRAME); + + FfxFloat32 RWLoadReconstructedDepthInterpolatedFrame(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return ffxAsFloat(rw_reconstructed_depth_interpolated_frame[iPxPos]); + } + + void StoreReconstructedDepthInterpolatedFrame(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32 value) + { + FfxUInt32 uDepth = ffxAsUInt32(value); + rw_reconstructed_depth_interpolated_frame[iPxPos] = uDepth; + } + + void UpdateReconstructedDepthInterpolatedFrame(FfxInt32x2 iPxSample, FfxFloat32 fDepth) + { + FfxUInt32 uDepth = ffxAsUInt32(fDepth); + +#if FFX_FRAMEINTERPOLATION_OPTION_INVERTED_DEPTH + InterlockedMax(rw_reconstructed_depth_interpolated_frame[iPxSample], uDepth); +#else + InterlockedMin(rw_reconstructed_depth_interpolated_frame[iPxSample], uDepth); // min for standard, max for inverted depth +#endif + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_UAV_DISOCCLUSION_MASK + RWTexture2D rw_disocclusion_mask : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_DISOCCLUSION_MASK); + + FfxFloat32x2 RWLoadDisocclusionMask(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return rw_disocclusion_mask[iPxPos]; + } + + void StoreDisocclusionMask(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x2 val) + { + rw_disocclusion_mask[iPxPos] = val; + } +#endif + +#if defined(FFX_FRAMEINTERPOLATION_BIND_UAV_GAME_MOTION_VECTOR_FIELD_X) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_UAV_GAME_MOTION_VECTOR_FIELD_Y) + + RWTexture2D rw_game_motion_vector_field_x : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_GAME_MOTION_VECTOR_FIELD_X); + RWTexture2D rw_game_motion_vector_field_y : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_GAME_MOTION_VECTOR_FIELD_Y); + + FfxUInt32 RWLoadGameMotionVectorFieldX(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return rw_game_motion_vector_field_x[iPxPos]; + } + + void StoreGameMotionVectorFieldX(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32 val) + { + rw_game_motion_vector_field_x[iPxPos] = val; + } + + FfxUInt32 RWLoadGameMotionVectorFieldY(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return rw_game_motion_vector_field_y[iPxPos]; + } + + void StoreGameMotionVectorFieldY(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32 val) + { + rw_game_motion_vector_field_y[iPxPos] = val; + } + + void UpdateGameMotionVectorField(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32x2 packedVector) + { + InterlockedMax(rw_game_motion_vector_field_x[iPxPos], packedVector.x); + InterlockedMax(rw_game_motion_vector_field_y[iPxPos], packedVector.y); + } + + FfxUInt32 UpdateGameMotionVectorFieldEx(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32x2 packedVector) + { + FfxUInt32 uPreviousValueX = 0; + FfxUInt32 uPreviousValueY = 0; + InterlockedMax(rw_game_motion_vector_field_x[iPxPos], packedVector.x, uPreviousValueX); + InterlockedMax(rw_game_motion_vector_field_y[iPxPos], packedVector.y, uPreviousValueY); + + const FfxUInt32 uExistingVectorFieldEntry = ffxMax(uPreviousValueX, uPreviousValueY); + + return uExistingVectorFieldEntry; + } +#endif + +#if defined(FFX_FRAMEINTERPOLATION_BIND_UAV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_X) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_UAV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_Y) + + RWTexture2D rw_optical_flow_motion_vector_field_x : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_X); + RWTexture2D rw_optical_flow_motion_vector_field_y : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_Y); + + FfxUInt32 RWLoadOpticalflowMotionVectorFieldX(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return rw_optical_flow_motion_vector_field_x[iPxPos]; + } + void StoreOpticalflowMotionVectorFieldX(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32 val) + { + rw_optical_flow_motion_vector_field_x[iPxPos] = val; + } + FfxUInt32 RWLoadOpticalflowMotionVectorFieldY(FFX_PARAMETER_IN FfxInt32x2 iPxPos) + { + return rw_optical_flow_motion_vector_field_y[iPxPos]; + } + void StoreOpticalflowMotionVectorFieldY(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32 val) + { + rw_optical_flow_motion_vector_field_y[iPxPos] = val; + } + void UpdateOpticalflowMotionVectorField(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32x2 packedVector) + { + InterlockedMax(rw_optical_flow_motion_vector_field_x[iPxPos], packedVector.x); + InterlockedMax(rw_optical_flow_motion_vector_field_y[iPxPos], packedVector.y); + } +#endif + +#ifdef FFX_FRAMEINTERPOLATION_BIND_UAV_COUNTERS + globallycoherent RWStructuredBuffer rw_counters : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_COUNTERS); + + FfxUInt32 RWLoadCounter(FFX_PARAMETER_IN FfxInt32 iPxPos) + { + return rw_counters[iPxPos]; + } + + void StoreCounter(FFX_PARAMETER_IN FfxInt32 iPxPos, FFX_PARAMETER_IN FfxUInt32 counter) + { + rw_counters[iPxPos] = counter; + } + void AtomicIncreaseCounter(FFX_PARAMETER_IN FfxInt32 iPxPos, FFX_PARAMETER_OUT FfxUInt32 oldVal) + { + InterlockedAdd(rw_counters[iPxPos], 1, oldVal); + } +#endif + + +#if defined(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_0) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_1) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_2) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_3) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_4) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_5) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_6) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_7) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_8) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_9) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_10) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_11) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_12) + + RWTexture2D rw_inpainting_pyramid0 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_0); + RWTexture2D rw_inpainting_pyramid1 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_1); + RWTexture2D rw_inpainting_pyramid2 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_2); + RWTexture2D rw_inpainting_pyramid3 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_3); + RWTexture2D rw_inpainting_pyramid4 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_4); + globallycoherent RWTexture2D rw_inpainting_pyramid5 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_5); + RWTexture2D rw_inpainting_pyramid6 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_6); + RWTexture2D rw_inpainting_pyramid7 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_7); + RWTexture2D rw_inpainting_pyramid8 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_8); + RWTexture2D rw_inpainting_pyramid9 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_9); + RWTexture2D rw_inpainting_pyramid10 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_10); + RWTexture2D rw_inpainting_pyramid11 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_11); + RWTexture2D rw_inpainting_pyramid12 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_12); + + + FfxFloat32x4 RWLoadInpaintingPyramid(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32 index) + { + #define LOAD(idx) \ + if (index == idx) \ + { \ + return rw_inpainting_pyramid##idx[iPxPos]; \ + } + LOAD(0); + LOAD(1); + LOAD(2); + LOAD(3); + LOAD(4); + LOAD(5); + LOAD(6); + LOAD(7); + LOAD(8); + LOAD(9); + LOAD(10); + LOAD(11); + LOAD(12); + return 0; + + #undef LOAD + } + + void StoreInpaintingPyramid(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x4 outValue, FFX_PARAMETER_IN FfxUInt32 index) + { + #define STORE(idx) \ + if (index == idx) \ + { \ + rw_inpainting_pyramid##idx[iPxPos] = outValue; \ + } + + STORE(0); + STORE(1); + STORE(2); + STORE(3); + STORE(4); + STORE(5); + STORE(6); + STORE(7); + STORE(8); + STORE(9); + STORE(10); + STORE(11); + STORE(12); + + #undef STORE + } +#endif + +#endif // #if defined(FFX_GPU) diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h.meta b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h.meta new file mode 100644 index 0000000..7cba01c --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_callbacks_hlsl.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: 8aa4708e4b50cd149a4df075f45b2ac7 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_common.h b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_common.h new file mode 100644 index 0000000..8206bf4 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_common.h @@ -0,0 +1,445 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#if !defined(FFX_FRAMEINTERPOLATION_COMMON_H) +#define FFX_FRAMEINTERPOLATION_COMMON_H + +#define FFX_FRAMEINTERPOLATION_DISPATCH_DRAW_DEBUG_TEAR_LINES (1 << 0) +#define FFX_FRAMEINTERPOLATION_DISPATCH_DRAW_DEBUG_RESET_INDICATORS (1 << 1) +#define FFX_FRAMEINTERPOLATION_DISPATCH_DRAW_DEBUG_VIEW (1 << 2) + +FFX_STATIC const FfxFloat32 FFX_FRAMEINTERPOLATION_EPSILON = 1e-03f; +FFX_STATIC const FfxFloat32 FFX_FRAMEINTERPOLATION_FLT_MAX = 3.402823466e+38f; +FFX_STATIC const FfxFloat32 FFX_FRAMEINTERPOLATION_FLT_MIN = 1.175494351e-38f; + +FFX_STATIC const FfxFloat32 fReconstructedDepthBilinearWeightThreshold = FFX_FRAMEINTERPOLATION_EPSILON; + +FfxFloat32 RGBToLuma(FfxFloat32x3 fLinearRgb) +{ + return dot(fLinearRgb, FfxFloat32x3(0.2126f, 0.7152f, 0.0722f)); +} + +FfxFloat32 LinearRec2020ToLuminance(FfxFloat32x3 linearRec2020RGB) +{ + FfxFloat32 fY = 0.2627 * linearRec2020RGB.x + 0.678 * linearRec2020RGB.y + 0.0593 * linearRec2020RGB.z; + return fY; +} + +FfxFloat32x3 ffxscRGBToLinear(FfxFloat32x3 value, FfxFloat32 minLuminance, FfxFloat32 maxLuminance) +{ + FfxFloat32x3 p = value - ffxBroadcast3(minLuminance / 80.0f); + return p / ffxBroadcast3((maxLuminance - minLuminance) / 80.0f); +} + +FfxFloat32x3 RawRGBToLinear(FfxFloat32x3 fRawRgb) +{ + FfxFloat32x3 fLinearRgb; + + switch (BackBufferTransferFunction()) + { + case 0: + fLinearRgb = ffxLinearFromSrgb(fRawRgb); + break; + case 1: + fLinearRgb = ffxLinearFromPQ(fRawRgb) * (10000.0f / MaxLuminance()); + break; + case 2: + fLinearRgb = ffxscRGBToLinear(fRawRgb, MinLuminance(), MaxLuminance()); + break; + } + + return fLinearRgb; +} + +FfxFloat32 RawRGBToLuminance(FfxFloat32x3 fRawRgb) +{ + FfxFloat32 fLuminance = 0.0f; + + switch (BackBufferTransferFunction()) + { + case 0: + fLuminance = RGBToLuma(RawRGBToLinear(fRawRgb)); + break; + case 1: + fLuminance = LinearRec2020ToLuminance(RawRGBToLinear(fRawRgb)); + break; + case 2: + fLuminance = RGBToLuma(RawRGBToLinear(fRawRgb)); + break; + } + + return fLuminance; +} + +FfxFloat32 RawRGBToPerceivedLuma(FfxFloat32x3 fRawRgb) +{ + FfxFloat32 fLuminance = RawRGBToLuminance(fRawRgb); + + FfxFloat32 fPercievedLuminance = 0; + if (fLuminance <= 216.0f / 24389.0f) + { + fPercievedLuminance = fLuminance * (24389.0f / 27.0f); + } + else + { + fPercievedLuminance = ffxPow(fLuminance, 1.0f / 3.0f) * 116.0f - 16.0f; + } + + return fPercievedLuminance * 0.01f; +} + +struct BilinearSamplingData +{ + FfxInt32x2 iOffsets[4]; + FfxFloat32 fWeights[4]; + FfxInt32x2 iBasePos; +}; + +BilinearSamplingData GetBilinearSamplingData(FfxFloat32x2 fUv, FfxInt32x2 iSize) +{ + BilinearSamplingData data; + + FfxFloat32x2 fPxSample = (fUv * iSize) - FfxFloat32x2(0.5f, 0.5f); + data.iBasePos = FfxInt32x2(floor(fPxSample)); + FfxFloat32x2 fPxFrac = ffxFract(fPxSample); + + data.iOffsets[0] = FfxInt32x2(0, 0); + data.iOffsets[1] = FfxInt32x2(1, 0); + data.iOffsets[2] = FfxInt32x2(0, 1); + data.iOffsets[3] = FfxInt32x2(1, 1); + + data.fWeights[0] = (1 - fPxFrac.x) * (1 - fPxFrac.y); + data.fWeights[1] = (fPxFrac.x) * (1 - fPxFrac.y); + data.fWeights[2] = (1 - fPxFrac.x) * (fPxFrac.y); + data.fWeights[3] = (fPxFrac.x) * (fPxFrac.y); + + return data; +} + +#if defined(FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION) +FfxFloat32 ConvertFromDeviceDepthToViewSpace(FfxFloat32 fDeviceDepth) +{ + const FfxFloat32x4 deviceToViewDepth = DeviceToViewSpaceTransformFactors(); + return deviceToViewDepth[1] / (fDeviceDepth - deviceToViewDepth[0]); +} + +FfxFloat32x2 ComputeNdc(FfxFloat32x2 fPxPos, FfxInt32x2 iSize) +{ + return fPxPos / FfxFloat32x2(iSize) * FfxFloat32x2(2.0f, -2.0f) + FfxFloat32x2(-1.0f, 1.0f); +} + +FfxFloat32x3 GetViewSpacePosition(FfxInt32x2 iViewportPos, FfxInt32x2 iViewportSize, FfxFloat32 fDeviceDepth) +{ + const FfxFloat32x4 fDeviceToViewDepth = DeviceToViewSpaceTransformFactors(); + + const FfxFloat32 Z = ConvertFromDeviceDepthToViewSpace(fDeviceDepth); + + const FfxFloat32x2 fNdcPos = ComputeNdc(iViewportPos, iViewportSize); + const FfxFloat32 X = fDeviceToViewDepth[2] * fNdcPos.x * Z; + const FfxFloat32 Y = fDeviceToViewDepth[3] * fNdcPos.y * Z; + + return FfxFloat32x3(X, Y, Z); +} +#endif + +FfxBoolean IsOnScreen(FfxInt32x2 pos, FfxInt32x2 size) +{ + return all(FFX_LESS_THAN(FfxUInt32x2(pos), FfxUInt32x2(size))); +} + +FfxBoolean IsUvInside(FfxFloat32x2 fUv) +{ + return (fUv.x > 0.0f && fUv.x < 1.0f) && (fUv.y > 0.0f && fUv.y < 1.0f); +} + +FfxBoolean IsInRect(FfxInt32x2 pos, FfxInt32x2 iRectCorner, FfxInt32x2 iRectSize) +{ + return (pos.x >= iRectCorner.x && pos.x < (iRectSize.x + iRectCorner.x) && pos.y >= iRectCorner.y && pos.y < (iRectSize.y + iRectCorner.y)); +} + +FfxFloat32 MinDividedByMax(const FfxFloat32 v0, const FfxFloat32 v1) +{ + const FfxFloat32 m = ffxMax(v0, v1); + return m != 0 ? ffxMin(v0, v1) / m : 0; +} + +FfxFloat32 NormalizedDot3(const FfxFloat32x3 v0, const FfxFloat32x3 v1) +{ + FfxFloat32 fMaxLength = ffxMax(length(v0), length(v1)); + + return fMaxLength > 0.0f ? dot(v0 / fMaxLength, v1 / fMaxLength) : 1.0f; +} + +FfxFloat32 NormalizedDot2(const FfxFloat32x2 v0, const FfxFloat32x2 v1) +{ + FfxFloat32 fMaxLength = ffxMax(length(v0), length(v1)); + + return fMaxLength > 0.0f ? dot(v0 / fMaxLength, v1 / fMaxLength) : 1.0f; +} + +FfxFloat32 CalculateStaticContentFactor(FfxFloat32x3 fCurrentInterpolationSource, FfxFloat32x3 fPresentColor) +{ + const FfxFloat32x3 fFactor = ffxSaturate(FfxFloat32x3( + ffxSaturate((1.0f - MinDividedByMax(fCurrentInterpolationSource.r, fPresentColor.r)) / 0.1f), + ffxSaturate((1.0f - MinDividedByMax(fCurrentInterpolationSource.g, fPresentColor.g)) / 0.1f), + ffxSaturate((1.0f - MinDividedByMax(fCurrentInterpolationSource.b, fPresentColor.b)) / 0.1f) + )); + + return max(fFactor.x, max(fFactor.y, fFactor.z)); +} + +// +// MOTION VECTOR FIELD +// + +FFX_STATIC const FfxUInt32 MOTION_VECTOR_FIELD_ENTRY_BIT_COUNT = 32; + +// Make sure all bit counts add up to MOTION_VECTOR_FIELD_ENTRY_BIT_COUNT +FFX_STATIC const FfxUInt32 MOTION_VECTOR_FIELD_VECTOR_COEFFICIENT_BIT_COUNT = 16; +FFX_STATIC const FfxUInt32 MOTION_VECTOR_FIELD_PRIORITY_LOW_BIT_COUNT = 5; +FFX_STATIC const FfxUInt32 MOTION_VECTOR_FIELD_PRIORITY_HIGH_BIT_COUNT = 10; +FFX_STATIC const FfxUInt32 MOTION_VECTOR_PRIMARY_VECTOR_INDICATION_BIT_COUNT = 1; + +FFX_STATIC const FfxUInt32 MOTION_VECTOR_FIELD_PRIMARY_VECTOR_INDICATION_BIT = (1U << (MOTION_VECTOR_FIELD_ENTRY_BIT_COUNT - 1)); + +FFX_STATIC const FfxUInt32 PRIORITY_LOW_MAX = (1U << MOTION_VECTOR_FIELD_PRIORITY_LOW_BIT_COUNT) - 1; +FFX_STATIC const FfxUInt32 PRIORITY_HIGH_MAX = (1U << MOTION_VECTOR_FIELD_PRIORITY_HIGH_BIT_COUNT) - 1; + +FFX_STATIC const FfxUInt32 PRIORITY_LOW_OFFSET = MOTION_VECTOR_FIELD_VECTOR_COEFFICIENT_BIT_COUNT; +FFX_STATIC const FfxUInt32 PRIORITY_HIGH_OFFSET = PRIORITY_LOW_OFFSET + MOTION_VECTOR_FIELD_PRIORITY_LOW_BIT_COUNT; +FFX_STATIC const FfxUInt32 PRIMARY_VECTOR_INDICATION_OFFSET = PRIORITY_HIGH_OFFSET + MOTION_VECTOR_FIELD_PRIORITY_HIGH_BIT_COUNT; + +struct VectorFieldEntry +{ + FfxFloat32x2 fMotionVector; + FfxFloat32 uHighPriorityFactor; + FfxFloat32 uLowPriorityFactor; + FfxBoolean bValid; + FfxBoolean bPrimary; + FfxBoolean bSecondary; + FfxBoolean bInPainted; + FfxFloat32 fVelocity; + FfxBoolean bNegOutside; + FfxBoolean bPosOutside; +}; + +VectorFieldEntry NewVectorFieldEntry() +{ + VectorFieldEntry vfe; + vfe.fMotionVector = FfxFloat32x2(0.0, 0.0); + vfe.uHighPriorityFactor = 0.0; + vfe.uLowPriorityFactor = 0.0; + vfe.bValid = false; + vfe.bPrimary = false; + vfe.bSecondary = false; + vfe.bInPainted = false; + vfe.fVelocity = 0.0; + vfe.bNegOutside = false; + vfe.bPosOutside = false; + return vfe; +} + +FfxBoolean PackedVectorFieldEntryIsPrimary(FfxUInt32 packedEntry) +{ + return ((packedEntry & MOTION_VECTOR_FIELD_PRIMARY_VECTOR_INDICATION_BIT) != 0); +} + +FfxUInt32x2 PackVectorFieldEntries(FfxBoolean bIsPrimary, FfxUInt32 uHighPriorityFactor, FfxUInt32 uLowPriorityFactor, FfxFloat32x2 fMotionVector) +{ + const FfxUInt32 uPriority = + (FfxUInt32(bIsPrimary) * MOTION_VECTOR_FIELD_PRIMARY_VECTOR_INDICATION_BIT) + | ((uHighPriorityFactor & PRIORITY_HIGH_MAX) << PRIORITY_HIGH_OFFSET) + | ((uLowPriorityFactor & PRIORITY_LOW_MAX) << PRIORITY_LOW_OFFSET); + + FfxUInt32 packedX = uPriority | ffxF32ToF16(fMotionVector.x); + FfxUInt32 packedY = uPriority | ffxF32ToF16(fMotionVector.y); + + return FfxUInt32x2(packedX, packedY); +} + +void UnpackVectorFieldEntries(FfxUInt32x2 packed, out VectorFieldEntry vfElement) +{ + vfElement.uHighPriorityFactor = FfxFloat32((packed.x >> PRIORITY_HIGH_OFFSET) & PRIORITY_HIGH_MAX) / PRIORITY_HIGH_MAX; + vfElement.uLowPriorityFactor = FfxFloat32((packed.x >> PRIORITY_LOW_OFFSET) & PRIORITY_LOW_MAX) / PRIORITY_LOW_MAX; + + vfElement.bPrimary = PackedVectorFieldEntryIsPrimary(packed.x); + vfElement.bValid = (vfElement.uHighPriorityFactor > 0.0f); + vfElement.bSecondary = vfElement.bValid && !vfElement.bPrimary; + + // Reverse priority factor for secondary vectors + if (vfElement.bSecondary) + { + vfElement.uHighPriorityFactor = 1.0f - vfElement.uHighPriorityFactor; + } + + vfElement.fMotionVector.x = ffxUnpackF32(packed.x).x; + vfElement.fMotionVector.y = ffxUnpackF32(packed.y).x; + vfElement.bInPainted = false; +} + +// +// MOTION VECTOR FIELD +// + +#if defined(FFX_FRAMEINTERPOLATION_BIND_SRV_INPAINTING_PYRAMID) +FfxFloat32x4 ComputeMvInpaintingLevel(FfxFloat32x2 fUv, const FfxInt32 iMipLevel, const FfxInt32x2 iTexSize) +{ + BilinearSamplingData bilinearInfo = GetBilinearSamplingData(fUv, iTexSize); + + FfxFloat32 fSum = 0.0f; + FfxFloat32x4 fColor = FfxFloat32x4(0.0, 0.0, 0.0, 0.0); + fColor.z = 0; + + const FfxFloat32 fMaxPriorityFactor = 1.0f; + + for (FfxInt32 iSampleIndex = 0; iSampleIndex < 4; iSampleIndex++) + { + const FfxInt32x2 iOffset = bilinearInfo.iOffsets[iSampleIndex]; + const FfxInt32x2 iSamplePos = bilinearInfo.iBasePos + iOffset; + + if (IsOnScreen(iSamplePos, iTexSize)) + { + FfxFloat32x4 fSample = LoadInpaintingPyramid(iMipLevel, iSamplePos); + + const FfxFloat32 fPriorityFactor = fSample.z; + const FfxFloat32 fValidMvFactor = FfxFloat32(fSample.z > 0); + const FfxFloat32 fSampleWeight = bilinearInfo.fWeights[iSampleIndex] * fValidMvFactor * fPriorityFactor; + + fSum += fSampleWeight; + fColor += fSample * fSampleWeight; + } + } + + fColor /= (fSum > 0.0f) ? fSum : 1.0f; + + return fColor; +} +#if defined(FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_SRV_GAME_MOTION_VECTOR_FIELD_X) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_SRV_GAME_MOTION_VECTOR_FIELD_Y) + +void LoadInpaintedGameFieldMv(FfxFloat32x2 fUv, out VectorFieldEntry vfElement) +{ + FfxInt32x2 iPxSample = FfxInt32x2(fUv * RenderSize()); + FfxUInt32x2 packedGameFieldMv = LoadGameFieldMv(iPxSample); + UnpackVectorFieldEntries(packedGameFieldMv, vfElement); + + if (!vfElement.bValid) + { + //FfxFloat32x2 fUv = (FfxFloat32x2(iPxSample) + 0.5f) / RenderSize(); + FfxInt32x2 iTexSize = RenderSize(); + + FfxFloat32x4 fInPaintedVector = FfxFloat32x4(0.0, 0.0, 0.0, 0.0); + for (FfxInt32 iMipLevel = 0; iMipLevel < 11 && (fInPaintedVector.w == 0.0f); iMipLevel++) + { + iTexSize /= 2; + + fInPaintedVector = ComputeMvInpaintingLevel(fUv, iMipLevel, iTexSize); + } + + vfElement.fMotionVector = fInPaintedVector.xy; + vfElement.uHighPriorityFactor = fInPaintedVector.z; + vfElement.uLowPriorityFactor = fInPaintedVector.w; + vfElement.bInPainted = true; + } + + vfElement.bNegOutside = !IsUvInside(fUv - vfElement.fMotionVector); + vfElement.bPosOutside = !IsUvInside(fUv + vfElement.fMotionVector); + vfElement.fVelocity = length(vfElement.fMotionVector); +} +#endif +#endif + +#if defined(FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_X) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_Y) && \ + defined(FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION) +void SampleOpticalFlowMotionVectorField(FfxFloat32x2 fUv, out VectorFieldEntry vfElement) +{ + const FfxFloat32 scaleFactor = 1.0f; + + BilinearSamplingData bilinearInfo = GetBilinearSamplingData(fUv, FfxInt32x2(GetOpticalFlowSize2() * scaleFactor)); + + vfElement = NewVectorFieldEntry(); + + FfxFloat32 fWeightSum = 0.0f; + for (FfxInt32 iSampleIndex = 0; iSampleIndex < 4; iSampleIndex++) + { + const FfxInt32x2 iOffset = bilinearInfo.iOffsets[iSampleIndex]; + const FfxInt32x2 iSamplePos = bilinearInfo.iBasePos + iOffset; + + if (IsOnScreen(iSamplePos, FfxInt32x2(GetOpticalFlowSize2() * scaleFactor))) + { + const FfxFloat32 fWeight = bilinearInfo.fWeights[iSampleIndex]; + + VectorFieldEntry fOfVectorSample = NewVectorFieldEntry(); + FfxInt32x2 packedOpticalFlowMv = FfxInt32x2(LoadOpticalFlowFieldMv(iSamplePos)); + UnpackVectorFieldEntries(packedOpticalFlowMv, fOfVectorSample); + + vfElement.fMotionVector += fOfVectorSample.fMotionVector * fWeight; + vfElement.uHighPriorityFactor += fOfVectorSample.uHighPriorityFactor * fWeight; + vfElement.uLowPriorityFactor += fOfVectorSample.uLowPriorityFactor * fWeight; + + fWeightSum += fWeight; + } + } + + if (fWeightSum > 0.0f) + { + vfElement.fMotionVector /= fWeightSum; + vfElement.uHighPriorityFactor /= fWeightSum; + vfElement.uLowPriorityFactor /= fWeightSum; + } + + vfElement.bNegOutside = !IsUvInside(fUv - vfElement.fMotionVector); + vfElement.bPosOutside = !IsUvInside(fUv + vfElement.fMotionVector); + vfElement.fVelocity = length(vfElement.fMotionVector); +} +#endif + +FfxFloat32x3 Tonemap(FfxFloat32x3 fRgb) +{ + return fRgb / (ffxMax(ffxMax(0.f, fRgb.r), ffxMax(fRgb.g, fRgb.b)) + 1.f).xxx; +} + +FfxFloat32x3 InverseTonemap(FfxFloat32x3 fRgb) +{ + return fRgb / ffxMax(FFX_TONEMAP_EPSILON, 1.f - ffxMax(fRgb.r, ffxMax(fRgb.g, fRgb.b))).xxx; +} + +FfxInt32x2 ComputeHrPosFromLrPos(FfxInt32x2 iPxLrPos) +{ + FfxFloat32x2 fSrcJitteredPos = FfxFloat32x2(iPxLrPos) + 0.5f - Jitter(); + FfxFloat32x2 fLrPosInHr = (fSrcJitteredPos / RenderSize()) * DisplaySize(); + FfxInt32x2 iPxHrPos = FfxInt32x2(floor(fLrPosInHr)); + return iPxHrPos; +} +#if FFX_HALF +FFX_MIN16_I2 ComputeHrPosFromLrPos(FFX_MIN16_I2 iPxLrPos) +{ + FFX_MIN16_F2 fSrcJitteredPos = FFX_MIN16_F2(iPxLrPos) + FFX_MIN16_F(0.5f) - FFX_MIN16_F2(Jitter()); + FFX_MIN16_F2 fLrPosInHr = (fSrcJitteredPos / FFX_MIN16_F2(RenderSize())) * FFX_MIN16_F2(DisplaySize()); + FFX_MIN16_I2 iPxHrPos = FFX_MIN16_I2(floor(fLrPosInHr)); + return iPxHrPos; +} +#endif + +#endif //!defined(FFX_FRAMEINTERPOLATION_COMMON_H) diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_common.h.meta b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_common.h.meta new file mode 100644 index 0000000..f465efb --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_common.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: 35acb60e8d4c40a458862ab63bd9e45c +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid.h b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid.h new file mode 100644 index 0000000..75b3e1e --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid.h @@ -0,0 +1,121 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_FRAMEINTERPOLATION_COMPUTE_GAME_VECTOR_FIELD_INPAINTING_PYRAMID_H +#define FFX_FRAMEINTERPOLATION_COMPUTE_GAME_VECTOR_FIELD_INPAINTING_PYRAMID_H + +#include "ffx_frameinterpolation_common.h" +//-------------------------------------------------------------------------------------- +// Buffer definitions - global atomic counter +//-------------------------------------------------------------------------------------- + +FFX_GROUPSHARED FfxUInt32 spdCounter; +FFX_GROUPSHARED FfxFloat32 spdIntermediateR[16][16]; +FFX_GROUPSHARED FfxFloat32 spdIntermediateG[16][16]; +FFX_GROUPSHARED FfxFloat32 spdIntermediateB[16][16]; +FFX_GROUPSHARED FfxFloat32 spdIntermediateA[16][16]; + +FfxFloat32x4 SpdLoadSourceImage(FfxInt32x2 tex, FfxUInt32 slice) +{ + VectorFieldEntry gameMv; + FfxUInt32x2 packedGameFieldMv = LoadGameFieldMv(tex); + UnpackVectorFieldEntries(packedGameFieldMv, gameMv); + + return FfxFloat32x4(gameMv.fMotionVector, gameMv.uHighPriorityFactor, gameMv.uLowPriorityFactor) * FfxFloat32(DisplaySize().x > 0); +} + +FfxFloat32x4 SpdLoad(FfxInt32x2 tex, FfxUInt32 slice) +{ + return RWLoadInpaintingPyramid(tex, 5); +} + +void SpdStore(FfxInt32x2 pix, FfxFloat32x4 outValue, FfxUInt32 index, FfxUInt32 slice) +{ + StoreInpaintingPyramid(pix, outValue, index); +} + +void SpdIncreaseAtomicCounter(FfxUInt32 slice) +{ + AtomicIncreaseCounter(COUNTER_SPD, spdCounter); +} + +FfxUInt32 SpdGetAtomicCounter() +{ + return spdCounter; +} +void SpdResetAtomicCounter(FfxUInt32 slice) +{ + StoreCounter(COUNTER_SPD, 0); +} + +FfxFloat32x4 SpdLoadIntermediate(FfxUInt32 x, FfxUInt32 y) +{ + return FfxFloat32x4( + spdIntermediateR[x][y], + spdIntermediateG[x][y], + spdIntermediateB[x][y], + spdIntermediateA[x][y]); +} + +void SpdStoreIntermediate(FfxUInt32 x, FfxUInt32 y, FfxFloat32x4 value) +{ + spdIntermediateR[x][y] = value.x; + spdIntermediateG[x][y] = value.y; + spdIntermediateB[x][y] = value.z; + spdIntermediateA[x][y] = value.w; +} + +FfxFloat32x4 SpdReduce4(FfxFloat32x4 v0, FfxFloat32x4 v1, FfxFloat32x4 v2, FfxFloat32x4 v3) +{ + FfxFloat32x4 vec = FfxFloat32x4(0,0,0,0); + + FfxFloat32 fWeightSum = 0.0f; +#define ADD(SAMPLE) { \ + FfxFloat32 fWeight = FfxFloat32(SAMPLE.z > 0.0f); \ + vec += SAMPLE * fWeight; \ + fWeightSum += fWeight; \ + } + + ADD(v0); + ADD(v1); + ADD(v2); + ADD(v3); + + vec /= (fWeightSum > FFX_FRAMEINTERPOLATION_EPSILON) ? fWeightSum : 1.0f; + + return vec; +} + +#include "spd/ffx_spd.h" + +void computeFrameinterpolationGameVectorFieldInpaintingPyramid(FfxInt32x3 iGroupId, FfxInt32 iLocalIndex) +{ + SpdDownsample( + FfxUInt32x2(iGroupId.xy), + FfxUInt32(iLocalIndex), + FfxUInt32(NumMips()), + FfxUInt32(NumWorkGroups()), + FfxUInt32(iGroupId.z), + FfxUInt32x2(WorkGroupOffset())); +} + +#endif // FFX_FRAMEINTERPOLATION_COMPUTE_GAME_VECTOR_FIELD_INPAINTING_PYRAMID_H diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid.h.meta b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid.h.meta new file mode 100644 index 0000000..6781e85 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: 283ecd643b314d348886d886b8c7b6fa +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_compute_inpainting_pyramid.h b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_compute_inpainting_pyramid.h new file mode 100644 index 0000000..da2b672 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_compute_inpainting_pyramid.h @@ -0,0 +1,120 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_FRAMEINTERPOLATION_COMPUTE_INPAINTING_PYRAMID_H +#define FFX_FRAMEINTERPOLATION_COMPUTE_INPAINTING_PYRAMID_H + +//-------------------------------------------------------------------------------------- +// Buffer definitions - global atomic counter +//-------------------------------------------------------------------------------------- + +FFX_GROUPSHARED FfxUInt32 spdCounter; +FFX_GROUPSHARED FfxFloat32 spdIntermediateR[16][16]; +FFX_GROUPSHARED FfxFloat32 spdIntermediateG[16][16]; +FFX_GROUPSHARED FfxFloat32 spdIntermediateB[16][16]; +FFX_GROUPSHARED FfxFloat32 spdIntermediateA[16][16]; + +FfxFloat32x4 SpdLoadSourceImage(FfxInt32x2 tex, FfxUInt32 slice) +{ + FfxFloat32x4 fColor = LoadFrameInterpolationOutput(tex) * FfxFloat32(DisplaySize().x > 0); + + // reverse sample weights + fColor.w = ffxSaturate(1.0f - fColor.w); + + + if (tex.x < InterpolationRectBase().x || tex.x >= (InterpolationRectSize().x + InterpolationRectBase().x) || tex.y < InterpolationRectBase().y || + tex.y >= (InterpolationRectSize().y + InterpolationRectBase().y)) + { + fColor.w = 0.0f; // don't take contributions from outside of the interpolation rect + } + + return fColor; +} + +FfxFloat32x4 SpdLoad(FfxInt32x2 tex, FfxUInt32 slice) +{ + return RWLoadInpaintingPyramid(tex, 5); +} + +void SpdStore(FfxInt32x2 pix, FfxFloat32x4 outValue, FfxUInt32 index, FfxUInt32 slice) +{ + StoreInpaintingPyramid(pix, outValue, index); +} + +void SpdIncreaseAtomicCounter(FfxUInt32 slice) +{ + AtomicIncreaseCounter(COUNTER_SPD, spdCounter); +} + +FfxUInt32 SpdGetAtomicCounter() +{ + return spdCounter; +} +void SpdResetAtomicCounter(FfxUInt32 slice) +{ + StoreCounter(COUNTER_SPD, 0); +} + +FfxFloat32x4 SpdLoadIntermediate(FfxUInt32 x, FfxUInt32 y) +{ + return FfxFloat32x4( + spdIntermediateR[x][y], + spdIntermediateG[x][y], + spdIntermediateB[x][y], + spdIntermediateA[x][y]); +} + +void SpdStoreIntermediate(FfxUInt32 x, FfxUInt32 y, FfxFloat32x4 value) +{ + spdIntermediateR[x][y] = value.x; + spdIntermediateG[x][y] = value.y; + spdIntermediateB[x][y] = value.z; + spdIntermediateA[x][y] = value.w; +} + +FfxFloat32x4 SpdReduce4(FfxFloat32x4 v0, FfxFloat32x4 v1, FfxFloat32x4 v2, FfxFloat32x4 v3) +{ + FfxFloat32x4 w = FfxFloat32x4(v0.w, v1.w, v2.w, v3.w); + + FfxFloat32 sum = (w[0] + w[1] + w[2] + w[3]); + + if (sum == 0.0f) { + return FfxFloat32x4(0.0, 0.0, 0.0, 0.0); + } + + return (v0 * w[0] + v1 * w[1] + v2 * w[2] + v3 * w[3]) / sum; +} + +#include "spd/ffx_spd.h" + +void computeFrameinterpolationInpaintingPyramid(FfxInt32x3 iGroupId, FfxInt32 iLocalIndex) +{ + SpdDownsample( + FfxUInt32x2(iGroupId.xy), + FfxUInt32(iLocalIndex), + FfxUInt32(NumMips()), + FfxUInt32(NumWorkGroups()), + FfxUInt32(iGroupId.z), + FfxUInt32x2(WorkGroupOffset())); +} + +#endif // FFX_FRAMEINTERPOLATION_COMPUTE_INPAINTING_PYRAMID_H diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_compute_inpainting_pyramid.h.meta b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_compute_inpainting_pyramid.h.meta new file mode 100644 index 0000000..e83eb34 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_compute_inpainting_pyramid.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: 1044379078f56104f8a6b0a227287666 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_debug_view.h b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_debug_view.h new file mode 100644 index 0000000..d94defe --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_debug_view.h @@ -0,0 +1,163 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_FRAMEINTERPOLATION_DEBUG_VIEW_H +#define FFX_FRAMEINTERPOLATION_DEBUG_VIEW_H + +struct FfxFrameInterpolationDebugViewport +{ + FfxInt32x2 offset; + FfxInt32x2 size; +}; + +// Macro to cull and draw debug viewport +#define DRAW_VIEWPORT(function, pos, vp) \ + { \ + if (pointIsInsideViewport(pos, vp)) \ + { \ + function(pos, vp); \ + } \ + } + +FfxFloat32x2 getTransformedUv(FfxInt32x2 iPxPos, FfxFrameInterpolationDebugViewport vp) +{ + FfxFloat32x2 fUv = (FfxFloat32x2(iPxPos - vp.offset) + 0.5f) / vp.size; + + return fUv; +} + +FfxFloat32x4 getMotionVectorColor(FfxFloat32x2 fMotionVector) +{ + return FfxFloat32x4(0.5f + fMotionVector * DisplaySize() * 0.1f, 0.5f, 1.0f); +} + +FfxFloat32x4 getUnusedIndicationColor(FfxInt32x2 iPxPos, FfxFrameInterpolationDebugViewport vp) +{ + FfxInt32x2 basePos = iPxPos - vp.offset; + + FfxFloat32 ar = FfxFloat32(vp.size.x) / FfxFloat32(vp.size.y); + + return FfxFloat32x4(basePos.x == FfxInt32(basePos.y * ar), 0, 0, 1); +} + +void drawGameMotionVectorFieldVectors(FfxInt32x2 iPxPos, FfxFrameInterpolationDebugViewport vp) +{ + FfxFloat32x2 fUv = getTransformedUv(iPxPos, vp); + + VectorFieldEntry gameMv; + LoadInpaintedGameFieldMv(fUv, gameMv); + + StoreFrameinterpolationOutput(iPxPos, getMotionVectorColor(gameMv.fMotionVector)); +} + +void drawGameMotionVectorFieldDepthPriority(FfxInt32x2 iPxPos, FfxFrameInterpolationDebugViewport vp) +{ + FfxFloat32x2 fUv = getTransformedUv(iPxPos, vp); + + VectorFieldEntry gameMv; + LoadInpaintedGameFieldMv(fUv, gameMv); + + StoreFrameinterpolationOutput(iPxPos, FfxFloat32x4(0, gameMv.uHighPriorityFactor, 0, 1)); +} + +void drawOpticalFlowMotionVectorField(FfxInt32x2 iPxPos, FfxFrameInterpolationDebugViewport vp) +{ + FfxFloat32x2 fUv = getTransformedUv(iPxPos, vp); + + VectorFieldEntry ofMv; + SampleOpticalFlowMotionVectorField(fUv, ofMv); + + StoreFrameinterpolationOutput(iPxPos, getMotionVectorColor(ofMv.fMotionVector)); +} + +void drawDisocclusionMask(FfxInt32x2 iPxPos, FfxFrameInterpolationDebugViewport vp) +{ + FfxFloat32x2 fUv = getTransformedUv(iPxPos, vp); + + FfxFloat32x2 fLrUv = fUv * (FfxFloat32x2(RenderSize()) / GetMaxRenderSize()); + + FfxFloat32x2 fDisocclusionFactor = ffxSaturate(SampleDisocclusionMask(fLrUv).xy); + + StoreFrameinterpolationOutput(iPxPos, FfxFloat32x4(fDisocclusionFactor, 0, 1)); +} + +void drawPresentBackbuffer(FfxInt32x2 iPxPos, FfxFrameInterpolationDebugViewport vp) +{ + FfxFloat32x2 fUv = getTransformedUv(iPxPos, vp); + + FfxFloat32x4 fPresentColor = getUnusedIndicationColor(iPxPos, vp); + + if (GetHUDLessAttachedFactor() == 1) + { + fPresentColor = SamplePresentBackbuffer(fUv); + } + + StoreFrameinterpolationOutput(iPxPos, fPresentColor); +} + +void drawCurrentInterpolationSource(FfxInt32x2 iPxPos, FfxFrameInterpolationDebugViewport vp) +{ + FfxFloat32x2 fUv = getTransformedUv(iPxPos, vp); + + FfxFloat32x4 fCurrentBackBuffer = FfxFloat32x4(SampleCurrentBackbuffer(fUv), 1.0f); + + StoreFrameinterpolationOutput(iPxPos, fCurrentBackBuffer); +} + +FfxBoolean pointIsInsideViewport(FfxInt32x2 iPxPos, FfxFrameInterpolationDebugViewport vp) +{ + FfxInt32x2 extent = vp.offset + vp.size; + + return (iPxPos.x >= vp.offset.x && iPxPos.x < extent.x) && (iPxPos.y >= vp.offset.y && iPxPos.y < extent.y); +} + +void computeDebugView(FfxInt32x2 iPxPos) +{ +#define VIEWPORT_GRID_SIZE_X 3 +#define VIEWPORT_GRID_SIZE_Y 3 + + FfxFloat32x2 fViewportScale = FfxFloat32x2(1.0f / VIEWPORT_GRID_SIZE_X, 1.0f / VIEWPORT_GRID_SIZE_Y); + FfxInt32x2 iViewportSize = FfxInt32x2(DisplaySize() * fViewportScale); + + // compute grid [y][x] for easier placement of viewports + FfxFrameInterpolationDebugViewport vp[VIEWPORT_GRID_SIZE_Y][VIEWPORT_GRID_SIZE_X]; + for (FfxInt32 y = 0; y < VIEWPORT_GRID_SIZE_Y; y++) + { + for (FfxInt32 x = 0; x < VIEWPORT_GRID_SIZE_X; x++) + { + vp[y][x].offset = iViewportSize * FfxInt32x2(x, y); + vp[y][x].size = iViewportSize; + } + } + + // top row + DRAW_VIEWPORT(drawGameMotionVectorFieldVectors, iPxPos, vp[0][0]); + DRAW_VIEWPORT(drawGameMotionVectorFieldDepthPriority, iPxPos, vp[0][1]); + DRAW_VIEWPORT(drawOpticalFlowMotionVectorField, iPxPos, vp[0][2]); + + // bottom row + DRAW_VIEWPORT(drawDisocclusionMask, iPxPos, vp[2][0]); + DRAW_VIEWPORT(drawCurrentInterpolationSource, iPxPos, vp[2][1]); + DRAW_VIEWPORT(drawPresentBackbuffer, iPxPos, vp[2][2]); +} + +#endif // FFX_FRAMEINTERPOLATION_DEBUG_VIEW_H diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_debug_view.h.meta b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_debug_view.h.meta new file mode 100644 index 0000000..e342567 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_debug_view.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: b57f077e3c35e814fb8ad642a8f61ddd +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_disocclusion_mask.h b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_disocclusion_mask.h new file mode 100644 index 0000000..d9a9e29 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_disocclusion_mask.h @@ -0,0 +1,142 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_FRAMEINTERPOLATION_DISOCCLUSION_MASK_H +#define FFX_FRAMEINTERPOLATION_DISOCCLUSION_MASK_H + +FFX_STATIC const FfxFloat32 DepthClipBaseScale = 1.0f; + +FfxFloat32 ComputeSampleDepthClip(FfxInt32x2 iPxSamplePos, FfxFloat32 fPreviousDepth, FfxFloat32 fPreviousDepthBilinearWeight, FfxFloat32 fCurrentDepthViewSpace) +{ + FfxFloat32 fPrevNearestDepthViewSpace = ConvertFromDeviceDepthToViewSpace(fPreviousDepth); + + // Depth separation logic ref: See "Minimum Triangle Separation for Correct Z-Buffer Occlusion" + // Intention: worst case of formula in Figure4 combined with Ksep factor in Section 4 + const FfxFloat32 fHalfViewportWidth = RenderSize().x * 0.5f; + FfxFloat32 fDepthThreshold = ffxMax(fCurrentDepthViewSpace, fPrevNearestDepthViewSpace); + + // WARNING: Ksep only works with reversed-z with infinite projection. + const FfxFloat32 Ksep = 1.37e-05f; + FfxFloat32 fRequiredDepthSeparation = Ksep * fDepthThreshold * TanHalfFoV() * fHalfViewportWidth; + FfxFloat32 fDepthDiff = fCurrentDepthViewSpace - fPrevNearestDepthViewSpace; + + FfxFloat32 fDepthClipFactor = (fDepthDiff > 0) ? ffxSaturate(fRequiredDepthSeparation / fDepthDiff) : 1.0f; + + return fPreviousDepthBilinearWeight * fDepthClipFactor * ffxLerp(1.0f, DepthClipBaseScale, ffxSaturate(fDepthDiff * fDepthDiff)); +} + +FfxFloat32 LoadEstimatedDepth(FfxUInt32 estimatedIndex, FfxInt32x2 iSamplePos) +{ + if (estimatedIndex == 0) + { + return LoadReconstructedDepthPreviousFrame(iSamplePos); + } + else if (estimatedIndex == 1) + { + return LoadDilatedDepth(iSamplePos); + } + + return 0; +} + +FfxFloat32 ComputeDepthClip(FfxUInt32 estimatedIndex, FfxFloat32x2 fUvSample, FfxFloat32 fCurrentDepthSample) +{ + FfxFloat32 fCurrentDepthViewSpace = ConvertFromDeviceDepthToViewSpace(fCurrentDepthSample); + BilinearSamplingData bilinearInfo = GetBilinearSamplingData(fUvSample, RenderSize()); + + FfxFloat32 fDilatedSum = 0.0f; + FfxFloat32 fDepth = 0.0f; + FfxFloat32 fWeightSum = 0.0f; + for (FfxInt32 iSampleIndex = 0; iSampleIndex < 4; iSampleIndex++) { + + const FfxInt32x2 iOffset = bilinearInfo.iOffsets[iSampleIndex]; + const FfxInt32x2 iSamplePos = bilinearInfo.iBasePos + iOffset; + + if (IsOnScreen(iSamplePos, RenderSize())) { + const FfxFloat32 fWeight = bilinearInfo.fWeights[iSampleIndex]; + if (fWeight > fReconstructedDepthBilinearWeightThreshold) { + + const FfxFloat32 fPrevDepthSample = LoadEstimatedDepth(estimatedIndex, iSamplePos); + const FfxFloat32 fPrevNearestDepthViewSpace = ConvertFromDeviceDepthToViewSpace(fPrevDepthSample); + + const FfxFloat32 fDepthDiff = fCurrentDepthViewSpace - fPrevNearestDepthViewSpace; + + if (fDepthDiff > 0.0f) { + +#if FFX_FRAMEINTERPOLATION_OPTION_INVERTED_DEPTH + const FfxFloat32 fPlaneDepth = ffxMin(fPrevDepthSample, fCurrentDepthSample); +#else + const FfxFloat32 fPlaneDepth = ffxMax(fPrevDepthSample, fCurrentDepthSample); +#endif + + const FfxFloat32x3 fCenter = GetViewSpacePosition(FfxInt32x2(RenderSize() * 0.5f), RenderSize(), fPlaneDepth); + const FfxFloat32x3 fCorner = GetViewSpacePosition(FfxInt32x2(0, 0), RenderSize(), fPlaneDepth); + + const FfxFloat32 fHalfViewportWidth = length(FfxFloat32x2(RenderSize())); + const FfxFloat32 fDepthThreshold = ffxMin(fCurrentDepthViewSpace, fPrevNearestDepthViewSpace); + + const FfxFloat32 Ksep = 1.37e-05f; + const FfxFloat32 Kfov = length(fCorner) / length(fCenter); + const FfxFloat32 fRequiredDepthSeparation = Ksep * Kfov * fHalfViewportWidth * fDepthThreshold; + + const FfxFloat32 fResolutionFactor = ffxSaturate(length(FfxFloat32x2(RenderSize())) / length(FfxFloat32x2(1920.0f, 1080.0f))); + const FfxFloat32 fPower = ffxLerp(1.0f, 3.0f, fResolutionFactor); + + fDepth += FfxFloat32((fRequiredDepthSeparation / fDepthDiff) >= 1.0f) * fWeight; + fWeightSum += fWeight; + } + } + } + } + + return (fWeightSum > 0.0f) ? ffxSaturate(1.0f - fDepth / fWeightSum) : 0.0f; +} + +void computeDisocclusionMask(FfxInt32x2 iPxPos) +{ + FfxFloat32 fDilatedDepth = LoadEstimatedInterpolationFrameDepth(iPxPos); + + FfxFloat32x2 fDepthUv = (iPxPos + 0.5f) / RenderSize(); + FfxFloat32 fCurrentDepthViewSpace = ConvertFromDeviceDepthToViewSpace(fDilatedDepth); + + VectorFieldEntry gameMv; + LoadInpaintedGameFieldMv(fDepthUv, gameMv); + + const FfxFloat32 fDepthClipInterpolatedToPrevious = 1.0f - ComputeDepthClip(0, fDepthUv + gameMv.fMotionVector, fDilatedDepth); + const FfxFloat32 fDepthClipInterpolatedToCurrent = 1.0f - ComputeDepthClip(1, fDepthUv - gameMv.fMotionVector, fDilatedDepth); + FfxFloat32x2 fDisocclusionMask = FfxFloat32x2(fDepthClipInterpolatedToPrevious, fDepthClipInterpolatedToCurrent); + + fDisocclusionMask = FfxFloat32x2(FFX_GREATER_THAN_EQUAL(fDisocclusionMask, ffxBroadcast2(FFX_FRAMEINTERPOLATION_EPSILON))); + + // Avoid false disocclusion if primary game vector pointer outside screen area + const FfxFloat32x2 fSrcMotionVector = gameMv.fMotionVector * 2.0f; + const FfxInt32x2 iSamplePosPrevious = FfxInt32x2((fDepthUv + fSrcMotionVector) * RenderSize()); + fDisocclusionMask.x = ffxSaturate(fDisocclusionMask.x + FfxFloat32(!IsOnScreen(iSamplePosPrevious, RenderSize()))); + + const FfxInt32x2 iSamplePosCurrent = FfxInt32x2((fDepthUv - fSrcMotionVector) * RenderSize()); + fDisocclusionMask.y = ffxSaturate(fDisocclusionMask.y + FfxFloat32(!IsOnScreen(iSamplePosCurrent, RenderSize()))); + + StoreDisocclusionMask(iPxPos, fDisocclusionMask); + +} + +#endif // FFX_FRAMEINTERPOLATION_DISOCCLUSION_MASK_H diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_disocclusion_mask.h.meta b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_disocclusion_mask.h.meta new file mode 100644 index 0000000..5dc9472 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_disocclusion_mask.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: dfee50799482d8d409645894f08f1a7e +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_game_motion_vector_field.h b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_game_motion_vector_field.h new file mode 100644 index 0000000..bc90996 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_game_motion_vector_field.h @@ -0,0 +1,118 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_FRAMEINTERPOLATION_GAME_MOTION_VECTOR_FIELD_H +#define FFX_FRAMEINTERPOLATION_GAME_MOTION_VECTOR_FIELD_H + +FfxUInt32 getPriorityFactorFromViewSpaceDepth(FfxFloat32 fViewSpaceDepthInMeters) +{ + fViewSpaceDepthInMeters = ffxPow(fViewSpaceDepthInMeters, 0.33f); + + FfxUInt32 uPriorityFactor = FfxUInt32(FfxFloat32(1 - (fViewSpaceDepthInMeters * (1.0f / (1.0f + fViewSpaceDepthInMeters)))) * PRIORITY_HIGH_MAX); + + return ffxMax(1, uPriorityFactor); +} + +void computeGameFieldMvs(FfxInt32x2 iPxPos) +{ + const FfxFloat32x2 fUvInScreenSpace = (FfxFloat32x2(iPxPos) + 0.5f) / RenderSize(); + const FfxFloat32x2 fUvInInterpolationRectStart = FfxFloat32x2(InterpolationRectBase()) / DisplaySize(); + const FfxFloat32x2 fUvLetterBoxScale = FfxFloat32x2(InterpolationRectSize()) / DisplaySize(); + const FfxFloat32x2 fUvInInterpolationRect = fUvInInterpolationRectStart + fUvInScreenSpace * fUvLetterBoxScale; + + const FfxFloat32 fDepthSample = LoadDilatedDepth(iPxPos); + const FfxFloat32x2 fGameMotionVector = LoadDilatedMotionVector(iPxPos); + const FfxFloat32x2 fMotionVectorHalf = fGameMotionVector * 0.5f; + const FfxFloat32x2 fInterpolatedLocationUv = fUvInScreenSpace + fMotionVectorHalf; + + const FfxFloat32 fViewSpaceDepth = ConvertFromDeviceDepthToViewSpace(fDepthSample); + const FfxUInt32 uHighPriorityFactorPrimary = getPriorityFactorFromViewSpaceDepth(fViewSpaceDepth); + + FfxFloat32x3 prevBackbufferCol = SamplePreviousBackbuffer(fUvInInterpolationRect).xyz; + FfxFloat32x3 curBackbufferCol = SamplePreviousBackbuffer(fUvInInterpolationRect + fGameMotionVector * fUvLetterBoxScale).xyz; + FfxFloat32 prevLuma = 0.001f + RawRGBToLuminance(prevBackbufferCol); + FfxFloat32 currLuma = 0.001f + RawRGBToLuminance(curBackbufferCol); + + FfxUInt32 uLowPriorityFactor = FfxUInt32(ffxRound(ffxPow(MinDividedByMax(prevLuma, currLuma), 1.0f / 1.0f) * PRIORITY_LOW_MAX)) + * FfxUInt32(IsUvInside(fUvInInterpolationRect + fGameMotionVector * fUvLetterBoxScale)); + + // Update primary motion vectors + { + const FfxUInt32x2 packedVectorPrimary = PackVectorFieldEntries(true, uHighPriorityFactorPrimary, uLowPriorityFactor, fMotionVectorHalf); + + BilinearSamplingData bilinearInfo = GetBilinearSamplingData(fInterpolatedLocationUv, RenderSize()); + for (FfxInt32 iSampleIndex = 0; iSampleIndex < 4; iSampleIndex++) + { + const FfxInt32x2 iOffset = bilinearInfo.iOffsets[iSampleIndex]; + const FfxInt32x2 iSamplePos = bilinearInfo.iBasePos + iOffset; + + if (IsOnScreen(iSamplePos, RenderSize())) + { + UpdateGameMotionVectorField(iSamplePos, packedVectorPrimary); + } + } + } + + // Update secondary vectors + // Main purpose of secondary vectors is to improve quality of inpainted vectors + const FfxBoolean bWriteSecondaryVectors = length(fMotionVectorHalf * RenderSize()) > FFX_FRAMEINTERPOLATION_EPSILON; + if (bWriteSecondaryVectors) + { + FfxBoolean bWriteSecondary = true; + FfxUInt32 uNumPrimaryHits = 0; + const FfxFloat32 fSecondaryStepScale = length(1.0f / RenderSize()); + const FfxFloat32x2 fStepMv = normalize(fGameMotionVector); + const FfxFloat32 fBreakDist = ffxMin(length(fMotionVectorHalf), length(FfxFloat32x2(0.5f, 0.5f))); + + for (FfxFloat32 fMvScale = fSecondaryStepScale; fMvScale <= fBreakDist && bWriteSecondary; fMvScale += fSecondaryStepScale) + { + const FfxFloat32x2 fSecondaryLocationUv = fInterpolatedLocationUv - fStepMv * fMvScale; + BilinearSamplingData bilinearInfo = GetBilinearSamplingData(fSecondaryLocationUv, RenderSize()); + + // Reverse depth prio for secondary vectors + FfxUInt32 uHighPriorityFactorSecondary = ffxMax(1, PRIORITY_HIGH_MAX - uHighPriorityFactorPrimary); + + const FfxFloat32x2 fToCenter = normalize(FfxFloat32x2(0.5f, 0.5f) - fSecondaryLocationUv); + uLowPriorityFactor = FfxUInt32(ffxMax(0.0f, dot(fToCenter, fStepMv)) * PRIORITY_LOW_MAX); + const FfxUInt32x2 packedVectorSecondary = PackVectorFieldEntries(false, uHighPriorityFactorSecondary, uLowPriorityFactor, fMotionVectorHalf); + + // Only write secondary mvs to single bilinear location + for (FfxInt32 iSampleIndex = 0; iSampleIndex < 1; iSampleIndex++) + { + const FfxInt32x2 iOffset = bilinearInfo.iOffsets[iSampleIndex]; + const FfxInt32x2 iSamplePos = bilinearInfo.iBasePos + iOffset; + + bWriteSecondary = bWriteSecondary && IsOnScreen(iSamplePos, RenderSize()); + + if (bWriteSecondary) + { + const FfxUInt32 uExistingVectorFieldEntry = UpdateGameMotionVectorFieldEx(iSamplePos, packedVectorSecondary); + + uNumPrimaryHits += FfxUInt32(PackedVectorFieldEntryIsPrimary(uExistingVectorFieldEntry)); + bWriteSecondary = bWriteSecondary && (uNumPrimaryHits <= 3); + } + } + } + } +} + +#endif // FFX_FRAMEINTERPOLATION_GAME_MOTION_VECTOR_FIELD_H diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_game_motion_vector_field.h.meta b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_game_motion_vector_field.h.meta new file mode 100644 index 0000000..df0d217 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_game_motion_vector_field.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: f45abe4270f0ed646a68e0cfae830b3d +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_inpainting.h b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_inpainting.h new file mode 100644 index 0000000..7ad3630 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_inpainting.h @@ -0,0 +1,150 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_FRAMEINTERPOLATION_INPAINTING_H +#define FFX_FRAMEINTERPOLATION_INPAINTING_H + +FfxFloat32x4 ComputeInpaintingLevel(FfxFloat32x2 fUv, const FfxInt32 iMipLevel, const FfxInt32x2 iTexSize) +{ + BilinearSamplingData bilinearInfo = GetBilinearSamplingData(fUv, iTexSize); + + FfxFloat32x4 fColor = FfxFloat32x4(0.0, 0.0, 0.0, 0.0); + + for (FfxInt32 iSampleIndex = 0; iSampleIndex < 4; iSampleIndex++) { + + const FfxInt32x2 iOffset = bilinearInfo.iOffsets[iSampleIndex]; + const FfxInt32x2 iSamplePos = bilinearInfo.iBasePos + iOffset; + + if (IsOnScreen(iSamplePos, iTexSize)) { + + FfxFloat32x4 fSample = LoadInpaintingPyramid(iMipLevel, iSamplePos); + + const FfxFloat32 fWeight = bilinearInfo.fWeights[iSampleIndex] * FfxFloat32(fSample.w > 0.0f); + + fColor += FfxFloat32x4(fSample.rgb * fWeight, fWeight); + } + } + + return fColor; +} + +FfxFloat32x3 ComputeInpainting(FfxInt32x2 iPxPos) +{ + FfxFloat32x2 fUv = (iPxPos + 0.5f) / (DisplaySize()); + + FfxFloat32x4 fColor = FfxFloat32x4(0.0, 0.0, 0.0, 0.0); + FfxFloat32 fWeightSum = 0.0f; + FfxInt32x2 iTexSize = DisplaySize(); + + for (FfxInt32 iMipLevel = 0; iMipLevel < 10; iMipLevel++) { + + iTexSize /= 2; + + FfxFloat32x4 fMipColor = ComputeInpaintingLevel(fUv, iMipLevel, iTexSize); + + if (fMipColor.w > 0.0f) { + const FfxFloat32x3 fNormalizedMipColor = fMipColor.rgb / fMipColor.w; + const FfxFloat32 fMipWeight = ffxPow(1.0f - iMipLevel / 10.0f, 3.0f) * fMipColor.w; + + fColor += FfxFloat32x4(fNormalizedMipColor, 1.0f) * fMipWeight; + } + } + + return fColor.rgb / fColor.w; +} + +void drawDebugTearLines(FfxInt32x2 iPxPos, inout FfxFloat32x3 fColor, inout FfxBoolean bWriteColor) +{ + if (iPxPos.x < 16) + { + fColor.g = 1.f; + bWriteColor = true; + } + else if (iPxPos.x > DisplaySize().x - 16) + { + fColor += GetDebugBarColor(); + bWriteColor = true; + } + +} + +void drawDebugResetIndicators(FfxInt32x2 iPxPos, inout FfxFloat32x3 fColor, inout FfxBoolean bWriteColor) +{ + if (iPxPos.y < 32 && Reset()) + { + fColor.r = 1.f; + bWriteColor = true; + } + else if (iPxPos.y > 32 && iPxPos.y < 64 && HasSceneChanged()) + { + fColor.b = 1.f; + bWriteColor = true; + } +} + +void computeInpainting(FfxInt32x2 iPxPos) +{ + FfxBoolean bWriteColor = false; + FfxFloat32x4 fInterpolatedColor = RWLoadFrameinterpolationOutput(iPxPos); + + const FfxFloat32 fInPaintingWeight = fInterpolatedColor.w; + if (fInPaintingWeight > FFX_FRAMEINTERPOLATION_EPSILON) + { + fInterpolatedColor.rgb = ffxLerp(fInterpolatedColor.rgb, ComputeInpainting(iPxPos) * FfxFloat32(DisplaySize().x > 0), fInPaintingWeight); + bWriteColor = true; + } + + if (GetHUDLessAttachedFactor() == 1) + { + const FfxFloat32x3 fCurrentInterpolationSource = LoadCurrentBackbuffer(iPxPos).rgb; + const FfxFloat32x3 fPresentColor = LoadPresentBackbuffer(iPxPos).rgb; + + if (any(FFX_GREATER_THAN(abs(fCurrentInterpolationSource - fPresentColor), FfxFloat32x3(0.0, 0.0, 0.0)))) + { + const FfxFloat32 fStaticFactor = CalculateStaticContentFactor(RawRGBToLinear(fCurrentInterpolationSource), RawRGBToLinear(fPresentColor)); + + if (fStaticFactor > FFX_FRAMEINTERPOLATION_EPSILON) + { + fInterpolatedColor.rgb = ffxLerp(fInterpolatedColor.rgb, fPresentColor, fStaticFactor); + bWriteColor = true; + } + } + } + + if ((GetDispatchFlags() & FFX_FRAMEINTERPOLATION_DISPATCH_DRAW_DEBUG_TEAR_LINES) != 0) + { + drawDebugTearLines(iPxPos, fInterpolatedColor.rgb, bWriteColor); + } + + if ((GetDispatchFlags() & FFX_FRAMEINTERPOLATION_DISPATCH_DRAW_DEBUG_RESET_INDICATORS) != 0) + { + drawDebugResetIndicators(iPxPos, fInterpolatedColor.rgb, bWriteColor); + } + + if (bWriteColor) + { + StoreFrameinterpolationOutput(iPxPos, FfxFloat32x4(fInterpolatedColor.rgb, 1.0f)); + } + +} + +#endif // FFX_FRAMEINTERPOLATION_INPAINTING_H diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_inpainting.h.meta b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_inpainting.h.meta new file mode 100644 index 0000000..b5ddc2a --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_inpainting.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: 17b45333e20e75042b320d5631323144 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_optical_flow_vector_field.h b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_optical_flow_vector_field.h new file mode 100644 index 0000000..2379074 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_optical_flow_vector_field.h @@ -0,0 +1,124 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_FRAMEINTERPOLATION_OPTICAL_FLOW_VECTOR_FIELD_H +#define FFX_FRAMEINTERPOLATION_OPTICAL_FLOW_VECTOR_FIELD_H + +void computeOpticalFlowFieldMvs(FfxUInt32x2 dtID, FfxFloat32x2 fOpticalFlowVector) +{ + FfxFloat32x2 fUv = FfxFloat32x2(FfxFloat32x2(dtID)+0.5f) / GetOpticalFlowSize2(); + + const FfxFloat32 scaleFactor = 1.0f; + FfxFloat32x2 fMotionVectorHalf = fOpticalFlowVector * 0.5f; + + FfxFloat32 fDilatedDepth = ConvertFromDeviceDepthToViewSpace(LoadDilatedDepth(FfxInt32x2(dtID))); + + FfxFloat32x3 prevBackbufferCol = SamplePreviousBackbuffer(fUv).xyz; + FfxFloat32x3 curBackbufferCol = SampleCurrentBackbuffer(fUv + fOpticalFlowVector).xyz; + + FfxFloat32 prevLuma = 0.001f + RawRGBToLuminance(prevBackbufferCol); + FfxFloat32 currLuma = 0.001f + RawRGBToLuminance(curBackbufferCol); + + FfxFloat32 fVelocity = length(fOpticalFlowVector * InterpolationRectSize()); + FfxUInt32 uHighPriorityFactor = FfxUInt32(fVelocity > 1.0f) * FfxUInt32(ffxSaturate(fVelocity / length(InterpolationRectSize() * 0.05f)) * PRIORITY_HIGH_MAX); + + if(uHighPriorityFactor > 0) { + FfxUInt32 uLowPriorityFactor = FfxUInt32(ffxRound(ffxPow(MinDividedByMax(prevLuma, currLuma), 1.0f / 1.0f) * PRIORITY_LOW_MAX)) + * FfxUInt32(IsUvInside(fUv + fOpticalFlowVector)); + + // Project current depth into previous frame locations. + // Push to all pixels having some contribution if reprojection is using bilinear logic. + + const FfxUInt32x2 packedVectorPrimary = PackVectorFieldEntries(true, uHighPriorityFactor, uLowPriorityFactor, fMotionVectorHalf); + + BilinearSamplingData bilinearInfo = GetBilinearSamplingData(fUv + fMotionVectorHalf, GetOpticalFlowSize2()); + for (FfxInt32 iSampleIndex = 0; iSampleIndex < 4; iSampleIndex++) + { + const FfxInt32x2 iOffset = bilinearInfo.iOffsets[iSampleIndex]; + const FfxInt32x2 iSamplePos = bilinearInfo.iBasePos + iOffset; + + if (IsOnScreen(iSamplePos, GetOpticalFlowSize2())) + { + UpdateOpticalflowMotionVectorField(iSamplePos, packedVectorPrimary); + } + } + } +} + +void computeOpticalFlowVectorField(FfxInt32x2 iPxPos) +{ + FfxFloat32x2 fOpticalFlowVector = FfxFloat32x2(0.0, 0.0); + FfxFloat32x2 fOpticalFlowVector3x3Avg = FfxFloat32x2(0.0, 0.0); + FfxInt32 size = 1; + FfxFloat32 sw = 0.0f; + + for(FfxInt32 y = -size; y <= size; y++) { + for(FfxInt32 x = -size; x <= size; x++) { + + FfxInt32x2 samplePos = iPxPos + FfxInt32x2(x, y); + + FfxFloat32x2 vs = LoadOpticalFlow(samplePos); + FfxFloat32 fConfidenceFactor = ffxMax(FFX_FRAMEINTERPOLATION_EPSILON, LoadOpticalFlowConfidence(samplePos)); + + + FfxFloat32 len = length(vs * InterpolationRectSize()); + FfxFloat32 len_factor = ffxMax(0.0f, 512.0f - len) * FfxFloat32(len > 1.0f); + FfxFloat32 w = len_factor; + + fOpticalFlowVector3x3Avg += vs * w; + + sw += w; + } + } + + fOpticalFlowVector3x3Avg /= sw; + + + sw = 0.0f; + for(FfxInt32 y = -size; y <= size; y++) { + for(FfxInt32 x = -size; x <= size; x++) { + + FfxInt32x2 samplePos = iPxPos + FfxInt32x2(x, y); + + FfxFloat32x2 vs = LoadOpticalFlow(samplePos); + + FfxFloat32 fConfidenceFactor = ffxMax(FFX_FRAMEINTERPOLATION_EPSILON, LoadOpticalFlowConfidence(samplePos)); + FfxFloat32 len = length(vs * InterpolationRectSize()); + FfxFloat32 len_factor = ffxMax(0.0f, 512.0f - len) * FfxFloat32(len > 1.0f); + + + FfxFloat32 w = ffxMax(0.0f, ffxPow(dot(fOpticalFlowVector3x3Avg, vs), 1.25f)) * len_factor; + + fOpticalFlowVector += vs * w; + sw += w; + } + } + + if (sw > FFX_FRAMEINTERPOLATION_EPSILON) + { + fOpticalFlowVector /= sw; + } + + computeOpticalFlowFieldMvs(iPxPos, fOpticalFlowVector); +} + +#endif // FFX_FRAMEINTERPOLATION_OPTICAL_FLOW_VECTOR_FIELD_H diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_optical_flow_vector_field.h.meta b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_optical_flow_vector_field.h.meta new file mode 100644 index 0000000..42ef19b --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_optical_flow_vector_field.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: 15da5f8073799904887da30032ca05c5 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_reconstruct_dilated_velocity_and_previous_depth.h b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_reconstruct_dilated_velocity_and_previous_depth.h new file mode 100644 index 0000000..e92a579 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_reconstruct_dilated_velocity_and_previous_depth.h @@ -0,0 +1,123 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_FRAMEINTERPOLATION_RECONSTRUCT_DILATED_VELOCITY_AND_PREVIOUS_DEPTH_H +#define FFX_FRAMEINTERPOLATION_RECONSTRUCT_DILATED_VELOCITY_AND_PREVIOUS_DEPTH_H + +void ReconstructPrevDepth(FfxInt32x2 iPxPos, FfxFloat32 fDepth, FfxFloat32x2 fMotionVector, FfxInt32x2 iPxDepthSize) +{ + fMotionVector *= FfxFloat32(length(fMotionVector * DisplaySize()) > 0.1f); + + FfxFloat32x2 fUv = (iPxPos + FfxFloat32(0.5)) / iPxDepthSize; + FfxFloat32x2 fReprojectedUv = fUv + fMotionVector; + + BilinearSamplingData bilinearInfo = GetBilinearSamplingData(fReprojectedUv, RenderSize()); + + // Project current depth into previous frame locations. + // Push to all pixels having some contribution if reprojection is using bilinear logic. + for (FfxInt32 iSampleIndex = 0; iSampleIndex < 4; iSampleIndex++) { + + const FfxInt32x2 iOffset = bilinearInfo.iOffsets[iSampleIndex]; + FfxFloat32 fWeight = bilinearInfo.fWeights[iSampleIndex]; + + if (fWeight > fReconstructedDepthBilinearWeightThreshold) { + + FfxInt32x2 iStorePos = bilinearInfo.iBasePos + iOffset; + if (IsOnScreen(iStorePos, iPxDepthSize)) { + UpdateReconstructedDepthPreviousFrame(iStorePos, fDepth); + } + } + } +} + +void FindNearestDepth(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxInt32x2 iPxSize, FFX_PARAMETER_OUT FfxFloat32 fNearestDepth, FFX_PARAMETER_OUT FfxInt32x2 fNearestDepthCoord) +{ + const FfxInt32 iSampleCount = 9; + const FfxInt32x2 iSampleOffsets[iSampleCount] = { + FfxInt32x2(+0, +0), + FfxInt32x2(+1, +0), + FfxInt32x2(+0, +1), + FfxInt32x2(+0, -1), + FfxInt32x2(-1, +0), + FfxInt32x2(-1, +1), + FfxInt32x2(+1, +1), + FfxInt32x2(-1, -1), + FfxInt32x2(+1, -1), + }; + + // pull out the depth loads to allow SC to batch them + FfxFloat32 depth[9]; + FfxInt32 iSampleIndex = 0; + FFX_UNROLL + for (iSampleIndex = 0; iSampleIndex < iSampleCount; ++iSampleIndex) { + + FfxInt32x2 iPos = iPxPos + iSampleOffsets[iSampleIndex]; + depth[iSampleIndex] = LoadInputDepth(iPos); + } + + // find closest depth + fNearestDepthCoord = iPxPos; + fNearestDepth = depth[0]; + FFX_UNROLL + for (iSampleIndex = 1; iSampleIndex < iSampleCount; ++iSampleIndex) { + + FfxInt32x2 iPos = iPxPos + iSampleOffsets[iSampleIndex]; + if (IsOnScreen(iPos, iPxSize)) { + + FfxFloat32 fNdDepth = depth[iSampleIndex]; +#if FFX_FRAMEINTERPOLATION_OPTION_INVERTED_DEPTH + if (fNdDepth > fNearestDepth) { +#else + if (fNdDepth < fNearestDepth) { +#endif + fNearestDepthCoord = iPos; + fNearestDepth = fNdDepth; + } + } + } +} + +void ReconstructAndDilate(FfxInt32x2 iPxLrPos) +{ + FfxFloat32 fDilatedDepth; + FfxInt32x2 iNearestDepthCoord; + + FindNearestDepth(iPxLrPos, RenderSize(), fDilatedDepth, iNearestDepthCoord); + +#if FFX_FRAMEINTERPOLATION_OPTION_LOW_RES_MOTION_VECTORS + FfxInt32x2 iSamplePos = iPxLrPos; + FfxInt32x2 iMotionVectorPos = iNearestDepthCoord; +#else + FfxInt32x2 iSamplePos = ComputeHrPosFromLrPos(iPxLrPos); + FfxInt32x2 iMotionVectorPos = ComputeHrPosFromLrPos(iNearestDepthCoord); +#endif + + FfxFloat32x2 fDilatedMotionVector = LoadInputMotionVector(iMotionVectorPos); + + StoreDilatedDepth(iPxLrPos, fDilatedDepth); + StoreDilatedMotionVectors(iPxLrPos, fDilatedMotionVector); + + ReconstructPrevDepth(iPxLrPos, fDilatedDepth, fDilatedMotionVector, RenderSize()); +} + + +#endif //!defined( FFX_FRAMEINTERPOLATION_RECONSTRUCT_DILATED_VELOCITY_AND_PREVIOUS_DEPTH_H ) diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_reconstruct_dilated_velocity_and_previous_depth.h.meta b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_reconstruct_dilated_velocity_and_previous_depth.h.meta new file mode 100644 index 0000000..4c51d46 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_reconstruct_dilated_velocity_and_previous_depth.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: d1f7e253b96e263459e1fd69948501f2 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_reconstruct_previous_depth.h b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_reconstruct_previous_depth.h new file mode 100644 index 0000000..3f6cdbc --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_reconstruct_previous_depth.h @@ -0,0 +1,59 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_FRAMEINTERPOLATION_RECONSTRUCT_PREVIOUS_DEPTH_H +#define FFX_FRAMEINTERPOLATION_RECONSTRUCT_PREVIOUS_DEPTH_H + +void ReconstructPrevDepth(FfxInt32x2 iPxPos, FfxUInt32 depthTarget, FfxFloat32 fDepth, FfxFloat32x2 fMotionVector, FfxInt32x2 iPxDepthSize) +{ + const FfxFloat32x2 fUv = (iPxPos + FfxFloat32(0.5)) / iPxDepthSize; + + // Project current depth into previous frame locations. + // Push to all pixels having some contribution if reprojection is using bilinear logic. + BilinearSamplingData bilinearInfo = GetBilinearSamplingData(fUv + fMotionVector, RenderSize()); + for (FfxInt32 iSampleIndex = 0; iSampleIndex < 4; iSampleIndex++) + { + const FfxInt32x2 iOffset = bilinearInfo.iOffsets[iSampleIndex]; + const FfxInt32x2 iSamplePos = bilinearInfo.iBasePos + iOffset; + const FfxFloat32 fSampleWeight = bilinearInfo.fWeights[iSampleIndex]; + + if (fSampleWeight > fReconstructedDepthBilinearWeightThreshold) + { + if (IsOnScreen(iSamplePos, RenderSize())) + { + if (depthTarget != 0) { + UpdateReconstructedDepthInterpolatedFrame(iSamplePos, fDepth); + } + } + } + } +} + +void reconstructPreviousDepth(FfxInt32x2 iPxPos) +{ + FfxFloat32x2 fMotionVector = LoadDilatedMotionVector(iPxPos); + FfxFloat32 fDilatedDepth = LoadDilatedDepth(iPxPos); + + ReconstructPrevDepth(iPxPos, 1, fDilatedDepth, fMotionVector * 0.5f, RenderSize()); +} + +#endif // FFX_FRAMEINTERPOLATION_RECONSTRUCT_PREVIOUS_DEPTH_H diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_reconstruct_previous_depth.h.meta b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_reconstruct_previous_depth.h.meta new file mode 100644 index 0000000..0969d51 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_reconstruct_previous_depth.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: eaacebc61381a1b4381556b2abf31aa3 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_resources.h b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_resources.h new file mode 100644 index 0000000..3bc5a94 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_resources.h @@ -0,0 +1,99 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_FRAMEINTERPOLATION_RESOURCES_H +#define FFX_FRAMEINTERPOLATION_RESOURCES_H + +#if defined(FFX_CPU) || defined(FFX_GPU) +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_NULL 0 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_OUTPUT 1 +//#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_BACKBUFFER 2 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_PREVIOUS_INTERPOLATION_SOURCE 3 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_CURRENT_INTERPOLATION_SOURCE 4 + +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_DEPTH 5 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_MOTION_VECTORS 6 + +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_RESERVED_2 7 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_RESERVED_3 8 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_RESERVED_4 9 + +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_DILATED_DEPTH 10 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS 11 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_RECONSTRUCTED_DEPTH_PREVIOUS_FRAME 12 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_RECONSTRUCTED_DEPTH_INTERPOLATED_FRAME 13 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_DISOCCLUSION_MASK 14 + +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_GAME_MOTION_VECTOR_FIELD_X 15 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_GAME_MOTION_VECTOR_FIELD_Y 16 + +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_OPTICAL_FLOW_MOTION_VECTOR_FIELD_X 17 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_OPTICAL_FLOW_MOTION_VECTOR_FIELD_Y 18 + +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_OPTICAL_FLOW_VECTOR 19 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_RESERVED_5 20 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_OPTICAL_FLOW_CONFIDENCE 21 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_OPTICAL_FLOW_GLOBAL_MOTION 22 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_OPTICAL_FLOW_SCENE_CHANGE_DETECTION 23 + +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_RESERVED_6 25 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_RESERVED_7 26 + +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_DEBUG_OUTPUT_0 27 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_DEBUG_OUTPUT_1 28 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_DEBUG_OUTPUT 29 + +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_RESERVED_8 30 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_PRESENT_BACKBUFFER 31 + +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_COUNTERS 32 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_INPAINTING_PYRAMID 33 // same as FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_INPAINTING_PYRAMID_MIPMAP_0 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_INPAINTING_PYRAMID_MIPMAP_0 33 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_INPAINTING_PYRAMID_MIPMAP_1 34 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_INPAINTING_PYRAMID_MIPMAP_2 35 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_INPAINTING_PYRAMID_MIPMAP_3 36 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_INPAINTING_PYRAMID_MIPMAP_4 37 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_INPAINTING_PYRAMID_MIPMAP_5 38 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_INPAINTING_PYRAMID_MIPMAP_6 39 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_INPAINTING_PYRAMID_MIPMAP_7 40 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_INPAINTING_PYRAMID_MIPMAP_8 41 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_INPAINTING_PYRAMID_MIPMAP_9 42 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_INPAINTING_PYRAMID_MIPMAP_10 43 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_INPAINTING_PYRAMID_MIPMAP_11 44 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_INPAINTING_PYRAMID_MIPMAP_12 45 + +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_DILATED_DEPTH_0 46 // resources for ping ponging if async is enabled. +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_DILATED_DEPTH_1 47 // code relies on them being interleaved +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS_0 48 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS_1 49 // code relies on them being interleaved +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_RECONSTRUCTED_DEPTH_PREVIOUS_FRAME_0 50 +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_RECONSTRUCTED_DEPTH_PREVIOUS_FRAME_1 51 // code relies on them being interleaved + +#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_COUNT 52 + +#define FFX_FRAMEINTERPOLATION_CONSTANTBUFFER_IDENTIFIER 0 +#define FFX_FRAMEINTERPOLATION_INPAINTING_PYRAMID_CONSTANTBUFFER_IDENTIFIER 1 +#define FFX_FRAMEINTERPOLATION_CONSTANTBUFFER_COUNT 2 + +#endif // #if defined(FFX_CPU) || defined(FFX_GPU) + +#endif //!defined( FFX_FRAMEINTERPOLATION_RESOURCES_H ) diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_resources.h.meta b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_resources.h.meta new file mode 100644 index 0000000..8bd52d1 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_resources.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: c372a686ee040fd4d94e4e778dcfa3f0 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_setup.h b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_setup.h new file mode 100644 index 0000000..60dd323 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_setup.h @@ -0,0 +1,50 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_FRAMEINTERPOLATION_SETUP_H +#define FFX_FRAMEINTERPOLATION_SETUP_H + +void setupFrameinterpolationResources(FfxInt32x2 iPxPos) +{ + // Update reset counters + StoreCounter(COUNTER_SPD, 0); + if (all(FFX_EQUAL(iPxPos, FfxInt32x2(0, 0)))) + { + if(Reset() || HasSceneChanged()) { + StoreCounter(COUNTER_FRAME_INDEX_SINCE_LAST_RESET, 0); + } else { + FfxUInt32 counter = RWLoadCounter(COUNTER_FRAME_INDEX_SINCE_LAST_RESET); + StoreCounter(COUNTER_FRAME_INDEX_SINCE_LAST_RESET, counter + 1); + } + } + + // Reset resources + StoreGameMotionVectorFieldX(iPxPos, 0); + StoreGameMotionVectorFieldY(iPxPos, 0); + + StoreOpticalflowMotionVectorFieldX(iPxPos, 0); + StoreOpticalflowMotionVectorFieldY(iPxPos, 0); + + StoreDisocclusionMask(iPxPos, FfxFloat32x2(0.0, 0.0)); +} + +#endif // FFX_FRAMEINTERPOLATION_SETUP_H diff --git a/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_setup.h.meta b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_setup.h.meta new file mode 100644 index 0000000..95ead02 --- /dev/null +++ b/Shaders/shaders/frameinterpolation/ffx_frameinterpolation_setup.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: b762adf78ca62cf438224ff32c1356e0 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/fsr3.meta b/Shaders/shaders/fsr3.meta new file mode 100644 index 0000000..cd9fdf2 --- /dev/null +++ b/Shaders/shaders/fsr3.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: d97a9a04054e249448b39b8184db3e9e +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/fsr3/ffx_fsr3_callbacks_hlsl.h b/Shaders/shaders/fsr3/ffx_fsr3_callbacks_hlsl.h new file mode 100644 index 0000000..b824060 --- /dev/null +++ b/Shaders/shaders/fsr3/ffx_fsr3_callbacks_hlsl.h @@ -0,0 +1,24 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#include "../fsr2/ffx_fsr2_callbacks_hlsl.h" +#include "ffx_fsr3_resources.h" diff --git a/Shaders/shaders/fsr3/ffx_fsr3_callbacks_hlsl.h.meta b/Shaders/shaders/fsr3/ffx_fsr3_callbacks_hlsl.h.meta new file mode 100644 index 0000000..eee8301 --- /dev/null +++ b/Shaders/shaders/fsr3/ffx_fsr3_callbacks_hlsl.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: 8bfa8bccfff25794a9101dcbeebb43e2 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/fsr3/ffx_fsr3_common.h b/Shaders/shaders/fsr3/ffx_fsr3_common.h new file mode 100644 index 0000000..f8c935c --- /dev/null +++ b/Shaders/shaders/fsr3/ffx_fsr3_common.h @@ -0,0 +1,25 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#include "../fsr2/ffx_fsr2_common.h" +#include "../frameinterpolation/ffx_frameinterpolation_common.h" +#include "../opticalflow/ffx_opticalflow_common.h" diff --git a/Shaders/shaders/fsr3/ffx_fsr3_common.h.meta b/Shaders/shaders/fsr3/ffx_fsr3_common.h.meta new file mode 100644 index 0000000..0ecdda0 --- /dev/null +++ b/Shaders/shaders/fsr3/ffx_fsr3_common.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: f2c220b7bde9eac4594a94240ba6b075 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/fsr3/ffx_fsr3_resources.h b/Shaders/shaders/fsr3/ffx_fsr3_resources.h new file mode 100644 index 0000000..89a3fe6 --- /dev/null +++ b/Shaders/shaders/fsr3/ffx_fsr3_resources.h @@ -0,0 +1,37 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_FSR3_RESOURCES_H +#define FFX_FSR3_RESOURCES_H + +#include "../fsr2/ffx_fsr2_resources.h" +#include "../frameinterpolation/ffx_frameinterpolation_resources.h" + +#if defined(FFX_CPU) || defined(FFX_GPU) + +#define FFX_FSR3_RESOURCE_IDENTIFIER_OPTICAL_FLOW_VECTOR 0 +#define FFX_FSR3_RESOURCE_IDENTIFIER_OPTICAL_FLOW_SCD_OUTPUT 1 + +#define FFX_FSR3_RESOURCE_IDENTIFIER_COUNT 2 +#endif // #if defined(FFX_CPU) || defined(FFX_GPU) + +#endif //!defined( FFX_FSR2_RESOURCES_H ) diff --git a/Shaders/shaders/fsr3/ffx_fsr3_resources.h.meta b/Shaders/shaders/fsr3/ffx_fsr3_resources.h.meta new file mode 100644 index 0000000..c74880c --- /dev/null +++ b/Shaders/shaders/fsr3/ffx_fsr3_resources.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: 58bbdf17b5a92a848a552e2be710e756 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/opticalflow.meta b/Shaders/shaders/opticalflow.meta new file mode 100644 index 0000000..01617ca --- /dev/null +++ b/Shaders/shaders/opticalflow.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: aaf36a03a1aeb0e41824564023b1bf38 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_callbacks_hlsl.h b/Shaders/shaders/opticalflow/ffx_opticalflow_callbacks_hlsl.h new file mode 100644 index 0000000..bd1d484 --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_callbacks_hlsl.h @@ -0,0 +1,634 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_OPTICALFLOW_CALLBACKS_HLSL_H +#define FFX_OPTICALFLOW_CALLBACKS_HLSL_H + +#if defined(FFX_GPU) +#ifdef __hlsl_dx_compiler +#pragma dxc diagnostic push +#pragma dxc diagnostic ignored "-Wambig-lit-shift" +#endif //__hlsl_dx_compiler +#include "ffx_core.h" +#ifdef __hlsl_dx_compiler +#pragma dxc diagnostic pop +#endif //__hlsl_dx_compiler + +#define FFX_OPTICALFLOW_USE_MSAD4_INSTRUCTION 1 +#define FFX_OPTICALFLOW_FIX_TOP_LEFT_BIAS 1 +#define FFX_OPTICALFLOW_USE_HEURISTICS 1 +#define FFX_OPTICALFLOW_BLOCK_SIZE 8 +#define FFX_LOCAL_SEARCH_FALLBACK 1 + +// perf optimization for h/w not supporting accelerated msad4() +#if !defined(FFX_PREFER_WAVE64) && defined(FFX_OPTICALFLOW_USE_MSAD4_INSTRUCTION) +#undef FFX_OPTICALFLOW_USE_MSAD4_INSTRUCTION +#endif + +#include "opticalflow/ffx_opticalflow_common.h" + +#ifndef FFX_PREFER_WAVE64 +#define FFX_PREFER_WAVE64 +#endif + + +#pragma warning(disable: 3205) // conversion from larger type to smaller + +#define DECLARE_SRV_REGISTER(regIndex) t##regIndex +#define DECLARE_UAV_REGISTER(regIndex) u##regIndex +#define DECLARE_CB_REGISTER(regIndex) b##regIndex +#define FFX_OPTICALFLOW_DECLARE_SRV(regIndex) register(DECLARE_SRV_REGISTER(regIndex)) +#define FFX_OPTICALFLOW_DECLARE_UAV(regIndex) register(DECLARE_UAV_REGISTER(regIndex)) +#define FFX_OPTICALFLOW_DECLARE_CB(regIndex) register(DECLARE_CB_REGISTER(regIndex)) + +#if defined(FFX_OPTICALFLOW_BIND_CB_COMMON) + cbuffer cbOF : FFX_OPTICALFLOW_DECLARE_CB(FFX_OPTICALFLOW_BIND_CB_COMMON) + { + FfxInt32x2 iInputLumaResolution; + FfxUInt32 uOpticalFlowPyramidLevel; + FfxUInt32 uOpticalFlowPyramidLevelCount; + + FfxUInt32 iFrameIndex; + FfxUInt32 backbufferTransferFunction; + FfxFloat32x2 minMaxLuminance; + }; +#define FFX_OPTICALFLOW_CONSTANT_BUFFER_1_SIZE 8 + +#endif //FFX_OPTICALFLOW_BIND_CB_COMMON + +#if defined(FFX_OPTICALFLOW_BIND_CB_SPD) +cbuffer cbOF_SPD : FFX_OPTICALFLOW_DECLARE_CB(FFX_OPTICALFLOW_BIND_CB_SPD) { + + FfxUInt32 mips; + FfxUInt32 numWorkGroups; + FfxUInt32x2 workGroupOffset; + FfxUInt32 numWorkGroupOpticalFlowInputPyramid; + FfxUInt32 pad0_; + FfxUInt32 pad1_; + FfxUInt32 pad2_; +}; + +FfxUInt32 NumWorkGroups() +{ + return numWorkGroupOpticalFlowInputPyramid; +} +#endif //FFX_OPTICALFLOW_BIND_CB_SPD + +#define FFX_OPTICALFLOW_CONSTANT_BUFFER_2_SIZE 8 + +#define FFX_OPTICALFLOW_DESCRIPTOR_COUNT 32 + +#define FFX_OPTICALFLOW_ROOTSIG_STRINGIFY(p) FFX_OPTICALFLOW_ROOTSIG_STR(p) +#define FFX_OPTICALFLOW_ROOTSIG_STR(p) #p +#define FFX_OPTICALFLOW_ROOTSIG [RootSignature( "DescriptorTable(UAV(u0, numDescriptors = " FFX_OPTICALFLOW_ROOTSIG_STRINGIFY(FFX_OPTICALFLOW_DESCRIPTOR_COUNT) ")), " \ + "DescriptorTable(SRV(t0, numDescriptors = " FFX_OPTICALFLOW_ROOTSIG_STRINGIFY(FFX_OPTICALFLOW_DESCRIPTOR_COUNT) ")), " \ + "CBV(b0), " \ + "StaticSampler(s0, filter = FILTER_MIN_MAG_MIP_POINT, " \ + "addressU = TEXTURE_ADDRESS_CLAMP, " \ + "addressV = TEXTURE_ADDRESS_CLAMP, " \ + "addressW = TEXTURE_ADDRESS_CLAMP, " \ + "comparisonFunc = COMPARISON_NEVER, " \ + "borderColor = STATIC_BORDER_COLOR_TRANSPARENT_BLACK), " \ + "StaticSampler(s1, filter = FILTER_MIN_MAG_MIP_LINEAR, " \ + "addressU = TEXTURE_ADDRESS_CLAMP, " \ + "addressV = TEXTURE_ADDRESS_CLAMP, " \ + "addressW = TEXTURE_ADDRESS_CLAMP, " \ + "comparisonFunc = COMPARISON_NEVER, " \ + "borderColor = STATIC_BORDER_COLOR_TRANSPARENT_BLACK)" )] + +#define FFX_OPTICALFLOW_CB2_ROOTSIG [RootSignature( "DescriptorTable(UAV(u0, numDescriptors = " FFX_OPTICALFLOW_ROOTSIG_STRINGIFY(FFX_OPTICALFLOW_DESCRIPTOR_COUNT) ")), " \ + "DescriptorTable(SRV(t0, numDescriptors = " FFX_OPTICALFLOW_ROOTSIG_STRINGIFY(FFX_OPTICALFLOW_DESCRIPTOR_COUNT) ")), " \ + "CBV(b0), " \ + "StaticSampler(s0, filter = FILTER_MIN_MAG_MIP_POINT, " \ + "addressU = TEXTURE_ADDRESS_CLAMP, " \ + "addressV = TEXTURE_ADDRESS_CLAMP, " \ + "addressW = TEXTURE_ADDRESS_CLAMP, " \ + "comparisonFunc = COMPARISON_NEVER, " \ + "borderColor = STATIC_BORDER_COLOR_TRANSPARENT_BLACK), " \ + "StaticSampler(s1, filter = FILTER_MIN_MAG_MIP_LINEAR, " \ + "addressU = TEXTURE_ADDRESS_CLAMP, " \ + "addressV = TEXTURE_ADDRESS_CLAMP, " \ + "addressW = TEXTURE_ADDRESS_CLAMP, " \ + "comparisonFunc = COMPARISON_NEVER, " \ + "borderColor = STATIC_BORDER_COLOR_TRANSPARENT_BLACK)" )] +#if defined(FFX_OPTICALFLOW_EMBED_ROOTSIG) +#define FFX_OPTICALFLOW_EMBED_ROOTSIG_CONTENT FFX_OPTICALFLOW_ROOTSIG +#define FFX_OPTICALFLOW_EMBED_CB2_ROOTSIG_CONTENT FFX_OPTICALFLOW_CB2_ROOTSIG +#else +#define FFX_OPTICALFLOW_EMBED_ROOTSIG_CONTENT +#define FFX_OPTICALFLOW_EMBED_CB2_ROOTSIG_CONTENT +#endif // #if FFX_OPTICALFLOW_EMBED_ROOTSIG + +FfxInt32x2 DisplaySize() +{ + return iInputLumaResolution; +} + +FfxUInt32 FrameIndex() +{ + return iFrameIndex; +} + +FfxUInt32 BackbufferTransferFunction() +{ + return backbufferTransferFunction; +} + +FfxFloat32x2 MinMaxLuminance() +{ + return minMaxLuminance; +} + +FfxBoolean CrossedSceneChangeThreshold(FfxFloat32 sceneChangeValue) +{ + return sceneChangeValue > 0.45f; +} + +FfxUInt32 OpticalFlowPyramidLevel() +{ + return uOpticalFlowPyramidLevel; +} + +FfxUInt32 OpticalFlowPyramidLevelCount() +{ + return uOpticalFlowPyramidLevelCount; +} + +FfxInt32x2 OpticalFlowHistogramMaxVelocity() +{ + const FfxInt32 searchRadius = 8; + FfxInt32 scale = FfxInt32(1) << (OpticalFlowPyramidLevelCount() - 1 - OpticalFlowPyramidLevel()); + FfxInt32 maxVelocity = searchRadius * scale; + return FfxInt32x2(maxVelocity, maxVelocity); +} + + #if defined FFX_OPTICALFLOW_BIND_SRV_INPUT_COLOR + Texture2D r_input_color : FFX_OPTICALFLOW_DECLARE_SRV(FFX_OPTICALFLOW_BIND_SRV_INPUT_COLOR); + #endif + #if defined FFX_OPTICALFLOW_BIND_SRV_INPUT_MOTION_VECTORS + Texture2D r_input_motion_vectors : FFX_OPTICALFLOW_DECLARE_SRV(FFX_OPTICALFLOW_BIND_SRV_INPUT_MOTION_VECTORS); + #endif + #if defined FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_INPUT + Texture2D r_optical_flow_input : FFX_OPTICALFLOW_DECLARE_SRV(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_INPUT); + #endif + #if defined FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_PREVIOUS_INPUT + Texture2D r_optical_flow_previous_input : FFX_OPTICALFLOW_DECLARE_SRV(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_PREVIOUS_INPUT); + #endif + #if defined FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW + Texture2D r_optical_flow : FFX_OPTICALFLOW_DECLARE_SRV(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW); + #endif + #if defined FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_PREVIOUS + Texture2D r_optical_flow_previous : FFX_OPTICALFLOW_DECLARE_SRV(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_PREVIOUS); + #endif + #if defined FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_ADDITIONAL_INFO + Texture2D r_optical_flow_additional_info : FFX_OPTICALFLOW_DECLARE_SRV(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_ADDITIONAL_INFO); + #endif + #if defined FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_ADDITIONAL_INFO_PREVIOUS + Texture2D r_optical_flow_additional_info_previous : FFX_OPTICALFLOW_DECLARE_SRV(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_ADDITIONAL_INFO_PREVIOUS); + #endif + #if defined FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_HISTOGRAM + Texture2D r_optical_flow_histogram : FFX_OPTICALFLOW_DECLARE_SRV(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_HISTOGRAM); + #endif + #if defined FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH + Texture2D r_optical_flow_global_motion_search : FFX_OPTICALFLOW_DECLARE_SRV(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH); + #endif + + // UAV declarations + #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT + RWTexture2D rw_optical_flow_input : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT); + #endif + #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_1 + globallycoherent RWTexture2D rw_optical_flow_input_level_1 : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_1); + #endif + #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_2 + globallycoherent RWTexture2D rw_optical_flow_input_level_2 : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_2); + #endif + #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_3 + globallycoherent RWTexture2D rw_optical_flow_input_level_3 : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_3); + #endif + #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_4 + globallycoherent RWTexture2D rw_optical_flow_input_level_4 : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_4); + #endif + #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_5 + globallycoherent RWTexture2D rw_optical_flow_input_level_5 : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_5); + #endif + #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_6 + globallycoherent RWTexture2D rw_optical_flow_input_level_6 : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_6); + #endif + #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW + RWTexture2D rw_optical_flow : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW); + #endif + #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_NEXT_LEVEL + RWTexture2D rw_optical_flow_next_level : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_NEXT_LEVEL); + #endif + #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_ADDITIONAL_INFO + RWTexture2D rw_optical_flow_additional_info : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_ADDITIONAL_INFO); + #endif + #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_ADDITIONAL_INFO_NEXT_LEVEL + RWTexture2D rw_optical_flow_additional_info_next_level : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_ADDITIONAL_INFO_NEXT_LEVEL); + #endif + #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_HISTOGRAM + RWTexture2D rw_optical_flow_histogram : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_HISTOGRAM); + #endif + #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH + globallycoherent RWTexture2D rw_optical_flow_global_motion_search: FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH); + #endif + #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_HISTOGRAM + RWTexture2D rw_optical_flow_scd_histogram : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_HISTOGRAM); + #endif + #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_PREVIOUS_HISTOGRAM + RWTexture2D rw_optical_flow_scd_previous_histogram : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_PREVIOUS_HISTOGRAM); + #endif + #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_TEMP + RWTexture2D rw_optical_flow_scd_temp : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_TEMP); + #endif + #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_OUTPUT + RWTexture2D rw_optical_flow_scd_output : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_OUTPUT); + #endif + +#if defined(FFX_OPTICALFLOW_BIND_SRV_INPUT_COLOR) +FfxFloat32x4 LoadInputColor(FfxUInt32x2 iPxHistory) +{ + return r_input_color[iPxHistory]; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_SRV_INPUT_MOTION_VECTORS) +FfxFloat32x2 LoadGameMotionVector(FfxInt32x2 iPxPos) +{ + FfxFloat32x2 positionScale = FfxFloat32x2(RenderSize()) / DisplaySize(); + return r_input_motion_vectors[iPxPos * positionScale] * motionVectorScale / positionScale; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT) +void StoreOpticalFlowInput(FfxInt32x2 iPxPos, FfxUInt32 fLuma) +{ + rw_optical_flow_input[iPxPos] = fLuma; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_INPUT) +FfxUInt32 LoadOpticalFlowInput(FfxInt32x2 iPxPos) +{ +#if FFX_OPTICALFLOW_USE_MSAD4_INSTRUCTION == 1 + return max(1, r_optical_flow_input[iPxPos]); +#else + return r_optical_flow_input[iPxPos]; +#endif +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT) +FfxUInt32 LoadRwOpticalFlowInput(FfxInt32x2 iPxPos) +{ + return rw_optical_flow_input[iPxPos]; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_PREVIOUS_INPUT) +FfxUInt32 LoadOpticalFlowPreviousInput(FfxInt32x2 iPxPos) +{ +#if FFX_OPTICALFLOW_USE_MSAD4_INSTRUCTION == 1 + return max(1, r_optical_flow_previous_input[iPxPos]); +#else + return r_optical_flow_previous_input[iPxPos]; +#endif +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW) +FfxInt32x2 LoadOpticalFlow(FfxInt32x2 iPxPos) +{ + return r_optical_flow[iPxPos]; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW) +FfxInt32x2 LoadRwOpticalFlow(FfxInt32x2 iPxPos) +{ + return rw_optical_flow[iPxPos]; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_PREVIOUS) +FfxInt32x2 LoadPreviousOpticalFlow(FfxInt32x2 iPxPos) +{ + return r_optical_flow_previous[iPxPos]; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW) +void StoreOpticalFlow(FfxInt32x2 iPxPos, FfxInt32x2 motionVector) +{ + rw_optical_flow[iPxPos] = motionVector; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_NEXT_LEVEL) +void StoreOpticalFlowNextLevel(FfxInt32x2 iPxPos, FfxInt32x2 motionVector) +{ + rw_optical_flow_next_level[iPxPos] = motionVector; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_ADDITIONAL_INFO) +FfxUInt32x2 LoadOpticalFlowAdditionalInfo(FfxInt32x2 iPxPos) +{ + return r_optical_flow_additional_info[iPxPos]; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_ADDITIONAL_INFO) +FfxUInt32x2 LoadRwOpticalFlowAdditionalInfo(FfxInt32x2 iPxPos) +{ + return rw_optical_flow_additional_info[iPxPos]; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_ADDITIONAL_INFO_PREVIOUS) +FfxUInt32x2 LoadPreviousOpticalFlowAdditionalInfo(FfxInt32x2 iPxPos) +{ + return r_optical_flow_additional_info_previous[iPxPos]; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_ADDITIONAL_INFO) +void StoreOpticalFlowAdditionalInfo(FfxInt32x2 iPxPos, FfxUInt32x2 additionalInfo) +{ + rw_optical_flow_additional_info[iPxPos] = additionalInfo; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_ADDITIONAL_INFO_NEXT_LEVEL) +void StoreOpticalFlowNextLevelAdditionalInfo(FfxInt32x2 iPxPos, FfxUInt32x2 additionalInfo) +{ + rw_optical_flow_additional_info_next_level[iPxPos] = additionalInfo; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_HISTOGRAM) +FfxUInt32 LoadOpticalFlowHistogram(FfxInt32x2 iBucketId) +{ + return r_optical_flow_histogram[iBucketId]; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_HISTOGRAM) +void AtomicIncrementOpticalFlowHistogram(FfxInt32x2 iBucketId) +{ + InterlockedAdd(rw_optical_flow_histogram[iBucketId], 1); +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH) +FfxInt32x2 LoadGlobalMotionVector() +{ + FfxInt32 vx = FfxInt32(r_optical_flow_global_motion_search[FfxInt32x2(0, 0)]); + FfxInt32 vy = FfxInt32(r_optical_flow_global_motion_search[FfxInt32x2(1, 0)]); + return FfxInt32x2(vx, vy); +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH) +FfxInt32x2 LoadRwGlobalMotionVector() +{ + FfxInt32 vx = FfxInt32(rw_optical_flow_global_motion_search[FfxInt32x2(0, 0)]); + FfxInt32 vy = FfxInt32(rw_optical_flow_global_motion_search[FfxInt32x2(1, 0)]); + return FfxInt32x2(vx, vy); +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH) +FfxUInt32 LoadGlobalMotionValue(FfxInt32 index) +{ + return rw_optical_flow_global_motion_search[FfxInt32x2(index, 0)]; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH) +void StoreGlobalMotionValue(FfxInt32 index, FfxUInt32 value) +{ + rw_optical_flow_global_motion_search[FfxInt32x2(index, 0)] = value; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH) +FfxUInt32 AtomicIncrementGlobalMotionValue(FfxInt32 index) +{ + FfxUInt32 initialValue; + InterlockedAdd(rw_optical_flow_global_motion_search[FfxInt32x2(index, 0)], 1, initialValue); + return initialValue; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_HISTOGRAM) +FfxUInt32 LoadRwSCDHistogram(FfxInt32 iIndex) +{ + return rw_optical_flow_scd_histogram[FfxInt32x2(iIndex, 0)]; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_HISTOGRAM) +void StoreSCDHistogram(FfxInt32 iIndex, FfxUInt32 value) +{ + rw_optical_flow_scd_histogram[FfxInt32x2(iIndex, 0)] = value; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_HISTOGRAM) +void AtomicIncrementSCDHistogram(FfxInt32 iIndex, FfxUInt32 valueToAdd) +{ + InterlockedAdd(rw_optical_flow_scd_histogram[FfxInt32x2(iIndex, 0)], valueToAdd); +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_PREVIOUS_HISTOGRAM) +FfxFloat32 LoadRwSCDPreviousHistogram(FfxInt32 iIndex) +{ + return rw_optical_flow_scd_previous_histogram[FfxInt32x2(iIndex, 0)]; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_PREVIOUS_HISTOGRAM) +void StoreSCDPreviousHistogram(FfxInt32 iIndex, FfxFloat32 value) +{ + rw_optical_flow_scd_previous_histogram[FfxInt32x2(iIndex, 0)] = value; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_TEMP) +FfxUInt32 LoadRwSCDTemp(FfxInt32 iIndex) +{ + return rw_optical_flow_scd_temp[FfxInt32x2(iIndex, 0)]; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_TEMP) +void AtomicIncrementSCDTemp(FfxInt32 iIndex, FfxUInt32 valueToAdd) +{ + InterlockedAdd(rw_optical_flow_scd_temp[FfxInt32x2(iIndex, 0)], valueToAdd); +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_TEMP) +void ResetSCDTemp() +{ + rw_optical_flow_scd_temp[FfxInt32x2(0, 0)] = 0; + rw_optical_flow_scd_temp[FfxInt32x2(1, 0)] = 0; + rw_optical_flow_scd_temp[FfxInt32x2(2, 0)] = 0; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_OUTPUT) +FfxUInt32 LoadRwSCDOutput(FfxInt32 iIndex) +{ + return rw_optical_flow_scd_output[FfxInt32x2(iIndex, 0)]; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_OUTPUT) +void StoreSCDOutput(FfxInt32 iIndex, FfxUInt32 value) +{ + rw_optical_flow_scd_output[FfxInt32x2(iIndex, 0)] = value; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_OUTPUT) +FfxUInt32 AtomicIncrementSCDOutput(FfxInt32 iIndex, FfxUInt32 valueToAdd) +{ + FfxUInt32 initialValue; + InterlockedAdd(rw_optical_flow_scd_output[FfxInt32x2(iIndex, 0)], valueToAdd, initialValue); + return initialValue; +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_DEBUG_VISUALIZATION) +void StoreDebugVisualization(FfxUInt32x2 iPxPos, FfxFloat32x3 fColor) +{ + rw_debug_visualization[iPxPos] = FfxFloat32x4(fColor, 1.f); +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_OUTPUT) +FfxFloat32 GetSceneChangeValue() +{ + if (FrameIndex() <= 5) + return 1.0; + else + return ffxAsFloat(LoadRwSCDOutput(SCD_OUTPUT_SCENE_CHANGE_SLOT)); +} + +FfxBoolean IsSceneChanged() +{ + if (FrameIndex() <= 5) + { + return 1.0; + } + else + { + return (LoadRwSCDOutput(SCD_OUTPUT_HISTORY_BITS_SLOT) & 0xfu) != 0; + } +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_INPUT) +FfxUInt32 LoadFirstImagePackedLuma(FfxInt32x2 iPxPos) +{ + const FfxInt32 lumaTextureWidth = DisplaySize().x >> OpticalFlowPyramidLevel(); + const FfxInt32 lumaTextureHeight = DisplaySize().y >> OpticalFlowPyramidLevel(); + + FfxInt32x2 adjustedPos = FfxInt32x2( + ffxClamp(iPxPos.x, 0, lumaTextureWidth - 4), + ffxClamp(iPxPos.y, 0, lumaTextureHeight - 1) + ); + + FfxUInt32 luma0 = LoadOpticalFlowInput(adjustedPos + FfxInt32x2(0, 0)); + FfxUInt32 luma1 = LoadOpticalFlowInput(adjustedPos + FfxInt32x2(1, 0)); + FfxUInt32 luma2 = LoadOpticalFlowInput(adjustedPos + FfxInt32x2(2, 0)); + FfxUInt32 luma3 = LoadOpticalFlowInput(adjustedPos + FfxInt32x2(3, 0)); + + return GetPackedLuma(lumaTextureWidth, iPxPos.x, luma0, luma1, luma2, luma3); +} +#endif + +#if defined(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_PREVIOUS_INPUT) +FfxUInt32 LoadSecondImagePackedLuma(FfxInt32x2 iPxPos) +{ + const FfxInt32 lumaTextureWidth = DisplaySize().x >> OpticalFlowPyramidLevel(); + const FfxInt32 lumaTextureHeight = DisplaySize().y >> OpticalFlowPyramidLevel(); + + FfxInt32x2 adjustedPos = FfxInt32x2( + ffxClamp(iPxPos.x, 0, lumaTextureWidth - 4), + ffxClamp(iPxPos.y, 0, lumaTextureHeight - 1) + ); + + FfxUInt32 luma0 = LoadOpticalFlowPreviousInput(adjustedPos + FfxInt32x2(0, 0)); + FfxUInt32 luma1 = LoadOpticalFlowPreviousInput(adjustedPos + FfxInt32x2(1, 0)); + FfxUInt32 luma2 = LoadOpticalFlowPreviousInput(adjustedPos + FfxInt32x2(2, 0)); + FfxUInt32 luma3 = LoadOpticalFlowPreviousInput(adjustedPos + FfxInt32x2(3, 0)); + + return GetPackedLuma(lumaTextureWidth, iPxPos.x, luma0, luma1, luma2, luma3); +} +#endif + + +void SPD_SetMipmap(int2 iPxPos, int index, float value) +{ + switch (index) + { + case 0: +#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_1 + rw_optical_flow_input_level_1[iPxPos] = value; +#endif // #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_1 + break; + case 1: +#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_2 + rw_optical_flow_input_level_2[iPxPos] = value; +#endif // #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_2 + break; + case 2: +#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_3 + rw_optical_flow_input_level_3[iPxPos] = value; +#endif // #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_3 + break; + case 3: +#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_4 + rw_optical_flow_input_level_4[iPxPos] = value; +#endif // #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_4 + break; + case 4: +#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_5 + rw_optical_flow_input_level_5[iPxPos] = value; +#endif // #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_5 + break; + case 5: +#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_6 + rw_optical_flow_input_level_6[iPxPos] = value; +#endif // #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_6 + break; + } +} + +#endif // #if defined(FFX_GPU) + +#endif // FFX_OPTICALFLOW_CALLBACKS_HLSL_H diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_callbacks_hlsl.h.meta b/Shaders/shaders/opticalflow/ffx_opticalflow_callbacks_hlsl.h.meta new file mode 100644 index 0000000..61367be --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_callbacks_hlsl.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: 0a41d30eeb0591642bf99639bfd5d9ec +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_common.h b/Shaders/shaders/opticalflow/ffx_opticalflow_common.h new file mode 100644 index 0000000..907e7ac --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_common.h @@ -0,0 +1,99 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#if !defined(FFX_OPTICALFLOW_COMMON_H) +#define FFX_OPTICALFLOW_COMMON_H + +#if defined(FFX_GPU) + +#define SCD_OUTPUT_SCENE_CHANGE_SLOT 0 +#define SCD_OUTPUT_HISTORY_BITS_SLOT 1 +#define SCD_OUTPUT_COMPLETED_WORKGROUPS_SLOT 2 + + +#define ffxClamp(x, a, b) (ffxMax(a, ffxMin(b, x))) + + +FfxUInt32 GetPackedLuma(FfxInt32 width, FfxInt32 x, FfxUInt32 luma0, FfxUInt32 luma1, FfxUInt32 luma2, FfxUInt32 luma3) +{ + FfxUInt32 packedLuma = luma0 | (luma1 << 8) | (luma2 << 16) | (luma3 << 24); + + if (x < 0) + { + FfxUInt32 outOfScreenFiller = packedLuma & 0xffu; + if (x <= -1) + packedLuma = (packedLuma << 8) | outOfScreenFiller; + if (x <= -2) + packedLuma = (packedLuma << 8) | outOfScreenFiller; + if (x <= -3) + packedLuma = (packedLuma << 8) | outOfScreenFiller; + } + else if (x > width - 4) + { + FfxUInt32 outOfScreenFiller = packedLuma & 0xff000000u; + if (x >= width - 3) + packedLuma = (packedLuma >> 8) | outOfScreenFiller; + if (x >= width - 2) + packedLuma = (packedLuma >> 8) | outOfScreenFiller; + if (x >= width - 1) + packedLuma = (packedLuma >> 8) | outOfScreenFiller; + } + return packedLuma; +} + +FfxUInt32 Sad(FfxUInt32 a, FfxUInt32 b) +{ +#if FFX_OPTICALFLOW_USE_MSAD4_INSTRUCTION == 1 + return msad4(a, FfxUInt32x2(b, 0), FfxUInt32x4(0, 0, 0, 0)).x; +#else + return abs(FfxInt32((a >> 0) & 0xffu) - FfxInt32((b >> 0) & 0xffu)) + + abs(FfxInt32((a >> 8) & 0xffu) - FfxInt32((b >> 8) & 0xffu)) + + abs(FfxInt32((a >> 16) & 0xffu) - FfxInt32((b >> 16) & 0xffu)) + + abs(FfxInt32((a >> 24) & 0xffu) - FfxInt32((b >> 24) & 0xffu)); +#endif +} + +FfxUInt32x4 QSad(FfxUInt32 a0, FfxUInt32 a1, FfxUInt32 b) +{ +#if FFX_OPTICALFLOW_USE_MSAD4_INSTRUCTION == 1 + return msad4(b, FfxUInt32x2(a0, a1), FfxUInt32x4(0, 0, 0, 0)); +#else + FfxUInt32x4 sad; + sad.x = Sad(a0, b); + + a0 = (a0 >> 8) | ((a1 & 0xffu) << 24); + a1 >>= 8; + sad.y = Sad(a0, b); + + a0 = (a0 >> 8) | ((a1 & 0xffu) << 24); + a1 >>= 8; + sad.z = Sad(a0, b); + + a0 = (a0 >> 8) | ((a1 & 0xffu) << 24); + sad.w = Sad(a0, b); + return sad; +#endif +} + +#endif // #if defined(FFX_GPU) + +#endif //!defined(FFX_OPTICALFLOW_COMMON_H) diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_common.h.meta b/Shaders/shaders/opticalflow/ffx_opticalflow_common.h.meta new file mode 100644 index 0000000..3fce8a6 --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_common.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: 615cf613a2a57034ba6c11f20a092fd0 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_compute_luminance_pyramid.h b/Shaders/shaders/opticalflow/ffx_opticalflow_compute_luminance_pyramid.h new file mode 100644 index 0000000..b83710c --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_compute_luminance_pyramid.h @@ -0,0 +1,107 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_OPTICALFLOW_COMPUTE_LUMINANCE_PYRAMID_H +#define FFX_OPTICALFLOW_COMPUTE_LUMINANCE_PYRAMID_H + +FFX_GROUPSHARED FfxFloat32 spdIntermediateR[16][16]; +FFX_GROUPSHARED FfxFloat32 spdIntermediateG[16][16]; +FFX_GROUPSHARED FfxFloat32 spdIntermediateB[16][16]; +FFX_GROUPSHARED FfxFloat32 spdIntermediateA[16][16]; + +void SPD_IncreaseAtomicCounter(inout FfxUInt32 spdCounter) +{ +} + +void SPD_ResetAtomicCounter() +{ +} + +FfxFloat32x4 SpdLoadSourceImage(FfxFloat32x2 tex, FfxUInt32 slice) +{ + FfxFloat32 luma = LoadRwOpticalFlowInput(FfxInt32x2(tex)); + return FfxFloat32x4(luma, 0, 0, 0); +} + +FfxFloat32x4 SpdLoad(FfxInt32x2 tex, FfxUInt32 slice) +{ + return FfxFloat32x4(0, 0, 0, 0); +} + +void SpdStore(FfxInt32x2 pix, FfxFloat32x4 outValue, FfxUInt32 index, FfxUInt32 slice) +{ + SPD_SetMipmap(pix, index, outValue.r); +} + +void SpdIncreaseAtomicCounter(FfxUInt32 slice) +{ +} + +FfxUInt32 SpdGetAtomicCounter() +{ + return 0; +} + +void SpdResetAtomicCounter(FfxUInt32 slice) +{ + SPD_ResetAtomicCounter(); +} + +FfxFloat32x4 SpdLoadIntermediate(FfxUInt32 x, FfxUInt32 y) +{ + return FfxFloat32x4( + spdIntermediateR[x][y], + spdIntermediateG[x][y], + spdIntermediateB[x][y], + spdIntermediateA[x][y]); +} +void SpdStoreIntermediate(FfxUInt32 x, FfxUInt32 y, FfxFloat32x4 value) +{ + spdIntermediateR[x][y] = value.x; + spdIntermediateG[x][y] = value.y; + spdIntermediateB[x][y] = value.z; + spdIntermediateA[x][y] = value.w; +} +FfxFloat32x4 SpdReduce4(FfxFloat32x4 v0, FfxFloat32x4 v1, FfxFloat32x4 v2, FfxFloat32x4 v3) +{ + return (v0 + v1 + v2 + v3) * 0.25; +} + +#ifdef FFX_HALF +#undef FFX_HALF +#endif + +// https://github.com/GPUOpen-Effects/FidelityFX-SPD/blob/master/docs/FidelityFX_SPD.pdf +#include "spd/ffx_spd.h" + +void ComputeOpticalFlowInputPyramid(FfxInt32x2 iGroupId, FfxInt32 iLocalIndex) +{ + SpdDownsample( + FfxUInt32x2(iGroupId.xy), + FfxUInt32(iLocalIndex), + 6, // mip levels to generate + FfxUInt32(NumWorkGroups()), + 1 // single slice + ); +} + +#endif // FFX_OPTICALFLOW_COMPUTE_LUMINANCE_PYRAMID_H diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_compute_luminance_pyramid.h.meta b/Shaders/shaders/opticalflow/ffx_opticalflow_compute_luminance_pyramid.h.meta new file mode 100644 index 0000000..ace4862 --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_compute_luminance_pyramid.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: 432b61ec0a1a27147bd8ced835676678 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_compute_optical_flow_v5.h b/Shaders/shaders/opticalflow/ffx_opticalflow_compute_optical_flow_v5.h new file mode 100644 index 0000000..9c1b522 --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_compute_optical_flow_v5.h @@ -0,0 +1,279 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_OPTICALFLOW_COMPUTE_OPTICAL_FLOW_V5_H +#define FFX_OPTICALFLOW_COMPUTE_OPTICAL_FLOW_V5_H + +#define CompareSize (4 * 2) +#define BlockSizeY 8 +#define BlockSizeX 8 +#define ThreadCount (4 * 16) +#define SearchRadiusX (8) +#define SearchRadiusY (8) +#define BlockCount 2 + +#define SearchBufferSizeX ((CompareSize + SearchRadiusX*2)/4) +#define SearchBufferSizeY (CompareSize + SearchRadiusY*2) + +FFX_GROUPSHARED FfxUInt32 pixels[CompareSize][CompareSize / 4]; +FFX_GROUPSHARED FfxUInt32 searchBuffer[1][SearchBufferSizeY * SearchBufferSizeX]; +#define bankBreaker 1 +FFX_GROUPSHARED FfxUInt32 sadMapBuffer[4][SearchRadiusY * 2][(SearchRadiusX * 2) / 4 + bankBreaker]; + +#define MaxWaves 2 +FFX_GROUPSHARED FfxUInt32 sWaveSad[MaxWaves]; +FFX_GROUPSHARED FfxUInt32 sWaveMin[MaxWaves]; + +FfxUInt32 BlockSad64(FfxUInt32 blockSadSum, FfxInt32 iLocalIndex, FfxInt32 iLaneToBlockId, FfxInt32 block) +{ + if (iLaneToBlockId != block) + { + blockSadSum = 0u; + } + blockSadSum = ffxWaveSum(blockSadSum); + + if (ffxWaveLaneCount() == 32) + { + FfxInt32 waveId = iLocalIndex >> 5u; + if (ffxWaveIsFirstLane()) + { + sWaveSad[waveId] = blockSadSum; + } + FFX_GROUP_MEMORY_BARRIER; + blockSadSum += sWaveSad[waveId ^ 1]; + } + + return blockSadSum; +} + +FfxUInt32 SadMapMinReduction256(FfxInt32x2 iSearchId, FfxInt32 iLocalIndex) +{ + FfxUInt32 min01 = ffxMin(sadMapBuffer[0][iSearchId.y][iSearchId.x], sadMapBuffer[1][iSearchId.y][iSearchId.x]); + FfxUInt32 min23 = ffxMin(sadMapBuffer[2][iSearchId.y][iSearchId.x], sadMapBuffer[3][iSearchId.y][iSearchId.x]); + FfxUInt32 min0123 = ffxMin(min01, min23); + min0123 = ffxWaveMin(min0123); + + if (ffxWaveLaneCount() == 32) + { + FfxInt32 waveId = iLocalIndex >> 5u; + + if (ffxWaveIsFirstLane()) + { + sWaveMin[waveId] = min0123; + } + FFX_GROUP_MEMORY_BARRIER; + min0123 = ffxMin(min0123, sWaveMin[waveId ^ 1]); + } + + return min0123; +} + +void LoadSearchBuffer(FfxInt32 iLocalIndex, FfxInt32x2 iPxPosShifted) +{ + FfxInt32 baseX = (iPxPosShifted.x - SearchRadiusX); + FfxInt32 baseY = (iPxPosShifted.y - SearchRadiusY); + + for (FfxInt32 id = iLocalIndex; id < SearchBufferSizeX * SearchBufferSizeY; id += ThreadCount) + { + FfxInt32 idx = id % SearchBufferSizeX; + FfxInt32 idy = id / SearchBufferSizeX; + FfxInt32 x = baseX + idx * 4; + FfxInt32 y = baseY + idy; + searchBuffer[0][id] = LoadSecondImagePackedLuma(FfxInt32x2(x, y)); + } + FFX_GROUP_MEMORY_BARRIER; +} + +FfxUInt32x4 CalculateQSads2(FfxInt32x2 iSearchId) +{ + FfxUInt32x4 sad = ffxBroadcast4(0u); + +#if FFX_OPTICALFLOW_USE_MSAD4_INSTRUCTION == 1 + + FfxInt32 idx = iSearchId.y * 6 + iSearchId.x; + + sad = msad4(pixels[0][0], FfxUInt32x2(searchBuffer[0][idx], searchBuffer[0][idx + 1]), sad); + sad = msad4(pixels[0][1], FfxUInt32x2(searchBuffer[0][idx + 1], searchBuffer[0][idx + 2]), sad); + idx += 6; + sad = msad4(pixels[1][0], FfxUInt32x2(searchBuffer[0][idx], searchBuffer[0][idx + 1]), sad); + sad = msad4(pixels[1][1], FfxUInt32x2(searchBuffer[0][idx + 1], searchBuffer[0][idx + 2]), sad); + idx += 6; + sad = msad4(pixels[2][0], FfxUInt32x2(searchBuffer[0][idx], searchBuffer[0][idx + 1]), sad); + sad = msad4(pixels[2][1], FfxUInt32x2(searchBuffer[0][idx + 1], searchBuffer[0][idx + 2]), sad); + idx += 6; + sad = msad4(pixels[3][0], FfxUInt32x2(searchBuffer[0][idx], searchBuffer[0][idx + 1]), sad); + sad = msad4(pixels[3][1], FfxUInt32x2(searchBuffer[0][idx + 1], searchBuffer[0][idx + 2]), sad); + idx += 6; + sad = msad4(pixels[4][0], FfxUInt32x2(searchBuffer[0][idx], searchBuffer[0][idx + 1]), sad); + sad = msad4(pixels[4][1], FfxUInt32x2(searchBuffer[0][idx + 1], searchBuffer[0][idx + 2]), sad); + idx += 6; + sad = msad4(pixels[5][0], FfxUInt32x2(searchBuffer[0][idx], searchBuffer[0][idx + 1]), sad); + sad = msad4(pixels[5][1], FfxUInt32x2(searchBuffer[0][idx + 1], searchBuffer[0][idx + 2]), sad); + idx += 6; + sad = msad4(pixels[6][0], FfxUInt32x2(searchBuffer[0][idx], searchBuffer[0][idx + 1]), sad); + sad = msad4(pixels[6][1], FfxUInt32x2(searchBuffer[0][idx + 1], searchBuffer[0][idx + 2]), sad); + idx += 6; + sad = msad4(pixels[7][0], FfxUInt32x2(searchBuffer[0][idx], searchBuffer[0][idx + 1]), sad); + sad = msad4(pixels[7][1], FfxUInt32x2(searchBuffer[0][idx + 1], searchBuffer[0][idx + 2]), sad); + +#else + for (FfxInt32 dy = 0; dy < CompareSize; dy++) + { + FfxInt32 rowOffset = (iSearchId.y + dy) * SearchBufferSizeX; + FfxUInt32 a0 = searchBuffer[0][rowOffset + iSearchId.x]; + FfxUInt32 a1 = searchBuffer[0][rowOffset + iSearchId.x + 1]; + FfxUInt32 a2 = searchBuffer[0][rowOffset + iSearchId.x + 2]; + sad += QSad(a0, a1, pixels[dy][0]); + sad += QSad(a1, a2, pixels[dy][1]); + } +#endif + + return sad; +} + +FfxUInt32x2 abs_2(FfxInt32x2 val) +{ + FfxInt32x2 tmp = val; + FfxInt32x2 mask = tmp >> 31; + FfxUInt32x2 res = (tmp + mask) ^ mask; + return res; +} + +FfxUInt32 EncodeSearchCoord(FfxInt32x2 coord) +{ +#if FFX_OPTICALFLOW_FIX_TOP_LEFT_BIAS == 1 + FfxUInt32x2 absCoord = FfxUInt32x2(abs_2(coord - 8)); + return FfxUInt32(absCoord.y << 12) | FfxUInt32(absCoord.x << 8) | FfxUInt32(coord.y << 4) | FfxUInt32(coord.x); +#else //FFX_OPTICALFLOW_FIX_TOP_LEFT_BIAS == 1 + return FfxUInt32(coord.y << 8) | FfxUInt32(coord.x); +#endif //FFX_OPTICALFLOW_FIX_TOP_LEFT_BIAS == 1 +} + +FfxInt32x2 DecodeSearchCoord(FfxUInt32 bits) +{ +#if FFX_OPTICALFLOW_FIX_TOP_LEFT_BIAS == 1 + FfxInt32 dx = FfxInt32(bits & 0xfu) - SearchRadiusX; + FfxInt32 dy = FfxInt32((bits >> 4) & 0xfu) - SearchRadiusY; + + return FfxInt32x2(dx, dy); +#else + FfxInt32 dx = FfxInt32(bits & 0xffu) - SearchRadiusX; + FfxInt32 dy = FfxInt32((bits >> 8) & 0xffu) - SearchRadiusY; + + return FfxInt32x2(dx, dy); +#endif +} + +void PrepareSadMap(FfxInt32x2 iSearchId, FfxUInt32x4 qsad) +{ + sadMapBuffer[0][iSearchId.y][iSearchId.x] = (qsad.x << 16) | EncodeSearchCoord(FfxInt32x2(iSearchId.x * 4 + 0, iSearchId.y)); + sadMapBuffer[1][iSearchId.y][iSearchId.x] = (qsad.y << 16) | EncodeSearchCoord(FfxInt32x2(iSearchId.x * 4 + 1, iSearchId.y)); + sadMapBuffer[2][iSearchId.y][iSearchId.x] = (qsad.z << 16) | EncodeSearchCoord(FfxInt32x2(iSearchId.x * 4 + 2, iSearchId.y)); + sadMapBuffer[3][iSearchId.y][iSearchId.x] = (qsad.w << 16) | EncodeSearchCoord(FfxInt32x2(iSearchId.x * 4 + 3, iSearchId.y)); + FFX_GROUP_MEMORY_BARRIER; +} + + +uint ABfe(uint src, uint off, uint bits) { uint mask = (1u << bits) - 1u; return (src >> off) & mask; } +uint ABfi(uint src, uint ins, uint mask) { return (ins & mask) | (src & (~mask)); } +uint ABfiM(uint src, uint ins, uint bits) { uint mask = (1u << bits) - 1u; return (ins & mask) | (src & (~mask)); } +void MapThreads(in FfxInt32x2 iGroupId, in FfxInt32 iLocalIndex, + out FfxInt32x2 iSearchId, out FfxInt32x2 iPxPos, out FfxInt32 iLaneToBlockId) +{ + iSearchId = FfxInt32x2(ABfe(iLocalIndex, 0u, 2u), ABfe(iLocalIndex, 2u, 4u)); + iLaneToBlockId = FfxInt32(ABfe(iLocalIndex, 1u, 1u) | (ABfe(iLocalIndex, 5u, 1u) << 1u)); + iPxPos = (iGroupId << 4u) + iSearchId * FfxInt32x2(4, 1); +} + +void ComputeOpticalFlowAdvanced(FfxInt32x2 iGlobalId, FfxInt32x2 iLocalId, FfxInt32x2 iGroupId, FfxInt32 iLocalIndex) +{ + FfxInt32x2 iSearchId; + FfxInt32x2 iPxPos; + FfxInt32 iLaneToBlockId; + MapThreads(iGroupId, iLocalIndex, iSearchId, iPxPos, iLaneToBlockId); + + FfxInt32x2 currentOFPos = iPxPos >> 3u; + + if (IsSceneChanged()) + { + if ((iSearchId.y & 0x7) == 0 && (iSearchId.x & 0x1) == 0) + { + StoreOpticalFlow(currentOFPos, FfxInt32x2(0, 0)); + } + + return; + } + + const FfxBoolean bUsePredictionFromPreviousLevel = (OpticalFlowPyramidLevel() != OpticalFlowPyramidLevelCount() - 1); + + FfxUInt32 packedLuma_4blocks = LoadFirstImagePackedLuma(iPxPos); + +#if FFX_LOCAL_SEARCH_FALLBACK == 1 + FfxUInt32 prevPackedLuma_4blocks = LoadSecondImagePackedLuma(iPxPos); + FfxUInt32 sad_4blocks = Sad(packedLuma_4blocks, prevPackedLuma_4blocks); +#endif //FFX_LOCAL_SEARCH_FALLBACK + + FfxInt32x2 ofGroupOffset = iGroupId << 1u; + FfxInt32x2 pixelGroupOffset = iGroupId << 4u; + + FfxInt32x2 blockId; + for (blockId.y = 0; blockId.y < BlockCount; blockId.y++) + { + for (blockId.x = 0; blockId.x < BlockCount; blockId.x++) + { + FfxInt32x2 currentVector = LoadRwOpticalFlow(ofGroupOffset + blockId); + if (!bUsePredictionFromPreviousLevel) + { + currentVector = FfxInt32x2(0, 0); + } + + if (iLaneToBlockId == blockId.y * 2 + blockId.x) + { + pixels[iSearchId.y & 0x7][iSearchId.x & 0x1] = packedLuma_4blocks; + } + + LoadSearchBuffer(iLocalIndex, pixelGroupOffset + blockId * 8 + currentVector); + + FfxUInt32x4 qsad = CalculateQSads2(iSearchId); + + PrepareSadMap(iSearchId, qsad); + FfxUInt32 minSad = SadMapMinReduction256(iSearchId, iLocalIndex); + + FfxInt32x2 minSadCoord = DecodeSearchCoord(minSad); + FfxInt32x2 newVector = currentVector + minSadCoord; + +#if FFX_LOCAL_SEARCH_FALLBACK == 1 + FfxUInt32 blockSadSum = BlockSad64(sad_4blocks, iLocalIndex, iLaneToBlockId, blockId.x + blockId.y * 2); + if (OpticalFlowPyramidLevel() == 0 && blockSadSum <= (minSad >> 16u)) + { + newVector = FfxInt32x2(0, 0); + } +#endif //FFX_LOCAL_SEARCH_FALLBACK + + { + StoreOpticalFlow(ofGroupOffset + blockId, newVector); + } + } + } +} + +#endif // FFX_OPTICALFLOW_COMPUTE_OPTICAL_FLOW_V5_H diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_compute_optical_flow_v5.h.meta b/Shaders/shaders/opticalflow/ffx_opticalflow_compute_optical_flow_v5.h.meta new file mode 100644 index 0000000..9c71e06 --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_compute_optical_flow_v5.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: 61f6df1e3ffe27440b49b1677bb9b25c +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_compute_scd_divergence.h b/Shaders/shaders/opticalflow/ffx_opticalflow_compute_scd_divergence.h new file mode 100644 index 0000000..7f473f6 --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_compute_scd_divergence.h @@ -0,0 +1,159 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_OPTICALFLOW_COMPUTE_SCD_DIVERGENCE_H +#define FFX_OPTICALFLOW_COMPUTE_SCD_DIVERGENCE_H + +FFX_GROUPSHARED FfxFloat32 sourceHistogram[256]; +FFX_GROUPSHARED FfxFloat32 filteredHistogram[256]; +FFX_GROUPSHARED FfxFloat32 tempBuffer[256]; +FFX_GROUPSHARED FfxFloat32x2 tempBuffer2[256]; + +void ComputeSCDHistogramsDivergence(FfxInt32x3 iGlobalId, FfxInt32x2 iLocalId, FfxInt32 iLocalIndex, FfxInt32x2 iGroupId, FfxInt32x2 iGroupSize) +{ + FFX_STATIC const FfxFloat32 Factor = 1000000.0; + FFX_STATIC const FfxInt32 WhereToStop = 3*9 - 1; + FFX_STATIC const FfxInt32 HistogramCount = 3 * 3; + + FFX_STATIC const FfxFloat32 Kernel[] = { + 0.0088122291, 0.027143577, 0.065114059, 0.12164907, 0.17699835, 0.20056541 + }; + + sourceHistogram[iLocalIndex] = FfxFloat32(LoadRwSCDHistogram(iGlobalId.x)); + FFX_GROUP_MEMORY_BARRIER; + + const FfxInt32 kernelShift = -5; + const FfxInt32 indexToRead = iLocalIndex + kernelShift; + + FfxFloat32 val = 0.0; + val += Kernel[0] * sourceHistogram[ffxClamp(indexToRead + 0, 0, 255)]; + val += Kernel[1] * sourceHistogram[ffxClamp(indexToRead + 1, 0, 255)]; + val += Kernel[2] * sourceHistogram[ffxClamp(indexToRead + 2, 0, 255)]; + val += Kernel[3] * sourceHistogram[ffxClamp(indexToRead + 3, 0, 255)]; + val += Kernel[4] * sourceHistogram[ffxClamp(indexToRead + 4, 0, 255)]; + val += Kernel[5] * sourceHistogram[ffxClamp(indexToRead + 5, 0, 255)]; + val += Kernel[4] * sourceHistogram[ffxClamp(indexToRead + 6, 0, 255)]; + val += Kernel[3] * sourceHistogram[ffxClamp(indexToRead + 7, 0, 255)]; + val += Kernel[2] * sourceHistogram[ffxClamp(indexToRead + 8, 0, 255)]; + val += Kernel[1] * sourceHistogram[ffxClamp(indexToRead + 9, 0, 255)]; + val += Kernel[0] * sourceHistogram[ffxClamp(indexToRead + 10, 0, 255)]; + + val += 1.0; + + if (iGlobalId.y == 0) + { + if (iLocalIndex == 0) + filteredHistogram[255] = 1.0; + else + filteredHistogram[iLocalIndex - 1] = val; + } + else if (iGlobalId.y == 1) + { + filteredHistogram[iLocalIndex] = val; + } + else if (iGlobalId.y == 2) + { + if (iLocalIndex == 255) + filteredHistogram[0] = 1.0; + else + filteredHistogram[iLocalIndex + 1] = val; + } + FFX_GROUP_MEMORY_BARRIER; + + tempBuffer[iLocalIndex] = filteredHistogram[iLocalIndex]; + FFX_GROUP_MEMORY_BARRIER; + + if (iLocalIndex < 128) tempBuffer[iLocalIndex] += tempBuffer[iLocalIndex + 128]; + FFX_GROUP_MEMORY_BARRIER; + + if (iLocalIndex < 64) tempBuffer[iLocalIndex] += tempBuffer[iLocalIndex + 64]; + FFX_GROUP_MEMORY_BARRIER; + + if (iLocalIndex < 32) tempBuffer[iLocalIndex] += tempBuffer[iLocalIndex + 32]; + if (iLocalIndex < 16) tempBuffer[iLocalIndex] += tempBuffer[iLocalIndex + 16]; + if (iLocalIndex < 8 ) tempBuffer[iLocalIndex] += tempBuffer[iLocalIndex + 8]; + if (iLocalIndex < 4 ) tempBuffer[iLocalIndex] += tempBuffer[iLocalIndex + 4]; + if (iLocalIndex < 2 ) tempBuffer[iLocalIndex] += tempBuffer[iLocalIndex + 2]; + if (iLocalIndex < 1 ) tempBuffer[iLocalIndex] += tempBuffer[iLocalIndex + 1]; + FFX_GROUP_MEMORY_BARRIER; + + filteredHistogram[iLocalIndex] /= tempBuffer[0]; + + FfxFloat32 currentFilteredHistogramsValue = filteredHistogram[iLocalIndex]; + FfxFloat32 previousHistogramsValue = LoadRwSCDPreviousHistogram(iGlobalId.x); + + tempBuffer2[iLocalIndex] = FfxFloat32x2( + currentFilteredHistogramsValue * log(currentFilteredHistogramsValue / previousHistogramsValue), + previousHistogramsValue * log(previousHistogramsValue / currentFilteredHistogramsValue) + ); + FFX_GROUP_MEMORY_BARRIER; + + if (iLocalIndex < 128) tempBuffer2[iLocalIndex] += tempBuffer2[iLocalIndex + 128]; + FFX_GROUP_MEMORY_BARRIER; + + if (iLocalIndex < 64) tempBuffer2[iLocalIndex] += tempBuffer2[iLocalIndex + 64]; + FFX_GROUP_MEMORY_BARRIER; + + if (iLocalIndex < 32) tempBuffer2[iLocalIndex] += tempBuffer2[iLocalIndex + 32]; + if (iLocalIndex < 16) tempBuffer2[iLocalIndex] += tempBuffer2[iLocalIndex + 16]; + if (iLocalIndex < 8 ) tempBuffer2[iLocalIndex] += tempBuffer2[iLocalIndex + 8]; + if (iLocalIndex < 4 ) tempBuffer2[iLocalIndex] += tempBuffer2[iLocalIndex + 4]; + if (iLocalIndex < 2 ) tempBuffer2[iLocalIndex] += tempBuffer2[iLocalIndex + 2]; + + if (iLocalIndex == 0) + { + FfxFloat32x2 sum = tempBuffer2[0] + tempBuffer2[1]; + + FfxFloat32 resFloat = 1 - exp(-(abs(sum.x) + abs(sum.y))); + FfxUInt32 resUInt = FfxUInt32((resFloat / FfxFloat32(HistogramCount)) * Factor); + AtomicIncrementSCDTemp(iGlobalId.y, resUInt); + + FfxUInt32 oldFinishedGroupCount = AtomicIncrementSCDOutput(SCD_OUTPUT_COMPLETED_WORKGROUPS_SLOT, 1); + if (oldFinishedGroupCount == WhereToStop) + { + FfxUInt32 res0 = LoadRwSCDTemp(0); + FfxUInt32 res1 = LoadRwSCDTemp(1); + FfxUInt32 res2 = LoadRwSCDTemp(2); + FfxFloat32 sceneChangeValue = ffxMin(res0, ffxMin(res1, res2)) / Factor; + + FfxUInt32 history = LoadRwSCDOutput(SCD_OUTPUT_HISTORY_BITS_SLOT) << 1; + if (CrossedSceneChangeThreshold(sceneChangeValue)) + { + history |= 1; + } + StoreSCDOutput(SCD_OUTPUT_SCENE_CHANGE_SLOT, ffxAsUInt32(sceneChangeValue)); + StoreSCDOutput(SCD_OUTPUT_HISTORY_BITS_SLOT, history); + StoreSCDOutput(SCD_OUTPUT_COMPLETED_WORKGROUPS_SLOT, 0); + + ResetSCDTemp(); + } + } + + if (iGlobalId.y == 1) + { + StoreSCDPreviousHistogram(iGlobalId.x, currentFilteredHistogramsValue); + + StoreSCDHistogram(iGlobalId.x, 0); + } +} + +#endif // FFX_OPTICALFLOW_COMPUTE_SCD_DIVERGENCE_H diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_compute_scd_divergence.h.meta b/Shaders/shaders/opticalflow/ffx_opticalflow_compute_scd_divergence.h.meta new file mode 100644 index 0000000..e3ffc2c --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_compute_scd_divergence.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: 76bc7e89a8db43140abe32ba5d4a79fc +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_filter_optical_flow_v5.h b/Shaders/shaders/opticalflow/ffx_opticalflow_filter_optical_flow_v5.h new file mode 100644 index 0000000..8ebf0be --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_filter_optical_flow_v5.h @@ -0,0 +1,58 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_OPTICALFLOW_FILTER_OPTICAL_FLOW_V5_H +#define FFX_OPTICALFLOW_FILTER_OPTICAL_FLOW_V5_H + +void FilterOpticalFlow(FfxInt32x2 iGlobalId, FfxInt32x2 iLocalId, FfxInt32x2 iGroupId, FfxInt32 iLocalIndex) +{ + FfxInt32x2 tmpMV[9]; + FfxInt32 idx = 0; + for (FfxInt32 xx = -1; xx < 2; xx++) + { + for (FfxInt32 yy = -1; yy < 2; yy++) + { + + tmpMV[idx] = LoadPreviousOpticalFlow(iGlobalId + FfxInt32x2(xx, yy)); + idx++; + } + } + + FfxUInt32 ret = 0xFFFFFFFF; + for (FfxInt32 i = 0; i < 9; ++i) + { + FfxUInt32 tmp = 0; + for (FfxInt32 j = 0; j < 9; ++j) + { + FfxInt32x2 delta = tmpMV[i] - tmpMV[j]; + tmp = delta.x * delta.x + (delta.y * delta.y + tmp); + } + + ret = min(((tmp) << 4) | i, ret); + } + + FfxUInt32 minIdx = ret & 0xF; + + StoreOpticalFlow(iGlobalId, tmpMV[minIdx]); +} + +#endif // FFX_OPTICALFLOW_FILTER_OPTICAL_FLOW_V5_H diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_filter_optical_flow_v5.h.meta b/Shaders/shaders/opticalflow/ffx_opticalflow_filter_optical_flow_v5.h.meta new file mode 100644 index 0000000..2e50c17 --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_filter_optical_flow_v5.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: 9a5d2cc46aec47749b1b98b58392afd4 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_generate_scd_histogram.h b/Shaders/shaders/opticalflow/ffx_opticalflow_generate_scd_histogram.h new file mode 100644 index 0000000..aead438 --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_generate_scd_histogram.h @@ -0,0 +1,92 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_OPTICALFLOW_GENERATE_SCD_HISTOGRAM_H +#define FFX_OPTICALFLOW_GENERATE_SCD_HISTOGRAM_H + +#define LBASE 10 + +FFX_GROUPSHARED FfxUInt32 scdBuffer[256 * LBASE]; + +void GenerateSceneChangeDetectionHistogram(FfxInt32x3 iGlobalId, FfxInt32x2 iLocalId, FfxInt32 iLocalIndex, FfxInt32x2 iGroupId, FfxInt32x2 iGroupSize) +{ + FFX_STATIC const FfxUInt32 HistogramsPerDim = 3; + + FfxUInt32 divX = DisplaySize().x / HistogramsPerDim; + FfxUInt32 divY = DisplaySize().y / HistogramsPerDim; + + FfxUInt32 nx = iGlobalId.z % HistogramsPerDim; + FfxUInt32 ny = iGlobalId.z / HistogramsPerDim; + FfxUInt32 startX = divX * nx; + FfxUInt32 startY = divY * ny; + FfxUInt32 stopX = startX + divX; + FfxUInt32 stopY = startY + divY; + + const FfxUInt32 bufferOffset = iLocalIndex * LBASE; + + for (FfxInt32 i = 0; i < LBASE; i++) + { + scdBuffer[bufferOffset + i] = 0; + } + FFX_GROUP_MEMORY_BARRIER; + + FfxInt32x2 coord = FfxInt32x2(startX + (4 * iGlobalId.x), startY + iGlobalId.y); + if (coord.x < stopX) + { + for (; coord.y < stopY; coord.y += 128) + { + FfxUInt32x4 color = FfxUInt32x4( + LoadOpticalFlowInput(coord + FfxInt32x2(0, 0)), + LoadOpticalFlowInput(coord + FfxInt32x2(1, 0)), + LoadOpticalFlowInput(coord + FfxInt32x2(2, 0)), + LoadOpticalFlowInput(coord + FfxInt32x2(3, 0)) + ); + color *= LBASE; + + FfxUInt32 scramblingOffset = iLocalIndex % LBASE; + +#if defined(FFX_HLSL) + InterlockedAdd(scdBuffer[color.x + scramblingOffset], 1); + InterlockedAdd(scdBuffer[color.y + scramblingOffset], 1); + InterlockedAdd(scdBuffer[color.z + scramblingOffset], 1); + InterlockedAdd(scdBuffer[color.w + scramblingOffset], 1); +#elif defined(FFX_GLSL) + atomicAdd(scdBuffer[color.x + scramblingOffset], 1); + atomicAdd(scdBuffer[color.y + scramblingOffset], 1); + atomicAdd(scdBuffer[color.z + scramblingOffset], 1); + atomicAdd(scdBuffer[color.w + scramblingOffset], 1); +#endif + } + } + FFX_GROUP_MEMORY_BARRIER; + + FfxUInt32 value = 0; + for (FfxInt32 i = 0; i < LBASE; i++) + { + value += scdBuffer[bufferOffset + i]; + } + + FfxUInt32 histogramStart = (iGroupSize.x * iGroupSize.y) * iGlobalId.z; + AtomicIncrementSCDHistogram(FfxInt32(histogramStart + iLocalIndex), value); +} + +#endif // FFX_OPTICALFLOW_GENERATE_SCD_HISTOGRAM_H diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_generate_scd_histogram.h.meta b/Shaders/shaders/opticalflow/ffx_opticalflow_generate_scd_histogram.h.meta new file mode 100644 index 0000000..2e1f169 --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_generate_scd_histogram.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: a9cccb4a935288247bbc3bd4eb909530 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_prepare_luma.h b/Shaders/shaders/opticalflow/ffx_opticalflow_prepare_luma.h new file mode 100644 index 0000000..57fd8a7 --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_prepare_luma.h @@ -0,0 +1,106 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_OPTICALFLOW_PREPARE_LUMA_H +#define FFX_OPTICALFLOW_PREPARE_LUMA_H + +FfxFloat32 LuminanceToPerceivedLuminance(FfxFloat32 fLuminance) +{ + FfxFloat32 fPercievedLuminance = 0; + if (fLuminance <= 216.0f / 24389.0f) { + fPercievedLuminance = fLuminance * (24389.0f / 27.0f); + } + else { + fPercievedLuminance = ffxPow(fLuminance, 1.0f / 3.0f) * 116.0f - 16.0f; + } + + return fPercievedLuminance * 0.01f; +} + +FfxFloat32 LinearLdrToLuminance(FfxFloat32x3 linearRec709RGB) +{ + FfxFloat32 fY = 0.2126 * linearRec709RGB.x + 0.7152 * linearRec709RGB.y + 0.0722 * linearRec709RGB.z; + return fY; +} + +FfxFloat32 LinearRec2020ToLuminance(FfxFloat32x3 linearRec2020RGB) +{ + FfxFloat32 fY = 0.2627 * linearRec2020RGB.x + 0.678 * linearRec2020RGB.y + 0.0593 * linearRec2020RGB.z; + return fY; +} + +FfxFloat32 PQCorrectedHdrToLuminance(FfxFloat32x3 pq, FfxFloat32 maxLuminance) +{ + FfxFloat32 fY = LinearRec2020ToLuminance(ffxLinearFromPQ(pq) * (10000.0f / maxLuminance)); + return fY; +} + +FfxFloat32x3 ffxscRGBToLinear(FfxFloat32x3 value, FfxFloat32 minLuminance, FfxFloat32 maxLuminance) +{ + FfxFloat32x3 p = value - ffxBroadcast3(minLuminance / 80.0f); + return p / ffxBroadcast3((maxLuminance - minLuminance) / 80.0f); +} + +FfxFloat32 SCRGBCorrectedHdrToLuminance(FfxFloat32x3 scRGB, FfxFloat32 minLuminance, FfxFloat32 maxLuminance) +{ + FfxFloat32 fY = LinearLdrToLuminance(ffxscRGBToLinear(scRGB, minLuminance, maxLuminance)); + return fY; +} + +void PrepareLuma(FfxInt32x2 iGlobalId, FfxInt32 iLocalIndex) +{ +#define PixelsPerThreadX 2 +#define PixelsPerThreadY 2 +#pragma unroll + for (FfxInt32 y = 0; y < PixelsPerThreadY; y++) + { +#pragma unroll + for (FfxInt32 x = 0; x < PixelsPerThreadX; x++) + { + FfxInt32x2 pos = iGlobalId * FfxInt32x2(PixelsPerThreadX, PixelsPerThreadY) + FfxInt32x2(x, y); + FfxInt32x2 iPxHrPos = pos; + FfxFloat32 fY = 0.0; + + FfxFloat32x3 inputColor = LoadInputColor(iPxHrPos).rgb; + + FfxUInt32 backbufferTransferFunction = BackbufferTransferFunction(); + if (backbufferTransferFunction == 0) + { + fY = LinearLdrToLuminance(inputColor); + } + else if (backbufferTransferFunction == 1) + { + fY = PQCorrectedHdrToLuminance(inputColor, MinMaxLuminance()[1]); + fY = LuminanceToPerceivedLuminance(fY); + } + else if (backbufferTransferFunction == 2) + { + fY = SCRGBCorrectedHdrToLuminance(inputColor, MinMaxLuminance()[0], MinMaxLuminance()[1]); + fY = LuminanceToPerceivedLuminance(fY); + } + + StoreOpticalFlowInput(pos, FfxUInt32(fY * 255)); + } + } +} + +#endif // FFX_OPTICALFLOW_PREPARE_LUMA_H diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_prepare_luma.h.meta b/Shaders/shaders/opticalflow/ffx_opticalflow_prepare_luma.h.meta new file mode 100644 index 0000000..a2d8f4c --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_prepare_luma.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: 33627e1139c933848b4455e66f0035cd +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_resources.h b/Shaders/shaders/opticalflow/ffx_opticalflow_resources.h new file mode 100644 index 0000000..4676af4 --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_resources.h @@ -0,0 +1,74 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_OPTICALFLOW_RESOURCES_H +#define FFX_OPTICALFLOW_RESOURCES_H + +#if defined(FFX_CPU) || defined(FFX_GPU) + +#define FFX_OF_RESOURCE_IDENTIFIER_NULL 0 + +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_INPUT_1 1 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_INPUT_1_LEVEL_1 2 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_INPUT_1_LEVEL_2 3 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_INPUT_1_LEVEL_3 4 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_INPUT_1_LEVEL_4 5 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_INPUT_1_LEVEL_5 6 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_INPUT_1_LEVEL_6 7 + +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_INPUT_2 8 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_INPUT_2_LEVEL_1 9 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_INPUT_2_LEVEL_2 10 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_INPUT_2_LEVEL_3 11 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_INPUT_2_LEVEL_4 12 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_INPUT_2_LEVEL_5 13 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_INPUT_2_LEVEL_6 14 + +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_1 15 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_1_LEVEL_1 16 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_1_LEVEL_2 17 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_1_LEVEL_3 18 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_1_LEVEL_4 19 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_1_LEVEL_5 20 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_1_LEVEL_6 21 + +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_2 22 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_2_LEVEL_1 23 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_2_LEVEL_2 24 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_2_LEVEL_3 25 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_2_LEVEL_4 26 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_2_LEVEL_5 27 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_2_LEVEL_6 28 + +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_SCD_HISTOGRAM 29 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_SCD_PREVIOUS_HISTOGRAM 30 +#define FFX_OF_RESOURCE_IDENTIFIER_OPTICAL_FLOW_SCD_TEMP 31 + +#define FFX_OF_RESOURCE_IDENTIFIER_COUNT 32 + +#define FFX_OPTICALFLOW_CONSTANTBUFFER_IDENTIFIER 0 +#define FFX_OPTICALFLOW_CONSTANTBUFFER_IDENTIFIER_SPD 1 +#define FFX_OPTICALFLOW_CONSTANTBUFFER_COUNT 2 + +#endif // #if defined(FFX_CPU) || defined(FFX_GPU) + +#endif //!defined( FFX_OPTICALFLOW_RESOURCES_H ) diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_resources.h.meta b/Shaders/shaders/opticalflow/ffx_opticalflow_resources.h.meta new file mode 100644 index 0000000..a2c7aa7 --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_resources.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: ecffc17f9a96d7540b7723e9f5d6ccac +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_scale_optical_flow_advanced_v5.h b/Shaders/shaders/opticalflow/ffx_opticalflow_scale_optical_flow_advanced_v5.h new file mode 100644 index 0000000..16238f4 --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_scale_optical_flow_advanced_v5.h @@ -0,0 +1,99 @@ +// This file is part of the FidelityFX SDK. +// +// Copyright (C) 2024 Advanced Micro Devices, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#ifndef FFX_OPTICALFLOW_SCALE_OPTICAL_FLOW_ADVANCED_V5_H +#define FFX_OPTICALFLOW_SCALE_OPTICAL_FLOW_ADVANCED_V5_H + +#define WG_WIDTH FFX_OPTICALFLOW_THREAD_GROUP_WIDTH +#define WG_HEIGHT FFX_OPTICALFLOW_THREAD_GROUP_HEIGHT +#define WG_DEPTH FFX_OPTICALFLOW_THREAD_GROUP_DEPTH +FFX_GROUPSHARED FfxInt32x2 nearestVectors[4][WG_HEIGHT][WG_WIDTH]; +FFX_GROUPSHARED FfxUInt32 localRegion[4][WG_HEIGHT][WG_WIDTH]; +FFX_GROUPSHARED FfxUInt32 sads[4][WG_HEIGHT][WG_WIDTH]; + +void ScaleOpticalFlowAdvanced(FfxInt32x3 iGlobalId, FfxInt32x3 iLocalId) +{ + if (IsSceneChanged()) + { + StoreOpticalFlowNextLevel(iGlobalId.xy, FfxInt32x2(0, 0)); + + return; + } + + int xOffset = (iLocalId.z % 2) - 1 + iGlobalId.x % 2; + int yOffset = (iLocalId.z / 2) - 1 + iGlobalId.y % 2; + + FfxInt32x2 srcOFPos = FfxInt32x2( + (iGlobalId.x / 2) + xOffset, + (iGlobalId.y / 2) + yOffset + ); + + FfxInt32x2 nearestVector = LoadOpticalFlow(srcOFPos); + nearestVectors[iLocalId.z][iLocalId.y][iLocalId.x] = nearestVector * 2; + + int maxY = 4; + for (int n = iLocalId.z; n < maxY; n += WG_DEPTH) + { + { + FfxInt32x2 lumaPos = FfxInt32x2((iGlobalId.x) * 4, iGlobalId.y * maxY + n); + FfxUInt32 firstPixel = LoadFirstImagePackedLuma(lumaPos); + localRegion[n][iLocalId.y][iLocalId.x] = firstPixel; + } + } + FFX_GROUP_MEMORY_BARRIER; + + uint sad = 0; + for (int n = 0; n < maxY; n++) + { + { + FfxInt32x2 lumaPos = FfxInt32x2((iGlobalId.x) * 4, (iGlobalId.y * maxY + n)) + nearestVector; + FfxUInt32 secondPixel = LoadSecondImagePackedLuma(lumaPos); + sad += Sad(localRegion[n][iLocalId.y][iLocalId.x], secondPixel); + } + } + sads[iLocalId.z][iLocalId.y][iLocalId.x] = sad; + + FFX_GROUP_MEMORY_BARRIER; + + { + if (iLocalId.z == 0) + { + uint bestSad = 0xffffffff; + uint bestId = 0; + + for (int n = 0; n < 4; n++) + { + if ((sads[n][iLocalId.y][iLocalId.x]) < bestSad) + { + bestSad = sads[n][iLocalId.y][iLocalId.x]; + bestId = n; + } + } + + FfxInt32x2 outputVector = nearestVectors[bestId][iLocalId.y][iLocalId.x]; + + StoreOpticalFlowNextLevel(iGlobalId.xy, outputVector); + } + } +} + +#endif // FFX_OPTICALFLOW_SCALE_OPTICAL_FLOW_ADVANCED_V5_H diff --git a/Shaders/shaders/opticalflow/ffx_opticalflow_scale_optical_flow_advanced_v5.h.meta b/Shaders/shaders/opticalflow/ffx_opticalflow_scale_optical_flow_advanced_v5.h.meta new file mode 100644 index 0000000..593d1ba --- /dev/null +++ b/Shaders/shaders/opticalflow/ffx_opticalflow_scale_optical_flow_advanced_v5.h.meta @@ -0,0 +1,60 @@ +fileFormatVersion: 2 +guid: 357cee7b9e5993044ad428e29696a2a2 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude GameCoreScarlett: 1 + Exclude GameCoreXboxOne: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude PS4: 1 + Exclude PS5: 1 + Exclude WebGL: 1 + Exclude Win: 1 + Exclude Win64: 1 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + userData: + assetBundleName: + assetBundleVariant: