mirror of
https://git.triforceproject.com/triforce/source
synced 2026-11-19 16:20:01 -04:00
Triforce v0.2.0
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
558
third_party/fidelityfx-sdk/include/FidelityFX/gpu/ffx_common_types.h
vendored
Normal file
558
third_party/fidelityfx-sdk/include/FidelityFX/gpu/ffx_common_types.h
vendored
Normal file
@@ -0,0 +1,558 @@
|
||||
// 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_COMMON_TYPES_H
|
||||
#define FFX_COMMON_TYPES_H
|
||||
|
||||
#if defined(FFX_CPU)
|
||||
#define FFX_PARAMETER_IN
|
||||
#define FFX_PARAMETER_OUT
|
||||
#define FFX_PARAMETER_INOUT
|
||||
#define FFX_PARAMETER_UNIFORM
|
||||
#elif defined(FFX_HLSL)
|
||||
#define FFX_PARAMETER_IN in
|
||||
#define FFX_PARAMETER_OUT out
|
||||
#define FFX_PARAMETER_INOUT inout
|
||||
#define FFX_PARAMETER_UNIFORM uniform
|
||||
#elif defined(FFX_GLSL)
|
||||
#define FFX_PARAMETER_IN in
|
||||
#define FFX_PARAMETER_OUT out
|
||||
#define FFX_PARAMETER_INOUT inout
|
||||
#define FFX_PARAMETER_UNIFORM const //[cacao_placeholder] until a better fit is found!
|
||||
#endif // #if defined(FFX_CPU)
|
||||
|
||||
#if defined(FFX_CPU)
|
||||
/// A typedef for a boolean value.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef bool FfxBoolean;
|
||||
|
||||
/// A typedef for a unsigned 8bit integer.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef uint8_t FfxUInt8;
|
||||
|
||||
/// A typedef for a unsigned 16bit integer.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef uint16_t FfxUInt16;
|
||||
|
||||
/// A typedef for a unsigned 32bit integer.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef uint32_t FfxUInt32;
|
||||
|
||||
/// A typedef for a unsigned 64bit integer.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef uint64_t FfxUInt64;
|
||||
|
||||
/// A typedef for a signed 8bit integer.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef int8_t FfxInt8;
|
||||
|
||||
/// A typedef for a signed 16bit integer.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef int16_t FfxInt16;
|
||||
|
||||
/// A typedef for a signed 32bit integer.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef int32_t FfxInt32;
|
||||
|
||||
/// A typedef for a signed 64bit integer.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef int64_t FfxInt64;
|
||||
|
||||
/// A typedef for a floating point value.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef float FfxFloat32;
|
||||
|
||||
/// A typedef for a 2-dimensional floating point value.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef float FfxFloat32x2[2];
|
||||
|
||||
/// A typedef for a 3-dimensional floating point value.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef float FfxFloat32x3[3];
|
||||
|
||||
/// A typedef for a 4-dimensional floating point value.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef float FfxFloat32x4[4];
|
||||
|
||||
/// A typedef for a 2x2 floating point matrix.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef float FfxFloat32x2x2[4];
|
||||
|
||||
/// A typedef for a 3x3 floating point matrix.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef float FfxFloat32x3x3[9];
|
||||
|
||||
/// A typedef for a 3x4 floating point matrix.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef float FfxFloat32x3x4[12];
|
||||
|
||||
/// A typedef for a 4x4 floating point matrix.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef float FfxFloat32x4x4[16];
|
||||
|
||||
/// A typedef for a 2-dimensional 32bit signed integer.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef int32_t FfxInt32x2[2];
|
||||
|
||||
/// A typedef for a 3-dimensional 32bit signed integer.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef int32_t FfxInt32x3[3];
|
||||
|
||||
/// A typedef for a 4-dimensional 32bit signed integer.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef int32_t FfxInt32x4[4];
|
||||
|
||||
/// A typedef for a 2-dimensional 32bit usigned integer.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef uint32_t FfxUInt32x2[2];
|
||||
|
||||
/// A typedef for a 3-dimensional 32bit unsigned integer.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef uint32_t FfxUInt32x3[3];
|
||||
|
||||
/// A typedef for a 4-dimensional 32bit unsigned integer.
|
||||
///
|
||||
/// @ingroup CPUTypes
|
||||
typedef uint32_t FfxUInt32x4[4];
|
||||
#endif // #if defined(FFX_CPU)
|
||||
|
||||
#if defined(FFX_HLSL)
|
||||
|
||||
#define FfxFloat32Mat4 matrix <float, 4, 4>
|
||||
#define FfxFloat32Mat3 matrix <float, 3, 3>
|
||||
|
||||
/// A typedef for a boolean value.
|
||||
///
|
||||
/// @ingroup HLSLTypes
|
||||
typedef bool FfxBoolean;
|
||||
|
||||
#if FFX_HLSL_SM>=62
|
||||
|
||||
/// @defgroup HLSL62Types HLSL 6.2 And Above Types
|
||||
/// HLSL 6.2 and above type defines for all commonly used variables
|
||||
///
|
||||
/// @ingroup HLSLTypes
|
||||
|
||||
/// A typedef for a floating point value.
|
||||
///
|
||||
/// @ingroup HLSL62Types
|
||||
typedef float32_t FfxFloat32;
|
||||
|
||||
/// A typedef for a 2-dimensional floating point value.
|
||||
///
|
||||
/// @ingroup HLSL62Types
|
||||
typedef float32_t2 FfxFloat32x2;
|
||||
|
||||
/// A typedef for a 3-dimensional floating point value.
|
||||
///
|
||||
/// @ingroup HLSL62Types
|
||||
typedef float32_t3 FfxFloat32x3;
|
||||
|
||||
/// A typedef for a 4-dimensional floating point value.
|
||||
///
|
||||
/// @ingroup HLSL62Types
|
||||
typedef float32_t4 FfxFloat32x4;
|
||||
|
||||
/// A [cacao_placeholder] typedef for matrix type until confirmed.
|
||||
typedef float4x4 FfxFloat32x4x4;
|
||||
typedef float3x4 FfxFloat32x3x4;
|
||||
typedef float3x3 FfxFloat32x3x3;
|
||||
typedef float2x2 FfxFloat32x2x2;
|
||||
|
||||
/// A typedef for a unsigned 32bit integer.
|
||||
///
|
||||
/// @ingroup HLSL62Types
|
||||
typedef uint32_t FfxUInt32;
|
||||
|
||||
/// A typedef for a 2-dimensional 32bit unsigned integer.
|
||||
///
|
||||
/// @ingroup HLSL62Types
|
||||
typedef uint32_t2 FfxUInt32x2;
|
||||
|
||||
/// A typedef for a 3-dimensional 32bit unsigned integer.
|
||||
///
|
||||
/// @ingroup HLSL62Types
|
||||
typedef uint32_t3 FfxUInt32x3;
|
||||
|
||||
/// A typedef for a 4-dimensional 32bit unsigned integer.
|
||||
///
|
||||
/// @ingroup HLSL62Types
|
||||
typedef uint32_t4 FfxUInt32x4;
|
||||
|
||||
/// A typedef for a signed 32bit integer.
|
||||
///
|
||||
/// @ingroup HLSL62Types
|
||||
typedef int32_t FfxInt32;
|
||||
|
||||
/// A typedef for a 2-dimensional signed 32bit integer.
|
||||
///
|
||||
/// @ingroup HLSL62Types
|
||||
typedef int32_t2 FfxInt32x2;
|
||||
|
||||
/// A typedef for a 3-dimensional signed 32bit integer.
|
||||
///
|
||||
/// @ingroup HLSL62Types
|
||||
typedef int32_t3 FfxInt32x3;
|
||||
|
||||
/// A typedef for a 4-dimensional signed 32bit integer.
|
||||
///
|
||||
/// @ingroup HLSL62Types
|
||||
typedef int32_t4 FfxInt32x4;
|
||||
|
||||
#else // #if FFX_HLSL_SM>=62
|
||||
|
||||
/// @defgroup HLSLBaseTypes HLSL 6.1 And Below Types
|
||||
/// HLSL 6.1 and below type defines for all commonly used variables
|
||||
///
|
||||
/// @ingroup HLSLTypes
|
||||
|
||||
#define FfxFloat32 float
|
||||
#define FfxFloat32x2 float2
|
||||
#define FfxFloat32x3 float3
|
||||
#define FfxFloat32x4 float4
|
||||
|
||||
/// A [cacao_placeholder] typedef for matrix type until confirmed.
|
||||
#define FfxFloat32x4x4 float4x4
|
||||
#define FfxFloat32x3x4 float3x4
|
||||
#define FfxFloat32x3x3 float3x3
|
||||
#define FfxFloat32x2x2 float2x2
|
||||
|
||||
/// A typedef for a unsigned 32bit integer.
|
||||
///
|
||||
/// @ingroup GPU
|
||||
typedef uint FfxUInt32;
|
||||
typedef uint2 FfxUInt32x2;
|
||||
typedef uint3 FfxUInt32x3;
|
||||
typedef uint4 FfxUInt32x4;
|
||||
|
||||
typedef int FfxInt32;
|
||||
typedef int2 FfxInt32x2;
|
||||
typedef int3 FfxInt32x3;
|
||||
typedef int4 FfxInt32x4;
|
||||
|
||||
#endif // #if FFX_HLSL_SM>=62
|
||||
|
||||
#if FFX_HALF
|
||||
|
||||
#if FFX_HLSL_SM >= 62
|
||||
|
||||
typedef float16_t FfxFloat16;
|
||||
typedef float16_t2 FfxFloat16x2;
|
||||
typedef float16_t3 FfxFloat16x3;
|
||||
typedef float16_t4 FfxFloat16x4;
|
||||
|
||||
/// A typedef for an unsigned 16bit integer.
|
||||
///
|
||||
/// @ingroup HLSLTypes
|
||||
typedef uint16_t FfxUInt16;
|
||||
typedef uint16_t2 FfxUInt16x2;
|
||||
typedef uint16_t3 FfxUInt16x3;
|
||||
typedef uint16_t4 FfxUInt16x4;
|
||||
|
||||
/// A typedef for a signed 16bit integer.
|
||||
///
|
||||
/// @ingroup HLSLTypes
|
||||
typedef int16_t FfxInt16;
|
||||
typedef int16_t2 FfxInt16x2;
|
||||
typedef int16_t3 FfxInt16x3;
|
||||
typedef int16_t4 FfxInt16x4;
|
||||
#else // #if FFX_HLSL_SM>=62
|
||||
typedef min16float FfxFloat16;
|
||||
typedef min16float2 FfxFloat16x2;
|
||||
typedef min16float3 FfxFloat16x3;
|
||||
typedef min16float4 FfxFloat16x4;
|
||||
|
||||
/// A typedef for an unsigned 16bit integer.
|
||||
///
|
||||
/// @ingroup HLSLTypes
|
||||
typedef min16uint FfxUInt16;
|
||||
typedef min16uint2 FfxUInt16x2;
|
||||
typedef min16uint3 FfxUInt16x3;
|
||||
typedef min16uint4 FfxUInt16x4;
|
||||
|
||||
/// A typedef for a signed 16bit integer.
|
||||
///
|
||||
/// @ingroup HLSLTypes
|
||||
typedef min16int FfxInt16;
|
||||
typedef min16int2 FfxInt16x2;
|
||||
typedef min16int3 FfxInt16x3;
|
||||
typedef min16int4 FfxInt16x4;
|
||||
#endif // #if FFX_HLSL_SM>=62
|
||||
|
||||
#endif // FFX_HALF
|
||||
|
||||
#endif // #if defined(FFX_HLSL)
|
||||
|
||||
#if defined(FFX_GLSL)
|
||||
|
||||
#define FfxFloat32Mat4 mat4
|
||||
#define FfxFloat32Mat3 mat3
|
||||
|
||||
/// A typedef for a boolean value.
|
||||
///
|
||||
/// @ingroup GLSLTypes
|
||||
#define FfxBoolean bool
|
||||
#define FfxFloat32 float
|
||||
#define FfxFloat32x2 vec2
|
||||
#define FfxFloat32x3 vec3
|
||||
#define FfxFloat32x4 vec4
|
||||
#define FfxUInt32 uint
|
||||
#define FfxUInt32x2 uvec2
|
||||
#define FfxUInt32x3 uvec3
|
||||
#define FfxUInt32x4 uvec4
|
||||
#define FfxInt32 int
|
||||
#define FfxInt32x2 ivec2
|
||||
#define FfxInt32x3 ivec3
|
||||
#define FfxInt32x4 ivec4
|
||||
|
||||
/// A [cacao_placeholder] typedef for matrix type until confirmed.
|
||||
#define FfxFloat32x4x4 mat4
|
||||
#define FfxFloat32x3x4 mat4x3
|
||||
#define FfxFloat32x3x3 mat3
|
||||
#define FfxFloat32x2x2 mat2
|
||||
|
||||
#if FFX_HALF
|
||||
#define FfxFloat16 float16_t
|
||||
#define FfxFloat16x2 f16vec2
|
||||
#define FfxFloat16x3 f16vec3
|
||||
#define FfxFloat16x4 f16vec4
|
||||
#define FfxUInt16 uint16_t
|
||||
#define FfxUInt16x2 u16vec2
|
||||
#define FfxUInt16x3 u16vec3
|
||||
#define FfxUInt16x4 u16vec4
|
||||
#define FfxInt16 int16_t
|
||||
#define FfxInt16x2 i16vec2
|
||||
#define FfxInt16x3 i16vec3
|
||||
#define FfxInt16x4 i16vec4
|
||||
#endif // FFX_HALF
|
||||
#endif // #if defined(FFX_GLSL)
|
||||
|
||||
// Global toggles:
|
||||
// #define FFX_HALF (1)
|
||||
// #define FFX_HLSL_SM (62)
|
||||
|
||||
#if FFX_HALF
|
||||
|
||||
#if FFX_HLSL_SM >= 62
|
||||
|
||||
#define FFX_MIN16_SCALAR( TypeName, BaseComponentType ) typedef BaseComponentType##16_t TypeName;
|
||||
#define FFX_MIN16_VECTOR( TypeName, BaseComponentType, COL ) typedef vector<BaseComponentType##16_t, COL> TypeName;
|
||||
#define FFX_MIN16_MATRIX( TypeName, BaseComponentType, ROW, COL ) typedef matrix<BaseComponentType##16_t, ROW, COL> TypeName;
|
||||
|
||||
#define FFX_16BIT_SCALAR( TypeName, BaseComponentType ) typedef BaseComponentType##16_t TypeName;
|
||||
#define FFX_16BIT_VECTOR( TypeName, BaseComponentType, COL ) typedef vector<BaseComponentType##16_t, COL> TypeName;
|
||||
#define FFX_16BIT_MATRIX( TypeName, BaseComponentType, ROW, COL ) typedef matrix<BaseComponentType##16_t, ROW, COL> TypeName;
|
||||
|
||||
#else //FFX_HLSL_SM>=62
|
||||
|
||||
#define FFX_MIN16_SCALAR( TypeName, BaseComponentType ) typedef min16##BaseComponentType TypeName;
|
||||
#define FFX_MIN16_VECTOR( TypeName, BaseComponentType, COL ) typedef vector<min16##BaseComponentType, COL> TypeName;
|
||||
#define FFX_MIN16_MATRIX( TypeName, BaseComponentType, ROW, COL ) typedef matrix<min16##BaseComponentType, ROW, COL> TypeName;
|
||||
|
||||
#define FFX_16BIT_SCALAR( TypeName, BaseComponentType ) FFX_MIN16_SCALAR( TypeName, BaseComponentType );
|
||||
#define FFX_16BIT_VECTOR( TypeName, BaseComponentType, COL ) FFX_MIN16_VECTOR( TypeName, BaseComponentType, COL );
|
||||
#define FFX_16BIT_MATRIX( TypeName, BaseComponentType, ROW, COL ) FFX_MIN16_MATRIX( TypeName, BaseComponentType, ROW, COL );
|
||||
|
||||
#endif //FFX_HLSL_SM>=62
|
||||
|
||||
#else //FFX_HALF
|
||||
|
||||
#define FFX_MIN16_SCALAR( TypeName, BaseComponentType ) typedef BaseComponentType TypeName;
|
||||
#define FFX_MIN16_VECTOR( TypeName, BaseComponentType, COL ) typedef vector<BaseComponentType, COL> TypeName;
|
||||
#define FFX_MIN16_MATRIX( TypeName, BaseComponentType, ROW, COL ) typedef matrix<BaseComponentType, ROW, COL> TypeName;
|
||||
|
||||
#define FFX_16BIT_SCALAR( TypeName, BaseComponentType ) typedef BaseComponentType TypeName;
|
||||
#define FFX_16BIT_VECTOR( TypeName, BaseComponentType, COL ) typedef vector<BaseComponentType, COL> TypeName;
|
||||
#define FFX_16BIT_MATRIX( TypeName, BaseComponentType, ROW, COL ) typedef matrix<BaseComponentType, ROW, COL> TypeName;
|
||||
|
||||
#endif //FFX_HALF
|
||||
|
||||
#if defined(FFX_GPU)
|
||||
// Common typedefs:
|
||||
#if defined(FFX_HLSL)
|
||||
FFX_MIN16_SCALAR( FFX_MIN16_F , float );
|
||||
FFX_MIN16_VECTOR( FFX_MIN16_F2, float, 2 );
|
||||
FFX_MIN16_VECTOR( FFX_MIN16_F3, float, 3 );
|
||||
FFX_MIN16_VECTOR( FFX_MIN16_F4, float, 4 );
|
||||
|
||||
FFX_MIN16_SCALAR( FFX_MIN16_I, int );
|
||||
FFX_MIN16_VECTOR( FFX_MIN16_I2, int, 2 );
|
||||
FFX_MIN16_VECTOR( FFX_MIN16_I3, int, 3 );
|
||||
FFX_MIN16_VECTOR( FFX_MIN16_I4, int, 4 );
|
||||
|
||||
FFX_MIN16_SCALAR( FFX_MIN16_U, uint );
|
||||
FFX_MIN16_VECTOR( FFX_MIN16_U2, uint, 2 );
|
||||
FFX_MIN16_VECTOR( FFX_MIN16_U3, uint, 3 );
|
||||
FFX_MIN16_VECTOR( FFX_MIN16_U4, uint, 4 );
|
||||
|
||||
FFX_16BIT_SCALAR( FFX_F16_t , float );
|
||||
FFX_16BIT_VECTOR( FFX_F16_t2, float, 2 );
|
||||
FFX_16BIT_VECTOR( FFX_F16_t3, float, 3 );
|
||||
FFX_16BIT_VECTOR( FFX_F16_t4, float, 4 );
|
||||
|
||||
FFX_16BIT_SCALAR( FFX_I16_t, int );
|
||||
FFX_16BIT_VECTOR( FFX_I16_t2, int, 2 );
|
||||
FFX_16BIT_VECTOR( FFX_I16_t3, int, 3 );
|
||||
FFX_16BIT_VECTOR( FFX_I16_t4, int, 4 );
|
||||
|
||||
FFX_16BIT_SCALAR( FFX_U16_t, uint );
|
||||
FFX_16BIT_VECTOR( FFX_U16_t2, uint, 2 );
|
||||
FFX_16BIT_VECTOR( FFX_U16_t3, uint, 3 );
|
||||
FFX_16BIT_VECTOR( FFX_U16_t4, uint, 4 );
|
||||
|
||||
#define TYPEDEF_MIN16_TYPES(Prefix) \
|
||||
typedef FFX_MIN16_F Prefix##_F; \
|
||||
typedef FFX_MIN16_F2 Prefix##_F2; \
|
||||
typedef FFX_MIN16_F3 Prefix##_F3; \
|
||||
typedef FFX_MIN16_F4 Prefix##_F4; \
|
||||
typedef FFX_MIN16_I Prefix##_I; \
|
||||
typedef FFX_MIN16_I2 Prefix##_I2; \
|
||||
typedef FFX_MIN16_I3 Prefix##_I3; \
|
||||
typedef FFX_MIN16_I4 Prefix##_I4; \
|
||||
typedef FFX_MIN16_U Prefix##_U; \
|
||||
typedef FFX_MIN16_U2 Prefix##_U2; \
|
||||
typedef FFX_MIN16_U3 Prefix##_U3; \
|
||||
typedef FFX_MIN16_U4 Prefix##_U4;
|
||||
|
||||
#define TYPEDEF_16BIT_TYPES(Prefix) \
|
||||
typedef FFX_16BIT_F Prefix##_F; \
|
||||
typedef FFX_16BIT_F2 Prefix##_F2; \
|
||||
typedef FFX_16BIT_F3 Prefix##_F3; \
|
||||
typedef FFX_16BIT_F4 Prefix##_F4; \
|
||||
typedef FFX_16BIT_I Prefix##_I; \
|
||||
typedef FFX_16BIT_I2 Prefix##_I2; \
|
||||
typedef FFX_16BIT_I3 Prefix##_I3; \
|
||||
typedef FFX_16BIT_I4 Prefix##_I4; \
|
||||
typedef FFX_16BIT_U Prefix##_U; \
|
||||
typedef FFX_16BIT_U2 Prefix##_U2; \
|
||||
typedef FFX_16BIT_U3 Prefix##_U3; \
|
||||
typedef FFX_16BIT_U4 Prefix##_U4;
|
||||
|
||||
#define TYPEDEF_FULL_PRECISION_TYPES(Prefix) \
|
||||
typedef FfxFloat32 Prefix##_F; \
|
||||
typedef FfxFloat32x2 Prefix##_F2; \
|
||||
typedef FfxFloat32x3 Prefix##_F3; \
|
||||
typedef FfxFloat32x4 Prefix##_F4; \
|
||||
typedef FfxInt32 Prefix##_I; \
|
||||
typedef FfxInt32x2 Prefix##_I2; \
|
||||
typedef FfxInt32x3 Prefix##_I3; \
|
||||
typedef FfxInt32x4 Prefix##_I4; \
|
||||
typedef FfxUInt32 Prefix##_U; \
|
||||
typedef FfxUInt32x2 Prefix##_U2; \
|
||||
typedef FfxUInt32x3 Prefix##_U3; \
|
||||
typedef FfxUInt32x4 Prefix##_U4;
|
||||
#endif // #if defined(FFX_HLSL)
|
||||
|
||||
#if defined(FFX_GLSL)
|
||||
|
||||
#if FFX_HALF
|
||||
|
||||
#define FFX_MIN16_F float16_t
|
||||
#define FFX_MIN16_F2 f16vec2
|
||||
#define FFX_MIN16_F3 f16vec3
|
||||
#define FFX_MIN16_F4 f16vec4
|
||||
|
||||
#define FFX_MIN16_I int16_t
|
||||
#define FFX_MIN16_I2 i16vec2
|
||||
#define FFX_MIN16_I3 i16vec3
|
||||
#define FFX_MIN16_I4 i16vec4
|
||||
|
||||
#define FFX_MIN16_U uint16_t
|
||||
#define FFX_MIN16_U2 u16vec2
|
||||
#define FFX_MIN16_U3 u16vec3
|
||||
#define FFX_MIN16_U4 u16vec4
|
||||
|
||||
#define FFX_16BIT_F float16_t
|
||||
#define FFX_16BIT_F2 f16vec2
|
||||
#define FFX_16BIT_F3 f16vec3
|
||||
#define FFX_16BIT_F4 f16vec4
|
||||
|
||||
#define FFX_16BIT_I int16_t
|
||||
#define FFX_16BIT_I2 i16vec2
|
||||
#define FFX_16BIT_I3 i16vec3
|
||||
#define FFX_16BIT_I4 i16vec4
|
||||
|
||||
#define FFX_16BIT_U uint16_t
|
||||
#define FFX_16BIT_U2 u16vec2
|
||||
#define FFX_16BIT_U3 u16vec3
|
||||
#define FFX_16BIT_U4 u16vec4
|
||||
|
||||
#else // FFX_HALF
|
||||
|
||||
#define FFX_MIN16_F float
|
||||
#define FFX_MIN16_F2 vec2
|
||||
#define FFX_MIN16_F3 vec3
|
||||
#define FFX_MIN16_F4 vec4
|
||||
|
||||
#define FFX_MIN16_I int
|
||||
#define FFX_MIN16_I2 ivec2
|
||||
#define FFX_MIN16_I3 ivec3
|
||||
#define FFX_MIN16_I4 ivec4
|
||||
|
||||
#define FFX_MIN16_U uint
|
||||
#define FFX_MIN16_U2 uvec2
|
||||
#define FFX_MIN16_U3 uvec3
|
||||
#define FFX_MIN16_U4 uvec4
|
||||
|
||||
#define FFX_16BIT_F float
|
||||
#define FFX_16BIT_F2 vec2
|
||||
#define FFX_16BIT_F3 vec3
|
||||
#define FFX_16BIT_F4 vec4
|
||||
|
||||
#define FFX_16BIT_I int
|
||||
#define FFX_16BIT_I2 ivec2
|
||||
#define FFX_16BIT_I3 ivec3
|
||||
#define FFX_16BIT_I4 ivec4
|
||||
|
||||
#define FFX_16BIT_U uint
|
||||
#define FFX_16BIT_U2 uvec2
|
||||
#define FFX_16BIT_U3 uvec3
|
||||
#define FFX_16BIT_U4 uvec4
|
||||
|
||||
#endif // FFX_HALF
|
||||
|
||||
#endif // #if defined(FFX_GLSL)
|
||||
|
||||
#endif // #if defined(FFX_GPU)
|
||||
#endif // #ifndef FFX_COMMON_TYPES_H
|
||||
80
third_party/fidelityfx-sdk/include/FidelityFX/gpu/ffx_core.h
vendored
Normal file
80
third_party/fidelityfx-sdk/include/FidelityFX/gpu/ffx_core.h
vendored
Normal file
@@ -0,0 +1,80 @@
|
||||
// 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.
|
||||
|
||||
/// @defgroup FfxGPU GPU
|
||||
/// The FidelityFX SDK GPU References
|
||||
///
|
||||
/// @ingroup ffxSDK
|
||||
|
||||
/// @defgroup FfxHLSL HLSL References
|
||||
/// FidelityFX SDK HLSL GPU References
|
||||
///
|
||||
/// @ingroup FfxGPU
|
||||
|
||||
/// @defgroup FfxGLSL GLSL References
|
||||
/// FidelityFX SDK GLSL GPU References
|
||||
///
|
||||
/// @ingroup FfxGPU
|
||||
|
||||
/// @defgroup FfxGPUEffects FidelityFX GPU References
|
||||
/// FidelityFX Effect GPU Reference Documentation
|
||||
///
|
||||
/// @ingroup FfxGPU
|
||||
|
||||
/// @defgroup GPUCore GPU Core
|
||||
/// GPU defines and functions
|
||||
///
|
||||
/// @ingroup FfxGPU
|
||||
|
||||
#if !defined(FFX_CORE_H)
|
||||
#define FFX_CORE_H
|
||||
|
||||
#ifdef __hlsl_dx_compiler
|
||||
#pragma dxc diagnostic push
|
||||
#pragma dxc diagnostic ignored "-Wambig-lit-shift"
|
||||
#endif //__hlsl_dx_compiler
|
||||
|
||||
#include "ffx_common_types.h"
|
||||
|
||||
#if defined(FFX_CPU)
|
||||
#include "ffx_core_cpu.h"
|
||||
#endif // #if defined(FFX_CPU)
|
||||
|
||||
#if defined(FFX_GLSL) && defined(FFX_GPU)
|
||||
#include "ffx_core_glsl.h"
|
||||
#endif // #if defined(FFX_GLSL) && defined(FFX_GPU)
|
||||
|
||||
#if defined(FFX_HLSL) && defined(FFX_GPU)
|
||||
#include "ffx_core_hlsl.h"
|
||||
#endif // #if defined(FFX_HLSL) && defined(FFX_GPU)
|
||||
|
||||
#if defined(FFX_GPU)
|
||||
#include "ffx_core_gpu_common.h"
|
||||
#include "ffx_core_gpu_common_half.h"
|
||||
#include "ffx_core_portability.h"
|
||||
#endif // #if defined(FFX_GPU)
|
||||
|
||||
#ifdef __hlsl_dx_compiler
|
||||
#pragma dxc diagnostic pop
|
||||
#endif //__hlsl_dx_compiler
|
||||
|
||||
#endif // #if !defined(FFX_CORE_H)
|
||||
1916
third_party/fidelityfx-sdk/include/FidelityFX/gpu/ffx_core_glsl.h
vendored
Normal file
1916
third_party/fidelityfx-sdk/include/FidelityFX/gpu/ffx_core_glsl.h
vendored
Normal file
File diff suppressed because it is too large
Load Diff
2736
third_party/fidelityfx-sdk/include/FidelityFX/gpu/ffx_core_gpu_common.h
vendored
Normal file
2736
third_party/fidelityfx-sdk/include/FidelityFX/gpu/ffx_core_gpu_common.h
vendored
Normal file
File diff suppressed because it is too large
Load Diff
2981
third_party/fidelityfx-sdk/include/FidelityFX/gpu/ffx_core_gpu_common_half.h
vendored
Normal file
2981
third_party/fidelityfx-sdk/include/FidelityFX/gpu/ffx_core_gpu_common_half.h
vendored
Normal file
File diff suppressed because it is too large
Load Diff
46
third_party/fidelityfx-sdk/include/FidelityFX/gpu/ffx_core_portability.h
vendored
Normal file
46
third_party/fidelityfx-sdk/include/FidelityFX/gpu/ffx_core_portability.h
vendored
Normal file
@@ -0,0 +1,46 @@
|
||||
// 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.
|
||||
|
||||
void ffxOpAAddOneF3(FFX_PARAMETER_OUT FfxFloat32x3 d, FfxFloat32x3 a, FfxFloat32 b)
|
||||
{
|
||||
d = a + ffxBroadcast3(b);
|
||||
}
|
||||
|
||||
void ffxOpACpyF3(FFX_PARAMETER_OUT FfxFloat32x3 d, FfxFloat32x3 a)
|
||||
{
|
||||
d = a;
|
||||
}
|
||||
|
||||
void ffxOpAMulF3(FFX_PARAMETER_OUT FfxFloat32x3 d, FfxFloat32x3 a, FfxFloat32x3 b)
|
||||
{
|
||||
d = a * b;
|
||||
}
|
||||
|
||||
void ffxOpAMulOneF3(FFX_PARAMETER_OUT FfxFloat32x3 d, FfxFloat32x3 a, FfxFloat32 b)
|
||||
{
|
||||
d = a * b;
|
||||
}
|
||||
|
||||
void ffxOpARcpF3(FFX_PARAMETER_OUT FfxFloat32x3 d, FfxFloat32x3 a)
|
||||
{
|
||||
d = ffxReciprocal(a);
|
||||
}
|
||||
@@ -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.
|
||||
|
||||
set(FRAMEINTERPOLATION_BASE_ARGS
|
||||
-DFFX_FRAMEINTERPOLATION_OPTION_UPSAMPLE_SAMPLERS_USE_DATA_HALF=0
|
||||
-DFFX_FRAMEINTERPOLATION_OPTION_ACCUMULATE_SAMPLERS_USE_DATA_HALF=0
|
||||
-DFFX_FRAMEINTERPOLATION_OPTION_REPROJECT_SAMPLERS_USE_DATA_HALF=1
|
||||
-DFFX_FRAMEINTERPOLATION_OPTION_POSTPROCESSLOCKSTATUS_SAMPLERS_USE_DATA_HALF=0
|
||||
# Upsample uses lanczos approximation
|
||||
-DFFX_FRAMEINTERPOLATION_OPTION_UPSAMPLE_USE_LANCZOS_TYPE=2
|
||||
-reflection -deps=gcc -DFFX_GPU=1)
|
||||
|
||||
set(FRAMEINTERPOLATION_PERMUTATION_ARGS
|
||||
-DFFX_FRAMEINTERPOLATION_OPTION_LOW_RES_MOTION_VECTORS={0,1}
|
||||
-DFFX_FRAMEINTERPOLATION_OPTION_JITTER_MOTION_VECTORS={0,1}
|
||||
-DFFX_FRAMEINTERPOLATION_OPTION_INVERTED_DEPTH={0,1})
|
||||
|
||||
set(FRAMEINTERPOLATION_INCLUDE_ARGS
|
||||
"${FFX_GPU_PATH}"
|
||||
"${FFX_GPU_PATH}/frameinterpolation")
|
||||
|
||||
if (NOT FRAMEINTERPOLATION_SHADER_EXT)
|
||||
set(FRAMEINTERPOLATION_SHADER_EXT *)
|
||||
endif()
|
||||
|
||||
file(GLOB FRAMEINTERPOLATION_SHADERS
|
||||
"shaders/frameinterpolation/*.${FRAMEINTERPOLATION_SHADER_EXT}")
|
||||
|
||||
# compile all the shaders
|
||||
compile_shaders_with_depfile(
|
||||
"${FFX_SC_EXECUTABLE}"
|
||||
"${FRAMEINTERPOLATION_BASE_ARGS}" "${FRAMEINTERPOLATION_API_BASE_ARGS}" "${FRAMEINTERPOLATION_PERMUTATION_ARGS}" "${FRAMEINTERPOLATION_INCLUDE_ARGS}"
|
||||
"${FRAMEINTERPOLATION_SHADERS}" "${FFX_PASS_SHADER_OUTPUT_PATH}" FRAMEINTERPOLATION_PERMUTATION_OUTPUTS)
|
||||
|
||||
# add the header files they generate to the main list of dependencies
|
||||
add_shader_output("${FRAMEINTERPOLATION_PERMUTATION_OUTPUTS}")
|
||||
187
third_party/fidelityfx-sdk/include/FidelityFX/gpu/frameinterpolation/ffx_frameinterpolation.h
vendored
Normal file
187
third_party/fidelityfx-sdk/include/FidelityFX/gpu/frameinterpolation/ffx_frameinterpolation.h
vendored
Normal file
@@ -0,0 +1,187 @@
|
||||
// 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()); // Get in previous frame buffer, the color of interpolated pixel
|
||||
InterpolationSourceColor fCurrColorGame = SampleTextureBilinear(true, fUvInScreenSpace, -gameMv.fMotionVector * fUvLetterBoxScale, DisplaySize()); // Get color in current framebuffer, of color of interpolated pixel
|
||||
|
||||
InterpolationSourceColor fPrevColorOF = SampleTextureBilinear(false, fUvInScreenSpace, +ofMv.fMotionVector * fUvLetterBoxScale, DisplaySize());
|
||||
InterpolationSourceColor fCurrColorOF = SampleTextureBilinear(true, fUvInScreenSpace, -ofMv.fMotionVector * fUvLetterBoxScale, DisplaySize());
|
||||
|
||||
FfxFloat32 fDisoccludedFactor = 0.0f;
|
||||
|
||||
// Disocclusion logic
|
||||
{
|
||||
fDisocclusionFactor.x *= FfxFloat32(!gameMv.bPosOutside); // fDisocclusionFactor.x of 1 means the pos of interpolated pixel is within bounds of previous frame.
|
||||
fDisocclusionFactor.y *= FfxFloat32(!gameMv.bNegOutside); // fDisocclusionFactor.y of 1 means the pos of interpolated pixel is within bounds of current frame
|
||||
|
||||
// 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));
|
||||
// Say if fDisocclusionFactor.x is 1 and fDisocclusionFactor.y = 0, then t will be 0. fInterpolatedColor will be entirely from fPrevColorGame
|
||||
fInterpolatedColor = ffxLerp(fPrevColorGame.fRaw, fCurrColorGame.fRaw, ffxSaturate(t));
|
||||
fDisoccludedFactor = ffxSaturate(1 - ffxMin(fDisocclusionFactor.x, fDisocclusionFactor.y));
|
||||
|
||||
if (fPrevColorGame.fBilinearWeightSum == 0.0f)
|
||||
{
|
||||
fInterpolatedColor = fCurrColorGame.fRaw;
|
||||
}
|
||||
else if (fCurrColorGame.fBilinearWeightSum == 0.0f)
|
||||
{
|
||||
fInterpolatedColor = fPrevColorGame.fRaw;
|
||||
}
|
||||
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
|
||||
@@ -0,0 +1,758 @@
|
||||
// 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"
|
||||
#include "ffx_core.h"
|
||||
|
||||
#define COUNTER_SPD 0
|
||||
#define COUNTER_FRAME_INDEX_SINCE_LAST_RESET 1
|
||||
|
||||
///////////////////////////////////////////////
|
||||
// declare CBs and CB accessors
|
||||
///////////////////////////////////////////////
|
||||
#if defined(FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION)
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION, std140) uniform cbFI_t
|
||||
{
|
||||
FfxInt32x2 renderSize;
|
||||
FfxInt32x2 displaySize;
|
||||
|
||||
FfxFloat32x2 displaySizeRcp;
|
||||
FfxFloat32 cameraNear;
|
||||
FfxFloat32 cameraFar;
|
||||
|
||||
FfxInt32x2 upscalerTargetSize;
|
||||
FfxInt32 Mode;
|
||||
FfxInt32 reset;
|
||||
|
||||
FfxFloat32x4 fDeviceToViewDepth;
|
||||
|
||||
FfxFloat32 deltaTime;
|
||||
FfxInt32 HUDLessAttachedFactor;
|
||||
FfxInt32x2 distortionFieldSize;
|
||||
|
||||
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;
|
||||
} cbFI;
|
||||
|
||||
FfxFloat32x2 Jitter()
|
||||
{
|
||||
return cbFI.fJitter;
|
||||
}
|
||||
|
||||
FfxInt32x2 InterpolationRectBase()
|
||||
{
|
||||
return cbFI.interpolationRectBase;
|
||||
}
|
||||
|
||||
FfxInt32x2 InterpolationRectSize()
|
||||
{
|
||||
return cbFI.interpolationRectSize;
|
||||
}
|
||||
|
||||
FfxFloat32x2 MotionVectorScale()
|
||||
{
|
||||
return cbFI.fMotionVectorScale;
|
||||
}
|
||||
|
||||
FfxInt32x2 RenderSize()
|
||||
{
|
||||
return cbFI.renderSize;
|
||||
}
|
||||
|
||||
FfxInt32x2 DisplaySize()
|
||||
{
|
||||
return cbFI.displaySize;
|
||||
}
|
||||
|
||||
FfxBoolean Reset()
|
||||
{
|
||||
return cbFI.reset == 1;
|
||||
}
|
||||
|
||||
FfxFloat32x4 DeviceToViewSpaceTransformFactors()
|
||||
{
|
||||
return cbFI.fDeviceToViewDepth;
|
||||
}
|
||||
|
||||
FfxInt32x2 GetOpticalFlowSize()
|
||||
{
|
||||
FfxInt32x2 iOpticalFlowSize = FfxInt32x2((1.0 / cbFI.opticalFlowScale) / FfxFloat32x2(cbFI.opticalFlowBlockSize.xx));
|
||||
|
||||
return iOpticalFlowSize;
|
||||
}
|
||||
|
||||
FfxInt32x2 GetOpticalFlowSize2()
|
||||
{
|
||||
return GetOpticalFlowSize() * 1;
|
||||
}
|
||||
|
||||
FfxFloat32x2 GetOpticalFlowScale()
|
||||
{
|
||||
return cbFI.opticalFlowScale;
|
||||
}
|
||||
|
||||
FfxInt32 GetOpticalFlowBlockSize()
|
||||
{
|
||||
return cbFI.opticalFlowBlockSize;
|
||||
}
|
||||
|
||||
FfxInt32 GetHUDLessAttachedFactor()
|
||||
{
|
||||
return cbFI.HUDLessAttachedFactor;
|
||||
}
|
||||
|
||||
FfxInt32x2 GetDistortionFieldSize()
|
||||
{
|
||||
return cbFI.distortionFieldSize;
|
||||
}
|
||||
|
||||
FfxUInt32 GetDispatchFlags()
|
||||
{
|
||||
return cbFI.dispatchFlags;
|
||||
}
|
||||
|
||||
FfxInt32x2 GetMaxRenderSize()
|
||||
{
|
||||
return cbFI.maxRenderSize;
|
||||
}
|
||||
|
||||
FfxInt32 GetOpticalFlowHalfResMode()
|
||||
{
|
||||
return cbFI.opticalFlowHalfResMode;
|
||||
}
|
||||
|
||||
FfxFloat32x3 GetDebugBarColor()
|
||||
{
|
||||
return cbFI.debugBarColor;
|
||||
}
|
||||
|
||||
FfxFloat32 TanHalfFoV()
|
||||
{
|
||||
return cbFI.fTanHalfFOV;
|
||||
}
|
||||
|
||||
FfxUInt32 BackBufferTransferFunction()
|
||||
{
|
||||
return cbFI.backBufferTransferFunction;
|
||||
}
|
||||
|
||||
FfxFloat32 MinLuminance()
|
||||
{
|
||||
return cbFI.minMaxLuminance[0];
|
||||
}
|
||||
|
||||
FfxFloat32 MaxLuminance()
|
||||
{
|
||||
return cbFI.minMaxLuminance[1];
|
||||
}
|
||||
|
||||
#endif // defined(FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION)
|
||||
|
||||
|
||||
#if defined(FFX_FRAMEINTERPOLATION_BIND_CB_INPAINTING_PYRAMID)
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_CB_INPAINTING_PYRAMID, std140) uniform cbInpaintingPyramid_t
|
||||
{
|
||||
FfxUInt32 mips;
|
||||
FfxUInt32 numWorkGroups;
|
||||
FfxUInt32x2 workGroupOffset;
|
||||
} cbInpaintingPyramid;
|
||||
|
||||
FfxUInt32 NumMips()
|
||||
{
|
||||
return cbInpaintingPyramid.mips;
|
||||
}
|
||||
FfxUInt32 NumWorkGroups()
|
||||
{
|
||||
return cbInpaintingPyramid.numWorkGroups;
|
||||
}
|
||||
FfxUInt32x2 WorkGroupOffset()
|
||||
{
|
||||
return cbInpaintingPyramid.workGroupOffset;
|
||||
}
|
||||
|
||||
#endif // defined(FFX_FRAMEINTERPOLATION_BIND_CB_INPAINTING_PYRAMID)
|
||||
|
||||
|
||||
///////////////////////////////////////////////
|
||||
// declare samplers
|
||||
///////////////////////////////////////////////
|
||||
|
||||
|
||||
layout (set = 0, binding = 1000) uniform sampler s_LinearClamp;
|
||||
|
||||
///////////////////////////////////////////////
|
||||
// declare SRVs and SRV accessors
|
||||
///////////////////////////////////////////////
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_PREVIOUS_INTERPOLATION_SOURCE
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_PREVIOUS_INTERPOLATION_SOURCE) uniform texture2D r_previous_interpolation_source;
|
||||
|
||||
FfxFloat32x3 LoadPreviousBackbuffer(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_previous_interpolation_source, iPxPos, 0).rgb;
|
||||
}
|
||||
FfxFloat32x3 SamplePreviousBackbuffer(FFX_PARAMETER_IN FfxFloat32x2 fUv)
|
||||
{
|
||||
return textureLod(sampler2D(r_previous_interpolation_source, s_LinearClamp), fUv, 0.0).xyz;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_CURRENT_INTERPOLATION_SOURCE
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_CURRENT_INTERPOLATION_SOURCE) uniform texture2D r_current_interpolation_source;
|
||||
|
||||
FfxFloat32x3 LoadCurrentBackbuffer(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_current_interpolation_source, iPxPos, 0).rgb;
|
||||
}
|
||||
FfxFloat32x3 SampleCurrentBackbuffer(FFX_PARAMETER_IN FfxFloat32x2 fUv)
|
||||
{
|
||||
return textureLod(sampler2D(r_current_interpolation_source, s_LinearClamp), fUv, 0.0).xyz;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_DILATED_MOTION_VECTORS
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_DILATED_MOTION_VECTORS) uniform texture2D r_dilated_motion_vectors;
|
||||
|
||||
FfxFloat32x2 LoadDilatedMotionVector(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_dilated_motion_vectors, iPxPos, 0).xy;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_DILATED_DEPTH
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_DILATED_DEPTH) uniform texture2D r_dilated_depth;
|
||||
|
||||
FfxFloat32 LoadDilatedDepth(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_dilated_depth, iPxPos, 0).x;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_RECONSTRUCTED_DEPTH_PREVIOUS_FRAME
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_RECONSTRUCTED_DEPTH_PREVIOUS_FRAME) uniform utexture2D r_reconstructed_depth_previous_frame;
|
||||
|
||||
FfxFloat32 LoadReconstructedDepthPreviousFrame(FFX_PARAMETER_IN FfxInt32x2 iPxInput)
|
||||
{
|
||||
return ffxAsFloat(texelFetch(r_reconstructed_depth_previous_frame, iPxInput, 0).x);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_RECONSTRUCTED_DEPTH_INTERPOLATED_FRAME
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_RECONSTRUCTED_DEPTH_INTERPOLATED_FRAME) uniform utexture2D r_reconstructed_depth_interpolated_frame;
|
||||
|
||||
FfxFloat32 LoadEstimatedInterpolationFrameDepth(FFX_PARAMETER_IN FfxInt32x2 iPxInput)
|
||||
{
|
||||
return ffxAsFloat(texelFetch(r_reconstructed_depth_interpolated_frame, iPxInput, 0).x);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_DISOCCLUSION_MASK
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_DISOCCLUSION_MASK) uniform texture2D r_disocclusion_mask;
|
||||
|
||||
FfxFloat32x4 LoadDisocclusionMask(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_disocclusion_mask, iPxPos, 0);
|
||||
}
|
||||
FfxFloat32x4 SampleDisocclusionMask(FFX_PARAMETER_IN FfxFloat32x2 fUv)
|
||||
{
|
||||
return textureLod(sampler2D(r_disocclusion_mask, 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)
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_GAME_MOTION_VECTOR_FIELD_X) uniform utexture2D r_game_motion_vector_field_x;
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_GAME_MOTION_VECTOR_FIELD_Y) uniform utexture2D r_game_motion_vector_field_y;
|
||||
|
||||
FfxUInt32x2 LoadGameFieldMv(FFX_PARAMETER_IN FfxInt32x2 iPxSample)
|
||||
{
|
||||
FfxUInt32 packedX = texelFetch(r_game_motion_vector_field_x, iPxSample, 0).x;
|
||||
FfxUInt32 packedY = texelFetch(r_game_motion_vector_field_y, iPxSample, 0).x;
|
||||
|
||||
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)
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_X) uniform utexture2D r_optical_flow_motion_vector_field_x;
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_Y) uniform utexture2D r_optical_flow_motion_vector_field_y;
|
||||
|
||||
FfxUInt32x2 LoadOpticalFlowFieldMv(FFX_PARAMETER_IN FfxInt32x2 iPxSample)
|
||||
{
|
||||
FfxUInt32 packedX = texelFetch(r_optical_flow_motion_vector_field_x, iPxSample, 0).x;
|
||||
FfxUInt32 packedY = texelFetch(r_optical_flow_motion_vector_field_y, iPxSample, 0).x;
|
||||
|
||||
return FfxUInt32x2(packedX, packedY);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW) uniform itexture2D r_optical_flow;
|
||||
|
||||
#if defined(FFX_FRAMEINTERPOLATION_BIND_CB_FRAMEINTERPOLATION)
|
||||
FfxFloat32x2 LoadOpticalFlow(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_optical_flow, iPxPos, 0).xy * GetOpticalFlowScale();
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_UPSAMPLED
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_UPSAMPLED) uniform texture2D r_optical_flow_upsampled;
|
||||
|
||||
FfxFloat32x2 LoadOpticalFlowUpsampled(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_optical_flow_upsampled, iPxPos, 0).xy;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_CONFIDENCE
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_CONFIDENCE) uniform utexture2D r_optical_flow_confidence;
|
||||
|
||||
FfxFloat32 LoadOpticalFlowConfidence(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_optical_flow_confidence, iPxPos, 0).y;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_GLOBAL_MOTION
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_GLOBAL_MOTION) uniform utexture2D r_optical_flow_global_motion;
|
||||
|
||||
FfxUInt32 LoadOpticalFlowGlobalMotion(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_optical_flow_global_motion, iPxPos, 0).x;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_SCENE_CHANGE_DETECTION
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_SCENE_CHANGE_DETECTION) uniform utexture2D r_optical_flow_scd;
|
||||
|
||||
FfxUInt32 LoadOpticalFlowSceneChangeDetection(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_optical_flow_scd, iPxPos, 0).x;
|
||||
}
|
||||
|
||||
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 ((texelFetch(r_optical_flow_scd, FfxInt32x2(SCD_OUTPUT_HISTORY_BITS_SLOT, 0), 0).x) & 0xfu) != 0;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_DEBUG
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_DEBUG) uniform texture2D r_optical_flow_debug;
|
||||
|
||||
FfxFloat32x4 LoadOpticalFlowDebug(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_optical_flow_debug, iPxPos, 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_OUTPUT
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_OUTPUT) uniform texture2D r_output;
|
||||
|
||||
FfxFloat32x4 LoadFrameInterpolationOutput(FFX_PARAMETER_IN FfxInt32x2 iPxInput)
|
||||
{
|
||||
return texelFetch(r_output, iPxInput, 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_INPAINTING_PYRAMID
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_INPAINTING_PYRAMID) uniform texture2D r_inpainting_pyramid;
|
||||
|
||||
FfxFloat32x4 LoadInpaintingPyramid(FFX_PARAMETER_IN FfxInt32 mipLevel, FFX_PARAMETER_IN FfxUInt32x2 iPxInput)
|
||||
{
|
||||
return texelFetch(r_inpainting_pyramid, FfxInt32x2(iPxInput), mipLevel);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_PRESENT_BACKBUFFER
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_PRESENT_BACKBUFFER) uniform texture2D r_present_backbuffer;
|
||||
|
||||
FfxFloat32x4 LoadPresentBackbuffer(FFX_PARAMETER_IN FfxInt32x2 iPxInput)
|
||||
{
|
||||
return texelFetch(r_present_backbuffer, iPxInput, 0);
|
||||
}
|
||||
FfxFloat32x4 SamplePresentBackbuffer(FFX_PARAMETER_IN FfxFloat32x2 fUv)
|
||||
{
|
||||
return textureLod(sampler2D(r_present_backbuffer, s_LinearClamp), fUv, 0.0);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_SRV_COUNTERS
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_COUNTERS) readonly buffer FrameInterpolationCounters_t
|
||||
{
|
||||
FfxUInt32 data[];
|
||||
} r_counters;
|
||||
|
||||
FfxUInt32 LoadCounter(FFX_PARAMETER_IN FfxInt32 iPxPos)
|
||||
{
|
||||
return r_counters.data[iPxPos];
|
||||
}
|
||||
|
||||
FfxUInt32 FrameIndexSinceLastReset()
|
||||
{
|
||||
return LoadCounter(COUNTER_FRAME_INDEX_SINCE_LAST_RESET);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#if defined(FFX_FRAMEINTERPOLATION_BIND_SRV_INPUT_DEPTH)
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_INPUT_DEPTH) uniform texture2D r_input_depth;
|
||||
|
||||
FfxFloat32 LoadInputDepth(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_input_depth, iPxPos, 0).x;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_FRAMEINTERPOLATION_BIND_SRV_INPUT_MOTION_VECTORS)
|
||||
layout (set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_INPUT_MOTION_VECTORS) uniform texture2D r_input_motion_vectors;
|
||||
|
||||
FfxFloat32x2 LoadInputMotionVector(FfxInt32x2 iPxDilatedMotionVectorPos)
|
||||
{
|
||||
FfxFloat32x2 fSrcMotionVector = texelFetch(r_input_motion_vectors, iPxDilatedMotionVectorPos, 0).xy;
|
||||
|
||||
FfxFloat32x2 fUvMotionVector = fSrcMotionVector * MotionVectorScale();
|
||||
|
||||
#if FFX_FRAMEINTERPOLATION_OPTION_JITTERED_MOTION_VECTORS
|
||||
fUvMotionVector -= MotionVectorJitterCancellation();
|
||||
#endif
|
||||
|
||||
return fUvMotionVector;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_FRAMEINTERPOLATION_BIND_SRV_DISTORTION_FIELD)
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_SRV_DISTORTION_FIELD) uniform texture2D r_input_distortion_field;
|
||||
FfxFloat32x2 SampleDistortionField(FFX_PARAMETER_IN FfxFloat32x2 fUv)
|
||||
{
|
||||
return textureLod(sampler2D(r_input_distortion_field, s_LinearClamp), fUv, 0.0).xy;
|
||||
}
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////
|
||||
// declare UAVs and UAV accessors
|
||||
///////////////////////////////////////////////
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_UAV_OUTPUT
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_OUTPUT /* app controlled format */) uniform image2D rw_output;
|
||||
|
||||
FfxFloat32x4 RWLoadFrameinterpolationOutput(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return imageLoad(rw_output, iPxPos);
|
||||
}
|
||||
|
||||
void StoreFrameinterpolationOutput(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x4 val)
|
||||
{
|
||||
imageStore(rw_output, iPxPos, val);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_UAV_DILATED_MOTION_VECTORS
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_DILATED_MOTION_VECTORS, rg16f) uniform image2D rw_dilated_motion_vectors;
|
||||
|
||||
FfxFloat32x2 RWLoadDilatedMotionVectors(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return imageLoad(rw_dilated_motion_vectors, iPxPos).xy;
|
||||
}
|
||||
|
||||
void StoreDilatedMotionVectors(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x2 val)
|
||||
{
|
||||
imageStore(rw_dilated_motion_vectors, iPxPos, FfxFloat32x4(val, 0.0, 0.0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_UAV_DILATED_DEPTH
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_DILATED_DEPTH, r32f) uniform image2D rw_dilated_depth;
|
||||
|
||||
FfxFloat32 RWLoadDilatedDepth(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return imageLoad(rw_dilated_depth, iPxPos).x;
|
||||
}
|
||||
|
||||
void StoreDilatedDepth(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32 val)
|
||||
{
|
||||
imageStore(rw_dilated_depth, iPxPos, FfxFloat32x4(val, 0.0, 0.0, 0.0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_UAV_RECONSTRUCTED_DEPTH_PREVIOUS_FRAME
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_RECONSTRUCTED_DEPTH_PREVIOUS_FRAME, r32ui) uniform uimage2D rw_reconstructed_depth_previous_frame;
|
||||
|
||||
FfxFloat32 RWLoadReconstructedDepthPreviousFrame(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return ffxAsFloat(imageLoad(rw_reconstructed_depth_previous_frame, iPxPos).x);
|
||||
}
|
||||
|
||||
void UpdateReconstructedDepthPreviousFrame(FfxInt32x2 iPxSample, FfxFloat32 fDepth)
|
||||
{
|
||||
FfxUInt32 uDepth = ffxAsUInt32(fDepth);
|
||||
|
||||
#if FFX_FRAMEINTERPOLATION_OPTION_INVERTED_DEPTH
|
||||
imageAtomicMax(rw_reconstructed_depth_previous_frame, iPxSample, uDepth);
|
||||
#else
|
||||
imageAtomicMin(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
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_RECONSTRUCTED_DEPTH_INTERPOLATED_FRAME, r32ui) uniform uimage2D rw_reconstructed_depth_interpolated_frame;
|
||||
|
||||
FfxFloat32 RWLoadReconstructedDepthInterpolatedFrame(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return ffxAsFloat(imageLoad(rw_reconstructed_depth_interpolated_frame, iPxPos).x);
|
||||
}
|
||||
|
||||
void StoreReconstructedDepthInterpolatedFrame(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32 value)
|
||||
{
|
||||
FfxUInt32 uDepth = ffxAsUInt32(value);
|
||||
imageStore(rw_reconstructed_depth_interpolated_frame, iPxPos, FfxUInt32x4(uDepth, 0, 0, 0));
|
||||
}
|
||||
|
||||
void UpdateReconstructedDepthInterpolatedFrame(FfxInt32x2 iPxSample, FfxFloat32 fDepth)
|
||||
{
|
||||
FfxUInt32 uDepth = ffxAsUInt32(fDepth);
|
||||
|
||||
#if FFX_FRAMEINTERPOLATION_OPTION_INVERTED_DEPTH
|
||||
imageAtomicMax(rw_reconstructed_depth_interpolated_frame, iPxSample, uDepth);
|
||||
#else
|
||||
imageAtomicMin(rw_reconstructed_depth_interpolated_frame, iPxSample, uDepth); // min for standard, max for inverted depth
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_UAV_DISOCCLUSION_MASK
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_DISOCCLUSION_MASK, rg8) uniform image2D rw_disocclusion_mask;
|
||||
|
||||
FfxFloat32x2 RWLoadDisocclusionMask(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return imageLoad(rw_disocclusion_mask, iPxPos).xy;
|
||||
}
|
||||
|
||||
void StoreDisocclusionMask(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x2 val)
|
||||
{
|
||||
imageStore(rw_disocclusion_mask, iPxPos, FfxFloat32x4(val, 0.0, 0.0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_FRAMEINTERPOLATION_BIND_UAV_GAME_MOTION_VECTOR_FIELD_X) && \
|
||||
defined(FFX_FRAMEINTERPOLATION_BIND_UAV_GAME_MOTION_VECTOR_FIELD_Y)
|
||||
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_GAME_MOTION_VECTOR_FIELD_X, r32ui) uniform uimage2D rw_game_motion_vector_field_x;
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_GAME_MOTION_VECTOR_FIELD_Y, r32ui) uniform uimage2D rw_game_motion_vector_field_y;
|
||||
|
||||
FfxUInt32 RWLoadGameMotionVectorFieldX(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return imageLoad(rw_game_motion_vector_field_x, iPxPos).x;
|
||||
}
|
||||
|
||||
void StoreGameMotionVectorFieldX(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32 val)
|
||||
{
|
||||
imageStore(rw_game_motion_vector_field_x, iPxPos, FfxUInt32x4(val, 0, 0, 0));
|
||||
}
|
||||
|
||||
FfxUInt32 RWLoadGameMotionVectorFieldY(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return imageLoad(rw_game_motion_vector_field_y, iPxPos).x;
|
||||
}
|
||||
|
||||
void StoreGameMotionVectorFieldY(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32 val)
|
||||
{
|
||||
imageStore(rw_game_motion_vector_field_y, iPxPos, FfxUInt32x4(val, 0, 0, 0));
|
||||
}
|
||||
|
||||
void UpdateGameMotionVectorField(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32x2 packedVector)
|
||||
{
|
||||
imageAtomicMax(rw_game_motion_vector_field_x, iPxPos, packedVector.x);
|
||||
imageAtomicMax(rw_game_motion_vector_field_y, iPxPos, packedVector.y);
|
||||
}
|
||||
|
||||
FfxUInt32 UpdateGameMotionVectorFieldEx(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32x2 packedVector)
|
||||
{
|
||||
FfxUInt32 uPreviousValueX = imageAtomicMax(rw_game_motion_vector_field_x, iPxPos, packedVector.x);
|
||||
FfxUInt32 uPreviousValueY = imageAtomicMax(rw_game_motion_vector_field_y, iPxPos, packedVector.y);
|
||||
|
||||
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)
|
||||
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_X, r32ui) uniform uimage2D rw_optical_flow_motion_vector_field_x;
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_Y, r32ui) uniform uimage2D rw_optical_flow_motion_vector_field_y;
|
||||
|
||||
FfxUInt32 RWLoadOpticalflowMotionVectorFieldX(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return imageLoad(rw_optical_flow_motion_vector_field_x, iPxPos).x;
|
||||
}
|
||||
void StoreOpticalflowMotionVectorFieldX(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32 val)
|
||||
{
|
||||
imageStore(rw_optical_flow_motion_vector_field_x, iPxPos, FfxUInt32x4(val, 0, 0, 0));
|
||||
}
|
||||
FfxUInt32 RWLoadOpticalflowMotionVectorFieldY(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return imageLoad(rw_optical_flow_motion_vector_field_y, iPxPos).x;
|
||||
}
|
||||
void StoreOpticalflowMotionVectorFieldY(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32 val)
|
||||
{
|
||||
imageStore(rw_optical_flow_motion_vector_field_y, iPxPos, FfxUInt32x4(val, 0, 0, 0));
|
||||
}
|
||||
void UpdateOpticalflowMotionVectorField(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32x2 packedVector)
|
||||
{
|
||||
imageAtomicMax(rw_optical_flow_motion_vector_field_x, iPxPos, packedVector.x);
|
||||
imageAtomicMax(rw_optical_flow_motion_vector_field_y, iPxPos, packedVector.y);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FFX_FRAMEINTERPOLATION_BIND_UAV_COUNTERS
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_COUNTERS) coherent buffer FrameInterpolationRWCounters_t
|
||||
{
|
||||
FfxUInt32 data[];
|
||||
} rw_counters;
|
||||
|
||||
FfxUInt32 RWLoadCounter(FFX_PARAMETER_IN FfxInt32 iPxPos)
|
||||
{
|
||||
return rw_counters.data[iPxPos];
|
||||
}
|
||||
|
||||
void StoreCounter(FFX_PARAMETER_IN FfxInt32 iPxPos, FFX_PARAMETER_IN FfxUInt32 counter)
|
||||
{
|
||||
rw_counters.data[iPxPos] = counter;
|
||||
}
|
||||
void AtomicIncreaseCounter(FFX_PARAMETER_IN FfxInt32 iPxPos, FFX_PARAMETER_OUT FfxUInt32 oldVal)
|
||||
{
|
||||
oldVal = atomicAdd(rw_counters.data[iPxPos], 1);
|
||||
}
|
||||
#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)
|
||||
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_0, rgba16f) uniform image2D rw_inpainting_pyramid0;
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_1, rgba16f) uniform image2D rw_inpainting_pyramid1;
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_2, rgba16f) uniform image2D rw_inpainting_pyramid2;
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_3, rgba16f) uniform image2D rw_inpainting_pyramid3;
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_4, rgba16f) uniform image2D rw_inpainting_pyramid4;
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_5, rgba16f) coherent uniform image2D rw_inpainting_pyramid5;
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_6, rgba16f) uniform image2D rw_inpainting_pyramid6;
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_7, rgba16f) uniform image2D rw_inpainting_pyramid7;
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_8, rgba16f) uniform image2D rw_inpainting_pyramid8;
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_9, rgba16f) uniform image2D rw_inpainting_pyramid9;
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_10, rgba16f) uniform image2D rw_inpainting_pyramid10;
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_11, rgba16f) uniform image2D rw_inpainting_pyramid11;
|
||||
layout(set = 0, binding = FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_12, rgba16f) uniform image2D rw_inpainting_pyramid12;
|
||||
|
||||
|
||||
FfxFloat32x4 RWLoadInpaintingPyramid(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32 index)
|
||||
{
|
||||
#define LOAD(idx) \
|
||||
if (index == idx) \
|
||||
{ \
|
||||
return imageLoad(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 FfxFloat32x4(0.0, 0.0, 0.0, 0.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) \
|
||||
{ \
|
||||
imageStore(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
|
||||
@@ -0,0 +1,814 @@
|
||||
// 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;
|
||||
FfxInt32x2 distortionFieldSize;
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
FfxInt32x2 GetDistortionFieldSize()
|
||||
{
|
||||
return distortionFieldSize;
|
||||
}
|
||||
|
||||
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<FfxFloat32x4> 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<FfxFloat32x4> 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<FfxFloat32x2> 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<FfxFloat32> 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<FfxUInt32> 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<FfxUInt32> 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<FfxFloat32x4> 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<FfxUInt32> r_game_motion_vector_field_x : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_GAME_MOTION_VECTOR_FIELD_X);
|
||||
Texture2D<FfxUInt32> 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<FfxUInt32> r_optical_flow_motion_vector_field_x : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_X);
|
||||
Texture2D<FfxUInt32> 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<FfxInt32x2> 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<FfxFloat32x2> 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<FfxUInt32x2> 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<FfxUInt32> 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<FfxUInt32> 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<FfxFloat32x4> 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
|
||||
|
||||
#if defined(FFX_FRAMEINTERPOLATION_BIND_SRV_INPAINTING_MASK) && defined(FFX_FRAMEINTERPOLATION_BIND_SRV_OUTPUT)
|
||||
Texture2D<FfxFloat32x3> r_output : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_OUTPUT);
|
||||
Texture2D<FfxFloat32> r_inpainting_mask : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_INPAINTING_MASK);
|
||||
|
||||
FfxFloat32x4 LoadFrameInterpolationOutput(FFX_PARAMETER_IN FfxInt32x2 iPxInput)
|
||||
{
|
||||
return FfxFloat32x4(r_output[iPxInput], r_inpainting_mask[iPxInput]);
|
||||
}
|
||||
#elif defined(FFX_FRAMEINTERPOLATION_BIND_SRV_OUTPUT)
|
||||
Texture2D<FfxFloat32x4> 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<FfxFloat32x4> 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<FfxFloat32x4> 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<FfxUInt32> 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<FfxFloat32> 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<FfxFloat32x4> 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
|
||||
|
||||
#if defined(FFX_FRAMEINTERPOLATION_BIND_SRV_DISTORTION_FIELD)
|
||||
Texture2D<FfxFloat32x2> r_input_distortion_field : FFX_DECLARE_SRV(FFX_FRAMEINTERPOLATION_BIND_SRV_DISTORTION_FIELD);
|
||||
FfxFloat32x2 SampleDistortionField(FFX_PARAMETER_IN FfxFloat32x2 fUv)
|
||||
{
|
||||
return r_input_distortion_field.SampleLevel(s_LinearClamp, fUv, 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////
|
||||
// declare UAVs and UAV accessors
|
||||
///////////////////////////////////////////////
|
||||
#if defined(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_MASK) && defined(FFX_FRAMEINTERPOLATION_BIND_UAV_OUTPUT)
|
||||
RWTexture2D<FfxFloat32x3> rw_output : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_OUTPUT);
|
||||
RWTexture2D<FfxFloat32> rw_inpainting_mask : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_MASK);
|
||||
|
||||
FfxFloat32x4 RWLoadFrameinterpolationOutput(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
return FfxFloat32x4(rw_output[iPxPos], rw_inpainting_mask[iPxPos]);
|
||||
}
|
||||
|
||||
void StoreFrameinterpolationOutput(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x4 val)
|
||||
{
|
||||
rw_output[iPxPos] = val.rgb;
|
||||
rw_inpainting_mask[iPxPos] = val.a;
|
||||
}
|
||||
|
||||
#elif defined(FFX_FRAMEINTERPOLATION_BIND_UAV_OUTPUT)
|
||||
RWTexture2D<FfxFloat32x4> 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<FfxFloat32x2> 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<FfxFloat32> 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<FfxUInt32> 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<FfxUInt32> 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<FfxFloat32x2> 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<FfxUInt32> rw_game_motion_vector_field_x : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_GAME_MOTION_VECTOR_FIELD_X);
|
||||
RWTexture2D<FfxUInt32> 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<FfxUInt32> rw_optical_flow_motion_vector_field_x : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_OPTICAL_FLOW_MOTION_VECTOR_FIELD_X);
|
||||
RWTexture2D<FfxUInt32> 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<FfxUInt32> 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<FfxFloat32x4> rw_inpainting_pyramid0 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_0);
|
||||
RWTexture2D<FfxFloat32x4> rw_inpainting_pyramid1 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_1);
|
||||
RWTexture2D<FfxFloat32x4> rw_inpainting_pyramid2 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_2);
|
||||
RWTexture2D<FfxFloat32x4> rw_inpainting_pyramid3 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_3);
|
||||
RWTexture2D<FfxFloat32x4> rw_inpainting_pyramid4 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_4);
|
||||
globallycoherent RWTexture2D<FfxFloat32x4> rw_inpainting_pyramid5 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_5);
|
||||
RWTexture2D<FfxFloat32x4> rw_inpainting_pyramid6 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_6);
|
||||
RWTexture2D<FfxFloat32x4> rw_inpainting_pyramid7 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_7);
|
||||
RWTexture2D<FfxFloat32x4> rw_inpainting_pyramid8 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_8);
|
||||
RWTexture2D<FfxFloat32x4> rw_inpainting_pyramid9 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_9);
|
||||
RWTexture2D<FfxFloat32x4> rw_inpainting_pyramid10 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_10);
|
||||
RWTexture2D<FfxFloat32x4> rw_inpainting_pyramid11 : FFX_DECLARE_UAV(FFX_FRAMEINTERPOLATION_BIND_UAV_INPAINTING_PYRAMID_MIPMAP_11);
|
||||
RWTexture2D<FfxFloat32x4> 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)
|
||||
445
third_party/fidelityfx-sdk/include/FidelityFX/gpu/frameinterpolation/ffx_frameinterpolation_common.h
vendored
Normal file
445
third_party/fidelityfx-sdk/include/FidelityFX/gpu/frameinterpolation/ffx_frameinterpolation_common.h
vendored
Normal file
@@ -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)
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -0,0 +1,172 @@
|
||||
// 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));
|
||||
}
|
||||
|
||||
FfxFloat32x4 getDistortionField(FfxInt32x2 iPxPos, FfxFrameInterpolationDebugViewport vp)
|
||||
{
|
||||
FfxFloat32x2 fUv = getTransformedUv(iPxPos, vp);
|
||||
|
||||
FfxFloat32x2 fDistortionFieldUv = abs(SampleDistortionField(fUv).xy);
|
||||
|
||||
return FfxFloat32x4(fDistortionFieldUv * 10.0f, 0.0f, 1.0f);
|
||||
}
|
||||
|
||||
void drawPresentBackbuffer(FfxInt32x2 iPxPos, FfxFrameInterpolationDebugViewport vp)
|
||||
{
|
||||
FfxFloat32x2 fUv = getTransformedUv(iPxPos, vp);
|
||||
|
||||
FfxFloat32x4 fPresentColor = getDistortionField(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
|
||||
@@ -0,0 +1,146 @@
|
||||
// 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)
|
||||
{
|
||||
const FfxFloat32x2 fUv = FfxFloat32x2(iSamplePos + 0.5f) / RenderSize();
|
||||
const FfxFloat32x2 fDistortionFieldUv = SampleDistortionField(fUv);
|
||||
FfxInt32x2 iDistortionPixelOffset = FfxInt32x2(fDistortionFieldUv.xy * RenderSize());
|
||||
|
||||
if (estimatedIndex == 0)
|
||||
{
|
||||
return LoadReconstructedDepthPreviousFrame(iSamplePos + iDistortionPixelOffset);
|
||||
}
|
||||
else if (estimatedIndex == 1)
|
||||
{
|
||||
return LoadDilatedDepth(iSamplePos + iDistortionPixelOffset);
|
||||
}
|
||||
|
||||
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
|
||||
@@ -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_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 fDistortionFieldUv = SampleDistortionField(fUvInScreenSpace);
|
||||
FfxInt32x2 iDistortionPixelOffset = FfxInt32x2(fDistortionFieldUv.xy * RenderSize());
|
||||
|
||||
const FfxFloat32x2 fUvInInterpolationRectStart = FfxFloat32x2(InterpolationRectBase()) / DisplaySize();
|
||||
const FfxFloat32x2 fUvLetterBoxScale = FfxFloat32x2(InterpolationRectSize()) / DisplaySize();
|
||||
const FfxFloat32x2 fUvInInterpolationRect = fUvInInterpolationRectStart + fUvInScreenSpace * fUvLetterBoxScale;
|
||||
|
||||
const FfxFloat32 fDepthSample = LoadDilatedDepth(iPxPos + iDistortionPixelOffset);
|
||||
const FfxFloat32x2 fGameMotionVector = LoadDilatedMotionVector(iPxPos + iDistortionPixelOffset);
|
||||
const FfxFloat32x2 fMotionVectorHalf = fGameMotionVector * 0.5f;
|
||||
const FfxFloat32x2 fInterpolatedLocationUv = fUvInScreenSpace + fMotionVectorHalf;
|
||||
|
||||
const FfxFloat32 fViewSpaceDepth = ConvertFromDeviceDepthToViewSpace(fDepthSample);
|
||||
const FfxUInt32 uHighPriorityFactorPrimary = getPriorityFactorFromViewSpaceDepth(fViewSpaceDepth);
|
||||
|
||||
// pixel position in current frame + Game Motion Vector -> pixel position in previous frame
|
||||
FfxFloat32x3 prevBackbufferCol = SamplePreviousBackbuffer(fUvInInterpolationRect+ fGameMotionVector * fUvLetterBoxScale).xyz; //returns color of current frame's pixel in previous frame buffer
|
||||
FfxFloat32x3 curBackbufferCol = SampleCurrentBackbuffer(fUvInInterpolationRect).xyz; // returns color of current frame's pixel in current frame buffer
|
||||
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
|
||||
@@ -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
|
||||
@@ -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_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;
|
||||
|
||||
// pixel position in current frame + fOpticalFlowVector-> pixel position in previous frame
|
||||
FfxFloat32x3 prevBackbufferCol = SamplePreviousBackbuffer(fUv + fOpticalFlowVector).xyz; // returns previous backbuffer color of current frame pixel position in previous frame
|
||||
FfxFloat32x3 curBackbufferCol = SampleCurrentBackbuffer(fUv).xyz; // returns current backbuffer color at current frame pixel position
|
||||
|
||||
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
|
||||
@@ -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 )
|
||||
@@ -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.
|
||||
|
||||
#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)
|
||||
{
|
||||
const FfxFloat32x2 fUv = (iPxPos + FfxFloat32(0.5f)) / RenderSize();
|
||||
const FfxFloat32x2 fDistortionFieldUv = SampleDistortionField(fUv);
|
||||
FfxInt32x2 iDistortionPixelOffset = FfxInt32x2(fDistortionFieldUv.xy * RenderSize());
|
||||
|
||||
FfxFloat32x2 fMotionVector = LoadDilatedMotionVector(iPxPos + iDistortionPixelOffset);
|
||||
FfxFloat32 fDilatedDepth = LoadDilatedDepth(iPxPos + iDistortionPixelOffset);
|
||||
|
||||
ReconstructPrevDepth(iPxPos, 1, fDilatedDepth, fMotionVector * 0.5f, RenderSize());
|
||||
}
|
||||
|
||||
#endif // FFX_FRAMEINTERPOLATION_RECONSTRUCT_PREVIOUS_DEPTH_H
|
||||
@@ -0,0 +1,95 @@
|
||||
// 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_INPAINTING_MASK 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_DEFAULT_DISTORTION_FIELD 46
|
||||
#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_DISTORTION_FIELD 47
|
||||
|
||||
#define FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_COUNT 48
|
||||
|
||||
#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 )
|
||||
@@ -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
|
||||
1252
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1.h
vendored
Normal file
1252
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr1/ffx_fsr1.h
vendored
Normal file
File diff suppressed because it is too large
Load Diff
172
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_accumulate.h
vendored
Normal file
172
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_accumulate.h
vendored
Normal file
@@ -0,0 +1,172 @@
|
||||
// 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.
|
||||
|
||||
void Accumulate(const AccumulationPassCommonParams params, FFX_PARAMETER_INOUT AccumulationPassData data)
|
||||
{
|
||||
// Avoid invalid values when accumulation and upsampled weight is 0
|
||||
data.fHistoryWeight *= FfxFloat32(data.fHistoryWeight > FSR3UPSCALER_FP16_MIN);
|
||||
data.fHistoryWeight = ffxMax(FSR3UPSCALER_EPSILON, data.fHistoryWeight + data.fUpsampledWeight);
|
||||
|
||||
#if FFX_FSR3UPSCALER_OPTION_HDR_COLOR_INPUT
|
||||
//YCoCg -> RGB -> Tonemap -> YCoCg (Use RGB tonemapper to avoid color desaturation)
|
||||
data.fUpsampledColor = RGBToYCoCg(Tonemap(YCoCgToRGB(data.fUpsampledColor)));
|
||||
data.fHistoryColor = RGBToYCoCg(Tonemap(YCoCgToRGB(data.fHistoryColor)));
|
||||
#endif
|
||||
|
||||
const FfxFloat32 fAlpha = ffxSaturate(data.fUpsampledWeight / data.fHistoryWeight);
|
||||
data.fHistoryColor = ffxLerp(data.fHistoryColor, data.fUpsampledColor, fAlpha);
|
||||
data.fHistoryColor = YCoCgToRGB(data.fHistoryColor);
|
||||
|
||||
#if FFX_FSR3UPSCALER_OPTION_HDR_COLOR_INPUT
|
||||
data.fHistoryColor = InverseTonemap(data.fHistoryColor);
|
||||
#endif
|
||||
}
|
||||
|
||||
void RectifyHistory(
|
||||
const AccumulationPassCommonParams params,
|
||||
FFX_PARAMETER_INOUT AccumulationPassData data
|
||||
)
|
||||
{
|
||||
const FfxFloat32 f4kVelocityFactor = ffxSaturate(params.f4KVelocity / 20.0f);
|
||||
const FfxFloat32 fDistanceFactor = ffxSaturate(0.75f - params.fFarthestDepthInMeters / 20.0f);
|
||||
const FfxFloat32 fAccumulationFactor = 1.0f - params.fAccumulation;
|
||||
const FfxFloat32 fReactiveFactor = ffxPow(params.fReactiveMask, 1.0f / 2.0f);
|
||||
const FfxFloat32 fShadingChangeFactor = params.fShadingChange;
|
||||
const FfxFloat32 fBoxScaleT = ffxMax(f4kVelocityFactor, ffxMax(fDistanceFactor, ffxMax(fAccumulationFactor, ffxMax(fReactiveFactor, fShadingChangeFactor))));
|
||||
|
||||
const FfxFloat32 fBoxScale = ffxLerp(3.0f, 1.0f, fBoxScaleT);
|
||||
const FfxFloat32x3 fScaledBoxVec = data.clippingBox.boxVec * FfxFloat32x3(1.7f, 1.0f, 1.0f) * fBoxScale;
|
||||
|
||||
const FfxFloat32x3 fClampedScaledBoxVec = ffxMax(fScaledBoxVec, FfxFloat32x3(1.193e-7f, 1.193e-7f, 1.193e-7f));
|
||||
const FfxFloat32x3 fTransformedHistoryColor = (data.fHistoryColor - data.clippingBox.boxCenter) / fClampedScaledBoxVec;
|
||||
|
||||
if (length(fTransformedHistoryColor)>1.f) {
|
||||
const FfxFloat32x3 fClampedHistoryColor = normalize(fTransformedHistoryColor);
|
||||
const FfxFloat32x3 fFinalClampedHistoryColor = (fClampedHistoryColor * fScaledBoxVec) + data.clippingBox.boxCenter;
|
||||
|
||||
// Scale history color using rectification info, also using accumulation mask to avoid potential invalid color protection
|
||||
const FfxFloat32 fHistoryContribution = ffxMax(params.fLumaInstabilityFactor, data.fLockContributionThisFrame) * params.fAccumulation * (1 - params.fDisocclusion);
|
||||
data.fHistoryColor = ffxLerp(fFinalClampedHistoryColor, data.fHistoryColor, ffxSaturate(fHistoryContribution));
|
||||
}
|
||||
}
|
||||
|
||||
void UpdateLockStatus(AccumulationPassCommonParams params, FFX_PARAMETER_INOUT AccumulationPassData data)
|
||||
{
|
||||
data.fLock *= FfxFloat32(params.bIsNewSample == false);
|
||||
|
||||
const FfxFloat32 fLifetimeDecreaseFactor = ffxMax(ffxSaturate(params.fShadingChange), ffxMax(params.fReactiveMask, params.fDisocclusion));
|
||||
data.fLock = ffxMax(0.0f, data.fLock - fLifetimeDecreaseFactor * fLockMax);
|
||||
|
||||
// Compute this frame lock contribution
|
||||
data.fLockContributionThisFrame = ffxSaturate(ffxSaturate(data.fLock - fLockThreshold) * (fLockMax - fLockThreshold));
|
||||
|
||||
const FfxFloat32 fNewLockIntensity = LoadRwNewLocks(params.iPxHrPos) * (1.0f - ffxMax(params.fShadingChange * 0, params.fReactiveMask));
|
||||
data.fLock = ffxMax(0.0f, ffxMin(data.fLock + fNewLockIntensity, fLockMax));
|
||||
|
||||
// Preparing for next frame
|
||||
const FfxFloat32 fLifetimeDecrease = (0.1f / JitterSequenceLength()) * (1.0f - fLifetimeDecreaseFactor);
|
||||
data.fLock = ffxMax(0.0f, data.fLock - fLifetimeDecrease);
|
||||
|
||||
// we expect similar motion for next frame
|
||||
// kill lock if that location is outside screen, avoid locks to be clamped to screen borders
|
||||
const FfxFloat32x2 fEstimatedUvNextFrame = params.fHrUv - params.fMotionVector;
|
||||
data.fLock *= FfxFloat32(IsUvInside(fEstimatedUvNextFrame) == true);
|
||||
}
|
||||
|
||||
void ComputeBaseAccumulationWeight(const AccumulationPassCommonParams params, FFX_PARAMETER_INOUT AccumulationPassData data)
|
||||
{
|
||||
FfxFloat32 fBaseAccumulation = params.fAccumulation;
|
||||
|
||||
fBaseAccumulation = ffxMin(fBaseAccumulation, ffxLerp(fBaseAccumulation, 0.15f, ffxSaturate(ffxMax(0.0f, (params.f4KVelocity * VelocityFactor()) / 0.5f))));
|
||||
|
||||
data.fHistoryWeight = fBaseAccumulation;
|
||||
}
|
||||
|
||||
void InitPassData(FfxInt32x2 iPxHrPos, FFX_PARAMETER_INOUT AccumulationPassCommonParams params, FFX_PARAMETER_INOUT AccumulationPassData data)
|
||||
{
|
||||
// Init constant params
|
||||
params.iPxHrPos = iPxHrPos;
|
||||
const FfxFloat32x2 fHrUv = (iPxHrPos + 0.5f) / UpscaleSize();
|
||||
params.fHrUv = fHrUv;
|
||||
params.fLrUvJittered = fHrUv + Jitter() / RenderSize();
|
||||
params.fLrUv_HwSampler = ClampUv(params.fLrUvJittered, RenderSize(), MaxRenderSize());
|
||||
|
||||
params.fMotionVector = GetMotionVector(iPxHrPos, fHrUv);
|
||||
params.f4KVelocity = Get4KVelocity(params.fMotionVector);
|
||||
|
||||
ComputeReprojectedUVs(params);
|
||||
|
||||
const FfxFloat32x2 fLumaInstabilityUv_HW = ClampUv(fHrUv, RenderSize(), MaxRenderSize());
|
||||
params.fLumaInstabilityFactor = SampleLumaInstability(fLumaInstabilityUv_HW);
|
||||
|
||||
const FfxFloat32x2 fFarthestDepthUv = ClampUv(params.fLrUvJittered, RenderSize() / 2, GetFarthestDepthMip1ResourceDimensions());
|
||||
params.fFarthestDepthInMeters = SampleFarthestDepthMip1(fFarthestDepthUv);
|
||||
params.bIsNewSample = (params.bIsExistingSample == false || 0 == FrameIndex());
|
||||
|
||||
const FfxFloat32x4 fDilatedReactiveMasks = SampleDilatedReactiveMasks(params.fLrUv_HwSampler);
|
||||
params.fReactiveMask = ffxSaturate(fDilatedReactiveMasks[REACTIVE]);
|
||||
params.fDisocclusion = ffxSaturate(fDilatedReactiveMasks[DISOCCLUSION]);
|
||||
params.fShadingChange = ffxSaturate(fDilatedReactiveMasks[SHADING_CHANGE]);
|
||||
params.fAccumulation = ffxSaturate(fDilatedReactiveMasks[ACCUMULAION]);
|
||||
params.fAccumulation *= FfxFloat32(round(params.fAccumulation * 100.0f) > 1.0f);
|
||||
|
||||
// Init variable data
|
||||
data.fUpsampledColor = FfxFloat32x3(0.0f, 0.0f, 0.0f);
|
||||
data.fHistoryColor = FfxFloat32x3(0.0f, 0.0f, 0.0f);
|
||||
data.fHistoryWeight = 1.0f;
|
||||
data.fUpsampledWeight = 0.0f;
|
||||
data.fLock = 0.0f;
|
||||
data.fLockContributionThisFrame = 0.0f;
|
||||
}
|
||||
|
||||
void Accumulate(FfxInt32x2 iPxHrPos)
|
||||
{
|
||||
AccumulationPassCommonParams params;
|
||||
AccumulationPassData data;
|
||||
InitPassData(iPxHrPos, params, data);
|
||||
|
||||
if (params.bIsExistingSample && !params.bIsNewSample) {
|
||||
ReprojectHistoryColor(params, data);
|
||||
}
|
||||
|
||||
UpdateLockStatus(params, data);
|
||||
|
||||
ComputeBaseAccumulationWeight(params, data);
|
||||
|
||||
ComputeUpsampledColorAndWeight(params, data);
|
||||
|
||||
RectifyHistory(params, data);
|
||||
|
||||
Accumulate(params, data);
|
||||
|
||||
data.fHistoryColor /= Exposure();
|
||||
|
||||
data.fHistoryColor = ffxMax(data.fHistoryColor, FfxFloat32x3(0.0f, 0.0f, 0.0f));
|
||||
|
||||
StoreInternalColorAndWeight(iPxHrPos, FfxFloat32x4(data.fHistoryColor, data.fLock));
|
||||
|
||||
// Output final color when RCAS is disabled
|
||||
#if FFX_FSR3UPSCALER_OPTION_APPLY_SHARPENING == 0
|
||||
StoreUpscaledOutput(iPxHrPos, data.fHistoryColor);
|
||||
#endif
|
||||
StoreNewLocks(iPxHrPos, 0);
|
||||
}
|
||||
903
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_callbacks_glsl.h
vendored
Normal file
903
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_callbacks_glsl.h
vendored
Normal file
@@ -0,0 +1,903 @@
|
||||
// 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_fsr3upscaler_resources.h"
|
||||
|
||||
#if defined(FFX_GPU)
|
||||
#include "ffx_core.h"
|
||||
#endif // #if defined(FFX_GPU)
|
||||
|
||||
#if defined(FFX_GPU)
|
||||
#ifndef FFX_PREFER_WAVE64
|
||||
#define FFX_PREFER_WAVE64
|
||||
#endif // FFX_PREFER_WAVE64
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_CB_FSR3UPSCALER)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_CB_FSR3UPSCALER, std140) uniform cbFSR3UPSCALER_t
|
||||
{
|
||||
FfxInt32x2 iRenderSize;
|
||||
FfxInt32x2 iPreviousFrameRenderSize;
|
||||
|
||||
FfxInt32x2 iUpscaleSize;
|
||||
FfxInt32x2 iPreviousFrameUpscaleSize;
|
||||
|
||||
FfxInt32x2 iMaxRenderSize;
|
||||
FfxInt32x2 iMaxUpscaleSize;
|
||||
|
||||
FfxFloat32x4 fDeviceToViewDepth;
|
||||
|
||||
FfxFloat32x2 fJitter;
|
||||
FfxFloat32x2 fPreviousFrameJitter;
|
||||
|
||||
FfxFloat32x2 fMotionVectorScale;
|
||||
FfxFloat32x2 fDownscaleFactor;
|
||||
|
||||
FfxFloat32x2 fMotionVectorJitterCancellation;
|
||||
FfxFloat32 fTanHalfFOV;
|
||||
FfxFloat32 fJitterSequenceLength;
|
||||
|
||||
FfxFloat32 fDeltaTime;
|
||||
FfxFloat32 fDeltaPreExposure;
|
||||
FfxFloat32 fViewSpaceToMetersFactor;
|
||||
FfxFloat32 fFrameIndex;
|
||||
|
||||
FfxFloat32 fVelocityFactor;
|
||||
FfxFloat32 fReactivenessScale;
|
||||
FfxFloat32 fShadingChangeScale;
|
||||
FfxFloat32 fAccumulationAddedPerFrame;
|
||||
FfxFloat32 fMinDisocclusionAccumulation;
|
||||
} cbFSR3Upscaler;
|
||||
|
||||
|
||||
FfxInt32x2 RenderSize()
|
||||
{
|
||||
return cbFSR3Upscaler.iRenderSize;
|
||||
}
|
||||
|
||||
FfxInt32x2 PreviousFrameRenderSize()
|
||||
{
|
||||
return cbFSR3Upscaler.iPreviousFrameRenderSize;
|
||||
}
|
||||
|
||||
FfxInt32x2 MaxRenderSize()
|
||||
{
|
||||
return cbFSR3Upscaler.iMaxRenderSize;
|
||||
}
|
||||
|
||||
FfxInt32x2 UpscaleSize()
|
||||
{
|
||||
return cbFSR3Upscaler.iUpscaleSize;
|
||||
}
|
||||
|
||||
FfxInt32x2 PreviousFrameUpscaleSize()
|
||||
{
|
||||
return cbFSR3Upscaler.iPreviousFrameUpscaleSize;
|
||||
}
|
||||
|
||||
FfxInt32x2 MaxUpscaleSize()
|
||||
{
|
||||
return cbFSR3Upscaler.iMaxUpscaleSize;
|
||||
}
|
||||
|
||||
FfxFloat32x2 Jitter()
|
||||
{
|
||||
return cbFSR3Upscaler.fJitter;
|
||||
}
|
||||
|
||||
FfxFloat32x2 PreviousFrameJitter()
|
||||
{
|
||||
return cbFSR3Upscaler.fPreviousFrameJitter;
|
||||
}
|
||||
|
||||
FfxFloat32x4 DeviceToViewSpaceTransformFactors()
|
||||
{
|
||||
return cbFSR3Upscaler.fDeviceToViewDepth;
|
||||
}
|
||||
|
||||
FfxFloat32x2 MotionVectorScale()
|
||||
{
|
||||
return cbFSR3Upscaler.fMotionVectorScale;
|
||||
}
|
||||
|
||||
FfxFloat32x2 DownscaleFactor()
|
||||
{
|
||||
return cbFSR3Upscaler.fDownscaleFactor;
|
||||
}
|
||||
|
||||
FfxFloat32x2 MotionVectorJitterCancellation()
|
||||
{
|
||||
return cbFSR3Upscaler.fMotionVectorJitterCancellation;
|
||||
}
|
||||
|
||||
FfxFloat32 TanHalfFoV()
|
||||
{
|
||||
return cbFSR3Upscaler.fTanHalfFOV;
|
||||
}
|
||||
|
||||
FfxFloat32 JitterSequenceLength()
|
||||
{
|
||||
return cbFSR3Upscaler.fJitterSequenceLength;
|
||||
}
|
||||
|
||||
FfxFloat32 DeltaTime()
|
||||
{
|
||||
return cbFSR3Upscaler.fDeltaTime;
|
||||
}
|
||||
|
||||
FfxFloat32 DeltaPreExposure()
|
||||
{
|
||||
return cbFSR3Upscaler.fDeltaPreExposure;
|
||||
}
|
||||
|
||||
FfxFloat32 ViewSpaceToMetersFactor()
|
||||
{
|
||||
return cbFSR3Upscaler.fViewSpaceToMetersFactor;
|
||||
}
|
||||
|
||||
FfxFloat32 FrameIndex()
|
||||
{
|
||||
return cbFSR3Upscaler.fFrameIndex;
|
||||
}
|
||||
|
||||
FfxFloat32 VelocityFactor()
|
||||
{
|
||||
return cbFSR3Upscaler.fVelocityFactor;
|
||||
}
|
||||
|
||||
FfxFloat32 AccumulationAddedPerFrame()
|
||||
{
|
||||
return cbFSR3Upscaler.fAccumulationAddedPerFrame;
|
||||
}
|
||||
|
||||
FfxFloat32 MinDisocclusionAccumulation()
|
||||
{
|
||||
return cbFSR3Upscaler.fMinDisocclusionAccumulation;
|
||||
}
|
||||
|
||||
#endif // #if defined(FSR3UPSCALER_BIND_CB_FSR3UPSCALER)
|
||||
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_CB_AUTOREACTIVE)
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_CB_AUTOREACTIVE, std140) uniform cbGenerateReactive_t
|
||||
{
|
||||
FfxFloat32 fTcThreshold; // 0.1 is a good starting value, lower will result in more TC pixels
|
||||
FfxFloat32 fTcScale;
|
||||
FfxFloat32 fReactiveScale;
|
||||
FfxFloat32 fReactiveMax;
|
||||
} cbGenerateReactive;
|
||||
|
||||
FfxFloat32 TcThreshold()
|
||||
{
|
||||
return cbGenerateReactive.fTcThreshold;
|
||||
}
|
||||
|
||||
FfxFloat32 TcScale()
|
||||
{
|
||||
return cbGenerateReactive.fTcScale;
|
||||
}
|
||||
|
||||
FfxFloat32 ReactiveScale()
|
||||
{
|
||||
return cbGenerateReactive.fReactiveScale;
|
||||
}
|
||||
|
||||
FfxFloat32 ReactiveMax()
|
||||
{
|
||||
return cbGenerateReactive.fReactiveMax;
|
||||
}
|
||||
#endif // #if defined(FSR3UPSCALER_BIND_CB_AUTOREACTIVE)
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_CB_RCAS)
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_CB_RCAS, std140) uniform cbRCAS_t
|
||||
{
|
||||
FfxUInt32x4 rcasConfig;
|
||||
} cbRCAS;
|
||||
|
||||
FfxUInt32x4 RCASConfig()
|
||||
{
|
||||
return cbRCAS.rcasConfig;
|
||||
}
|
||||
#endif // #if defined(FSR3UPSCALER_BIND_CB_RCAS)
|
||||
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_CB_REACTIVE)
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_CB_REACTIVE, std140) uniform cbGenerateReactive_t
|
||||
{
|
||||
FfxFloat32 gen_reactive_scale;
|
||||
FfxFloat32 gen_reactive_threshold;
|
||||
FfxFloat32 gen_reactive_binaryValue;
|
||||
FfxUInt32 gen_reactive_flags;
|
||||
} cbGenerateReactive;
|
||||
|
||||
FfxFloat32 GenReactiveScale()
|
||||
{
|
||||
return cbGenerateReactive.gen_reactive_scale;
|
||||
}
|
||||
|
||||
FfxFloat32 GenReactiveThreshold()
|
||||
{
|
||||
return cbGenerateReactive.gen_reactive_threshold;
|
||||
}
|
||||
|
||||
FfxFloat32 GenReactiveBinaryValue()
|
||||
{
|
||||
return cbGenerateReactive.gen_reactive_binaryValue;
|
||||
}
|
||||
|
||||
FfxUInt32 GenReactiveFlags()
|
||||
{
|
||||
return cbGenerateReactive.gen_reactive_flags;
|
||||
}
|
||||
#endif // #if defined(FSR3UPSCALER_BIND_CB_REACTIVE)
|
||||
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_CB_SPD)
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_CB_SPD, std140) uniform cbSPD_t
|
||||
{
|
||||
FfxUInt32 mips;
|
||||
FfxUInt32 numWorkGroups;
|
||||
FfxUInt32x2 workGroupOffset;
|
||||
FfxUInt32x2 renderSize;
|
||||
} cbSPD;
|
||||
|
||||
FfxUInt32 MipCount()
|
||||
{
|
||||
return cbSPD.mips;
|
||||
}
|
||||
|
||||
FfxUInt32 NumWorkGroups()
|
||||
{
|
||||
return cbSPD.numWorkGroups;
|
||||
}
|
||||
|
||||
FfxUInt32x2 WorkGroupOffset()
|
||||
{
|
||||
return cbSPD.workGroupOffset;
|
||||
}
|
||||
|
||||
FfxUInt32x2 SPD_RenderSize()
|
||||
{
|
||||
return cbSPD.renderSize;
|
||||
}
|
||||
#endif // #if defined(FSR3UPSCALER_BIND_CB_SPD)
|
||||
|
||||
layout (set = 0, binding = 1000) uniform sampler s_PointClamp;
|
||||
layout (set = 0, binding = 1001) uniform sampler s_LinearClamp;
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_SPD_MIPS)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_SPD_MIPS) uniform texture2D r_spd_mips;
|
||||
|
||||
FfxInt32x2 GetSPDMipDimensions(FfxUInt32 uMipLevel)
|
||||
{
|
||||
return textureSize(r_spd_mips, int(uMipLevel)).xy;
|
||||
}
|
||||
|
||||
FfxFloat32x2 SampleSPDMipLevel(FfxFloat32x2 fUV, FfxUInt32 mipLevel)
|
||||
{
|
||||
return textureLod(sampler2D(r_spd_mips, s_LinearClamp), fUV, float(mipLevel)).rg;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_INPUT_DEPTH)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_INPUT_DEPTH) uniform texture2D r_input_depth;
|
||||
|
||||
FfxFloat32 LoadInputDepth(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_input_depth, iPxPos, 0).r;
|
||||
}
|
||||
|
||||
FfxFloat32 SampleInputDepth(FfxFloat32x2 fUV)
|
||||
{
|
||||
return textureLod(sampler2D(r_input_depth, s_LinearClamp), fUV, 0.0).x;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_REACTIVE_MASK)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_REACTIVE_MASK) uniform texture2D r_reactive_mask;
|
||||
|
||||
FfxFloat32 LoadReactiveMask(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_reactive_mask, FfxInt32x2(iPxPos), 0).r * cbFSR3Upscaler.fReactivenessScale;
|
||||
}
|
||||
|
||||
FfxInt32x2 GetReactiveMaskResourceDimensions()
|
||||
{
|
||||
return textureSize(r_reactive_mask, 0).xy;
|
||||
}
|
||||
|
||||
FfxFloat32 SampleReactiveMask(FfxFloat32x2 fUV)
|
||||
{
|
||||
return textureLod(sampler2D(r_reactive_mask, s_LinearClamp), fUV, 0.0).x * cbFSR3Upscaler.fReactivenessScale;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_TRANSPARENCY_AND_COMPOSITION_MASK)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_TRANSPARENCY_AND_COMPOSITION_MASK) uniform texture2D r_transparency_and_composition_mask;
|
||||
|
||||
FfxFloat32 LoadTransparencyAndCompositionMask(FfxUInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_transparency_and_composition_mask, FfxInt32x2(iPxPos), 0).r;
|
||||
}
|
||||
|
||||
FfxInt32x2 GetTransparencyAndCompositionMaskResourceDimensions()
|
||||
{
|
||||
return textureSize(r_transparency_and_composition_mask, 0).xy;
|
||||
}
|
||||
|
||||
FfxFloat32 SampleTransparencyAndCompositionMask(FfxFloat32x2 fUV)
|
||||
{
|
||||
return textureLod(sampler2D(r_transparency_and_composition_mask, s_LinearClamp), fUV, 0.0).x;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_INPUT_COLOR)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_INPUT_COLOR) uniform texture2D r_input_color_jittered;
|
||||
|
||||
FfxFloat32x3 LoadInputColor(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_input_color_jittered, iPxPos, 0).rgb;
|
||||
}
|
||||
|
||||
FfxFloat32x3 SampleInputColor(FfxFloat32x2 fUV)
|
||||
{
|
||||
return textureLod(sampler2D(r_input_color_jittered, s_LinearClamp), fUV, 0.0).rgb;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_INPUT_MOTION_VECTORS)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_INPUT_MOTION_VECTORS) uniform texture2D r_input_motion_vectors;
|
||||
|
||||
FfxFloat32x2 LoadInputMotionVector(FfxInt32x2 iPxDilatedMotionVectorPos)
|
||||
{
|
||||
FfxFloat32x2 fSrcMotionVector = texelFetch(r_input_motion_vectors, iPxDilatedMotionVectorPos, 0).xy;
|
||||
|
||||
FfxFloat32x2 fUvMotionVector = fSrcMotionVector * MotionVectorScale();
|
||||
|
||||
#if FFX_FSR3UPSCALER_OPTION_JITTERED_MOTION_VECTORS
|
||||
fUvMotionVector -= MotionVectorJitterCancellation();
|
||||
#endif
|
||||
|
||||
return fUvMotionVector;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_INTERNAL_UPSCALED)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_INTERNAL_UPSCALED) uniform texture2D r_internal_upscaled_color;
|
||||
|
||||
FfxFloat32x4 LoadHistory(FfxInt32x2 iPxHistory)
|
||||
{
|
||||
return texelFetch(r_internal_upscaled_color, iPxHistory, 0);
|
||||
}
|
||||
|
||||
FfxFloat32x4 SampleHistory(FfxFloat32x2 fUV)
|
||||
{
|
||||
return textureLod(sampler2D(r_internal_upscaled_color, s_LinearClamp), fUV, 0.0);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_LUMA_HISTORY)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_LUMA_HISTORY, rgba8) uniform image2D rw_luma_history;
|
||||
|
||||
void StoreLumaHistory(FfxInt32x2 iPxPos, FfxFloat32x4 fLumaHistory)
|
||||
{
|
||||
imageStore(rw_luma_history, iPxPos, fLumaHistory);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_LUMA_HISTORY)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_LUMA_HISTORY) uniform texture2D r_luma_history;
|
||||
|
||||
FfxFloat32x4 LoadLumaHistory(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_luma_history, iPxPos, 0);
|
||||
}
|
||||
|
||||
FfxFloat32x4 SampleLumaHistory(FfxFloat32x2 fUV)
|
||||
{
|
||||
return textureLod(sampler2D(r_luma_history, s_LinearClamp), fUV, 0.0);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_RCAS_INPUT)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_RCAS_INPUT) uniform texture2D r_rcas_input;
|
||||
|
||||
FfxFloat32x4 LoadRCAS_Input(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_rcas_input, iPxPos, 0);
|
||||
}
|
||||
|
||||
FfxFloat32x3 SampleRCAS_Input(FfxFloat32x2 fUV)
|
||||
{
|
||||
return textureLod(sampler2D(r_rcas_input, s_LinearClamp), fUV, 0.0).rgb;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_INTERNAL_UPSCALED)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_INTERNAL_UPSCALED, rgba16f) writeonly uniform image2D rw_internal_upscaled_color;
|
||||
|
||||
void StoreReprojectedHistory(FfxInt32x2 iPxHistory, FfxFloat32x4 fHistory)
|
||||
{
|
||||
imageStore(rw_internal_upscaled_color, iPxHistory, fHistory);
|
||||
}
|
||||
|
||||
void StoreInternalColorAndWeight(FfxInt32x2 iPxPos, FfxFloat32x4 fColorAndWeight)
|
||||
{
|
||||
imageStore(rw_internal_upscaled_color, iPxPos, fColorAndWeight);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_UPSCALED_OUTPUT)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_UPSCALED_OUTPUT /* app controlled format */) writeonly uniform image2D rw_upscaled_output;
|
||||
|
||||
void StoreUpscaledOutput(FfxInt32x2 iPxPos, FfxFloat32x3 fColor)
|
||||
{
|
||||
imageStore(rw_upscaled_output, iPxPos, FfxFloat32x4(fColor, 1.0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_ACCUMULATION)
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_ACCUMULATION) uniform texture2D r_accumulation;
|
||||
|
||||
FfxFloat32 SampleAccumulation(FfxFloat32x2 fUV)
|
||||
{
|
||||
return textureLod(sampler2D(r_accumulation, s_LinearClamp), fUV, 0.0).x;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_ACCUMULATION)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_ACCUMULATION, r8) uniform image2D rw_accumulation;
|
||||
|
||||
void StoreAccumulation(FfxInt32x2 iPxPos, FfxFloat32 fAccumulation)
|
||||
{
|
||||
imageStore(rw_accumulation, iPxPos, vec4(fAccumulation, 0.0, 0.0, 0.0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_SHADING_CHANGE)
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_SHADING_CHANGE) uniform texture2D r_shading_change;
|
||||
|
||||
FfxFloat32 LoadShadingChange(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_shading_change, iPxPos, 0).x * cbFSR3Upscaler.fShadingChangeScale;
|
||||
}
|
||||
|
||||
FfxFloat32 SampleShadingChange(FfxFloat32x2 fUV)
|
||||
{
|
||||
return textureLod(sampler2D(r_shading_change, s_LinearClamp), fUV, 0.0).x * cbFSR3Upscaler.fShadingChangeScale;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_SHADING_CHANGE)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_SHADING_CHANGE, r8) uniform image2D rw_shading_change;
|
||||
|
||||
void StoreShadingChange(FfxInt32x2 iPxPos, FfxFloat32 fShadingChange)
|
||||
{
|
||||
imageStore(rw_shading_change, iPxPos, vec4(fShadingChange, 0.0, 0.0, 0.0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_FARTHEST_DEPTH)
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_FARTHEST_DEPTH) uniform texture2D r_farthest_depth;
|
||||
|
||||
FfxInt32x2 GetFarthestDepthResourceDimensions()
|
||||
{
|
||||
return textureSize(r_farthest_depth, 0).xy;
|
||||
}
|
||||
|
||||
FfxFloat32 LoadFarthestDepth(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_farthest_depth, iPxPos, 0).x;
|
||||
}
|
||||
|
||||
FfxFloat32 SampleFarthestDepth(FfxFloat32x2 fUV)
|
||||
{
|
||||
return textureLod(sampler2D(r_farthest_depth, s_LinearClamp), fUV, 0.0).x;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_FARTHEST_DEPTH)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_FARTHEST_DEPTH, r16f) uniform image2D rw_farthest_depth;
|
||||
|
||||
void StoreFarthestDepth(FfxInt32x2 iPxPos, FfxFloat32 fDepth)
|
||||
{
|
||||
imageStore(rw_farthest_depth, iPxPos, vec4(fDepth, 0.0, 0.0, 0.0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_FARTHEST_DEPTH_MIP1)
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_FARTHEST_DEPTH_MIP1) uniform texture2D r_farthest_depth_mip1;
|
||||
|
||||
FfxInt32x2 GetFarthestDepthMip1ResourceDimensions()
|
||||
{
|
||||
return textureSize(r_farthest_depth_mip1, 0).xy;
|
||||
}
|
||||
|
||||
FfxFloat32 LoadFarthestDepthMip1(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_farthest_depth_mip1, iPxPos, 0).x;
|
||||
}
|
||||
|
||||
FfxFloat32 SampleFarthestDepthMip1(FfxFloat32x2 fUV)
|
||||
{
|
||||
return textureLod(sampler2D(r_farthest_depth_mip1, s_LinearClamp), fUV, 0.0).x;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_FARTHEST_DEPTH_MIP1)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_FARTHEST_DEPTH_MIP1, r16f) uniform image2D rw_farthest_depth_mip1;
|
||||
|
||||
void StoreFarthestDepthMip1(FfxInt32x2 iPxPos, FfxFloat32 fDepth)
|
||||
{
|
||||
imageStore(rw_farthest_depth_mip1, iPxPos, vec4(fDepth, 0.0, 0.0, 0.0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_CURRENT_LUMA)
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_CURRENT_LUMA) uniform texture2D r_current_luma;
|
||||
|
||||
FfxFloat32 LoadCurrentLuma(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_current_luma, iPxPos, 0).r;
|
||||
}
|
||||
|
||||
FfxFloat32 SampleCurrentLuma(FfxFloat32x2 uv)
|
||||
{
|
||||
return textureLod(sampler2D(r_current_luma, s_LinearClamp), uv, 0.0).r;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_CURRENT_LUMA)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_CURRENT_LUMA, r16f) uniform image2D rw_current_luma;
|
||||
|
||||
void StoreCurrentLuma(FfxInt32x2 iPxPos, FfxFloat32 fLuma)
|
||||
{
|
||||
imageStore(rw_current_luma, iPxPos, vec4(fLuma, 0.0, 0.0, 0.0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_LUMA_INSTABILITY)
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_LUMA_INSTABILITY) uniform texture2D r_luma_instability;
|
||||
|
||||
FfxFloat32 SampleLumaInstability(FfxFloat32x2 uv)
|
||||
{
|
||||
return textureLod(sampler2D(r_luma_instability, s_LinearClamp), uv, 0.0).x;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_LUMA_INSTABILITY)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_LUMA_INSTABILITY, r16f) uniform image2D rw_luma_instability;
|
||||
|
||||
void StoreLumaInstability(FfxInt32x2 iPxPos, FfxFloat32 fLumaInstability)
|
||||
{
|
||||
imageStore(rw_luma_instability, iPxPos, vec4(fLumaInstability, 0.0, 0.0, 0.0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_PREVIOUS_LUMA)
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_PREVIOUS_LUMA) uniform texture2D r_previous_luma;
|
||||
|
||||
FfxFloat32 LoadPreviousLuma(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_previous_luma, iPxPos, 0).r;
|
||||
}
|
||||
|
||||
FfxFloat32 SamplePreviousLuma(FfxFloat32x2 uv)
|
||||
{
|
||||
return textureLod(sampler2D(r_previous_luma, s_LinearClamp), uv, 0.0).r;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_NEW_LOCKS)
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_NEW_LOCKS) uniform texture2D r_new_locks;
|
||||
|
||||
FfxFloat32 LoadNewLocks(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_new_locks, iPxPos, 0).r;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_NEW_LOCKS)
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_UAV_NEW_LOCKS, r8) uniform image2D rw_new_locks;
|
||||
|
||||
FfxFloat32 LoadRwNewLocks(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return imageLoad(rw_new_locks, iPxPos).r;
|
||||
}
|
||||
|
||||
void StoreNewLocks(FfxInt32x2 iPxPos, FfxFloat32 newLock)
|
||||
{
|
||||
imageStore(rw_new_locks, iPxPos, vec4(newLock, 0, 0, 0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_RECONSTRUCTED_PREV_NEAREST_DEPTH)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_RECONSTRUCTED_PREV_NEAREST_DEPTH) uniform utexture2D r_reconstructed_previous_nearest_depth;
|
||||
|
||||
FfxFloat32 LoadReconstructedPrevDepth(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return uintBitsToFloat(texelFetch(r_reconstructed_previous_nearest_depth, iPxPos, 0).r);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_RECONSTRUCTED_PREV_NEAREST_DEPTH)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_RECONSTRUCTED_PREV_NEAREST_DEPTH, r32ui) uniform uimage2D rw_reconstructed_previous_nearest_depth;
|
||||
|
||||
void StoreReconstructedDepth(FfxInt32x2 iPxSample, FfxFloat32 fDepth)
|
||||
{
|
||||
FfxUInt32 uDepth = floatBitsToUint(fDepth);
|
||||
|
||||
#if FFX_FSR3UPSCALER_OPTION_INVERTED_DEPTH
|
||||
imageAtomicMax(rw_reconstructed_previous_nearest_depth, iPxSample, uDepth);
|
||||
#else
|
||||
imageAtomicMin(rw_reconstructed_previous_nearest_depth, iPxSample, uDepth); // min for standard, max for inverted depth
|
||||
#endif
|
||||
}
|
||||
|
||||
void SetReconstructedDepth(FfxInt32x2 iPxSample, FfxUInt32 uValue)
|
||||
{
|
||||
imageStore(rw_reconstructed_previous_nearest_depth, iPxSample, uvec4(uValue, 0, 0, 0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_DILATED_DEPTH)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_DILATED_DEPTH, r32f) writeonly uniform image2D rw_dilated_depth;
|
||||
|
||||
void StoreDilatedDepth(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32 fDepth)
|
||||
{
|
||||
imageStore(rw_dilated_depth, iPxPos, vec4(fDepth, 0.0, 0.0, 0.0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_DILATED_MOTION_VECTORS)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_DILATED_MOTION_VECTORS, rg16f) writeonly uniform image2D rw_dilated_motion_vectors;
|
||||
|
||||
void StoreDilatedMotionVector(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x2 fMotionVector)
|
||||
{
|
||||
imageStore(rw_dilated_motion_vectors, iPxPos, vec4(fMotionVector, 0.0, 0.0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_DILATED_MOTION_VECTORS)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_DILATED_MOTION_VECTORS) uniform texture2D r_dilated_motion_vectors;
|
||||
|
||||
FfxFloat32x2 LoadDilatedMotionVector(FfxInt32x2 iPxInput)
|
||||
{
|
||||
return texelFetch(r_dilated_motion_vectors, iPxInput, 0).xy;
|
||||
}
|
||||
|
||||
FfxFloat32x2 SampleDilatedMotionVector(FfxFloat32x2 fUV)
|
||||
{
|
||||
return textureLod(sampler2D(r_dilated_motion_vectors, s_LinearClamp), fUV, 0.0).xy;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_DILATED_DEPTH)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_DILATED_DEPTH) uniform texture2D r_dilated_depth;
|
||||
|
||||
FfxFloat32 LoadDilatedDepth(FfxInt32x2 iPxInput)
|
||||
{
|
||||
return texelFetch(r_dilated_depth, iPxInput, 0).r;
|
||||
}
|
||||
|
||||
FfxFloat32 SampleDilatedDepth(FfxFloat32x2 fUV)
|
||||
{
|
||||
return textureLod(sampler2D(r_dilated_depth, s_LinearClamp), fUV, 0.0).r;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_INPUT_EXPOSURE)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_INPUT_EXPOSURE) uniform texture2D r_input_exposure;
|
||||
|
||||
FfxFloat32 Exposure()
|
||||
{
|
||||
FfxFloat32 exposure = texelFetch(r_input_exposure, FfxInt32x2(0, 0), 0).x;
|
||||
|
||||
if (exposure == 0.0) {
|
||||
exposure = 1.0;
|
||||
}
|
||||
|
||||
return exposure;
|
||||
}
|
||||
#endif
|
||||
|
||||
// BEGIN: FSR3UPSCALER_BIND_SRV_LANCZOS_LUT
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_LANCZOS_LUT)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_LANCZOS_LUT) uniform texture2D r_lanczos_lut;
|
||||
#endif
|
||||
|
||||
FfxFloat32 SampleLanczos2Weight(FfxFloat32 x)
|
||||
{
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_LANCZOS_LUT)
|
||||
return textureLod(sampler2D(r_lanczos_lut, s_LinearClamp), FfxFloat32x2(x / 2.0, 0.5), 0.0).x;
|
||||
#else
|
||||
return 0.f;
|
||||
#endif
|
||||
}
|
||||
// END: FSR3UPSCALER_BIND_SRV_LANCZOS_LUT
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_DILATED_REACTIVE_MASKS)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_DILATED_REACTIVE_MASKS) uniform texture2D r_dilated_reactive_masks;
|
||||
|
||||
FfxFloat32x4 SampleDilatedReactiveMasks(FfxFloat32x2 fUV)
|
||||
{
|
||||
return textureLod(sampler2D(r_dilated_reactive_masks, s_LinearClamp), fUV, 0.0);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_DILATED_REACTIVE_MASKS)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_DILATED_REACTIVE_MASKS, rgba8) writeonly uniform image2D rw_dilated_reactive_masks;
|
||||
|
||||
void StoreDilatedReactiveMasks(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x4 fDilatedReactiveMasks)
|
||||
{
|
||||
imageStore(rw_dilated_reactive_masks, iPxPos, fDilatedReactiveMasks);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_INPUT_OPAQUE_ONLY)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_SRV_INPUT_OPAQUE_ONLY) uniform texture2D r_input_opaque_only;
|
||||
|
||||
FfxFloat32x3 LoadOpaqueOnly(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_input_opaque_only, iPxPos, 0).xyz;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_PREV_PRE_ALPHA_COLOR)
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_PREV_PRE_ALPHA_COLOR) uniform texture2D r_input_prev_color_pre_alpha;
|
||||
|
||||
FfxFloat32x3 LoadPrevPreAlpha(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_input_prev_color_pre_alpha, iPxPos, 0).xyz;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_PREV_POST_ALPHA_COLOR)
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_PREV_POST_ALPHA_COLOR) uniform texture2D r_input_prev_color_post_alpha;
|
||||
|
||||
FfxFloat32x3 LoadPrevPostAlpha(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_input_prev_color_post_alpha, iPxPos, 0).xyz;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_AUTOREACTIVE) && \
|
||||
defined(FSR3UPSCALER_BIND_UAV_AUTOCOMPOSITION)
|
||||
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_UAV_AUTOREACTIVE, r32f) uniform image2D rw_output_autoreactive;
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_UAV_AUTOCOMPOSITION, r32f) uniform image2D rw_output_autocomposition;
|
||||
|
||||
void StoreAutoReactive(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos, FFX_PARAMETER_IN FFX_MIN16_F2 fReactive)
|
||||
{
|
||||
imageStore(rw_output_autoreactive, iPxPos, FfxFloat32x4(FfxFloat32(fReactive.x), 0.0, 0.0, 0.0));
|
||||
|
||||
imageStore(rw_output_autocomposition, iPxPos, FfxFloat32x4(FfxFloat32(fReactive.y), 0.0, 0.0, 0.0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_PREV_PRE_ALPHA_COLOR)
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_UAV_PREV_PRE_ALPHA_COLOR, r11f_g11f_b10f) uniform image2D rw_output_prev_color_pre_alpha;
|
||||
|
||||
void StorePrevPreAlpha(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos, FFX_PARAMETER_IN FFX_MIN16_F3 color)
|
||||
{
|
||||
imageStore(rw_output_prev_color_pre_alpha, iPxPos, FfxFloat32x4(color, 0.0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_PREV_POST_ALPHA_COLOR)
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_UAV_PREV_POST_ALPHA_COLOR, r11f_g11f_b10f) uniform image2D rw_output_prev_color_post_alpha;
|
||||
|
||||
void StorePrevPostAlpha(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos, FFX_PARAMETER_IN FFX_MIN16_F3 color)
|
||||
{
|
||||
imageStore(rw_output_prev_color_post_alpha, iPxPos, FfxFloat32x4(color, 0.0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_FRAME_INFO)
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_FRAME_INFO, rgba32f) uniform image2D rw_frame_info;
|
||||
|
||||
FfxFloat32x4 LoadFrameInfo()
|
||||
{
|
||||
return imageLoad(rw_frame_info, ivec2(0, 0));
|
||||
}
|
||||
|
||||
void StoreFrameInfo(FfxFloat32x4 fInfo)
|
||||
{
|
||||
imageStore(rw_frame_info, ivec2(0, 0), fInfo);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_FRAME_INFO)
|
||||
layout(set = 0, binding = FSR3UPSCALER_BIND_SRV_FRAME_INFO) uniform texture2D r_frame_info;
|
||||
|
||||
FfxFloat32x4 FrameInfo()
|
||||
{
|
||||
return texelFetch(r_frame_info, ivec2(0, 0), 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_0) && \
|
||||
defined(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_1) && \
|
||||
defined(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_2) && \
|
||||
defined(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_3) && \
|
||||
defined(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_4) && \
|
||||
defined(FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_5)
|
||||
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_0, rg16f) uniform image2D rw_spd_mip0;
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_1, rg16f) uniform image2D rw_spd_mip1;
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_2, rg16f) uniform image2D rw_spd_mip2;
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_3, rg16f) uniform image2D rw_spd_mip3;
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_4, rg16f) uniform image2D rw_spd_mip4;
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_SPD_MIPS_LEVEL_5, rg16f) coherent uniform image2D rw_spd_mip5;
|
||||
|
||||
FfxFloat32x2 RWLoadPyramid(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxUInt32 index)
|
||||
{
|
||||
#define LOAD(idx) \
|
||||
if (index == idx) \
|
||||
{ \
|
||||
return imageLoad(rw_spd_mip##idx, iPxPos).xy; \
|
||||
}
|
||||
LOAD(0);
|
||||
LOAD(1);
|
||||
LOAD(2);
|
||||
LOAD(3);
|
||||
LOAD(4);
|
||||
LOAD(5);
|
||||
|
||||
return FfxFloat32x2(0.0, 0.0);
|
||||
|
||||
#undef LOAD
|
||||
}
|
||||
|
||||
void StorePyramid(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x2 outValue, FFX_PARAMETER_IN FfxUInt32 index)
|
||||
{
|
||||
#define STORE(idx) \
|
||||
if (index == idx) \
|
||||
{ \
|
||||
imageStore(rw_spd_mip##idx, iPxPos, vec4(outValue, 0.0, 0.0)); \
|
||||
}
|
||||
|
||||
STORE(0);
|
||||
STORE(1);
|
||||
STORE(2);
|
||||
STORE(3);
|
||||
STORE(4);
|
||||
STORE(5);
|
||||
|
||||
#undef STORE
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined FSR3UPSCALER_BIND_UAV_SPD_GLOBAL_ATOMIC
|
||||
layout (set = 0, binding = FSR3UPSCALER_BIND_UAV_SPD_GLOBAL_ATOMIC, r32ui) coherent uniform uimage2D rw_spd_global_atomic;
|
||||
|
||||
void SPD_IncreaseAtomicCounter(inout FfxUInt32 spdCounter)
|
||||
{
|
||||
spdCounter = imageAtomicAdd(rw_spd_global_atomic, ivec2(0, 0), 1);
|
||||
}
|
||||
|
||||
void SPD_ResetAtomicCounter()
|
||||
{
|
||||
imageStore(rw_spd_global_atomic, ivec2(0, 0), uvec4(0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // #if defined(FFX_GPU)
|
||||
403
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_common.h
vendored
Normal file
403
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_common.h
vendored
Normal file
@@ -0,0 +1,403 @@
|
||||
// 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_FSR3UPSCALER_COMMON_H)
|
||||
#define FFX_FSR3UPSCALER_COMMON_H
|
||||
|
||||
#if defined(FFX_GPU)
|
||||
#pragma warning(error : 3206) // treat vector truncation warnings as errors
|
||||
#pragma warning(disable : 3205) // conversion from larger type to smaller
|
||||
#pragma warning(disable : 3571) // in ffxPow(f, e), f could be negative
|
||||
|
||||
FFX_STATIC const FfxFloat32 FSR3UPSCALER_FP16_MIN = 6.10e-05f;
|
||||
FFX_STATIC const FfxFloat32 FSR3UPSCALER_FP16_MAX = 65504.0f;
|
||||
FFX_STATIC const FfxFloat32 FSR3UPSCALER_EPSILON = FSR3UPSCALER_FP16_MIN;
|
||||
FFX_STATIC const FfxFloat32 FSR3UPSCALER_TONEMAP_EPSILON = FSR3UPSCALER_FP16_MIN;
|
||||
FFX_STATIC const FfxFloat32 FSR3UPSCALER_FP32_MAX = 3.402823466e+38f;
|
||||
FFX_STATIC const FfxFloat32 FSR3UPSCALER_FP32_MIN = 1.175494351e-38f;
|
||||
|
||||
// Reconstructed depth usage
|
||||
FFX_STATIC const FfxFloat32 fReconstructedDepthBilinearWeightThreshold = FSR3UPSCALER_EPSILON * 10;
|
||||
|
||||
FfxFloat32 ReconstructedDepthMvPxThreshold(FfxFloat32 fNearestDepthInMeters)
|
||||
{
|
||||
return ffxLerp(0.25f, 0.75f, ffxSaturate(fNearestDepthInMeters / 100.0f));
|
||||
}
|
||||
|
||||
// Accumulation
|
||||
FFX_STATIC const FfxFloat32 fUpsampleLanczosWeightScale = 1.0f / 16.0f;
|
||||
FFX_STATIC const FfxFloat32 fAverageLanczosWeightPerFrame = 0.74f * fUpsampleLanczosWeightScale; // Average lanczos weight for jitter accumulated samples
|
||||
FFX_STATIC const FfxFloat32 fAccumulationMaxOnMotion = 3.0f * fUpsampleLanczosWeightScale;
|
||||
|
||||
#define SHADING_CHANGE_SET_SIZE 5
|
||||
FFX_STATIC const FfxInt32 iShadingChangeMipStart = 0;
|
||||
FFX_STATIC const FfxFloat32 fShadingChangeSamplePow = 1.0f / 1.0f;
|
||||
|
||||
|
||||
FFX_STATIC const FfxFloat32 fLockThreshold = 1.0f;
|
||||
FFX_STATIC const FfxFloat32 fLockMax = 2.0f;
|
||||
|
||||
FFX_STATIC const FfxInt32 REACTIVE = 0;
|
||||
FFX_STATIC const FfxInt32 DISOCCLUSION = 1;
|
||||
FFX_STATIC const FfxInt32 SHADING_CHANGE = 2;
|
||||
FFX_STATIC const FfxInt32 ACCUMULAION = 3;
|
||||
|
||||
FFX_STATIC const FfxInt32 FRAME_INFO_EXPOSURE = 0;
|
||||
FFX_STATIC const FfxInt32 FRAME_INFO_LOG_LUMA = 1;
|
||||
FFX_STATIC const FfxInt32 FRAME_INFO_SCENE_AVERAGE_LUMA = 2;
|
||||
|
||||
FfxBoolean TonemapFirstFrame()
|
||||
{
|
||||
const FfxBoolean bEnabled = true;
|
||||
return FrameIndex() == 0 && bEnabled;
|
||||
}
|
||||
|
||||
FfxFloat32 AverageLanczosWeightPerFrame()
|
||||
{
|
||||
return 0.74f;
|
||||
}
|
||||
|
||||
FfxInt32x2 ShadingChangeRenderSize()
|
||||
{
|
||||
return FfxInt32x2(RenderSize() * 0.5f);
|
||||
}
|
||||
|
||||
FfxInt32x2 ShadingChangeMaxRenderSize()
|
||||
{
|
||||
return FfxInt32x2(MaxRenderSize() * 0.5f);
|
||||
}
|
||||
|
||||
FfxInt32x2 PreviousFrameShadingChangeRenderSize()
|
||||
{
|
||||
return FfxInt32x2(PreviousFrameRenderSize() * 0.5f);
|
||||
}
|
||||
|
||||
#if defined(FSR3UPSCALER_BIND_SRV_FRAME_INFO)
|
||||
FfxFloat32 SceneAverageLuma()
|
||||
{
|
||||
return FrameInfo()[FRAME_INFO_SCENE_AVERAGE_LUMA];
|
||||
}
|
||||
#endif
|
||||
|
||||
// Auto exposure
|
||||
FFX_STATIC const FfxFloat32 resetAutoExposureAverageSmoothing = 1e4f;
|
||||
|
||||
struct AccumulationPassCommonParams
|
||||
{
|
||||
FfxInt32x2 iPxHrPos;
|
||||
FfxFloat32x2 fHrUv;
|
||||
FfxFloat32x2 fLrUvJittered;
|
||||
FfxFloat32x2 fLrUv_HwSampler;
|
||||
FfxFloat32x2 fMotionVector;
|
||||
FfxFloat32x2 fReprojectedHrUv;
|
||||
FfxFloat32 f4KVelocity;
|
||||
FfxFloat32 fDisocclusion;
|
||||
FfxFloat32 fReactiveMask;
|
||||
FfxFloat32 fShadingChange;
|
||||
FfxFloat32 fAccumulation;
|
||||
FfxFloat32 fLumaInstabilityFactor;
|
||||
FfxFloat32 fFarthestDepthInMeters;
|
||||
|
||||
FfxBoolean bIsExistingSample;
|
||||
FfxBoolean bIsNewSample;
|
||||
};
|
||||
|
||||
FfxFloat32 Get4KVelocity(FfxFloat32x2 fMotionVector)
|
||||
{
|
||||
return length(fMotionVector * FfxFloat32x2(3840.0f, 2160.0f));
|
||||
}
|
||||
|
||||
struct RectificationBox
|
||||
{
|
||||
FfxFloat32x3 boxCenter;
|
||||
FfxFloat32x3 boxVec;
|
||||
FfxFloat32x3 aabbMin;
|
||||
FfxFloat32x3 aabbMax;
|
||||
FfxFloat32 fBoxCenterWeight;
|
||||
};
|
||||
|
||||
struct AccumulationPassData
|
||||
{
|
||||
RectificationBox clippingBox;
|
||||
FfxFloat32x3 fUpsampledColor;
|
||||
FfxFloat32 fUpsampledWeight;
|
||||
FfxFloat32x3 fHistoryColor;
|
||||
FfxFloat32 fHistoryWeight;
|
||||
FfxFloat32 fLock;
|
||||
FfxFloat32 fLockContributionThisFrame;
|
||||
};
|
||||
|
||||
void RectificationBoxAddInitialSample(FFX_PARAMETER_INOUT RectificationBox rectificationBox, const FfxFloat32x3 colorSample, const FfxFloat32 fSampleWeight)
|
||||
{
|
||||
rectificationBox.aabbMin = colorSample;
|
||||
rectificationBox.aabbMax = colorSample;
|
||||
|
||||
FfxFloat32x3 weightedSample = colorSample * fSampleWeight;
|
||||
rectificationBox.boxCenter = weightedSample;
|
||||
rectificationBox.boxVec = colorSample * weightedSample;
|
||||
rectificationBox.fBoxCenterWeight = fSampleWeight;
|
||||
}
|
||||
|
||||
void RectificationBoxAddSample(FfxBoolean bInitialSample, FFX_PARAMETER_INOUT RectificationBox rectificationBox, const FfxFloat32x3 colorSample, const FfxFloat32 fSampleWeight)
|
||||
{
|
||||
if (bInitialSample) {
|
||||
RectificationBoxAddInitialSample(rectificationBox, colorSample, fSampleWeight);
|
||||
} else {
|
||||
rectificationBox.aabbMin = ffxMin(rectificationBox.aabbMin, colorSample);
|
||||
rectificationBox.aabbMax = ffxMax(rectificationBox.aabbMax, colorSample);
|
||||
|
||||
FfxFloat32x3 weightedSample = colorSample * fSampleWeight;
|
||||
rectificationBox.boxCenter += weightedSample;
|
||||
rectificationBox.boxVec += colorSample * weightedSample;
|
||||
rectificationBox.fBoxCenterWeight += fSampleWeight;
|
||||
}
|
||||
}
|
||||
|
||||
void RectificationBoxComputeVarianceBoxData(FFX_PARAMETER_INOUT RectificationBox rectificationBox)
|
||||
{
|
||||
rectificationBox.fBoxCenterWeight = (abs(rectificationBox.fBoxCenterWeight) > FfxFloat32(FSR3UPSCALER_FP32_MIN) ? rectificationBox.fBoxCenterWeight : FfxFloat32(1.f));
|
||||
rectificationBox.boxCenter /= rectificationBox.fBoxCenterWeight;
|
||||
rectificationBox.boxVec /= rectificationBox.fBoxCenterWeight;
|
||||
FfxFloat32x3 stdDev = sqrt(abs(rectificationBox.boxVec - rectificationBox.boxCenter * rectificationBox.boxCenter));
|
||||
rectificationBox.boxVec = stdDev;
|
||||
}
|
||||
|
||||
FfxFloat32x3 SafeRcp3(FfxFloat32x3 v)
|
||||
{
|
||||
return (all(FFX_NOT_EQUAL(v, FfxFloat32x3(0, 0, 0)))) ? (FfxFloat32x3(1, 1, 1) / v) : FfxFloat32x3(0, 0, 0);
|
||||
}
|
||||
|
||||
FfxFloat32 MinDividedByMax(const FfxFloat32 v0, const FfxFloat32 v1, const FfxFloat32 fOnZeroReturnValue)
|
||||
{
|
||||
const FfxFloat32 m = ffxMax(v0, v1);
|
||||
return m != 0 ? ffxMin(v0, v1) / m : fOnZeroReturnValue;
|
||||
}
|
||||
|
||||
FfxFloat32 MinDividedByMax(const FfxFloat32 v0, const FfxFloat32 v1)
|
||||
{
|
||||
const FfxFloat32 m = ffxMax(v0, v1);
|
||||
return m != 0 ? ffxMin(v0, v1) / m : 0;
|
||||
}
|
||||
|
||||
FfxFloat32x3 YCoCgToRGB(FfxFloat32x3 fYCoCg)
|
||||
{
|
||||
FfxFloat32x3 fRgb;
|
||||
|
||||
fRgb = FfxFloat32x3(
|
||||
fYCoCg.x + fYCoCg.y - fYCoCg.z,
|
||||
fYCoCg.x + fYCoCg.z,
|
||||
fYCoCg.x - fYCoCg.y - fYCoCg.z);
|
||||
|
||||
return fRgb;
|
||||
}
|
||||
|
||||
FfxFloat32x3 RGBToYCoCg(FfxFloat32x3 fRgb)
|
||||
{
|
||||
FfxFloat32x3 fYCoCg;
|
||||
|
||||
fYCoCg = FfxFloat32x3(
|
||||
0.25f * fRgb.r + 0.5f * fRgb.g + 0.25f * fRgb.b,
|
||||
0.5f * fRgb.r - 0.5f * fRgb.b,
|
||||
-0.25f * fRgb.r + 0.5f * fRgb.g - 0.25f * fRgb.b);
|
||||
|
||||
return fYCoCg;
|
||||
}
|
||||
|
||||
FfxFloat32 RGBToLuma(FfxFloat32x3 fLinearRgb)
|
||||
{
|
||||
return dot(fLinearRgb, FfxFloat32x3(0.2126f, 0.7152f, 0.0722f));
|
||||
}
|
||||
|
||||
FfxFloat32 RGBToPerceivedLuma(FfxFloat32x3 fLinearRgb)
|
||||
{
|
||||
FfxFloat32 fLuminance = RGBToLuma(fLinearRgb);
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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(FSR3UPSCALER_TONEMAP_EPSILON, 1.f - ffxMax(fRgb.r, ffxMax(fRgb.g, fRgb.b))).xxx;
|
||||
}
|
||||
|
||||
FfxBoolean IsUvInside(FfxFloat32x2 fUv)
|
||||
{
|
||||
return (fUv.x >= 0.0f && fUv.x <= 1.0f) && (fUv.y >= 0.0f && fUv.y <= 1.0f);
|
||||
}
|
||||
|
||||
FfxInt32x2 ClampLoad(FfxInt32x2 iPxSample, FfxInt32x2 iPxOffset, FfxInt32x2 iTextureSize)
|
||||
{
|
||||
FfxInt32x2 result = iPxSample + iPxOffset;
|
||||
result.x = ffxMax(0, ffxMin(result.x, iTextureSize.x - 1));
|
||||
result.y = ffxMax(0, ffxMin(result.y, iTextureSize.y - 1));
|
||||
return result;
|
||||
}
|
||||
|
||||
FfxFloat32x2 ClampUv(FfxFloat32x2 fUv, FfxInt32x2 iTextureSize, FfxInt32x2 iResourceSize)
|
||||
{
|
||||
const FfxFloat32x2 fSampleLocation = fUv * iTextureSize;
|
||||
const FfxFloat32x2 fClampedLocation = ffxMax(FfxFloat32x2(0.5f, 0.5f), ffxMin(fSampleLocation, FfxFloat32x2(iTextureSize) - FfxFloat32x2(0.5f, 0.5f)));
|
||||
const FfxFloat32x2 fClampedUv = fClampedLocation / FfxFloat32x2(iResourceSize);
|
||||
|
||||
return fClampedUv;
|
||||
}
|
||||
|
||||
FfxBoolean IsOnScreen(FfxInt32x2 pos, FfxInt32x2 size)
|
||||
{
|
||||
return all(FFX_LESS_THAN(FfxUInt32x2(pos), FfxUInt32x2(size)));
|
||||
}
|
||||
|
||||
FfxFloat32 ComputeAutoExposureFromLavg(FfxFloat32 Lavg)
|
||||
{
|
||||
Lavg = exp(Lavg);
|
||||
|
||||
const FfxFloat32 S = 100.0f; //ISO arithmetic speed
|
||||
const FfxFloat32 K = 12.5f;
|
||||
FfxFloat32 ExposureISO100 = log2((Lavg * S) / K);
|
||||
|
||||
const FfxFloat32 q = 0.65f;
|
||||
FfxFloat32 Lmax = (78.0f / (q * S)) * ffxPow(2.0f, ExposureISO100);
|
||||
|
||||
return 1.0f / Lmax;
|
||||
}
|
||||
|
||||
FfxInt32x2 ComputeHrPosFromLrPos(FfxInt32x2 iPxLrPos)
|
||||
{
|
||||
FfxFloat32x2 fSrcJitteredPos = FfxFloat32x2(iPxLrPos) + 0.5f - Jitter();
|
||||
FfxFloat32x2 fLrPosInHr = (fSrcJitteredPos / RenderSize()) * UpscaleSize();
|
||||
FfxInt32x2 iPxHrPos = FfxInt32x2(floor(fLrPosInHr));
|
||||
return iPxHrPos;
|
||||
}
|
||||
|
||||
FfxFloat32x2 ComputeNdc(FfxFloat32x2 fPxPos, FfxInt32x2 iSize)
|
||||
{
|
||||
return fPxPos / FfxFloat32x2(iSize) * FfxFloat32x2(2.0f, -2.0f) + FfxFloat32x2(-1.0f, 1.0f);
|
||||
}
|
||||
|
||||
FfxFloat32 GetViewSpaceDepth(FfxFloat32 fDeviceDepth)
|
||||
{
|
||||
const FfxFloat32x4 fDeviceToViewDepth = DeviceToViewSpaceTransformFactors();
|
||||
|
||||
// fDeviceToViewDepth details found in ffx_fsr3upscaler.cpp
|
||||
return (fDeviceToViewDepth[1] / (fDeviceDepth - fDeviceToViewDepth[0]));
|
||||
}
|
||||
|
||||
FfxFloat32 GetViewSpaceDepthInMeters(FfxFloat32 fDeviceDepth)
|
||||
{
|
||||
return GetViewSpaceDepth(fDeviceDepth) * ViewSpaceToMetersFactor();
|
||||
}
|
||||
|
||||
FfxFloat32x3 GetViewSpacePosition(FfxInt32x2 iViewportPos, FfxInt32x2 iViewportSize, FfxFloat32 fDeviceDepth)
|
||||
{
|
||||
const FfxFloat32x4 fDeviceToViewDepth = DeviceToViewSpaceTransformFactors();
|
||||
|
||||
const FfxFloat32 Z = GetViewSpaceDepth(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);
|
||||
}
|
||||
|
||||
FfxFloat32x3 GetViewSpacePositionInMeters(FfxInt32x2 iViewportPos, FfxInt32x2 iViewportSize, FfxFloat32 fDeviceDepth)
|
||||
{
|
||||
return GetViewSpacePosition(iViewportPos, iViewportSize, fDeviceDepth) * ViewSpaceToMetersFactor();
|
||||
}
|
||||
|
||||
FfxFloat32 GetMaxDistanceInMeters()
|
||||
{
|
||||
#if FFX_FSR3UPSCALER_OPTION_INVERTED_DEPTH
|
||||
return GetViewSpaceDepth(0.0f) * ViewSpaceToMetersFactor();
|
||||
#else
|
||||
return GetViewSpaceDepth(1.0f) * ViewSpaceToMetersFactor();
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
struct PlaneData
|
||||
{
|
||||
FfxFloat32x3 fNormal;
|
||||
FfxFloat32 fDistanceFromOrigin;
|
||||
};
|
||||
|
||||
PlaneData GetPlaneFromPoints(FfxFloat32x3 fP0, FfxFloat32x3 fP1, FfxFloat32x3 fP2)
|
||||
{
|
||||
PlaneData plane;
|
||||
|
||||
FfxFloat32x3 v0 = fP0 - fP1;
|
||||
FfxFloat32x3 v1 = fP0 - fP2;
|
||||
plane.fNormal = normalize(cross(v0, v1));
|
||||
plane.fDistanceFromOrigin = -dot(fP0, plane.fNormal);
|
||||
|
||||
return plane;
|
||||
}
|
||||
|
||||
FfxFloat32 PointToPlaneDistance(PlaneData plane, FfxFloat32x3 fPoint)
|
||||
{
|
||||
return abs(dot(plane.fNormal, fPoint) + plane.fDistanceFromOrigin);
|
||||
}
|
||||
|
||||
#endif // #if defined(FFX_GPU)
|
||||
|
||||
#endif //!defined(FFX_FSR3UPSCALER_COMMON_H)
|
||||
115
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_luma_instability.h
vendored
Normal file
115
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_luma_instability.h
vendored
Normal file
@@ -0,0 +1,115 @@
|
||||
// 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.
|
||||
|
||||
struct LumaInstabilityFactorData
|
||||
{
|
||||
FfxFloat32x4 fLumaHistory;
|
||||
FfxFloat32 fLumaInstabilityFactor;
|
||||
};
|
||||
|
||||
LumaInstabilityFactorData ComputeLumaInstabilityFactor(LumaInstabilityFactorData data, FfxFloat32 fCurrentFrameLuma, FfxFloat32 fFarthestDepthInMeters)
|
||||
{
|
||||
const FfxInt32 N_MINUS_1 = 0;
|
||||
const FfxInt32 N_MINUS_2 = 1;
|
||||
const FfxInt32 N_MINUS_3 = 2;
|
||||
const FfxInt32 N_MINUS_4 = 3;
|
||||
|
||||
FfxFloat32 fLumaInstability = 0.0f;
|
||||
const FfxFloat32 fDiffs0 = (fCurrentFrameLuma - data.fLumaHistory[N_MINUS_1]);
|
||||
const FfxFloat32 fSimilarity0 = MinDividedByMax(fCurrentFrameLuma, data.fLumaHistory[N_MINUS_1], 1.0f);
|
||||
|
||||
FfxFloat32 fMaxSimilarity = fSimilarity0;
|
||||
|
||||
if (fSimilarity0 < 1.0f) {
|
||||
for (int i = N_MINUS_2; i <= N_MINUS_4; i++) {
|
||||
const FfxFloat32 fDiffs1 = (fCurrentFrameLuma - data.fLumaHistory[i]);
|
||||
const FfxFloat32 fSimilarity1 = MinDividedByMax(fCurrentFrameLuma, data.fLumaHistory[i]);
|
||||
|
||||
if (sign(fDiffs0) == sign(fDiffs1)) {
|
||||
|
||||
fMaxSimilarity = ffxMax(fMaxSimilarity, fSimilarity1);
|
||||
}
|
||||
}
|
||||
|
||||
fLumaInstability = FfxFloat32(fMaxSimilarity > fSimilarity0);
|
||||
}
|
||||
|
||||
// Shift history
|
||||
data.fLumaHistory[N_MINUS_4] = data.fLumaHistory[N_MINUS_3];
|
||||
data.fLumaHistory[N_MINUS_3] = data.fLumaHistory[N_MINUS_2];
|
||||
data.fLumaHistory[N_MINUS_2] = data.fLumaHistory[N_MINUS_1];
|
||||
data.fLumaHistory[N_MINUS_1] = fCurrentFrameLuma;
|
||||
|
||||
data.fLumaHistory /= Exposure();
|
||||
|
||||
data.fLumaInstabilityFactor = fLumaInstability * FfxFloat32(data.fLumaHistory[N_MINUS_4] != 0);
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
void LumaInstability(FfxInt32x2 iPxPos)
|
||||
{
|
||||
LumaInstabilityFactorData data;
|
||||
data.fLumaInstabilityFactor = 0.0f;
|
||||
data.fLumaHistory = FfxFloat32x4(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
|
||||
const FfxFloat32x2 fDilatedMotionVector = LoadDilatedMotionVector(iPxPos);
|
||||
const FfxFloat32x2 fUv = (iPxPos + 0.5f) / RenderSize();
|
||||
const FfxFloat32x2 fUvCurrFrameJittered = fUv + Jitter() / RenderSize();
|
||||
const FfxFloat32x2 fUvPrevFrameJittered = fUv + PreviousFrameJitter() / PreviousFrameRenderSize();
|
||||
const FfxFloat32x2 fReprojectedUv = fUvPrevFrameJittered + fDilatedMotionVector;
|
||||
|
||||
if (IsUvInside(fReprojectedUv))
|
||||
{
|
||||
const FfxFloat32x2 fUvReactive_HW = ClampUv(fUvCurrFrameJittered, RenderSize(), MaxRenderSize());
|
||||
|
||||
const FfxFloat32x4 fDilatedReactiveMasks = SampleDilatedReactiveMasks(fUvReactive_HW);
|
||||
const FfxFloat32 fReactiveMask = ffxSaturate(fDilatedReactiveMasks[REACTIVE]);
|
||||
const FfxFloat32 fDisocclusion = ffxSaturate(fDilatedReactiveMasks[DISOCCLUSION]);
|
||||
const FfxFloat32 fShadingChange = ffxSaturate(fDilatedReactiveMasks[SHADING_CHANGE]);
|
||||
const FfxFloat32 fAccumulation = ffxSaturate(fDilatedReactiveMasks[ACCUMULAION]);
|
||||
|
||||
const FfxBoolean bAccumulationFactor = fAccumulation > 0.9f;
|
||||
|
||||
const FfxBoolean bComputeInstability = bAccumulationFactor;
|
||||
|
||||
if (bComputeInstability) {
|
||||
|
||||
const FfxFloat32x2 fUv_HW = ClampUv(fUvCurrFrameJittered, RenderSize(), MaxRenderSize());
|
||||
const FfxFloat32 fCurrentFrameLuma = SampleCurrentLuma(fUv_HW) * Exposure();
|
||||
|
||||
const FfxFloat32x2 fReprojectedUv_HW = ClampUv(fReprojectedUv, PreviousFrameRenderSize(), MaxRenderSize());
|
||||
data.fLumaHistory = SampleLumaHistory(fReprojectedUv_HW) * DeltaPreExposure() * Exposure();
|
||||
|
||||
const FfxFloat32x2 fFarthestDepthUv_HW = ClampUv(fUvCurrFrameJittered, RenderSize() / 2, GetFarthestDepthMip1ResourceDimensions());
|
||||
const FfxFloat32 fFarthestDepthInMeters = SampleFarthestDepthMip1(fFarthestDepthUv_HW);
|
||||
|
||||
data = ComputeLumaInstabilityFactor(data, fCurrentFrameLuma, fFarthestDepthInMeters);
|
||||
|
||||
const FfxFloat32 fVelocityWeight = 1.0f - ffxSaturate(Get4KVelocity(fDilatedMotionVector) / 20.0f);
|
||||
data.fLumaInstabilityFactor *= fVelocityWeight * (1.0f - fDisocclusion) * (1.0f - fReactiveMask) * (1.0f - fShadingChange);
|
||||
}
|
||||
}
|
||||
|
||||
StoreLumaHistory(iPxPos, data.fLumaHistory);
|
||||
StoreLumaInstability(iPxPos, data.fLumaInstabilityFactor);
|
||||
}
|
||||
192
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_luma_pyramid.h
vendored
Normal file
192
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_luma_pyramid.h
vendored
Normal file
@@ -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.
|
||||
|
||||
FFX_GROUPSHARED FfxUInt32 spdCounter;
|
||||
|
||||
void SpdIncreaseAtomicCounter(FfxUInt32 slice)
|
||||
{
|
||||
SPD_IncreaseAtomicCounter(spdCounter);
|
||||
}
|
||||
|
||||
FfxUInt32 SpdGetAtomicCounter()
|
||||
{
|
||||
return spdCounter;
|
||||
}
|
||||
|
||||
void SpdResetAtomicCounter(FfxUInt32 slice)
|
||||
{
|
||||
SPD_ResetAtomicCounter();
|
||||
}
|
||||
|
||||
#ifndef SPD_PACKED_ONLY
|
||||
FFX_GROUPSHARED FfxFloat32 spdIntermediateR[16][16];
|
||||
FFX_GROUPSHARED FfxFloat32 spdIntermediateG[16][16];
|
||||
FFX_GROUPSHARED FfxFloat32 spdIntermediateB[16][16];
|
||||
FFX_GROUPSHARED FfxFloat32 spdIntermediateA[16][16];
|
||||
|
||||
FFX_STATIC const FfxInt32 LOG_LUMA = 0;
|
||||
FFX_STATIC const FfxInt32 LUMA = 1;
|
||||
FFX_STATIC const FfxInt32 DEPTH_IN_METERS = 2;
|
||||
|
||||
FfxFloat32x4 SpdLoadSourceImage(FfxFloat32x2 iPxPos, FfxUInt32 slice)
|
||||
{
|
||||
//We assume linear data. if non-linear input (sRGB, ...),
|
||||
//then we should convert to linear first and back to sRGB on output.
|
||||
const FfxInt32x2 iPxSamplePos = ClampLoad(FfxInt32x2(iPxPos), FfxInt32x2(0, 0), FfxInt32x2(RenderSize()));
|
||||
|
||||
const FfxFloat32 fLuma = LoadCurrentLuma(iPxSamplePos);
|
||||
const FfxFloat32 fLogLuma = ffxMax(FSR3UPSCALER_EPSILON, log(fLuma));
|
||||
const FfxFloat32 fFarthestDepthInMeters = LoadFarthestDepth(iPxSamplePos);
|
||||
|
||||
FfxFloat32x4 fOutput = FfxFloat32x4(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
fOutput[LOG_LUMA] = fLogLuma;
|
||||
fOutput[LUMA] = fLuma;
|
||||
fOutput[DEPTH_IN_METERS] = fFarthestDepthInMeters;
|
||||
|
||||
return fOutput;
|
||||
}
|
||||
|
||||
FfxFloat32x4 SpdLoad(FfxInt32x2 tex, FfxUInt32 slice)
|
||||
{
|
||||
return FfxFloat32x4(RWLoadPyramid(tex, 5), 0, 0);
|
||||
}
|
||||
|
||||
FfxFloat32x4 SpdReduce4(FfxFloat32x4 v0, FfxFloat32x4 v1, FfxFloat32x4 v2, FfxFloat32x4 v3)
|
||||
{
|
||||
return (v0 + v1 + v2 + v3) * 0.25f;
|
||||
}
|
||||
|
||||
void SpdStore(FfxInt32x2 pix, FfxFloat32x4 outValue, FfxUInt32 index, FfxUInt32 slice)
|
||||
{
|
||||
if (index == 5)
|
||||
{
|
||||
StorePyramid(pix, outValue.xy, index);
|
||||
}
|
||||
else if (index == 0) {
|
||||
StoreFarthestDepthMip1(pix, outValue[DEPTH_IN_METERS]);
|
||||
}
|
||||
|
||||
if (index == MipCount() - 1) { //accumulate on 1x1 level
|
||||
|
||||
if (all(FFX_EQUAL(pix, FfxInt32x2(0, 0))))
|
||||
{
|
||||
FfxFloat32x4 frameInfo = LoadFrameInfo();
|
||||
const FfxFloat32 fSceneAvgLuma = outValue[LUMA];
|
||||
const FfxFloat32 fPrevLogLuma = frameInfo[FRAME_INFO_LOG_LUMA];
|
||||
FfxFloat32 fLogLuma = outValue[LOG_LUMA];
|
||||
|
||||
if (fPrevLogLuma < resetAutoExposureAverageSmoothing) // Compare Lavg, so small or negative values
|
||||
{
|
||||
fLogLuma = fPrevLogLuma + (fLogLuma - fPrevLogLuma) * (1.0f - exp(-DeltaTime()));
|
||||
fLogLuma = ffxMax(0.0f, fLogLuma);
|
||||
}
|
||||
|
||||
frameInfo[FRAME_INFO_EXPOSURE] = ComputeAutoExposureFromLavg(fLogLuma);
|
||||
frameInfo[FRAME_INFO_LOG_LUMA] = fLogLuma;
|
||||
frameInfo[FRAME_INFO_SCENE_AVERAGE_LUMA] = fSceneAvgLuma;
|
||||
|
||||
StoreFrameInfo(frameInfo);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
// define fetch and store functions Packed
|
||||
#if FFX_HALF
|
||||
|
||||
FFX_GROUPSHARED FfxFloat16x2 spdIntermediateRG[16][16];
|
||||
FFX_GROUPSHARED FfxFloat16x2 spdIntermediateBA[16][16];
|
||||
|
||||
FfxFloat16x4 SpdLoadSourceImageH(FfxFloat32x2 tex, FfxUInt32 slice)
|
||||
{
|
||||
return FfxFloat16x4(0, 0, 0, 0);
|
||||
}
|
||||
|
||||
FfxFloat16x4 SpdLoadH(FfxInt32x2 p, FfxUInt32 slice)
|
||||
{
|
||||
return FfxFloat16x4(0, 0, 0, 0);
|
||||
}
|
||||
|
||||
void SpdStoreH(FfxInt32x2 p, FfxFloat16x4 value, FfxUInt32 mip, FfxUInt32 slice)
|
||||
{
|
||||
}
|
||||
|
||||
FfxFloat16x4 SpdLoadIntermediateH(FfxUInt32 x, FfxUInt32 y)
|
||||
{
|
||||
return FfxFloat16x4(
|
||||
spdIntermediateRG[x][y].x,
|
||||
spdIntermediateRG[x][y].y,
|
||||
spdIntermediateBA[x][y].x,
|
||||
spdIntermediateBA[x][y].y);
|
||||
}
|
||||
|
||||
void SpdStoreIntermediateH(FfxUInt32 x, FfxUInt32 y, FfxFloat16x4 value)
|
||||
{
|
||||
spdIntermediateRG[x][y] = value.xy;
|
||||
spdIntermediateBA[x][y] = value.zw;
|
||||
}
|
||||
|
||||
FfxFloat16x4 SpdReduce4H(FfxFloat16x4 v0, FfxFloat16x4 v1, FfxFloat16x4 v2, FfxFloat16x4 v3)
|
||||
{
|
||||
return (v0 + v1 + v2 + v3) * FfxFloat16(0.25);
|
||||
}
|
||||
#endif
|
||||
|
||||
#include "spd/ffx_spd.h"
|
||||
|
||||
void ComputeAutoExposure(FfxUInt32x3 WorkGroupId, FfxUInt32 LocalThreadIndex)
|
||||
{
|
||||
#if FFX_HALF
|
||||
SpdDownsampleH(
|
||||
FfxUInt32x2(WorkGroupId.xy),
|
||||
FfxUInt32(LocalThreadIndex),
|
||||
FfxUInt32(MipCount()),
|
||||
FfxUInt32(NumWorkGroups()),
|
||||
FfxUInt32(WorkGroupId.z),
|
||||
FfxUInt32x2(WorkGroupOffset()));
|
||||
#else
|
||||
SpdDownsample(
|
||||
FfxUInt32x2(WorkGroupId.xy),
|
||||
FfxUInt32(LocalThreadIndex),
|
||||
FfxUInt32(MipCount()),
|
||||
FfxUInt32(NumWorkGroups()),
|
||||
FfxUInt32(WorkGroupId.z),
|
||||
FfxUInt32x2(WorkGroupOffset()));
|
||||
#endif
|
||||
}
|
||||
152
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_prepare_inputs.h
vendored
Normal file
152
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_prepare_inputs.h
vendored
Normal file
@@ -0,0 +1,152 @@
|
||||
// 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.
|
||||
|
||||
void ReconstructPrevDepth(FfxInt32x2 iPxPos, FfxFloat32 fDepth, FfxFloat32x2 fMotionVector)
|
||||
{
|
||||
const FfxFloat32 fNearestDepthInMeters = ffxMin(GetViewSpaceDepthInMeters(fDepth), FSR3UPSCALER_FP16_MAX);
|
||||
const FfxFloat32 fReconstructedDeptMvThreshold = ReconstructedDepthMvPxThreshold(fNearestDepthInMeters);
|
||||
|
||||
// Discard small mvs
|
||||
fMotionVector *= FfxFloat32(Get4KVelocity(fMotionVector) > fReconstructedDeptMvThreshold);
|
||||
|
||||
const FfxFloat32x2 fUv = (iPxPos + FfxFloat32(0.5)) / RenderSize();
|
||||
const FfxFloat32x2 fReprojectedUv = fUv + fMotionVector;
|
||||
const 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];
|
||||
const FfxFloat32 fWeight = bilinearInfo.fWeights[iSampleIndex];
|
||||
|
||||
if (fWeight > fReconstructedDepthBilinearWeightThreshold) {
|
||||
|
||||
const FfxInt32x2 iStorePos = bilinearInfo.iBasePos + iOffset;
|
||||
if (IsOnScreen(iStorePos, RenderSize())) {
|
||||
StoreReconstructedDepth(iStorePos, fDepth);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct DepthExtents
|
||||
{
|
||||
FfxFloat32 fNearest;
|
||||
FfxInt32x2 fNearestCoord;
|
||||
FfxFloat32 fFarthest;
|
||||
};
|
||||
|
||||
DepthExtents FindDepthExtents(FFX_PARAMETER_IN FfxInt32x2 iPxPos)
|
||||
{
|
||||
DepthExtents extents;
|
||||
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
|
||||
extents.fNearestCoord = iPxPos;
|
||||
extents.fNearest = depth[0];
|
||||
extents.fFarthest = depth[0];
|
||||
FFX_UNROLL
|
||||
for (iSampleIndex = 1; iSampleIndex < iSampleCount; ++iSampleIndex) {
|
||||
|
||||
const FfxInt32x2 iPos = iPxPos + iSampleOffsets[iSampleIndex];
|
||||
if (IsOnScreen(iPos, RenderSize())) {
|
||||
|
||||
FfxFloat32 fNdDepth = depth[iSampleIndex];
|
||||
#if FFX_FSR3UPSCALER_OPTION_INVERTED_DEPTH
|
||||
if (fNdDepth > extents.fNearest) {
|
||||
extents.fFarthest = ffxMin(extents.fFarthest, fNdDepth);
|
||||
#else
|
||||
if (fNdDepth < extents.fNearest) {
|
||||
extents.fFarthest = ffxMax(extents.fFarthest, fNdDepth);
|
||||
#endif
|
||||
extents.fNearestCoord = iPos;
|
||||
extents.fNearest = fNdDepth;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return extents;
|
||||
}
|
||||
|
||||
FfxFloat32x2 DilateMotionVector(FfxInt32x2 iPxPos, const DepthExtents depthExtents)
|
||||
{
|
||||
#if FFX_FSR3UPSCALER_OPTION_LOW_RESOLUTION_MOTION_VECTORS
|
||||
const FfxInt32x2 iSamplePos = iPxPos;
|
||||
const FfxInt32x2 iMotionVectorPos = depthExtents.fNearestCoord;
|
||||
#else
|
||||
const FfxInt32x2 iSamplePos = ComputeHrPosFromLrPos(iPxPos);
|
||||
const FfxInt32x2 iMotionVectorPos = ComputeHrPosFromLrPos(depthExtents.fNearestCoord);
|
||||
#endif
|
||||
|
||||
const FfxFloat32x2 fDilatedMotionVector = LoadInputMotionVector(iMotionVectorPos);
|
||||
|
||||
return fDilatedMotionVector;
|
||||
}
|
||||
|
||||
FfxFloat32 GetCurrentFrameLuma(FfxInt32x2 iPxPos)
|
||||
{
|
||||
//We assume linear data. if non-linear input (sRGB, ...),
|
||||
//then we should convert to linear first and back to sRGB on output.
|
||||
const FfxFloat32x3 fRgb = ffxMax(FfxFloat32x3(0, 0, 0), LoadInputColor(iPxPos));
|
||||
const FfxFloat32 fLuma = RGBToLuma(fRgb);
|
||||
|
||||
return fLuma;
|
||||
}
|
||||
|
||||
void PrepareInputs(FfxInt32x2 iPxPos)
|
||||
{
|
||||
const DepthExtents depthExtents = FindDepthExtents(iPxPos);
|
||||
const FfxFloat32x2 fDilatedMotionVector = DilateMotionVector(iPxPos, depthExtents);
|
||||
|
||||
ReconstructPrevDepth(iPxPos, depthExtents.fNearest, fDilatedMotionVector);
|
||||
|
||||
StoreDilatedMotionVector(iPxPos, fDilatedMotionVector);
|
||||
StoreDilatedDepth(iPxPos, depthExtents.fNearest);
|
||||
|
||||
const FfxFloat32 fFarthestDepthInMeters = ffxMin(GetViewSpaceDepthInMeters(depthExtents.fFarthest), FSR3UPSCALER_FP16_MAX);
|
||||
StoreFarthestDepth(iPxPos, fFarthestDepthInMeters);
|
||||
|
||||
const FfxFloat32 fLuma = GetCurrentFrameLuma(iPxPos);
|
||||
StoreCurrentLuma(iPxPos, fLuma);
|
||||
}
|
||||
283
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_prepare_reactivity.h
vendored
Normal file
283
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_prepare_reactivity.h
vendored
Normal file
@@ -0,0 +1,283 @@
|
||||
// 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.
|
||||
|
||||
FfxFloat32 ComputeDisocclusions(FfxFloat32x2 fUv, FfxFloat32x2 fMotionVector, FfxFloat32 fCurrentDepthViewSpace)
|
||||
{
|
||||
const FfxFloat32 fNearestDepthInMeters = ffxMin(fCurrentDepthViewSpace * ViewSpaceToMetersFactor(), FSR3UPSCALER_FP16_MAX);
|
||||
const FfxFloat32 fReconstructedDeptMvThreshold = ReconstructedDepthMvPxThreshold(fNearestDepthInMeters);
|
||||
|
||||
fMotionVector *= FfxFloat32(Get4KVelocity(fMotionVector) > fReconstructedDeptMvThreshold);
|
||||
|
||||
const FfxFloat32x2 fReprojectedUv = fUv + fMotionVector;
|
||||
const BilinearSamplingData bilinearInfo = GetBilinearSamplingData(fReprojectedUv, RenderSize());
|
||||
|
||||
FfxFloat32 fDisocclusion = 0.0f;
|
||||
FfxFloat32 fWeightSum = 0.0f;
|
||||
FfxBoolean bPotentialDisocclusion = true;
|
||||
|
||||
for (FfxInt32 iSampleIndex = 0; iSampleIndex < 4 && bPotentialDisocclusion; iSampleIndex++)
|
||||
{
|
||||
|
||||
const FfxInt32x2 iOffset = bilinearInfo.iOffsets[iSampleIndex];
|
||||
const FfxInt32x2 iSamplePos = ClampLoad(bilinearInfo.iBasePos, iOffset, FfxInt32x2(RenderSize()));
|
||||
|
||||
if (IsOnScreen(iSamplePos, RenderSize())) {
|
||||
const FfxFloat32 fWeight = bilinearInfo.fWeights[iSampleIndex];
|
||||
if (fWeight > fReconstructedDepthBilinearWeightThreshold) {
|
||||
|
||||
const FfxFloat32 fPrevNearestDepthViewSpace = GetViewSpaceDepth(LoadReconstructedPrevDepth(iSamplePos));
|
||||
const FfxFloat32 fDepthDifference = fCurrentDepthViewSpace - fPrevNearestDepthViewSpace;
|
||||
|
||||
bPotentialDisocclusion = bPotentialDisocclusion && (fDepthDifference > FSR3UPSCALER_FP32_MIN);
|
||||
|
||||
if (bPotentialDisocclusion) {
|
||||
const FfxFloat32 fHalfViewportWidth = length(FfxFloat32x2(RenderSize()) * 0.5f);
|
||||
const FfxFloat32 fDepthThreshold = ffxMax(fCurrentDepthViewSpace, fPrevNearestDepthViewSpace);
|
||||
|
||||
const FfxFloat32 Ksep = 1.37e-05f;
|
||||
const FfxFloat32 fRequiredDepthSeparation = Ksep * fHalfViewportWidth * fDepthThreshold;
|
||||
|
||||
fDisocclusion += ffxSaturate(FfxFloat32(fRequiredDepthSeparation / fDepthDifference)) * fWeight;
|
||||
fWeightSum += fWeight;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fDisocclusion = (bPotentialDisocclusion && fWeightSum > 0) ? ffxSaturate(1.0f - fDisocclusion / fWeightSum) : 0.0f;
|
||||
|
||||
return fDisocclusion;
|
||||
}
|
||||
|
||||
FfxFloat32 ComputeMotionDivergence(FfxFloat32x2 fUv, FfxFloat32x2 fMotionVector, FfxFloat32 fCurrentDepthSample)
|
||||
{
|
||||
const FfxInt32x2 iPxReprojectedPos = FfxInt32x2((fUv + fMotionVector) * RenderSize());
|
||||
const FfxFloat32 fReprojectedDepth = LoadDilatedDepth(iPxReprojectedPos);
|
||||
const FfxFloat32x2 fReprojectedMotionVector = LoadDilatedMotionVector(iPxReprojectedPos);
|
||||
|
||||
const FfxFloat32 fReprojectedVelocity = Get4KVelocity(fReprojectedMotionVector);
|
||||
const FfxFloat32 f4KVelocity = Get4KVelocity(fMotionVector);
|
||||
|
||||
const FfxFloat32 fMaxLen = max(length(fMotionVector), length(fReprojectedMotionVector));
|
||||
|
||||
const FfxFloat32 fNucleusDepthInMeters = GetViewSpaceDepthInMeters(fReprojectedDepth);
|
||||
const FfxFloat32 fCurrentDepthInMeters = GetViewSpaceDepthInMeters(fCurrentDepthSample);
|
||||
|
||||
const FfxFloat32 fDistanceFactor = MinDividedByMax(fNucleusDepthInMeters, fCurrentDepthInMeters);
|
||||
const FfxFloat32 fVelocityFactor = ffxSaturate(f4KVelocity / 10.0f);
|
||||
const FfxFloat32 fMotionVectorFieldConfidence = (1.0f - ffxSaturate(fReprojectedVelocity / f4KVelocity)) * fDistanceFactor * fVelocityFactor;
|
||||
|
||||
return fMotionVectorFieldConfidence;
|
||||
}
|
||||
|
||||
FfxFloat32 DilateReactiveMasks(FfxInt32x2 iPxPos, FfxFloat32x2 fUv)
|
||||
{
|
||||
FfxFloat32 fDilatedReactiveMasks = 0.0f;
|
||||
|
||||
FFX_UNROLL
|
||||
for (FfxInt32 y = -1; y <=1; y++)
|
||||
{
|
||||
FFX_UNROLL
|
||||
for (FfxInt32 x = -1; x <= 1; x++)
|
||||
{
|
||||
const FfxInt32x2 sampleCoord = ClampLoad(iPxPos, FfxInt32x2(x, y), FfxInt32x2(RenderSize()));
|
||||
fDilatedReactiveMasks = ffxMax(fDilatedReactiveMasks, LoadReactiveMask(sampleCoord));
|
||||
}
|
||||
}
|
||||
|
||||
return fDilatedReactiveMasks;
|
||||
}
|
||||
|
||||
FfxFloat32 DilateTransparencyAndCompositionMasks(FfxInt32x2 iPxPos, FfxFloat32x2 fUv)
|
||||
{
|
||||
const FfxFloat32x2 fUvTransparencyAndCompositionMask = ClampUv(fUv, RenderSize(), GetTransparencyAndCompositionMaskResourceDimensions());
|
||||
return SampleTransparencyAndCompositionMask(fUvTransparencyAndCompositionMask);
|
||||
}
|
||||
|
||||
FfxFloat32 ComputeThinFeatureConfidence(FfxInt32x2 iPxPos)
|
||||
{
|
||||
/*
|
||||
1 2 3
|
||||
4 0 5
|
||||
6 7 8
|
||||
*/
|
||||
|
||||
const FfxInt32 iNucleusIndex = 0;
|
||||
const FfxInt32 iSampleCount = 9;
|
||||
const FfxInt32x2 iSampleOffsets[iSampleCount] = {
|
||||
FfxInt32x2(+0, +0),
|
||||
FfxInt32x2(-1, -1),
|
||||
FfxInt32x2(+0, -1),
|
||||
FfxInt32x2(+1, -1),
|
||||
FfxInt32x2(-1, +0),
|
||||
FfxInt32x2(+1, +0),
|
||||
FfxInt32x2(-1, +1),
|
||||
FfxInt32x2(+0, +1),
|
||||
FfxInt32x2(+1, +1),
|
||||
};
|
||||
|
||||
FfxFloat32 fSamples[iSampleCount];
|
||||
|
||||
FfxFloat32 fLumaMin = FSR3UPSCALER_FP32_MAX;
|
||||
FfxFloat32 fLumaMax = FSR3UPSCALER_FP32_MIN;
|
||||
|
||||
FFX_UNROLL
|
||||
for (FfxInt32 iSampleIndex = 0; iSampleIndex < iSampleCount; ++iSampleIndex) {
|
||||
const FfxInt32x2 iPxSamplePos = ClampLoad(iPxPos, iSampleOffsets[iSampleIndex], FfxInt32x2(RenderSize()));
|
||||
fSamples[iSampleIndex] = LoadCurrentLuma(iPxSamplePos) * Exposure();
|
||||
|
||||
fLumaMin = ffxMin(fLumaMin, fSamples[iSampleIndex]);
|
||||
fLumaMax = ffxMax(fLumaMax, fSamples[iSampleIndex]);
|
||||
}
|
||||
|
||||
const FfxFloat32 fThreshold = 0.9f;
|
||||
FfxFloat32 fDissimilarLumaMin = FSR3UPSCALER_FP32_MAX;
|
||||
FfxFloat32 fDissimilarLumaMax = 0;
|
||||
|
||||
#define SETBIT(x) (1U << x)
|
||||
|
||||
FfxUInt32 uPatternMask = SETBIT(iNucleusIndex); // Flag nucleus as similar
|
||||
|
||||
const FfxUInt32 uNumRejectionMasks = 4;
|
||||
const FfxUInt32 uRejectionMasks[uNumRejectionMasks] = {
|
||||
SETBIT(1) | SETBIT(2) | SETBIT(4) | SETBIT(iNucleusIndex), // Upper left
|
||||
SETBIT(2) | SETBIT(3) | SETBIT(5) | SETBIT(iNucleusIndex), // Upper right
|
||||
SETBIT(4) | SETBIT(6) | SETBIT(7) | SETBIT(iNucleusIndex), // Lower left
|
||||
SETBIT(5) | SETBIT(7) | SETBIT(8) | SETBIT(iNucleusIndex) // Lower right
|
||||
};
|
||||
|
||||
FfxInt32 iBitIndex = 1;
|
||||
FFX_UNROLL
|
||||
for (FfxInt32 iSampleIndex = 1; iSampleIndex < iSampleCount; ++iSampleIndex, ++iBitIndex) {
|
||||
|
||||
const FfxFloat32 fDifference = abs(fSamples[iSampleIndex] - fSamples[iNucleusIndex]) / (fLumaMax - fLumaMin);
|
||||
|
||||
if (fDifference < fThreshold)
|
||||
{
|
||||
uPatternMask |= SETBIT(iBitIndex);
|
||||
}
|
||||
else
|
||||
{
|
||||
fDissimilarLumaMin = ffxMin(fDissimilarLumaMin, fSamples[iSampleIndex]);
|
||||
fDissimilarLumaMax = ffxMax(fDissimilarLumaMax, fSamples[iSampleIndex]);
|
||||
}
|
||||
}
|
||||
|
||||
const FfxBoolean bIsRidge = fSamples[iNucleusIndex] > fDissimilarLumaMax || fSamples[iNucleusIndex] < fDissimilarLumaMin;
|
||||
|
||||
if (FFX_FALSE == bIsRidge)
|
||||
{
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
FFX_UNROLL
|
||||
for (FfxInt32 i = 0; i < uNumRejectionMasks; i++)
|
||||
{
|
||||
if ((uPatternMask & uRejectionMasks[i]) == uRejectionMasks[i])
|
||||
{
|
||||
return 0.0f;
|
||||
}
|
||||
}
|
||||
|
||||
return 1.0f - fLumaMin / fLumaMax;
|
||||
}
|
||||
|
||||
FfxFloat32 UpdateAccumulation(FfxInt32x2 iPxPos, FfxFloat32x2 fUv, FfxFloat32x2 fMotionVector, FfxFloat32 fDisocclusion, FfxFloat32 fShadingChange)
|
||||
{
|
||||
const FfxFloat32x2 fReprojectedUv = fUv + fMotionVector;
|
||||
FfxFloat32 fAccumulation = 0.0f;
|
||||
|
||||
if (IsUvInside(fReprojectedUv)) {
|
||||
const FfxFloat32x2 fReprojectedUv_HW = ClampUv(fReprojectedUv, PreviousFrameRenderSize(), MaxRenderSize());
|
||||
fAccumulation = ffxSaturate(SampleAccumulation(fReprojectedUv_HW));
|
||||
}
|
||||
const FfxFloat32 fAccumulationAddedPerFrame= AccumulationAddedPerFrame(); //default is 0.333
|
||||
|
||||
// Assume at frame N+0 fShadingChange is 1.0, and all subsequent frames fShadingChange is 0.0 and fDisocclusion is 0.0. Then,
|
||||
// frame N+0 fAccumulation will be 0.000
|
||||
// frame N+2 fAccumulation will be 0.000 + 0.333 * 1 == 0.333
|
||||
// frame N+3 fAccumulation will be 0.000 + 0.333 * 2 == 0.666
|
||||
// frame N+4 fAccumulation will be 0.000 + 0.333 * 3 == 0.999
|
||||
fAccumulation = ffxLerp(fAccumulation, 0.0f, fShadingChange);
|
||||
|
||||
const FfxFloat32 fMinDisocclusionAccumulation = MinDisocclusionAccumulation(); //default is -0.333
|
||||
// Assume at frame N+0 fDisocclusion is 1.0, and all subsequent frames fShadingChange is 0.0 and fDisocclusion is 0.0. Then,
|
||||
// frame N+0 fAccumulation will be -0.333f (but normalized to store in unorm)
|
||||
// frame N+1 fAccumulation will be -0.333f + 0.333 * 1 == 0.000
|
||||
// frame N+2 fAccumulation will be -0.333f + 0.333 * 2 == 0.333
|
||||
// frame N+3 fAccumulation will be -0.333f + 0.333 * 3 == 0.666
|
||||
// frame N+4 fAccumulation will be -0.333f + 0.333 * 4 == 0.999
|
||||
fAccumulation = ffxLerp(fAccumulation, ffxMin(fMinDisocclusionAccumulation, fAccumulation), fDisocclusion);
|
||||
|
||||
fAccumulation *= FfxFloat32(round(fAccumulation * 100.0f) > 1.0f);
|
||||
|
||||
// Update for next frame, normalize to store in unorm
|
||||
const FfxFloat32 fAccumulatedFramesToStore = ffxSaturate(fAccumulation + fAccumulationAddedPerFrame);
|
||||
StoreAccumulation(iPxPos, fAccumulatedFramesToStore);
|
||||
|
||||
return fAccumulation;
|
||||
}
|
||||
|
||||
FfxFloat32 ComputeShadingChange(FfxFloat32x2 fUv)
|
||||
{
|
||||
// NOTE: Here we re-apply jitter, will be reverted again when sampled in accumulation pass
|
||||
const FfxFloat32x2 fShadingChangeUv = ClampUv(fUv - Jitter() / RenderSize(), ShadingChangeRenderSize(), ShadingChangeMaxRenderSize());
|
||||
const FfxFloat32 fShadingChange = ffxSaturate(SampleShadingChange(fShadingChangeUv));
|
||||
|
||||
return fShadingChange;
|
||||
}
|
||||
|
||||
void PrepareReactivity(FfxInt32x2 iPxPos)
|
||||
{
|
||||
const FfxFloat32x2 fUv = (iPxPos + 0.5f) / RenderSize();
|
||||
const FfxFloat32x2 fMotionVector = LoadDilatedMotionVector(iPxPos);
|
||||
|
||||
// Discard small mvs
|
||||
const FfxFloat32 f4KVelocity = Get4KVelocity(fMotionVector);
|
||||
|
||||
const FfxFloat32x2 fDilatedUv = fUv + fMotionVector;
|
||||
const FfxFloat32 fDilatedDepth = LoadDilatedDepth(iPxPos);
|
||||
const FfxFloat32 fDepthInMeters = GetViewSpaceDepthInMeters(fDilatedDepth);
|
||||
|
||||
const FfxFloat32 fDisocclusion = ComputeDisocclusions(fUv, fMotionVector, GetViewSpaceDepth(fDilatedDepth));
|
||||
const FfxFloat32 fShadingChange = ffxMax(DilateReactiveMasks(iPxPos, fUv), ComputeShadingChange(fUv));
|
||||
|
||||
const FfxFloat32 fMotionDivergence = ComputeMotionDivergence(fUv, fMotionVector, fDilatedDepth);
|
||||
const FfxFloat32 fDilatedTransparencyAndComposition = DilateTransparencyAndCompositionMasks(iPxPos, fUv);
|
||||
const FfxFloat32 fFinalReactiveness = ffxMax(fMotionDivergence, fDilatedTransparencyAndComposition);
|
||||
|
||||
const FfxFloat32 fAccumulation = UpdateAccumulation(iPxPos, fUv, fMotionVector, fDisocclusion, fShadingChange);
|
||||
|
||||
FfxFloat32x4 fOutput;
|
||||
fOutput[REACTIVE] = fFinalReactiveness;
|
||||
fOutput[DISOCCLUSION] = fDisocclusion;
|
||||
fOutput[SHADING_CHANGE] = fShadingChange;
|
||||
fOutput[ACCUMULAION] = fAccumulation;
|
||||
|
||||
StoreDilatedReactiveMasks(iPxPos, fOutput);
|
||||
|
||||
const FfxFloat32 fLockStrength = ComputeThinFeatureConfidence(iPxPos);
|
||||
if (fLockStrength > (1.0f / 100.0f))
|
||||
{
|
||||
StoreNewLocks(ComputeHrPosFromLrPos(FfxInt32x2(iPxPos)), fLockStrength);
|
||||
}
|
||||
}
|
||||
112
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_rcas.h
vendored
Normal file
112
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_rcas.h
vendored
Normal file
@@ -0,0 +1,112 @@
|
||||
// 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 GROUP_SIZE 8
|
||||
#define FSR_RCAS_DENOISE 1
|
||||
|
||||
#include "ffx_core.h"
|
||||
|
||||
#if FFX_HALF && defined(__XBOX_SCARLETT) && defined(__XBATG_EXTRA_16_BIT_OPTIMISATION) && (__XBATG_EXTRA_16_BIT_OPTIMISATION == 1)
|
||||
#define FSR_RCAS_PREFER_PAIRED_VERSION 1
|
||||
#else
|
||||
#define FSR_RCAS_PREFER_PAIRED_VERSION 0
|
||||
#endif
|
||||
|
||||
void WriteUpscaledOutput(FFX_MIN16_U2 iPxHrPos, FfxFloat32x3 fUpscaledColor)
|
||||
{
|
||||
StoreUpscaledOutput(FFX_MIN16_I2(iPxHrPos), fUpscaledColor);
|
||||
}
|
||||
|
||||
#if FSR_RCAS_PREFER_PAIRED_VERSION
|
||||
#define FSR_RCAS_HX2 1
|
||||
FfxFloat16x4 FsrRcasLoadHx2(FfxInt16x2 p)
|
||||
{
|
||||
return FfxFloat16x4(LoadRCAS_Input(p));
|
||||
}
|
||||
void FsrRcasInputHx2(inout FfxFloat16x2 r, inout FfxFloat16x2 g, inout FfxFloat16x2 b)
|
||||
{
|
||||
FfxFloat32 e = Exposure();
|
||||
r = FfxFloat16x2(r * e);
|
||||
g = FfxFloat16x2(g * e);
|
||||
b = FfxFloat16x2(b * e);
|
||||
}
|
||||
|
||||
#include "fsr1/ffx_fsr1.h"
|
||||
|
||||
void CurrFilterPaired(FFX_MIN16_U2 pos)
|
||||
{
|
||||
FfxFloat16x2 cr;
|
||||
FfxFloat16x2 cg;
|
||||
FfxFloat16x2 cb;
|
||||
FsrRcasHx2(cr, cg, cb, pos, RCASConfig());
|
||||
FfxFloat32 InvExposure = 1.0f / Exposure();
|
||||
cr = FfxFloat16x2(cr * InvExposure);
|
||||
cg = FfxFloat16x2(cg * InvExposure);
|
||||
cb = FfxFloat16x2(cb * InvExposure);
|
||||
WriteUpscaledOutput(pos, FfxFloat16x3(cr.x, cg.x, cb.x)); //TODO: fix type
|
||||
pos.x += 8;
|
||||
WriteUpscaledOutput(pos, FfxFloat16x3(cr.y, cg.y, cb.y)); //TODO: fix type
|
||||
}
|
||||
#else
|
||||
#define FSR_RCAS_F 1
|
||||
FfxFloat32x4 FsrRcasLoadF(FfxInt32x2 p)
|
||||
{
|
||||
FfxFloat32x4 fColor = LoadRCAS_Input(p);
|
||||
|
||||
fColor.rgb *= Exposure();
|
||||
|
||||
return fColor;
|
||||
}
|
||||
void FsrRcasInputF(inout FfxFloat32 r, inout FfxFloat32 g, inout FfxFloat32 b) {}
|
||||
|
||||
#include "fsr1/ffx_fsr1.h"
|
||||
|
||||
void CurrFilter(FFX_MIN16_U2 pos)
|
||||
{
|
||||
FfxFloat32x3 c;
|
||||
FsrRcasF(c.r, c.g, c.b, pos, RCASConfig());
|
||||
|
||||
c /= Exposure();
|
||||
|
||||
WriteUpscaledOutput(pos, c);
|
||||
}
|
||||
|
||||
#endif // #if FSR_RCAS_PREFER_PAIRED_VERSION
|
||||
|
||||
void RCAS(FfxUInt32x3 LocalThreadId, FfxUInt32x3 WorkGroupId, FfxUInt32x3 Dtid)
|
||||
{
|
||||
// Do remapping of local xy in workgroup for a more PS-like swizzle pattern.
|
||||
FfxUInt32x2 gxy = ffxRemapForQuad(LocalThreadId.x) + FfxUInt32x2(WorkGroupId.x << 4u, WorkGroupId.y << 4u);
|
||||
#if FSR_RCAS_PREFER_PAIRED_VERSION
|
||||
CurrFilterPaired(FFX_MIN16_U2(gxy));
|
||||
gxy.y += 8u;
|
||||
CurrFilterPaired(FFX_MIN16_U2(gxy));
|
||||
#else
|
||||
CurrFilter(FFX_MIN16_U2(gxy));
|
||||
gxy.x += 8u;
|
||||
CurrFilter(FFX_MIN16_U2(gxy));
|
||||
gxy.y += 8u;
|
||||
CurrFilter(FFX_MIN16_U2(gxy));
|
||||
gxy.x -= 8u;
|
||||
CurrFilter(FFX_MIN16_U2(gxy));
|
||||
#endif
|
||||
}
|
||||
79
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_reproject.h
vendored
Normal file
79
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_reproject.h
vendored
Normal file
@@ -0,0 +1,79 @@
|
||||
// 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_FSR3UPSCALER_OPTION_REPROJECT_USE_LANCZOS_TYPE
|
||||
#define FFX_FSR3UPSCALER_OPTION_REPROJECT_USE_LANCZOS_TYPE 0 // Reference
|
||||
#endif
|
||||
|
||||
FfxFloat32x4 WrapHistory(FfxInt32x2 iPxSample)
|
||||
{
|
||||
return LoadHistory(iPxSample);
|
||||
}
|
||||
|
||||
DeclareCustomFetchBicubicSamples(FetchHistorySamples, WrapHistory)
|
||||
DeclareCustomTextureSample(HistorySample, FFX_FSR3UPSCALER_GET_LANCZOS_SAMPLER1D(FFX_FSR3UPSCALER_OPTION_REPROJECT_USE_LANCZOS_TYPE), FetchHistorySamples)
|
||||
|
||||
#if FFX_HALF
|
||||
FFX_MIN16_F4 WrapHistory16(FfxInt32x2 iPxSample)
|
||||
{
|
||||
return FFX_MIN16_F4(LoadHistory(iPxSample));
|
||||
}
|
||||
|
||||
DeclareCustomFetchBicubicSamplesMin16(FetchHistorySamples16, WrapHistory16)
|
||||
DeclareCustomTextureSampleMin16(HistorySample16, FFX_FSR3UPSCALER_GET_LANCZOS_SAMPLER1D(FFX_FSR3UPSCALER_OPTION_REPROJECT_USE_LANCZOS_TYPE), FetchHistorySamples16)
|
||||
#endif
|
||||
|
||||
FfxFloat32x2 GetMotionVector(FfxInt32x2 iPxHrPos, FfxFloat32x2 fHrUv)
|
||||
{
|
||||
#if FFX_FSR3UPSCALER_OPTION_LOW_RESOLUTION_MOTION_VECTORS
|
||||
const FfxFloat32x2 fDilatedMotionVector = LoadDilatedMotionVector(FFX_MIN16_I2(fHrUv * RenderSize()));
|
||||
#else
|
||||
const FfxFloat32x2 fDilatedMotionVector = LoadInputMotionVector(iPxHrPos);
|
||||
#endif
|
||||
|
||||
return fDilatedMotionVector;
|
||||
}
|
||||
|
||||
void ComputeReprojectedUVs(FFX_PARAMETER_INOUT AccumulationPassCommonParams params)
|
||||
{
|
||||
params.fReprojectedHrUv = params.fHrUv + params.fMotionVector;
|
||||
|
||||
params.bIsExistingSample = IsUvInside(params.fReprojectedHrUv);
|
||||
}
|
||||
|
||||
void ReprojectHistoryColor(const AccumulationPassCommonParams params, FFX_PARAMETER_INOUT AccumulationPassData data)
|
||||
|
||||
{
|
||||
#if FFX_HALF && FFX_FSR3UPSCALER_OPTION_REPROJECT_SAMPLERS_USE_DATA_HALF
|
||||
const FfxFloat32x4 fReprojectedHistory = FfxFloat32x4(HistorySample16(params.fReprojectedHrUv, UpscaleSize()));
|
||||
#else
|
||||
const FfxFloat32x4 fReprojectedHistory = HistorySample(params.fReprojectedHrUv, PreviousFrameUpscaleSize());
|
||||
#endif
|
||||
|
||||
data.fHistoryColor = fReprojectedHistory.rgb;
|
||||
data.fHistoryColor *= DeltaPreExposure();
|
||||
data.fHistoryColor *= Exposure();
|
||||
|
||||
data.fHistoryColor = RGBToYCoCg(data.fHistoryColor);
|
||||
|
||||
data.fLock = fReprojectedHistory.w;
|
||||
}
|
||||
100
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_resources.h
vendored
Normal file
100
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_resources.h
vendored
Normal file
@@ -0,0 +1,100 @@
|
||||
// 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_FSR3UPSCALER_RESOURCES_H
|
||||
#define FFX_FSR3UPSCALER_RESOURCES_H
|
||||
|
||||
#if defined(FFX_CPU) || defined(FFX_GPU)
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NULL 0
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_OPAQUE_ONLY 1
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_COLOR 2
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_MOTION_VECTORS 3
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_DEPTH 4
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_EXPOSURE 5
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_REACTIVE_MASK 6
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INPUT_TRANSPARENCY_AND_COMPOSITION_MASK 7
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_RECONSTRUCTED_PREVIOUS_NEAREST_DEPTH 8
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS 9
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_DEPTH 10
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR 11
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION 12
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_NEW_LOCKS 13
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_HISTORY 14
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DEBUG_OUTPUT 15
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LANCZOS_LUT 16
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_ATOMIC_COUNT 17
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_UPSCALED_OUTPUT 18
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_RCAS_INPUT 19
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION_1 20
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_ACCUMULATION_2 21
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR_1 22
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR_2 23
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_REACTIVITY 24
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_TRANSPARENCY_AND_COMPOSITION 25
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_DILATED_REACTIVE_MASKS 26
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS 27 // same as FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_0
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_0 27
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_1 28
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_2 29
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_3 30
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_4 31
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SPD_MIPS_LEVEL_5 32
|
||||
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_EXPOSURE 33
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FRAME_INFO 34
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_AUTOREACTIVE 35
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_AUTOCOMPOSITION_DEPRECATED 36
|
||||
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_HISTORY_1 37
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_HISTORY_2 38
|
||||
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_1 40
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_2 41
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SHADING_CHANGE 42
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FARTHEST_DEPTH 43
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_FARTHEST_DEPTH_MIP1 44
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_CURRENT_LUMA 45
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_PREVIOUS_LUMA 46
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_LUMA_INSTABILITY 48
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_INTERMEDIATE_FP16x1 49
|
||||
|
||||
|
||||
// Shading change detection mip level setting, value must be in the range [FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_0, FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_12]
|
||||
//#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_SHADING_CHANGE FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_4
|
||||
//#define FFX_FSR3UPSCALER_SHADING_CHANGE_MIP_LEVEL (FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_SHADING_CHANGE - FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_SCENE_LUMINANCE)
|
||||
|
||||
#define FFX_FSR3UPSCALER_RESOURCE_IDENTIFIER_COUNT 60
|
||||
|
||||
#define FFX_FSR3UPSCALER_CONSTANTBUFFER_IDENTIFIER_FSR3UPSCALER 0
|
||||
#define FFX_FSR3UPSCALER_CONSTANTBUFFER_IDENTIFIER_SPD 1
|
||||
#define FFX_FSR3UPSCALER_CONSTANTBUFFER_IDENTIFIER_RCAS 2
|
||||
#define FFX_FSR3UPSCALER_CONSTANTBUFFER_IDENTIFIER_GENREACTIVE 3
|
||||
#define FFX_FSR3UPSCALER_CONSTANTBUFFER_COUNT 4
|
||||
|
||||
#define FFX_FSR3UPSCALER_AUTOREACTIVEFLAGS_APPLY_TONEMAP 1
|
||||
#define FFX_FSR3UPSCALER_AUTOREACTIVEFLAGS_APPLY_INVERSETONEMAP 2
|
||||
#define FFX_FSR3UPSCALER_AUTOREACTIVEFLAGS_APPLY_THRESHOLD 4
|
||||
#define FFX_FSR3UPSCALER_AUTOREACTIVEFLAGS_USE_COMPONENTS_MAX 8
|
||||
|
||||
#endif // #if defined(FFX_CPU) || defined(FFX_GPU)
|
||||
|
||||
#endif //!defined( FFX_FSR3UPSCALER_RESOURCES_H )
|
||||
628
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_sample.h
vendored
Normal file
628
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_sample.h
vendored
Normal file
@@ -0,0 +1,628 @@
|
||||
// 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_FSR3UPSCALER_SAMPLE_H
|
||||
#define FFX_FSR3UPSCALER_SAMPLE_H
|
||||
|
||||
// suppress warnings
|
||||
#ifdef FFX_HLSL
|
||||
#pragma warning(disable: 4008) // potentially divide by zero
|
||||
#endif //FFX_HLSL
|
||||
|
||||
struct FetchedBilinearSamples {
|
||||
|
||||
FfxFloat32x4 fColor00;
|
||||
FfxFloat32x4 fColor10;
|
||||
|
||||
FfxFloat32x4 fColor01;
|
||||
FfxFloat32x4 fColor11;
|
||||
};
|
||||
|
||||
struct FetchedBicubicSamples {
|
||||
|
||||
FfxFloat32x4 fColor00;
|
||||
FfxFloat32x4 fColor10;
|
||||
FfxFloat32x4 fColor20;
|
||||
FfxFloat32x4 fColor30;
|
||||
|
||||
FfxFloat32x4 fColor01;
|
||||
FfxFloat32x4 fColor11;
|
||||
FfxFloat32x4 fColor21;
|
||||
FfxFloat32x4 fColor31;
|
||||
|
||||
FfxFloat32x4 fColor02;
|
||||
FfxFloat32x4 fColor12;
|
||||
FfxFloat32x4 fColor22;
|
||||
FfxFloat32x4 fColor32;
|
||||
|
||||
FfxFloat32x4 fColor03;
|
||||
FfxFloat32x4 fColor13;
|
||||
FfxFloat32x4 fColor23;
|
||||
FfxFloat32x4 fColor33;
|
||||
};
|
||||
|
||||
#if FFX_HALF
|
||||
struct FetchedBilinearSamplesMin16 {
|
||||
|
||||
FFX_MIN16_F4 fColor00;
|
||||
FFX_MIN16_F4 fColor10;
|
||||
|
||||
FFX_MIN16_F4 fColor01;
|
||||
FFX_MIN16_F4 fColor11;
|
||||
};
|
||||
|
||||
struct FetchedBicubicSamplesMin16 {
|
||||
|
||||
FFX_MIN16_F4 fColor00;
|
||||
FFX_MIN16_F4 fColor10;
|
||||
FFX_MIN16_F4 fColor20;
|
||||
FFX_MIN16_F4 fColor30;
|
||||
|
||||
FFX_MIN16_F4 fColor01;
|
||||
FFX_MIN16_F4 fColor11;
|
||||
FFX_MIN16_F4 fColor21;
|
||||
FFX_MIN16_F4 fColor31;
|
||||
|
||||
FFX_MIN16_F4 fColor02;
|
||||
FFX_MIN16_F4 fColor12;
|
||||
FFX_MIN16_F4 fColor22;
|
||||
FFX_MIN16_F4 fColor32;
|
||||
|
||||
FFX_MIN16_F4 fColor03;
|
||||
FFX_MIN16_F4 fColor13;
|
||||
FFX_MIN16_F4 fColor23;
|
||||
FFX_MIN16_F4 fColor33;
|
||||
};
|
||||
#else //FFX_HALF
|
||||
#define FetchedBicubicSamplesMin16 FetchedBicubicSamples
|
||||
#define FetchedBilinearSamplesMin16 FetchedBilinearSamples
|
||||
#endif //FFX_HALF
|
||||
|
||||
FfxFloat32x4 Linear(FfxFloat32x4 A, FfxFloat32x4 B, FfxFloat32 t)
|
||||
{
|
||||
return A + (B - A) * t;
|
||||
}
|
||||
|
||||
FfxFloat32x4 Bilinear(FetchedBilinearSamples BilinearSamples, FfxFloat32x2 fPxFrac)
|
||||
{
|
||||
FfxFloat32x4 fColorX0 = Linear(BilinearSamples.fColor00, BilinearSamples.fColor10, fPxFrac.x);
|
||||
FfxFloat32x4 fColorX1 = Linear(BilinearSamples.fColor01, BilinearSamples.fColor11, fPxFrac.x);
|
||||
FfxFloat32x4 fColorXY = Linear(fColorX0, fColorX1, fPxFrac.y);
|
||||
return fColorXY;
|
||||
}
|
||||
|
||||
#if FFX_HALF
|
||||
FFX_MIN16_F4 Linear(FFX_MIN16_F4 A, FFX_MIN16_F4 B, FFX_MIN16_F t)
|
||||
{
|
||||
return A + (B - A) * t;
|
||||
}
|
||||
|
||||
FFX_MIN16_F4 Bilinear(FetchedBilinearSamplesMin16 BilinearSamples, FFX_MIN16_F2 fPxFrac)
|
||||
{
|
||||
FFX_MIN16_F4 fColorX0 = Linear(BilinearSamples.fColor00, BilinearSamples.fColor10, fPxFrac.x);
|
||||
FFX_MIN16_F4 fColorX1 = Linear(BilinearSamples.fColor01, BilinearSamples.fColor11, fPxFrac.x);
|
||||
FFX_MIN16_F4 fColorXY = Linear(fColorX0, fColorX1, fPxFrac.y);
|
||||
return fColorXY;
|
||||
}
|
||||
#endif
|
||||
|
||||
FfxFloat32 Lanczos2NoClamp(FfxFloat32 x)
|
||||
{
|
||||
const FfxFloat32 PI = 3.141592653589793f; // TODO: share SDK constants
|
||||
return abs(x) < FSR3UPSCALER_EPSILON ? 1.f : (sin(PI * x) / (PI * x)) * (sin(0.5f * PI * x) / (0.5f * PI * x));
|
||||
}
|
||||
|
||||
FfxFloat32 Lanczos2(FfxFloat32 x)
|
||||
{
|
||||
x = ffxMin(abs(x), 2.0f);
|
||||
return Lanczos2NoClamp(x);
|
||||
}
|
||||
|
||||
#if FFX_HALF
|
||||
|
||||
#if 0
|
||||
FFX_MIN16_F Lanczos2NoClamp(FFX_MIN16_F x)
|
||||
{
|
||||
const FFX_MIN16_F PI = FFX_MIN16_F(3.141592653589793f); // TODO: share SDK constants
|
||||
return abs(x) < FFX_MIN16_F(FSR3UPSCALER_EPSILON) ? FFX_MIN16_F(1.f) : (sin(PI * x) / (PI * x)) * (sin(FFX_MIN16_F(0.5f) * PI * x) / (FFX_MIN16_F(0.5f) * PI * x));
|
||||
}
|
||||
#endif
|
||||
|
||||
FFX_MIN16_F Lanczos2(FFX_MIN16_F x)
|
||||
{
|
||||
x = ffxMin(abs(x), FFX_MIN16_F(2.0f));
|
||||
return FFX_MIN16_F(Lanczos2NoClamp(x));
|
||||
}
|
||||
#endif //FFX_HALF
|
||||
|
||||
// FSR1 lanczos approximation. Input is x*x and must be <= 4.
|
||||
FfxFloat32 Lanczos2ApproxSqNoClamp(FfxFloat32 x2)
|
||||
{
|
||||
FfxFloat32 a = (2.0f / 5.0f) * x2 - 1;
|
||||
FfxFloat32 b = (1.0f / 4.0f) * x2 - 1;
|
||||
return ((25.0f / 16.0f) * a * a - (25.0f / 16.0f - 1)) * (b * b);
|
||||
}
|
||||
|
||||
#if FFX_HALF
|
||||
FFX_MIN16_F Lanczos2ApproxSqNoClamp(FFX_MIN16_F x2)
|
||||
{
|
||||
FFX_MIN16_F a = FFX_MIN16_F(2.0f / 5.0f) * x2 - FFX_MIN16_F(1);
|
||||
FFX_MIN16_F b = FFX_MIN16_F(1.0f / 4.0f) * x2 - FFX_MIN16_F(1);
|
||||
return (FFX_MIN16_F(25.0f / 16.0f) * a * a - FFX_MIN16_F(25.0f / 16.0f - 1)) * (b * b);
|
||||
}
|
||||
|
||||
#if defined(__XBOX_SCARLETT) && defined(__XBATG_EXTRA_16_BIT_OPTIMISATION) && (__XBATG_EXTRA_16_BIT_OPTIMISATION == 1)
|
||||
FFX_MIN16_F2 PairedLanczos2ApproxSqNoClamp(FFX_MIN16_F2 x2)
|
||||
{
|
||||
// Xbox ATG (Pavel):
|
||||
//
|
||||
// 2.0 * x2 - 5.0 25.0 25.0 - 16.0 (2.0 * x2 - 5.0)^2 - (3.0)^2 (2.0 * x2 - 8.0) * (2.0 * x2 - 2.0) (x2 - 4.0) * (x2 - 1.0)
|
||||
// a = -------------- ==> ---- * a^2 - -------------- = ----------------------------- = ---------------------------------- = ----------------------- = b * (x2 - 1.0)
|
||||
// 5.0 16.0 16.0 16.0 16.0 4.0
|
||||
//
|
||||
// so we need to compute just (b * b) * (b * x2 - b), so we should get four packed instructions: 2 fma + 2 mul
|
||||
//
|
||||
|
||||
FFX_MIN16_F2 b = (0.25 * x2 - 1.0);
|
||||
return (b * b) * (b * x2 - b);
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif //FFX_HALF
|
||||
|
||||
FfxFloat32 Lanczos2ApproxSq(FfxFloat32 x2)
|
||||
{
|
||||
x2 = ffxMin(x2, 4.0f);
|
||||
return Lanczos2ApproxSqNoClamp(x2);
|
||||
}
|
||||
|
||||
#if FFX_HALF
|
||||
FFX_MIN16_F Lanczos2ApproxSq(FFX_MIN16_F x2)
|
||||
{
|
||||
x2 = ffxMin(x2, FFX_MIN16_F(4.0f));
|
||||
return Lanczos2ApproxSqNoClamp(x2);
|
||||
}
|
||||
|
||||
#if defined(__XBOX_SCARLETT) && defined(__XBATG_EXTRA_16_BIT_OPTIMISATION) && (__XBATG_EXTRA_16_BIT_OPTIMISATION == 1)
|
||||
FFX_MIN16_F2 PairedLanczos2ApproxSq(FFX_MIN16_F2 x2)
|
||||
{
|
||||
x2 = ffxMin(x2, FFX_MIN16_F2(4.0, 4.0));
|
||||
return PairedLanczos2ApproxSqNoClamp(x2);
|
||||
}
|
||||
#endif
|
||||
#endif //FFX_HALF
|
||||
|
||||
FfxFloat32 Lanczos2ApproxNoClamp(FfxFloat32 x)
|
||||
{
|
||||
return Lanczos2ApproxSqNoClamp(x * x);
|
||||
}
|
||||
|
||||
#if FFX_HALF
|
||||
FFX_MIN16_F Lanczos2ApproxNoClamp(FFX_MIN16_F x)
|
||||
{
|
||||
return Lanczos2ApproxSqNoClamp(x * x);
|
||||
}
|
||||
#endif //FFX_HALF
|
||||
|
||||
FfxFloat32 Lanczos2Approx(FfxFloat32 x)
|
||||
{
|
||||
return Lanczos2ApproxSq(x * x);
|
||||
}
|
||||
|
||||
#if FFX_HALF
|
||||
FFX_MIN16_F Lanczos2Approx(FFX_MIN16_F x)
|
||||
{
|
||||
return Lanczos2ApproxSq(x * x);
|
||||
}
|
||||
#endif //FFX_HALF
|
||||
|
||||
FfxFloat32 Lanczos2_UseLUT(FfxFloat32 x)
|
||||
{
|
||||
return SampleLanczos2Weight(abs(x));
|
||||
}
|
||||
|
||||
#if FFX_HALF
|
||||
FFX_MIN16_F Lanczos2_UseLUT(FFX_MIN16_F x)
|
||||
{
|
||||
return FFX_MIN16_F(SampleLanczos2Weight(abs(x)));
|
||||
}
|
||||
#endif //FFX_HALF
|
||||
|
||||
FfxFloat32x4 Lanczos2_UseLUT(FfxFloat32x4 fColor0, FfxFloat32x4 fColor1, FfxFloat32x4 fColor2, FfxFloat32x4 fColor3, FfxFloat32 t)
|
||||
{
|
||||
FfxFloat32 fWeight0 = Lanczos2_UseLUT(-1.f - t);
|
||||
FfxFloat32 fWeight1 = Lanczos2_UseLUT(-0.f - t);
|
||||
FfxFloat32 fWeight2 = Lanczos2_UseLUT(+1.f - t);
|
||||
FfxFloat32 fWeight3 = Lanczos2_UseLUT(+2.f - t);
|
||||
return (fWeight0 * fColor0 + fWeight1 * fColor1 + fWeight2 * fColor2 + fWeight3 * fColor3) / (fWeight0 + fWeight1 + fWeight2 + fWeight3);
|
||||
}
|
||||
#if FFX_HALF
|
||||
FFX_MIN16_F4 Lanczos2_UseLUT(FFX_MIN16_F4 fColor0, FFX_MIN16_F4 fColor1, FFX_MIN16_F4 fColor2, FFX_MIN16_F4 fColor3, FFX_MIN16_F t)
|
||||
{
|
||||
FFX_MIN16_F fWeight0 = Lanczos2_UseLUT(FFX_MIN16_F(-1.f) - t);
|
||||
FFX_MIN16_F fWeight1 = Lanczos2_UseLUT(FFX_MIN16_F(-0.f) - t);
|
||||
FFX_MIN16_F fWeight2 = Lanczos2_UseLUT(FFX_MIN16_F(+1.f) - t);
|
||||
FFX_MIN16_F fWeight3 = Lanczos2_UseLUT(FFX_MIN16_F(+2.f) - t);
|
||||
return (fWeight0 * fColor0 + fWeight1 * fColor1 + fWeight2 * fColor2 + fWeight3 * fColor3) / (fWeight0 + fWeight1 + fWeight2 + fWeight3);
|
||||
}
|
||||
#endif
|
||||
|
||||
FfxFloat32x4 Lanczos2(FfxFloat32x4 fColor0, FfxFloat32x4 fColor1, FfxFloat32x4 fColor2, FfxFloat32x4 fColor3, FfxFloat32 t)
|
||||
{
|
||||
FfxFloat32 fWeight0 = Lanczos2(-1.f - t);
|
||||
FfxFloat32 fWeight1 = Lanczos2(-0.f - t);
|
||||
FfxFloat32 fWeight2 = Lanczos2(+1.f - t);
|
||||
FfxFloat32 fWeight3 = Lanczos2(+2.f - t);
|
||||
return (fWeight0 * fColor0 + fWeight1 * fColor1 + fWeight2 * fColor2 + fWeight3 * fColor3) / (fWeight0 + fWeight1 + fWeight2 + fWeight3);
|
||||
}
|
||||
|
||||
FfxFloat32x4 Lanczos2(FetchedBicubicSamples Samples, FfxFloat32x2 fPxFrac)
|
||||
{
|
||||
FfxFloat32x4 fColorX0 = Lanczos2(Samples.fColor00, Samples.fColor10, Samples.fColor20, Samples.fColor30, fPxFrac.x);
|
||||
FfxFloat32x4 fColorX1 = Lanczos2(Samples.fColor01, Samples.fColor11, Samples.fColor21, Samples.fColor31, fPxFrac.x);
|
||||
FfxFloat32x4 fColorX2 = Lanczos2(Samples.fColor02, Samples.fColor12, Samples.fColor22, Samples.fColor32, fPxFrac.x);
|
||||
FfxFloat32x4 fColorX3 = Lanczos2(Samples.fColor03, Samples.fColor13, Samples.fColor23, Samples.fColor33, fPxFrac.x);
|
||||
FfxFloat32x4 fColorXY = Lanczos2(fColorX0, fColorX1, fColorX2, fColorX3, fPxFrac.y);
|
||||
|
||||
// Deringing
|
||||
|
||||
// TODO: only use 4 by checking jitter
|
||||
const FfxInt32 iDeringingSampleCount = 4;
|
||||
const FfxFloat32x4 fDeringingSamples[4] = {
|
||||
Samples.fColor11,
|
||||
Samples.fColor21,
|
||||
Samples.fColor12,
|
||||
Samples.fColor22,
|
||||
};
|
||||
|
||||
FfxFloat32x4 fDeringingMin = fDeringingSamples[0];
|
||||
FfxFloat32x4 fDeringingMax = fDeringingSamples[0];
|
||||
|
||||
FFX_UNROLL
|
||||
for (FfxInt32 iSampleIndex = 1; iSampleIndex < iDeringingSampleCount; ++iSampleIndex) {
|
||||
|
||||
fDeringingMin = ffxMin(fDeringingMin, fDeringingSamples[iSampleIndex]);
|
||||
fDeringingMax = ffxMax(fDeringingMax, fDeringingSamples[iSampleIndex]);
|
||||
}
|
||||
|
||||
fColorXY = clamp(fColorXY, fDeringingMin, fDeringingMax);
|
||||
|
||||
return fColorXY;
|
||||
}
|
||||
|
||||
#if FFX_HALF
|
||||
FFX_MIN16_F4 Lanczos2(FFX_MIN16_F4 fColor0, FFX_MIN16_F4 fColor1, FFX_MIN16_F4 fColor2, FFX_MIN16_F4 fColor3, FFX_MIN16_F t)
|
||||
{
|
||||
FFX_MIN16_F fWeight0 = Lanczos2(FFX_MIN16_F(-1.f) - t);
|
||||
FFX_MIN16_F fWeight1 = Lanczos2(FFX_MIN16_F(-0.f) - t);
|
||||
FFX_MIN16_F fWeight2 = Lanczos2(FFX_MIN16_F(+1.f) - t);
|
||||
FFX_MIN16_F fWeight3 = Lanczos2(FFX_MIN16_F(+2.f) - t);
|
||||
return (fWeight0 * fColor0 + fWeight1 * fColor1 + fWeight2 * fColor2 + fWeight3 * fColor3) / (fWeight0 + fWeight1 + fWeight2 + fWeight3);
|
||||
}
|
||||
|
||||
FFX_MIN16_F4 Lanczos2(FetchedBicubicSamplesMin16 Samples, FFX_MIN16_F2 fPxFrac)
|
||||
{
|
||||
FFX_MIN16_F4 fColorX0 = Lanczos2(Samples.fColor00, Samples.fColor10, Samples.fColor20, Samples.fColor30, fPxFrac.x);
|
||||
FFX_MIN16_F4 fColorX1 = Lanczos2(Samples.fColor01, Samples.fColor11, Samples.fColor21, Samples.fColor31, fPxFrac.x);
|
||||
FFX_MIN16_F4 fColorX2 = Lanczos2(Samples.fColor02, Samples.fColor12, Samples.fColor22, Samples.fColor32, fPxFrac.x);
|
||||
FFX_MIN16_F4 fColorX3 = Lanczos2(Samples.fColor03, Samples.fColor13, Samples.fColor23, Samples.fColor33, fPxFrac.x);
|
||||
FFX_MIN16_F4 fColorXY = Lanczos2(fColorX0, fColorX1, fColorX2, fColorX3, fPxFrac.y);
|
||||
|
||||
// Deringing
|
||||
|
||||
// TODO: only use 4 by checking jitter
|
||||
const FfxInt32 iDeringingSampleCount = 4;
|
||||
const FFX_MIN16_F4 fDeringingSamples[4] = {
|
||||
Samples.fColor11,
|
||||
Samples.fColor21,
|
||||
Samples.fColor12,
|
||||
Samples.fColor22,
|
||||
};
|
||||
|
||||
FFX_MIN16_F4 fDeringingMin = fDeringingSamples[0];
|
||||
FFX_MIN16_F4 fDeringingMax = fDeringingSamples[0];
|
||||
|
||||
FFX_UNROLL
|
||||
for (FfxInt32 iSampleIndex = 1; iSampleIndex < iDeringingSampleCount; ++iSampleIndex)
|
||||
{
|
||||
fDeringingMin = ffxMin(fDeringingMin, fDeringingSamples[iSampleIndex]);
|
||||
fDeringingMax = ffxMax(fDeringingMax, fDeringingSamples[iSampleIndex]);
|
||||
}
|
||||
|
||||
fColorXY = clamp(fColorXY, fDeringingMin, fDeringingMax);
|
||||
|
||||
return fColorXY;
|
||||
}
|
||||
#endif //FFX_HALF
|
||||
|
||||
|
||||
FfxFloat32x4 Lanczos2LUT(FetchedBicubicSamples Samples, FfxFloat32x2 fPxFrac)
|
||||
{
|
||||
FfxFloat32x4 fColorX0 = Lanczos2_UseLUT(Samples.fColor00, Samples.fColor10, Samples.fColor20, Samples.fColor30, fPxFrac.x);
|
||||
FfxFloat32x4 fColorX1 = Lanczos2_UseLUT(Samples.fColor01, Samples.fColor11, Samples.fColor21, Samples.fColor31, fPxFrac.x);
|
||||
FfxFloat32x4 fColorX2 = Lanczos2_UseLUT(Samples.fColor02, Samples.fColor12, Samples.fColor22, Samples.fColor32, fPxFrac.x);
|
||||
FfxFloat32x4 fColorX3 = Lanczos2_UseLUT(Samples.fColor03, Samples.fColor13, Samples.fColor23, Samples.fColor33, fPxFrac.x);
|
||||
FfxFloat32x4 fColorXY = Lanczos2_UseLUT(fColorX0, fColorX1, fColorX2, fColorX3, fPxFrac.y);
|
||||
|
||||
// Deringing
|
||||
|
||||
// TODO: only use 4 by checking jitter
|
||||
const FfxInt32 iDeringingSampleCount = 4;
|
||||
const FfxFloat32x4 fDeringingSamples[4] = {
|
||||
Samples.fColor11,
|
||||
Samples.fColor21,
|
||||
Samples.fColor12,
|
||||
Samples.fColor22,
|
||||
};
|
||||
|
||||
FfxFloat32x4 fDeringingMin = fDeringingSamples[0];
|
||||
FfxFloat32x4 fDeringingMax = fDeringingSamples[0];
|
||||
|
||||
FFX_UNROLL
|
||||
for (FfxInt32 iSampleIndex = 1; iSampleIndex < iDeringingSampleCount; ++iSampleIndex) {
|
||||
|
||||
fDeringingMin = ffxMin(fDeringingMin, fDeringingSamples[iSampleIndex]);
|
||||
fDeringingMax = ffxMax(fDeringingMax, fDeringingSamples[iSampleIndex]);
|
||||
}
|
||||
|
||||
fColorXY = clamp(fColorXY, fDeringingMin, fDeringingMax);
|
||||
|
||||
return fColorXY;
|
||||
}
|
||||
|
||||
#if FFX_HALF
|
||||
FFX_MIN16_F4 Lanczos2LUT(FetchedBicubicSamplesMin16 Samples, FFX_MIN16_F2 fPxFrac)
|
||||
{
|
||||
FFX_MIN16_F4 fColorX0 = Lanczos2_UseLUT(Samples.fColor00, Samples.fColor10, Samples.fColor20, Samples.fColor30, fPxFrac.x);
|
||||
FFX_MIN16_F4 fColorX1 = Lanczos2_UseLUT(Samples.fColor01, Samples.fColor11, Samples.fColor21, Samples.fColor31, fPxFrac.x);
|
||||
FFX_MIN16_F4 fColorX2 = Lanczos2_UseLUT(Samples.fColor02, Samples.fColor12, Samples.fColor22, Samples.fColor32, fPxFrac.x);
|
||||
FFX_MIN16_F4 fColorX3 = Lanczos2_UseLUT(Samples.fColor03, Samples.fColor13, Samples.fColor23, Samples.fColor33, fPxFrac.x);
|
||||
FFX_MIN16_F4 fColorXY = Lanczos2_UseLUT(fColorX0, fColorX1, fColorX2, fColorX3, fPxFrac.y);
|
||||
|
||||
// Deringing
|
||||
|
||||
// TODO: only use 4 by checking jitter
|
||||
const FfxInt32 iDeringingSampleCount = 4;
|
||||
const FFX_MIN16_F4 fDeringingSamples[4] = {
|
||||
Samples.fColor11,
|
||||
Samples.fColor21,
|
||||
Samples.fColor12,
|
||||
Samples.fColor22,
|
||||
};
|
||||
|
||||
FFX_MIN16_F4 fDeringingMin = fDeringingSamples[0];
|
||||
FFX_MIN16_F4 fDeringingMax = fDeringingSamples[0];
|
||||
|
||||
FFX_UNROLL
|
||||
for (FfxInt32 iSampleIndex = 1; iSampleIndex < iDeringingSampleCount; ++iSampleIndex)
|
||||
{
|
||||
fDeringingMin = ffxMin(fDeringingMin, fDeringingSamples[iSampleIndex]);
|
||||
fDeringingMax = ffxMax(fDeringingMax, fDeringingSamples[iSampleIndex]);
|
||||
}
|
||||
|
||||
fColorXY = clamp(fColorXY, fDeringingMin, fDeringingMax);
|
||||
|
||||
return fColorXY;
|
||||
}
|
||||
#endif //FFX_HALF
|
||||
|
||||
|
||||
|
||||
FfxFloat32x4 Lanczos2Approx(FfxFloat32x4 fColor0, FfxFloat32x4 fColor1, FfxFloat32x4 fColor2, FfxFloat32x4 fColor3, FfxFloat32 t)
|
||||
{
|
||||
FfxFloat32 fWeight0 = Lanczos2ApproxNoClamp(-1.f - t);
|
||||
FfxFloat32 fWeight1 = Lanczos2ApproxNoClamp(-0.f - t);
|
||||
FfxFloat32 fWeight2 = Lanczos2ApproxNoClamp(+1.f - t);
|
||||
FfxFloat32 fWeight3 = Lanczos2ApproxNoClamp(+2.f - t);
|
||||
return (fWeight0 * fColor0 + fWeight1 * fColor1 + fWeight2 * fColor2 + fWeight3 * fColor3) / (fWeight0 + fWeight1 + fWeight2 + fWeight3);
|
||||
}
|
||||
|
||||
#if FFX_HALF
|
||||
FFX_MIN16_F4 Lanczos2Approx(FFX_MIN16_F4 fColor0, FFX_MIN16_F4 fColor1, FFX_MIN16_F4 fColor2, FFX_MIN16_F4 fColor3, FFX_MIN16_F t)
|
||||
{
|
||||
FFX_MIN16_F fWeight0 = Lanczos2ApproxNoClamp(FFX_MIN16_F(-1.f) - t);
|
||||
FFX_MIN16_F fWeight1 = Lanczos2ApproxNoClamp(FFX_MIN16_F(-0.f) - t);
|
||||
FFX_MIN16_F fWeight2 = Lanczos2ApproxNoClamp(FFX_MIN16_F(+1.f) - t);
|
||||
FFX_MIN16_F fWeight3 = Lanczos2ApproxNoClamp(FFX_MIN16_F(+2.f) - t);
|
||||
return (fWeight0 * fColor0 + fWeight1 * fColor1 + fWeight2 * fColor2 + fWeight3 * fColor3) / (fWeight0 + fWeight1 + fWeight2 + fWeight3);
|
||||
}
|
||||
#endif //FFX_HALF
|
||||
|
||||
FfxFloat32x4 Lanczos2Approx(FetchedBicubicSamples Samples, FfxFloat32x2 fPxFrac)
|
||||
{
|
||||
FfxFloat32x4 fColorX0 = Lanczos2Approx(Samples.fColor00, Samples.fColor10, Samples.fColor20, Samples.fColor30, fPxFrac.x);
|
||||
FfxFloat32x4 fColorX1 = Lanczos2Approx(Samples.fColor01, Samples.fColor11, Samples.fColor21, Samples.fColor31, fPxFrac.x);
|
||||
FfxFloat32x4 fColorX2 = Lanczos2Approx(Samples.fColor02, Samples.fColor12, Samples.fColor22, Samples.fColor32, fPxFrac.x);
|
||||
FfxFloat32x4 fColorX3 = Lanczos2Approx(Samples.fColor03, Samples.fColor13, Samples.fColor23, Samples.fColor33, fPxFrac.x);
|
||||
FfxFloat32x4 fColorXY = Lanczos2Approx(fColorX0, fColorX1, fColorX2, fColorX3, fPxFrac.y);
|
||||
|
||||
// Deringing
|
||||
|
||||
// TODO: only use 4 by checking jitter
|
||||
const FfxInt32 iDeringingSampleCount = 4;
|
||||
const FfxFloat32x4 fDeringingSamples[4] = {
|
||||
Samples.fColor11,
|
||||
Samples.fColor21,
|
||||
Samples.fColor12,
|
||||
Samples.fColor22,
|
||||
};
|
||||
|
||||
FfxFloat32x4 fDeringingMin = fDeringingSamples[0];
|
||||
FfxFloat32x4 fDeringingMax = fDeringingSamples[0];
|
||||
|
||||
FFX_UNROLL
|
||||
for (FfxInt32 iSampleIndex = 1; iSampleIndex < iDeringingSampleCount; ++iSampleIndex)
|
||||
{
|
||||
fDeringingMin = ffxMin(fDeringingMin, fDeringingSamples[iSampleIndex]);
|
||||
fDeringingMax = ffxMax(fDeringingMax, fDeringingSamples[iSampleIndex]);
|
||||
}
|
||||
|
||||
fColorXY = clamp(fColorXY, fDeringingMin, fDeringingMax);
|
||||
|
||||
return fColorXY;
|
||||
}
|
||||
|
||||
#if FFX_HALF
|
||||
FFX_MIN16_F4 Lanczos2Approx(FetchedBicubicSamplesMin16 Samples, FFX_MIN16_F2 fPxFrac)
|
||||
{
|
||||
FFX_MIN16_F4 fColorX0 = Lanczos2Approx(Samples.fColor00, Samples.fColor10, Samples.fColor20, Samples.fColor30, fPxFrac.x);
|
||||
FFX_MIN16_F4 fColorX1 = Lanczos2Approx(Samples.fColor01, Samples.fColor11, Samples.fColor21, Samples.fColor31, fPxFrac.x);
|
||||
FFX_MIN16_F4 fColorX2 = Lanczos2Approx(Samples.fColor02, Samples.fColor12, Samples.fColor22, Samples.fColor32, fPxFrac.x);
|
||||
FFX_MIN16_F4 fColorX3 = Lanczos2Approx(Samples.fColor03, Samples.fColor13, Samples.fColor23, Samples.fColor33, fPxFrac.x);
|
||||
FFX_MIN16_F4 fColorXY = Lanczos2Approx(fColorX0, fColorX1, fColorX2, fColorX3, fPxFrac.y);
|
||||
|
||||
// Deringing
|
||||
|
||||
// TODO: only use 4 by checking jitter
|
||||
const FfxInt32 iDeringingSampleCount = 4;
|
||||
const FFX_MIN16_F4 fDeringingSamples[4] = {
|
||||
Samples.fColor11,
|
||||
Samples.fColor21,
|
||||
Samples.fColor12,
|
||||
Samples.fColor22,
|
||||
};
|
||||
|
||||
FFX_MIN16_F4 fDeringingMin = fDeringingSamples[0];
|
||||
FFX_MIN16_F4 fDeringingMax = fDeringingSamples[0];
|
||||
|
||||
FFX_UNROLL
|
||||
for (FfxInt32 iSampleIndex = 1; iSampleIndex < iDeringingSampleCount; ++iSampleIndex)
|
||||
{
|
||||
fDeringingMin = ffxMin(fDeringingMin, fDeringingSamples[iSampleIndex]);
|
||||
fDeringingMax = ffxMax(fDeringingMax, fDeringingSamples[iSampleIndex]);
|
||||
}
|
||||
|
||||
fColorXY = clamp(fColorXY, fDeringingMin, fDeringingMax);
|
||||
|
||||
return fColorXY;
|
||||
}
|
||||
#endif
|
||||
|
||||
// Clamp by offset direction. Assuming iPxSample is already in range and iPxOffset is compile time constant.
|
||||
FfxInt32x2 ClampCoord(FfxInt32x2 iPxSample, FfxInt32x2 iPxOffset, FfxInt32x2 iTextureSize)
|
||||
{
|
||||
FfxInt32x2 result = iPxSample + iPxOffset;
|
||||
result.x = ffxMax(1, ffxMin(result.x, iTextureSize.x - 2));
|
||||
result.y = ffxMax(1, ffxMin(result.y, iTextureSize.y - 2));
|
||||
return result;
|
||||
}
|
||||
#if FFX_HALF
|
||||
FFX_MIN16_I2 ClampCoord(FFX_MIN16_I2 iPxSample, FFX_MIN16_I2 iPxOffset, FFX_MIN16_I2 iTextureSize)
|
||||
{
|
||||
FFX_MIN16_I2 result = iPxSample + iPxOffset;
|
||||
result.x = ffxMax(FFX_MIN16_I(1), ffxMin(result.x, iTextureSize.x - FFX_MIN16_I(2)));
|
||||
result.y = ffxMax(FFX_MIN16_I(1), ffxMin(result.y, iTextureSize.y - FFX_MIN16_I(2)));
|
||||
return result;
|
||||
}
|
||||
#endif //FFX_HALF
|
||||
|
||||
|
||||
#define DeclareCustomFetchBicubicSamplesWithType(SampleType, TextureType, AddrType, Name, LoadTexture) \
|
||||
SampleType Name(AddrType iPxSample, AddrType iTextureSize) \
|
||||
{ \
|
||||
SampleType Samples; \
|
||||
\
|
||||
Samples.fColor00 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(-1, -1), iTextureSize))); \
|
||||
Samples.fColor10 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+0, -1), iTextureSize))); \
|
||||
Samples.fColor20 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+1, -1), iTextureSize))); \
|
||||
Samples.fColor30 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+2, -1), iTextureSize))); \
|
||||
\
|
||||
Samples.fColor01 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(-1, +0), iTextureSize))); \
|
||||
Samples.fColor11 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+0, +0), iTextureSize))); \
|
||||
Samples.fColor21 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+1, +0), iTextureSize))); \
|
||||
Samples.fColor31 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+2, +0), iTextureSize))); \
|
||||
\
|
||||
Samples.fColor02 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(-1, +1), iTextureSize))); \
|
||||
Samples.fColor12 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+0, +1), iTextureSize))); \
|
||||
Samples.fColor22 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+1, +1), iTextureSize))); \
|
||||
Samples.fColor32 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+2, +1), iTextureSize))); \
|
||||
\
|
||||
Samples.fColor03 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(-1, +2), iTextureSize))); \
|
||||
Samples.fColor13 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+0, +2), iTextureSize))); \
|
||||
Samples.fColor23 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+1, +2), iTextureSize))); \
|
||||
Samples.fColor33 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+2, +2), iTextureSize))); \
|
||||
\
|
||||
return Samples; \
|
||||
}
|
||||
|
||||
#define DeclareCustomFetchBicubicSamples(Name, LoadTexture) \
|
||||
DeclareCustomFetchBicubicSamplesWithType(FetchedBicubicSamples, FfxFloat32x4, FfxInt32x2, Name, LoadTexture)
|
||||
|
||||
#define DeclareCustomFetchBicubicSamplesMin16(Name, LoadTexture) \
|
||||
DeclareCustomFetchBicubicSamplesWithType(FetchedBicubicSamplesMin16, FFX_MIN16_F4, FfxInt32x2, Name, LoadTexture)
|
||||
|
||||
#define DeclareCustomFetchBilinearSamplesWithType(SampleType, TextureType,AddrType, Name, LoadTexture) \
|
||||
SampleType Name(AddrType iPxSample, AddrType iTextureSize) \
|
||||
{ \
|
||||
SampleType Samples; \
|
||||
Samples.fColor00 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+0, +0), iTextureSize))); \
|
||||
Samples.fColor10 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+1, +0), iTextureSize))); \
|
||||
Samples.fColor01 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+0, +1), iTextureSize))); \
|
||||
Samples.fColor11 = TextureType(LoadTexture(ClampCoord(iPxSample, AddrType(+1, +1), iTextureSize))); \
|
||||
return Samples; \
|
||||
}
|
||||
|
||||
#define DeclareCustomFetchBilinearSamples(Name, LoadTexture) \
|
||||
DeclareCustomFetchBilinearSamplesWithType(FetchedBilinearSamples, FfxFloat32x4, FfxInt32x2, Name, LoadTexture)
|
||||
|
||||
#define DeclareCustomFetchBilinearSamplesMin16(Name, LoadTexture) \
|
||||
DeclareCustomFetchBilinearSamplesWithType(FetchedBilinearSamplesMin16, FFX_MIN16_F4, FfxInt32x2, Name, LoadTexture)
|
||||
|
||||
// BE CAREFUL: there is some precision issues and (3253, 125) leading to (3252.9989778, 125.001102)
|
||||
// is common, so iPxSample can "jitter"
|
||||
#define DeclareCustomTextureSample(Name, InterpolateSamples, FetchSamples) \
|
||||
FfxFloat32x4 Name(FfxFloat32x2 fUvSample, FfxInt32x2 iTextureSize) \
|
||||
{ \
|
||||
FfxFloat32x2 fPxSample = (fUvSample * FfxFloat32x2(iTextureSize)) - FfxFloat32x2(0.5f, 0.5f); \
|
||||
FfxFloat32x2 fPxFrac = ffxFract(fPxSample); \
|
||||
/* Clamp base coords */ \
|
||||
fPxSample.x = ffxMax(0.0f, ffxMin(FfxFloat32(iTextureSize.x-1), fPxSample.x)); \
|
||||
fPxSample.y = ffxMax(0.0f, ffxMin(FfxFloat32(iTextureSize.y-1), fPxSample.y)); \
|
||||
/* */ \
|
||||
FfxInt32x2 iPxSample = FfxInt32x2(floor(fPxSample)); \
|
||||
FfxFloat32x4 fColorXY = FfxFloat32x4(InterpolateSamples(FetchSamples(iPxSample, iTextureSize), fPxFrac)); \
|
||||
return fColorXY; \
|
||||
}
|
||||
|
||||
#define DeclareCustomTextureSampleMin16(Name, InterpolateSamples, FetchSamples) \
|
||||
FFX_MIN16_F4 Name(FfxFloat32x2 fUvSample, FfxInt32x2 iTextureSize) \
|
||||
{ \
|
||||
FfxFloat32x2 fPxSample = (fUvSample * FfxFloat32x2(iTextureSize)) - FfxFloat32x2(0.5f, 0.5f); \
|
||||
FFX_MIN16_F2 fPxFrac = FFX_MIN16_F2(ffxFract(fPxSample)); \
|
||||
/* Clamp base coords */ \
|
||||
fPxSample.x = ffxMax(0.0f, ffxMin(FfxFloat32(iTextureSize.x), fPxSample.x)); \
|
||||
fPxSample.y = ffxMax(0.0f, ffxMin(FfxFloat32(iTextureSize.y), fPxSample.y)); \
|
||||
/* */ \
|
||||
FfxInt32x2 iPxSample = FfxInt32x2(floor(fPxSample)); \
|
||||
FFX_MIN16_F4 fColorXY = FFX_MIN16_F4(InterpolateSamples(FetchSamples(iPxSample, iTextureSize), fPxFrac)); \
|
||||
return fColorXY; \
|
||||
}
|
||||
|
||||
#define FFX_FSR3UPSCALER_CONCAT_ID(x, y) x ## y
|
||||
#define FFX_FSR3UPSCALER_CONCAT(x, y) FFX_FSR3UPSCALER_CONCAT_ID(x, y)
|
||||
#define FFX_FSR3UPSCALER_SAMPLER_1D_0 Lanczos2
|
||||
#define FFX_FSR3UPSCALER_SAMPLER_1D_1 Lanczos2LUT
|
||||
#define FFX_FSR3UPSCALER_SAMPLER_1D_2 Lanczos2Approx
|
||||
|
||||
#define FFX_FSR3UPSCALER_GET_LANCZOS_SAMPLER1D(x) FFX_FSR3UPSCALER_CONCAT(FFX_FSR3UPSCALER_SAMPLER_1D_, x)
|
||||
|
||||
#endif //!defined( FFX_FSR3UPSCALER_SAMPLE_H )
|
||||
68
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_shading_change.h
vendored
Normal file
68
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_shading_change.h
vendored
Normal file
@@ -0,0 +1,68 @@
|
||||
// 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.
|
||||
|
||||
FFX_STATIC const FfxInt32 s_MipLevelsToUse = 3;
|
||||
|
||||
struct ShadingChangeLumaInfo
|
||||
{
|
||||
FfxFloat32 fSamples[s_MipLevelsToUse];
|
||||
};
|
||||
|
||||
ShadingChangeLumaInfo ComputeShadingChangeLuma(FfxInt32x2 iPxPos, FfxFloat32x2 fUv, const FfxInt32x2 iCurrentSize)
|
||||
{
|
||||
ShadingChangeLumaInfo info;
|
||||
|
||||
const FfxFloat32x2 fMipUv = ClampUv(fUv, ShadingChangeRenderSize(), GetSPDMipDimensions(0));
|
||||
|
||||
FFX_UNROLL
|
||||
for (FfxInt32 iMipLevel = iShadingChangeMipStart; iMipLevel < s_MipLevelsToUse; iMipLevel++) {
|
||||
|
||||
const FfxFloat32x2 fSample = SampleSPDMipLevel(fMipUv, iMipLevel);
|
||||
|
||||
info.fSamples[iMipLevel] = abs(fSample.x * fSample.y);
|
||||
}
|
||||
|
||||
return info;
|
||||
}
|
||||
|
||||
void ShadingChange(FfxInt32x2 iPxPos)
|
||||
{
|
||||
if (IsOnScreen(FfxInt32x2(iPxPos), ShadingChangeRenderSize())) {
|
||||
|
||||
const FfxFloat32x2 fUv = (iPxPos + 0.5f) / ShadingChangeRenderSize();
|
||||
const FfxFloat32x2 fUvJittered = fUv + Jitter() / RenderSize();
|
||||
|
||||
const ShadingChangeLumaInfo info = ComputeShadingChangeLuma(iPxPos, fUvJittered, ShadingChangeRenderSize());
|
||||
|
||||
const FfxFloat32 fScale = 1.0f + iShadingChangeMipStart / s_MipLevelsToUse;
|
||||
FfxFloat32 fShadingChange = 0.0f;
|
||||
FFX_UNROLL
|
||||
for (int iMipLevel = iShadingChangeMipStart; iMipLevel < s_MipLevelsToUse; iMipLevel++)
|
||||
{
|
||||
if (info.fSamples[iMipLevel] > 0) {
|
||||
fShadingChange = ffxMax(fShadingChange, info.fSamples[iMipLevel]) * fScale;
|
||||
}
|
||||
}
|
||||
|
||||
StoreShadingChange(iPxPos, ffxSaturate(fShadingChange));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,297 @@
|
||||
// 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.
|
||||
|
||||
FFX_GROUPSHARED FfxUInt32 spdCounter;
|
||||
|
||||
void SpdIncreaseAtomicCounter(FfxUInt32 slice)
|
||||
{
|
||||
SPD_IncreaseAtomicCounter(spdCounter);
|
||||
}
|
||||
|
||||
FfxUInt32 SpdGetAtomicCounter()
|
||||
{
|
||||
return spdCounter;
|
||||
}
|
||||
|
||||
void SpdResetAtomicCounter(FfxUInt32 slice)
|
||||
{
|
||||
SPD_ResetAtomicCounter();
|
||||
}
|
||||
|
||||
#ifndef SPD_PACKED_ONLY
|
||||
FFX_GROUPSHARED FfxFloat32 spdIntermediateR[16][16];
|
||||
FFX_GROUPSHARED FfxFloat32 spdIntermediateG[16][16];
|
||||
FFX_GROUPSHARED FfxFloat32 spdIntermediateB[16][16];
|
||||
FFX_GROUPSHARED FfxFloat32 spdIntermediateA[16][16];
|
||||
|
||||
FFX_STATIC const FfxInt32 DIFFERENCE = 0;
|
||||
FFX_STATIC const FfxInt32 SIGN_SUM = 1;
|
||||
FFX_STATIC const FfxInt32 MIP0_INDICATOR = 2;
|
||||
|
||||
FfxFloat32x2 Sort2(FfxFloat32x2 v)
|
||||
{
|
||||
return FfxFloat32x2(ffxMin(v.x, v.y), ffxMax(v.x, v.y));
|
||||
}
|
||||
|
||||
struct SampleSet
|
||||
{
|
||||
FfxFloat32 fSamples[SHADING_CHANGE_SET_SIZE];
|
||||
};
|
||||
|
||||
#define CompareSwap(i, j) \
|
||||
{ \
|
||||
FfxFloat32 fTmp = ffxMin(fSet.fSamples[i], fSet.fSamples[j]);\
|
||||
fSet.fSamples[j] = ffxMax(fSet.fSamples[i], fSet.fSamples[j]);\
|
||||
fSet.fSamples[i] = fTmp;\
|
||||
}
|
||||
|
||||
#if SHADING_CHANGE_SET_SIZE == 5
|
||||
FFX_STATIC const FfxInt32x2 iSampleOffsets[5] = {FfxInt32x2(+0, +0), FfxInt32x2(-1, +0), FfxInt32x2(+1, +0), FfxInt32x2(+0, -1), FfxInt32x2(+0, +1)};
|
||||
|
||||
void SortSet(FFX_PARAMETER_INOUT SampleSet fSet)
|
||||
{
|
||||
CompareSwap(0, 3);
|
||||
CompareSwap(1, 4);
|
||||
CompareSwap(0, 2);
|
||||
CompareSwap(1, 3);
|
||||
CompareSwap(0, 1);
|
||||
CompareSwap(2, 4);
|
||||
CompareSwap(1, 2);
|
||||
CompareSwap(3, 4);
|
||||
CompareSwap(2, 3);
|
||||
}
|
||||
#endif
|
||||
|
||||
FfxFloat32 ComputeMinimumDifference(FfxInt32x2 iPxPos, SampleSet fSet0, SampleSet fSet1)
|
||||
{
|
||||
FfxFloat32 fMinDiff = FSR3UPSCALER_FP16_MAX - 1;
|
||||
FfxInt32 a = 0;
|
||||
FfxInt32 b = 0;
|
||||
|
||||
SortSet(fSet0);
|
||||
SortSet(fSet1);
|
||||
|
||||
const FfxFloat32 fMax = ffxMin(fSet0.fSamples[SHADING_CHANGE_SET_SIZE-1], fSet1.fSamples[SHADING_CHANGE_SET_SIZE-1]);
|
||||
|
||||
if (fMax > FSR3UPSCALER_FP32_MIN) {
|
||||
|
||||
FFX_UNROLL
|
||||
for (FfxInt32 i = 0; i < SHADING_CHANGE_SET_SIZE && (fMinDiff < FSR3UPSCALER_FP16_MAX); i++) {
|
||||
|
||||
FfxFloat32 fDiff = fSet0.fSamples[a] - fSet1.fSamples[b];
|
||||
|
||||
if (abs(fDiff) > FSR3UPSCALER_FP16_MIN) {
|
||||
|
||||
fDiff = sign(fDiff) * (1.0f - MinDividedByMax(fSet0.fSamples[a], fSet1.fSamples[b]));
|
||||
|
||||
fMinDiff = (abs(fDiff) < abs(fMinDiff)) ? fDiff : fMinDiff;
|
||||
|
||||
a += FfxInt32(fSet0.fSamples[a] < fSet1.fSamples[b]);
|
||||
b += FfxInt32(fSet0.fSamples[a] >= fSet1.fSamples[b]);
|
||||
}
|
||||
else
|
||||
{
|
||||
fMinDiff = FSR3UPSCALER_FP16_MAX;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return fMinDiff * FfxFloat32(fMinDiff < (FSR3UPSCALER_FP16_MAX - 1));
|
||||
}
|
||||
|
||||
SampleSet GetCurrentLumaBilinearSamples(FfxFloat32x2 fUv)
|
||||
{
|
||||
const FfxFloat32x2 fUvJittered = fUv + Jitter() / RenderSize();
|
||||
const FfxInt32x2 iBasePos = FfxInt32x2(floor(fUvJittered * RenderSize()));
|
||||
|
||||
SampleSet fSet;
|
||||
|
||||
for (FfxInt32 iSampleIndex = 0; iSampleIndex < SHADING_CHANGE_SET_SIZE; iSampleIndex++) {
|
||||
const FfxInt32x2 iSamplePos = ClampLoad(iBasePos, iSampleOffsets[iSampleIndex], RenderSize());
|
||||
fSet.fSamples[iSampleIndex] = LoadCurrentLuma(iSamplePos) * Exposure();
|
||||
fSet.fSamples[iSampleIndex] = ffxPow(fSet.fSamples[iSampleIndex], fShadingChangeSamplePow);
|
||||
fSet.fSamples[iSampleIndex] = ffxMax(fSet.fSamples[iSampleIndex], FSR3UPSCALER_EPSILON);
|
||||
}
|
||||
|
||||
return fSet;
|
||||
}
|
||||
|
||||
struct PreviousLumaBilinearSamplesData
|
||||
{
|
||||
SampleSet fSet;
|
||||
FfxBoolean bIsExistingSample;
|
||||
};
|
||||
|
||||
PreviousLumaBilinearSamplesData GetPreviousLumaBilinearSamples(FfxFloat32x2 fUv, FfxFloat32x2 fMotionVector)
|
||||
{
|
||||
PreviousLumaBilinearSamplesData data;
|
||||
|
||||
const FfxFloat32x2 fUvJittered = fUv + PreviousFrameJitter() / PreviousFrameRenderSize();
|
||||
const FfxFloat32x2 fReprojectedUv = fUvJittered + fMotionVector;
|
||||
|
||||
data.bIsExistingSample = IsUvInside(fReprojectedUv);
|
||||
|
||||
if (data.bIsExistingSample) {
|
||||
|
||||
const FfxInt32x2 iBasePos = FfxInt32x2(floor(fReprojectedUv * PreviousFrameRenderSize()));
|
||||
|
||||
for (FfxInt32 iSampleIndex = 0; iSampleIndex < SHADING_CHANGE_SET_SIZE; iSampleIndex++) {
|
||||
|
||||
const FfxInt32x2 iSamplePos = ClampLoad(iBasePos, iSampleOffsets[iSampleIndex], PreviousFrameRenderSize());
|
||||
data.fSet.fSamples[iSampleIndex] = LoadPreviousLuma(iSamplePos) * DeltaPreExposure() * Exposure();
|
||||
data.fSet.fSamples[iSampleIndex] = ffxPow(data.fSet.fSamples[iSampleIndex], fShadingChangeSamplePow);
|
||||
data.fSet.fSamples[iSampleIndex] = ffxMax(data.fSet.fSamples[iSampleIndex], FSR3UPSCALER_EPSILON);
|
||||
}
|
||||
}
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
FfxFloat32 ComputeDiff(FfxInt32x2 iPxPos, FfxFloat32x2 fUv, FfxFloat32x2 fMotionVector)
|
||||
{
|
||||
FfxFloat32 fMinDiff = 0.0f;
|
||||
|
||||
const SampleSet fCurrentSamples = GetCurrentLumaBilinearSamples(fUv);
|
||||
const PreviousLumaBilinearSamplesData previousData = GetPreviousLumaBilinearSamples(fUv, fMotionVector);
|
||||
|
||||
if (previousData.bIsExistingSample) {
|
||||
fMinDiff = ComputeMinimumDifference(iPxPos, fCurrentSamples, previousData.fSet);
|
||||
}
|
||||
|
||||
return fMinDiff;
|
||||
}
|
||||
|
||||
FfxFloat32x4 SpdLoadSourceImage(FfxFloat32x2 iPxPos, FfxUInt32 slice)
|
||||
{
|
||||
const FfxInt32x2 iPxSamplePos = ClampLoad(FfxInt32x2(iPxPos), FfxInt32x2(0, 0), FfxInt32x2(RenderSize()));
|
||||
const FfxFloat32x2 fDilatedMotionVector = LoadDilatedMotionVector(iPxSamplePos);
|
||||
const FfxFloat32x2 fUv = (iPxSamplePos + 0.5f) / RenderSize();
|
||||
|
||||
const FfxFloat32 fScaledAndSignedLumaDiff = ComputeDiff(iPxSamplePos, fUv, fDilatedMotionVector);
|
||||
|
||||
FfxFloat32x4 fOutput = FfxFloat32x4(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
fOutput[DIFFERENCE] = fScaledAndSignedLumaDiff;
|
||||
fOutput[SIGN_SUM] = (fScaledAndSignedLumaDiff != 0.0f) ? sign(fScaledAndSignedLumaDiff) : 0.0f;
|
||||
fOutput[MIP0_INDICATOR] = 1.0f;
|
||||
|
||||
return fOutput;
|
||||
}
|
||||
|
||||
FfxFloat32x4 SpdLoad(FfxInt32x2 tex, FfxUInt32 slice)
|
||||
{
|
||||
return FfxFloat32x4(RWLoadPyramid(tex, 5), 0, 0);
|
||||
}
|
||||
|
||||
FfxFloat32x4 SpdReduce4(FfxFloat32x4 v0, FfxFloat32x4 v1, FfxFloat32x4 v2, FfxFloat32x4 v3)
|
||||
{
|
||||
return (v0 + v1 + v2 + v3) * 0.25f;
|
||||
}
|
||||
|
||||
void SpdStore(FfxInt32x2 pix, FfxFloat32x4 outValue, FfxUInt32 index, FfxUInt32 slice)
|
||||
{
|
||||
if (index >= iShadingChangeMipStart)
|
||||
{
|
||||
StorePyramid(pix, outValue.xy, index);
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
// define fetch and store functions Packed
|
||||
#if FFX_HALF
|
||||
|
||||
FFX_GROUPSHARED FfxFloat16x2 spdIntermediateRG[16][16];
|
||||
FFX_GROUPSHARED FfxFloat16x2 spdIntermediateBA[16][16];
|
||||
|
||||
FfxFloat16x4 SpdLoadSourceImageH(FfxFloat32x2 tex, FfxUInt32 slice)
|
||||
{
|
||||
return FfxFloat16x4(0, 0, 0, 0);
|
||||
}
|
||||
|
||||
FfxFloat16x4 SpdLoadH(FfxInt32x2 p, FfxUInt32 slice)
|
||||
{
|
||||
return FfxFloat16x4(0, 0, 0, 0);
|
||||
}
|
||||
|
||||
void SpdStoreH(FfxInt32x2 p, FfxFloat16x4 value, FfxUInt32 mip, FfxUInt32 slice)
|
||||
{
|
||||
}
|
||||
|
||||
FfxFloat16x4 SpdLoadIntermediateH(FfxUInt32 x, FfxUInt32 y)
|
||||
{
|
||||
return FfxFloat16x4(
|
||||
spdIntermediateRG[x][y].x,
|
||||
spdIntermediateRG[x][y].y,
|
||||
spdIntermediateBA[x][y].x,
|
||||
spdIntermediateBA[x][y].y);
|
||||
}
|
||||
|
||||
void SpdStoreIntermediateH(FfxUInt32 x, FfxUInt32 y, FfxFloat16x4 value)
|
||||
{
|
||||
spdIntermediateRG[x][y] = value.xy;
|
||||
spdIntermediateBA[x][y] = value.zw;
|
||||
}
|
||||
|
||||
FfxFloat16x4 SpdReduce4H(FfxFloat16x4 v0, FfxFloat16x4 v1, FfxFloat16x4 v2, FfxFloat16x4 v3)
|
||||
{
|
||||
return (v0 + v1 + v2 + v3) * FfxFloat16(0.25);
|
||||
}
|
||||
#endif
|
||||
|
||||
#include "spd/ffx_spd.h"
|
||||
|
||||
void ComputeShadingChangePyramid(FfxUInt32x3 WorkGroupId, FfxUInt32 LocalThreadIndex)
|
||||
{
|
||||
#if FFX_HALF
|
||||
SpdDownsampleH(
|
||||
FfxUInt32x2(WorkGroupId.xy),
|
||||
FfxUInt32(LocalThreadIndex),
|
||||
FfxUInt32(MipCount()),
|
||||
FfxUInt32(NumWorkGroups()),
|
||||
FfxUInt32(WorkGroupId.z),
|
||||
FfxUInt32x2(WorkGroupOffset()));
|
||||
#else
|
||||
SpdDownsample(
|
||||
FfxUInt32x2(WorkGroupId.xy),
|
||||
FfxUInt32(LocalThreadIndex),
|
||||
FfxUInt32(MipCount()),
|
||||
FfxUInt32(NumWorkGroups()),
|
||||
FfxUInt32(WorkGroupId.z),
|
||||
FfxUInt32x2(WorkGroupOffset()));
|
||||
#endif
|
||||
}
|
||||
644
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_upsample.h
vendored
Normal file
644
third_party/fidelityfx-sdk/include/FidelityFX/gpu/fsr3upscaler/ffx_fsr3upscaler_upsample.h
vendored
Normal file
@@ -0,0 +1,644 @@
|
||||
// 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.
|
||||
|
||||
void Deringing(RectificationBox clippingBox, FFX_PARAMETER_INOUT FfxFloat32x3 fColor)
|
||||
{
|
||||
fColor = clamp(fColor, clippingBox.aabbMin, clippingBox.aabbMax);
|
||||
}
|
||||
|
||||
#ifndef FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE
|
||||
#define FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE 2 // Approximate
|
||||
#endif
|
||||
|
||||
FfxFloat32 GetUpsampleLanczosWeight(FfxFloat32x2 fSrcSampleOffset, FfxFloat32 fKernelWeight)
|
||||
{
|
||||
FfxFloat32x2 fSrcSampleOffsetBiased = fSrcSampleOffset * fKernelWeight.xx;
|
||||
#if FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 0 // LANCZOS_TYPE_REFERENCE
|
||||
FfxFloat32 fSampleWeight = Lanczos2(length(fSrcSampleOffsetBiased));
|
||||
#elif FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 1 // LANCZOS_TYPE_LUT
|
||||
FfxFloat32 fSampleWeight = Lanczos2_UseLUT(length(fSrcSampleOffsetBiased));
|
||||
#elif FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 2 // LANCZOS_TYPE_APPROXIMATE
|
||||
FfxFloat32 fSampleWeight = Lanczos2ApproxSq(dot(fSrcSampleOffsetBiased, fSrcSampleOffsetBiased));
|
||||
#else
|
||||
#error "Invalid Lanczos type"
|
||||
#endif
|
||||
return fSampleWeight;
|
||||
}
|
||||
|
||||
#if FFX_HALF
|
||||
FFX_MIN16_F GetUpsampleLanczosWeight(FFX_MIN16_F2 fSrcSampleOffset, FFX_MIN16_F fKernelWeight)
|
||||
{
|
||||
FFX_MIN16_F2 fSrcSampleOffsetBiased = fSrcSampleOffset * fKernelWeight.xx;
|
||||
#if FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 0 // LANCZOS_TYPE_REFERENCE
|
||||
FFX_MIN16_F fSampleWeight = Lanczos2(length(fSrcSampleOffsetBiased));
|
||||
#elif FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 1 // LANCZOS_TYPE_LUT
|
||||
FFX_MIN16_F fSampleWeight = Lanczos2_UseLUT(length(fSrcSampleOffsetBiased));
|
||||
#elif FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 2 // LANCZOS_TYPE_APPROXIMATE
|
||||
FFX_MIN16_F fSampleWeight = Lanczos2ApproxSq(dot(fSrcSampleOffsetBiased, fSrcSampleOffsetBiased));
|
||||
|
||||
// To Test: Save reciproqual sqrt compute
|
||||
// FfxFloat32 fSampleWeight = Lanczos2Sq_UseLUT(dot(fSrcSampleOffsetBiased, fSrcSampleOffsetBiased));
|
||||
#else
|
||||
#error "Invalid Lanczos type"
|
||||
#endif
|
||||
return fSampleWeight;
|
||||
}
|
||||
#endif
|
||||
|
||||
FfxFloat32 ComputeMaxKernelWeight(const AccumulationPassCommonParams params, FFX_PARAMETER_INOUT AccumulationPassData data) {
|
||||
|
||||
const FfxFloat32 fKernelSizeBias = 1.0f + (1.0f / FfxFloat32x2(DownscaleFactor()) - 1.0f).x;
|
||||
|
||||
return ffxMin(FfxFloat32(1.99f), fKernelSizeBias);
|
||||
}
|
||||
|
||||
FfxFloat32x3 LoadPreparedColor(FfxInt32x2 iSamplePos)
|
||||
{
|
||||
const FfxFloat32x3 fRgb = ffxMax(FfxFloat32x3(0, 0, 0), LoadInputColor(iSamplePos)) * Exposure();
|
||||
const FfxFloat32x3 fPreparedYCoCg = RGBToYCoCg(fRgb);
|
||||
|
||||
return fPreparedYCoCg;
|
||||
}
|
||||
|
||||
#if FFX_HALF && (FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 2) && defined(__XBOX_SCARLETT) && defined(__XBATG_EXTRA_16_BIT_OPTIMISATION) && (__XBATG_EXTRA_16_BIT_OPTIMISATION == 1)
|
||||
#define FFX_FSR3UPSCALER_USE_XBOX_PAIRED_16BIT_MATH_OPTIMIZATIONS 1
|
||||
#else
|
||||
#define FFX_FSR3UPSCALER_USE_XBOX_PAIRED_16BIT_MATH_OPTIMIZATIONS 0
|
||||
#endif
|
||||
|
||||
#if FFX_FSR3UPSCALER_USE_XBOX_PAIRED_16BIT_MATH_OPTIMIZATIONS
|
||||
|
||||
void LoadPreparedColorPairedRgb(FFX_PARAMETER_OUT FFX_MIN16_F2 r,
|
||||
FFX_PARAMETER_OUT FFX_MIN16_F2 g,
|
||||
FFX_PARAMETER_OUT FFX_MIN16_F2 b,
|
||||
FfxInt32x2 iSamplePos0,
|
||||
FfxInt32x2 iSamplePos1)
|
||||
{
|
||||
const FFX_MIN16_F3 sample0 = FFX_MIN16_F3(LoadInputColor(iSamplePos0));
|
||||
const FFX_MIN16_F3 sample1 = FFX_MIN16_F3(LoadInputColor(iSamplePos1));
|
||||
|
||||
r = ffxMax(FFX_MIN16_F2(0, 0), FFX_MIN16_F2(sample0.r, sample1.r));
|
||||
g = ffxMax(FFX_MIN16_F2(0, 0), FFX_MIN16_F2(sample0.g, sample1.g));
|
||||
b = ffxMax(FFX_MIN16_F2(0, 0), FFX_MIN16_F2(sample0.b, sample1.b));
|
||||
|
||||
r = FFX_MIN16_F2(r * Exposure());
|
||||
g = FFX_MIN16_F2(g * Exposure());
|
||||
b = FFX_MIN16_F2(b * Exposure());
|
||||
}
|
||||
|
||||
void TonemapPaired(FFX_PARAMETER_INOUT FFX_MIN16_F2 r, FFX_PARAMETER_INOUT FFX_MIN16_F2 g, FFX_PARAMETER_INOUT FFX_MIN16_F2 b)
|
||||
{
|
||||
FFX_MIN16_F2 denomF16 = ffxMax(ffxMax(ffxMax(0.0, r), g), b) + FFX_MIN16_F2(1.0, 1.0);
|
||||
|
||||
// NOTE: expect 2 x v_cvt_f32_f16
|
||||
FfxFloat32x2 denomF32 = FfxFloat32x2(denomF16);
|
||||
// NOTE: expect 2 x v_rcp_f32
|
||||
FfxFloat32x2 normF32 = FfxFloat32x2(1.0, 1.0) / denomF32;
|
||||
// NOTE: expect 2 x v_cvt_f16_f32
|
||||
FFX_MIN16_F2 normF16 = FFX_MIN16_F2(normF32);
|
||||
|
||||
r *= normF16;
|
||||
g *= normF16;
|
||||
b *= normF16;
|
||||
}
|
||||
|
||||
void RGBToYCoCgPaired(FFX_PARAMETER_INOUT FFX_MIN16_F2 r, FFX_PARAMETER_INOUT FFX_MIN16_F2 g, FFX_PARAMETER_INOUT FFX_MIN16_F2 b)
|
||||
{
|
||||
/**
|
||||
* NOTE: given the following conversion
|
||||
*
|
||||
* fYCoCg = FfxFloat32x3(
|
||||
* 0.25f * fRgb.r + 0.5f * fRgb.g + 0.25f * fRgb.b,
|
||||
* 0.5f * fRgb.r - 0.5f * fRgb.b,
|
||||
* -0.25f * fRgb.r + 0.5f * fRgb.g - 0.25f * fRgb.b);
|
||||
*
|
||||
* it's possible to notice that we can compute:
|
||||
* RplusBdiv4 = 0.25 * (R + B)
|
||||
*
|
||||
* so everything else is computed in 3 instructions
|
||||
* Y = G * 0.5 + RplusBdiv4
|
||||
* Co = 2 * RplusBdiv4 - G
|
||||
* Cg = G * 0.5 - RplusBdiv4
|
||||
*/
|
||||
|
||||
// NOTE: expect v_pk_add_f32 + v_pk_mul_f32
|
||||
FFX_MIN16_F2 RplusBdiv4 = (r + b) * 0.25;
|
||||
FFX_MIN16_F2 G = g;
|
||||
FFX_MIN16_F2 B = b;
|
||||
|
||||
// NOTE: expect 3x v_pk_fma_f32
|
||||
r = G * 0.5 + RplusBdiv4;
|
||||
g = RplusBdiv4 * 2.0 - B;
|
||||
b = G * 0.5 - RplusBdiv4;
|
||||
}
|
||||
|
||||
FFX_MIN16_F2 Compute3x3SamplesMinMaxPaired(FFX_PARAMETER_IN FFX_MIN16_F2 sampleCenter,
|
||||
FFX_PARAMETER_IN FFX_MIN16_F2 sample0,
|
||||
FFX_PARAMETER_IN FFX_MIN16_F2 sample1,
|
||||
FFX_PARAMETER_IN FFX_MIN16_F2 sample2,
|
||||
FFX_PARAMETER_IN FFX_MIN16_F2 sample3)
|
||||
{
|
||||
FFX_MIN16_F2 twoMinValues = ffxMin(ffxMin(sample0, sample1), ffxMin(sample2, sample3));
|
||||
FFX_MIN16_F2 twoMaxValues = ffxMax(ffxMax(sample0, sample1), ffxMax(sample2, sample3));
|
||||
|
||||
return FFX_MIN16_F2(
|
||||
ffxMin3Half(twoMinValues.x, twoMinValues.y, sampleCenter.x),
|
||||
ffxMax3Half(twoMaxValues.x, twoMaxValues.y, sampleCenter.x)
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
FFX_MIN16_F2 Bool2ToFloat16x2(bool x, bool y)
|
||||
{
|
||||
uint lo = x ? 0x00003c00 : 0x00000000;
|
||||
uint hi = y ? 0x3c000000 : 0x00000000;
|
||||
return FFX_MIN16_F2(__XB_AsHalf(lo).x, __XB_AsHalf(hi).y);
|
||||
}
|
||||
|
||||
struct PairedRectificationBoxAndAccumulatedColorAndWeight
|
||||
{
|
||||
FFX_MIN16_F2 boxCenterR;
|
||||
FFX_MIN16_F2 boxCenterG;
|
||||
FFX_MIN16_F2 boxCenterB;
|
||||
|
||||
FFX_MIN16_F2 boxVecR;
|
||||
FFX_MIN16_F2 boxVecG;
|
||||
FFX_MIN16_F2 boxVecB;
|
||||
|
||||
FFX_MIN16_F2 fBoxCenterWeight;
|
||||
|
||||
FFX_MIN16_F2 fColorR;
|
||||
FFX_MIN16_F2 fColorG;
|
||||
FFX_MIN16_F2 fColorB;
|
||||
FFX_MIN16_F2 fWeight;
|
||||
|
||||
FFX_MIN16_F fKernelBiasSq;
|
||||
FFX_MIN16_F fRectificationCurveBias;
|
||||
|
||||
void setKernelBiasAndRectificationCurveBias(FfxFloat32 kernelBias, FfxFloat32 rectificationCurveBias)
|
||||
{
|
||||
fKernelBiasSq = FFX_MIN16_F(kernelBias * kernelBias);
|
||||
fRectificationCurveBias = FFX_MIN16_F(rectificationCurveBias);
|
||||
}
|
||||
|
||||
void initUpscaledColor(FFX_MIN16_F fSrcSampleOffsetSq, FFX_MIN16_F fOnScreenWeight, FFX_MIN16_F2 sampleR, FFX_MIN16_F2 sampleG, FFX_MIN16_F2 sampleB)
|
||||
{
|
||||
#if FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 2 // LANCZOS_TYPE_APPROXIMATE
|
||||
const FFX_MIN16_F2 LanczosUpsampleWeight = FFX_MIN16_F2(
|
||||
PairedLanczos2ApproxSq(fSrcSampleOffsetSq * fKernelBiasSq).x,
|
||||
0.0
|
||||
);
|
||||
#else
|
||||
#error "Only LANCZOS_TYPE_APPROXIMATE is supported in paired version so far"
|
||||
#endif
|
||||
const FFX_MIN16_F2 fSampleWeight = fOnScreenWeight * LanczosUpsampleWeight;
|
||||
|
||||
fColorR = sampleR * fSampleWeight;
|
||||
fColorG = sampleG * fSampleWeight;
|
||||
fColorB = sampleB * fSampleWeight;
|
||||
fWeight = fSampleWeight;
|
||||
}
|
||||
|
||||
void initBox(FFX_MIN16_F fSrcSampleOffsetSq, FFX_MIN16_F fOnScreenWeight, FFX_MIN16_F2 sampleR, FFX_MIN16_F2 sampleG, FFX_MIN16_F2 sampleB)
|
||||
{
|
||||
const FFX_MIN16_F2 fBoxSampleWeight = FFX_MIN16_F2(
|
||||
exp(fRectificationCurveBias * fSrcSampleOffsetSq) * fOnScreenWeight,
|
||||
0.0
|
||||
);
|
||||
|
||||
FFX_MIN16_F2 weightedSampleR = sampleR * fBoxSampleWeight;
|
||||
FFX_MIN16_F2 weightedSampleG = sampleG * fBoxSampleWeight;
|
||||
FFX_MIN16_F2 weightedSampleB = sampleB * fBoxSampleWeight;
|
||||
|
||||
boxCenterR = weightedSampleR;
|
||||
boxCenterG = weightedSampleG;
|
||||
boxCenterB = weightedSampleB;
|
||||
|
||||
boxVecR = sampleR * weightedSampleR;
|
||||
boxVecG = sampleG * weightedSampleG;
|
||||
boxVecB = sampleB * weightedSampleB;
|
||||
|
||||
fBoxCenterWeight = fBoxSampleWeight;
|
||||
}
|
||||
|
||||
void addUpscaledColorSample(FFX_MIN16_F2 fSrcSampleOffsetSq, FFX_MIN16_F2 fOnScreenWeight, FFX_MIN16_F2 sampleR, FFX_MIN16_F2 sampleG, FFX_MIN16_F2 sampleB)
|
||||
{
|
||||
#if FFX_FSR3UPSCALER_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 2 // LANCZOS_TYPE_APPROXIMATE
|
||||
const FFX_MIN16_F2 LanczosUpsampleWeight = PairedLanczos2ApproxSq(fSrcSampleOffsetSq * fKernelBiasSq);
|
||||
#else
|
||||
#error "Only LANCZOS_TYPE_APPROXIMATE is supported in paired version so far"
|
||||
#endif
|
||||
const FFX_MIN16_F2 fSampleWeight = fOnScreenWeight * LanczosUpsampleWeight;
|
||||
|
||||
fColorR += sampleR * fSampleWeight;
|
||||
fColorG += sampleG * fSampleWeight;
|
||||
fColorB += sampleB * fSampleWeight;
|
||||
fWeight += fSampleWeight;
|
||||
}
|
||||
|
||||
void addBoxSample(FFX_MIN16_F2 fSrcSampleOffsetSq, FFX_MIN16_F2 fOnScreenWeight, FFX_MIN16_F2 sampleR, FFX_MIN16_F2 sampleG, FFX_MIN16_F2 sampleB)
|
||||
{
|
||||
// NOTE: ideally expect here 2x v_fma_mix + 2x v_exp_f32 + 2x v_fma_mix
|
||||
const FFX_MIN16_F2 fBoxSampleWeight = exp(fRectificationCurveBias * fSrcSampleOffsetSq) * fOnScreenWeight;
|
||||
|
||||
FFX_MIN16_F2 weightedSampleR = sampleR * fBoxSampleWeight;
|
||||
FFX_MIN16_F2 weightedSampleG = sampleG * fBoxSampleWeight;
|
||||
FFX_MIN16_F2 weightedSampleB = sampleB * fBoxSampleWeight;
|
||||
|
||||
boxCenterR += weightedSampleR;
|
||||
boxCenterG += weightedSampleG;
|
||||
boxCenterB += weightedSampleB;
|
||||
|
||||
boxVecR += sampleR * weightedSampleR;
|
||||
boxVecG += sampleG * weightedSampleG;
|
||||
boxVecB += sampleB * weightedSampleB;
|
||||
|
||||
fBoxCenterWeight += fBoxSampleWeight;
|
||||
}
|
||||
|
||||
void finalizeUpscaledColor(FFX_PARAMETER_OUT FfxFloat32x4 upscaledColorAndWeight)
|
||||
{
|
||||
upscaledColorAndWeight.r = fColorR.x + fColorR.y;
|
||||
upscaledColorAndWeight.g = fColorG.x + fColorG.y;
|
||||
upscaledColorAndWeight.b = fColorB.x + fColorB.y;
|
||||
|
||||
upscaledColorAndWeight.a = fWeight.x + fWeight.y;
|
||||
}
|
||||
|
||||
void finalizeBox(FFX_PARAMETER_OUT FfxFloat32x2 boxCenterAndVecR,
|
||||
FFX_PARAMETER_OUT FfxFloat32x2 boxCenterAndVecG,
|
||||
FFX_PARAMETER_OUT FfxFloat32x2 boxCenterAndVecB,
|
||||
FFX_PARAMETER_OUT FfxFloat32 boxCenterWeight)
|
||||
{
|
||||
boxCenterAndVecR = FfxFloat32x2(boxCenterR.x + boxCenterR.y, boxVecR.x + boxVecR.y);
|
||||
boxCenterAndVecG = FfxFloat32x2(boxCenterG.x + boxCenterG.y, boxVecG.x + boxVecG.y);
|
||||
boxCenterAndVecB = FfxFloat32x2(boxCenterB.x + boxCenterB.y, boxVecB.x + boxVecB.y);
|
||||
|
||||
boxCenterWeight = fBoxCenterWeight.x + fBoxCenterWeight.y;
|
||||
}
|
||||
};
|
||||
#endif // #if FFX_FSR3UPSCALER_USE_XBOX_PAIRED_16BIT_MATH_OPTIMIZATIONS
|
||||
|
||||
void ComputeUpsampledColorAndWeight(const AccumulationPassCommonParams params, FFX_PARAMETER_INOUT AccumulationPassData data)
|
||||
{
|
||||
// We compute a sliced lanczos filter with 2 lobes (other slices are accumulated temporaly)
|
||||
const FfxFloat32x2 fDstOutputPos = FfxFloat32x2(params.iPxHrPos) + FFX_BROADCAST_FLOAT32X2(0.5f);
|
||||
const FfxFloat32x2 fSrcOutputPos = fDstOutputPos * DownscaleFactor();
|
||||
const FfxInt32x2 iSrcInputPos = FfxInt32x2(floor(fSrcOutputPos));
|
||||
const FfxFloat32x2 fSrcUnjitteredPos = (FfxFloat32x2(iSrcInputPos) + FfxFloat32x2(0.5f, 0.5f)) - Jitter(); // This is the un-jittered position of the sample at offset 0,0
|
||||
const FfxFloat32x2 fBaseSampleOffset = FfxFloat32x2(fSrcUnjitteredPos - fSrcOutputPos);
|
||||
|
||||
FfxInt32x2 offsetTL;
|
||||
offsetTL.x = (fSrcUnjitteredPos.x > fSrcOutputPos.x) ? FfxInt32(-2) : FfxInt32(-1);
|
||||
offsetTL.y = (fSrcUnjitteredPos.y > fSrcOutputPos.y) ? FfxInt32(-2) : FfxInt32(-1);
|
||||
|
||||
//Load samples
|
||||
// If fSrcUnjitteredPos.y > fSrcOutputPos.y, indicates offsetTL.y = -2, sample offset Y will be [-2, 1], clipbox will be rows [1, 3].
|
||||
// Flip row# for sampling offset in this case, so first 0~2 rows in the sampled array can always be used for computing the clipbox.
|
||||
// This reduces branch or cmove on sampled colors, but moving this overhead to sample position / weight calculation time which apply to less values.
|
||||
const FfxBoolean bFlipRow = fSrcUnjitteredPos.y > fSrcOutputPos.y;
|
||||
const FfxBoolean bFlipCol = fSrcUnjitteredPos.x > fSrcOutputPos.x;
|
||||
const FfxFloat32x2 fOffsetTL = FfxFloat32x2(offsetTL);
|
||||
|
||||
const FfxBoolean bIsInitialSample = (params.fAccumulation == 0.0f);
|
||||
|
||||
#if FFX_FSR3UPSCALER_USE_XBOX_PAIRED_16BIT_MATH_OPTIMIZATIONS
|
||||
// Unroll the loop to load samples on Scarlett to help the shader compiler
|
||||
const FFX_MIN16_F2 fSampleOffsetX02 = __XB_AsHalf(bFlipCol ? __XB_AsUInt(FFX_MIN16_F2( 1, -1)) : __XB_AsUInt(FFX_MIN16_F2(-1, 1)));
|
||||
const FFX_MIN16_F2 fSampleOffsetY02 = __XB_AsHalf(bFlipRow ? __XB_AsUInt(FFX_MIN16_F2( 1, -1)) : __XB_AsUInt(FFX_MIN16_F2(-1, 1)));
|
||||
|
||||
typedef FfxInt32 FfxTexCoordI;
|
||||
typedef FfxInt32x2 FfxTexCoordI2;
|
||||
|
||||
const FfxTexCoordI2 iSrcSamplePosX01 = FfxTexCoordI2(iSrcInputPos.xx) + (bFlipCol ? FfxTexCoordI2( 1, 0) : FfxTexCoordI2(-1, 0));
|
||||
const FfxTexCoordI2 iSrcSamplePosX23 = FfxTexCoordI2(iSrcInputPos.xx) + (bFlipCol ? FfxTexCoordI2(-1, -2) : FfxTexCoordI2( 1, 2));
|
||||
|
||||
const FfxTexCoordI2 iSrcSamplePosY01 = FfxTexCoordI2(iSrcInputPos.yy) + (bFlipRow ? FfxTexCoordI2( 1, 0) : FfxTexCoordI2(-1, 0));
|
||||
const FfxTexCoordI2 iSrcSamplePosY23 = FfxTexCoordI2(iSrcInputPos.yy) + (bFlipRow ? FfxTexCoordI2(-1, -2) : FfxTexCoordI2( 1, 2));
|
||||
|
||||
const FfxTexCoordI2 renderSizeLastTexelCoord = FfxTexCoordI2(RenderSize()) - FfxTexCoordI2(1, 1);
|
||||
|
||||
const FfxTexCoordI2 iSrcSamplePosX01Clamped = FfxTexCoordI2(
|
||||
__XB_Med3_I32(iSrcSamplePosX01.x, 0, renderSizeLastTexelCoord.x),
|
||||
__XB_Med3_I32(iSrcSamplePosX01.y, 0, renderSizeLastTexelCoord.x)
|
||||
);
|
||||
|
||||
const FfxTexCoordI2 iSrcSamplePosX23Clamped = FfxTexCoordI2(
|
||||
__XB_Med3_I32(iSrcSamplePosX23.x, 0, renderSizeLastTexelCoord.x),
|
||||
__XB_Med3_I32(iSrcSamplePosX23.y, 0, renderSizeLastTexelCoord.x)
|
||||
);
|
||||
|
||||
const FfxTexCoordI2 iSrcSamplePosY01Clamped = FfxTexCoordI2(
|
||||
__XB_Med3_I32(iSrcSamplePosY01.x, 0, renderSizeLastTexelCoord.y),
|
||||
__XB_Med3_I32(iSrcSamplePosY01.y, 0, renderSizeLastTexelCoord.y)
|
||||
);
|
||||
|
||||
const FfxTexCoordI2 iSrcSamplePosY23Clamped = FfxTexCoordI2(
|
||||
__XB_Med3_I32(iSrcSamplePosY23.x, 0, renderSizeLastTexelCoord.y),
|
||||
__XB_Med3_I32(iSrcSamplePosY23.y, 0, renderSizeLastTexelCoord.y)
|
||||
);
|
||||
|
||||
FFX_MIN16_F2 TopCornerR, BotCornerR, HorzR, VertR, CenterR;
|
||||
FFX_MIN16_F2 TopCornerG, BotCornerG, HorzG, VertG, CenterG;
|
||||
FFX_MIN16_F2 TopCornerB, BotCornerB, HorzB, VertB, CenterB;
|
||||
|
||||
LoadPreparedColorPairedRgb(TopCornerR, TopCornerG, TopCornerB,
|
||||
FfxTexCoordI2(iSrcSamplePosX01Clamped.x, iSrcSamplePosY01Clamped.x),
|
||||
FfxTexCoordI2(iSrcSamplePosX23Clamped.x, iSrcSamplePosY01Clamped.x)
|
||||
);
|
||||
|
||||
LoadPreparedColorPairedRgb(BotCornerR, BotCornerG, BotCornerB,
|
||||
FfxTexCoordI2(iSrcSamplePosX01Clamped.x, iSrcSamplePosY23Clamped.x),
|
||||
FfxTexCoordI2(iSrcSamplePosX23Clamped.x, iSrcSamplePosY23Clamped.x)
|
||||
);
|
||||
|
||||
LoadPreparedColorPairedRgb(HorzR, HorzG, HorzB,
|
||||
FfxTexCoordI2(iSrcSamplePosX01Clamped.x, iSrcSamplePosY01Clamped.y),
|
||||
FfxTexCoordI2(iSrcSamplePosX23Clamped.x, iSrcSamplePosY01Clamped.y)
|
||||
);
|
||||
|
||||
LoadPreparedColorPairedRgb(VertR, VertG, VertB,
|
||||
FfxTexCoordI2(iSrcSamplePosX01Clamped.y, iSrcSamplePosY01Clamped.x),
|
||||
FfxTexCoordI2(iSrcSamplePosX01Clamped.y, iSrcSamplePosY23Clamped.x)
|
||||
);
|
||||
|
||||
// NOTE: duplicated data
|
||||
LoadPreparedColorPairedRgb(CenterR, CenterG, CenterB,
|
||||
FfxTexCoordI2(iSrcSamplePosX01Clamped.y, iSrcSamplePosY01Clamped.y),
|
||||
FfxTexCoordI2(iSrcSamplePosX01Clamped.y, iSrcSamplePosY01Clamped.y)
|
||||
);
|
||||
|
||||
#if FFX_FSR3UPSCALER_OPTION_HDR_COLOR_INPUT
|
||||
if (bIsInitialSample)
|
||||
{
|
||||
TonemapPaired(TopCornerR, TopCornerG, TopCornerB);
|
||||
TonemapPaired(BotCornerR, BotCornerG, BotCornerB);
|
||||
TonemapPaired(HorzR, HorzG, HorzB);
|
||||
TonemapPaired(VertR, VertG, VertB);
|
||||
TonemapPaired(CenterR, CenterG, CenterB);
|
||||
}
|
||||
#endif
|
||||
|
||||
RGBToYCoCgPaired(TopCornerR, TopCornerG, TopCornerB);
|
||||
RGBToYCoCgPaired(BotCornerR, BotCornerG, BotCornerB);
|
||||
RGBToYCoCgPaired(HorzR, HorzG, HorzB);
|
||||
RGBToYCoCgPaired(VertR, VertG, VertB);
|
||||
RGBToYCoCgPaired(CenterR, CenterG, CenterB);
|
||||
|
||||
#else
|
||||
FfxFloat32x3 fSamples[9];
|
||||
FfxInt32 iSampleIndex = 0;
|
||||
|
||||
FFX_UNROLL
|
||||
for (FfxInt32 row = 0; row < 3; row++) {
|
||||
FFX_UNROLL
|
||||
for (FfxInt32 col = 0; col < 3; col++) {
|
||||
const FfxInt32x2 iSampleColRow = FfxInt32x2(bFlipCol ? (3 - col) : col, bFlipRow ? (3 - row) : row);
|
||||
const FfxInt32x2 iSrcSamplePos = FfxInt32x2(iSrcInputPos) + offsetTL + iSampleColRow;
|
||||
const FfxInt32x2 iSampleCoord = ClampLoad(iSrcSamplePos, FfxInt32x2(0, 0), FfxInt32x2(RenderSize()));
|
||||
|
||||
fSamples[iSampleIndex] = LoadPreparedColor(iSampleCoord);
|
||||
|
||||
++iSampleIndex;
|
||||
}
|
||||
}
|
||||
|
||||
#if FFX_FSR3UPSCALER_OPTION_HDR_COLOR_INPUT
|
||||
if (bIsInitialSample)
|
||||
{
|
||||
for (iSampleIndex = 0; iSampleIndex < 9; ++iSampleIndex)
|
||||
{
|
||||
//YCoCg -> RGB -> Tonemap -> YCoCg (Use RGB tonemapper to avoid color desaturation)
|
||||
fSamples[iSampleIndex] = RGBToYCoCg(Tonemap(YCoCgToRGB(fSamples[iSampleIndex])));
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // #if FFX_FSR3UPSCALER_USE_XBOX_PAIRED_16BIT_MATH_OPTIMIZATIONS
|
||||
|
||||
// Identify how much of each upsampled color to be used for this frame
|
||||
const FfxFloat32 fKernelBiasMax = ComputeMaxKernelWeight(params, data);
|
||||
const FfxFloat32 fKernelBiasMin = ffxMax(1.0f, ((1.0f + fKernelBiasMax) * 0.3f));
|
||||
|
||||
const FfxFloat32 fKernelBiasWeight =
|
||||
ffxMin(1.0f - params.fDisocclusion * 0.5f,
|
||||
ffxMin(1.0f - params.fShadingChange,
|
||||
ffxSaturate(data.fHistoryWeight * 5.0f)
|
||||
));
|
||||
|
||||
const FfxFloat32 fKernelBias = ffxLerp(fKernelBiasMin, fKernelBiasMax, fKernelBiasWeight);
|
||||
|
||||
#if FFX_FSR3UPSCALER_USE_XBOX_PAIRED_16BIT_MATH_OPTIMIZATIONS
|
||||
// Unroll the loop to load samples on Scarlett to help the shader compiler
|
||||
const bool coordX0OnScreen = iSrcSamplePosX01.x == iSrcSamplePosX01Clamped.x;
|
||||
const bool coordX1OnScreen = iSrcSamplePosX01.y == iSrcSamplePosX01Clamped.y;
|
||||
const bool coordX2OnScreen = iSrcSamplePosX23.x == iSrcSamplePosX23Clamped.x;
|
||||
|
||||
const bool coordY0OnScreen = iSrcSamplePosY01.x == iSrcSamplePosY01Clamped.x;
|
||||
const bool coordY1OnScreen = iSrcSamplePosY01.y == iSrcSamplePosY01Clamped.y;
|
||||
const bool coordY2OnScreen = iSrcSamplePosY23.x == iSrcSamplePosY23Clamped.x;
|
||||
|
||||
const FFX_MIN16_F2 fBaseSampleOffsetHalf = FFX_MIN16_F2(fBaseSampleOffset);
|
||||
|
||||
const FFX_MIN16_F2 fSrcSampleOffsetX_02 = fBaseSampleOffsetHalf.xx + fSampleOffsetX02;
|
||||
const FFX_MIN16_F2 fSrcSampleOffsetY_02 = fBaseSampleOffsetHalf.yy + fSampleOffsetY02;
|
||||
|
||||
const FFX_MIN16_F2 fSrcSampleOffsetXSq_02 = fSrcSampleOffsetX_02 * fSrcSampleOffsetX_02;
|
||||
const FFX_MIN16_F2 fSrcSampleOffsetYSq_02 = fSrcSampleOffsetY_02 * fSrcSampleOffsetY_02;
|
||||
const FFX_MIN16_F2 fSrcSampleOffsetXYSq_11 = fBaseSampleOffsetHalf * fBaseSampleOffsetHalf;
|
||||
|
||||
const FfxFloat32 fRectificationCurveBias = -2.3f;
|
||||
PairedRectificationBoxAndAccumulatedColorAndWeight pairedBox;
|
||||
pairedBox.setKernelBiasAndRectificationCurveBias(fKernelBias, fRectificationCurveBias);
|
||||
|
||||
// init by o o o
|
||||
// o x o
|
||||
// o o o
|
||||
pairedBox.initBox(
|
||||
fSrcSampleOffsetXYSq_11.x + fSrcSampleOffsetXYSq_11.y,
|
||||
Bool2ToFloat16x2(coordX1OnScreen && coordY1OnScreen, false).x,
|
||||
CenterR, CenterG, CenterB
|
||||
);
|
||||
|
||||
// add remaining two samples from 1st row x o x
|
||||
// o * o
|
||||
// o o o
|
||||
pairedBox.addBoxSample(
|
||||
fSrcSampleOffsetXSq_02 + fSrcSampleOffsetYSq_02.xx,
|
||||
Bool2ToFloat16x2(coordX0OnScreen && coordY0OnScreen, coordX2OnScreen && coordY0OnScreen),
|
||||
TopCornerR, TopCornerG, TopCornerB
|
||||
);
|
||||
|
||||
// add two samples from 2nd row * o *
|
||||
// o * o
|
||||
// x o x
|
||||
pairedBox.addBoxSample(
|
||||
fSrcSampleOffsetXSq_02 + fSrcSampleOffsetYSq_02.yy,
|
||||
Bool2ToFloat16x2(coordX0OnScreen && coordY2OnScreen, coordX2OnScreen && coordY2OnScreen),
|
||||
BotCornerR, BotCornerG, BotCornerB
|
||||
);
|
||||
|
||||
// add two samples from 3rd row * o *
|
||||
// x * x
|
||||
// * o *
|
||||
pairedBox.addBoxSample(
|
||||
fSrcSampleOffsetXSq_02 + fSrcSampleOffsetXYSq_11.yy,
|
||||
Bool2ToFloat16x2(coordX0OnScreen && coordY1OnScreen, coordX2OnScreen && coordY1OnScreen),
|
||||
HorzR, HorzG, HorzB
|
||||
);
|
||||
|
||||
// add remaining samples * x *
|
||||
// * * *
|
||||
// * x *
|
||||
pairedBox.addBoxSample(
|
||||
fSrcSampleOffsetXYSq_11.xx + fSrcSampleOffsetYSq_02,
|
||||
Bool2ToFloat16x2(coordX1OnScreen && coordY0OnScreen, coordX1OnScreen && coordY2OnScreen),
|
||||
VertR, VertG, VertB
|
||||
);
|
||||
|
||||
FfxFloat32x2 boxCenterAndVecR, boxCenterAndVecG, boxCenterAndVecB;
|
||||
FfxFloat32 boxCenterWeight;
|
||||
pairedBox.finalizeBox(boxCenterAndVecR, boxCenterAndVecG, boxCenterAndVecB, boxCenterWeight);
|
||||
|
||||
if (!bIsInitialSample)
|
||||
{
|
||||
pairedBox.initUpscaledColor(
|
||||
fSrcSampleOffsetXYSq_11.x + fSrcSampleOffsetXYSq_11.y,
|
||||
Bool2ToFloat16x2(coordX1OnScreen && coordY1OnScreen, false).x,
|
||||
CenterR, CenterG, CenterB
|
||||
);
|
||||
|
||||
// add remaining two samples from 1st row x o x
|
||||
// o * o
|
||||
// o o o
|
||||
pairedBox.addUpscaledColorSample(
|
||||
fSrcSampleOffsetXSq_02 + fSrcSampleOffsetYSq_02.xx,
|
||||
Bool2ToFloat16x2(coordX0OnScreen && coordY0OnScreen, coordX2OnScreen && coordY0OnScreen),
|
||||
TopCornerR, TopCornerG, TopCornerB
|
||||
);
|
||||
|
||||
// add two samples from 2nd row * o *
|
||||
// o * o
|
||||
// x o x
|
||||
pairedBox.addUpscaledColorSample(
|
||||
fSrcSampleOffsetXSq_02 + fSrcSampleOffsetYSq_02.yy,
|
||||
Bool2ToFloat16x2(coordX0OnScreen && coordY2OnScreen, coordX2OnScreen && coordY2OnScreen),
|
||||
BotCornerR, BotCornerG, BotCornerB
|
||||
);
|
||||
|
||||
// add two samples from 3rd row * o *
|
||||
// x * x
|
||||
// * o *
|
||||
pairedBox.addUpscaledColorSample(
|
||||
fSrcSampleOffsetXSq_02 + fSrcSampleOffsetXYSq_11.yy,
|
||||
Bool2ToFloat16x2(coordX0OnScreen && coordY1OnScreen, coordX2OnScreen && coordY1OnScreen),
|
||||
HorzR, HorzG, HorzB
|
||||
);
|
||||
|
||||
// add remaining samples * x *
|
||||
// * * *
|
||||
// * x *
|
||||
pairedBox.addUpscaledColorSample(
|
||||
fSrcSampleOffsetXYSq_11.xx + fSrcSampleOffsetYSq_02,
|
||||
Bool2ToFloat16x2(coordX1OnScreen && coordY0OnScreen, coordX1OnScreen && coordY2OnScreen),
|
||||
VertR, VertG, VertB
|
||||
);
|
||||
|
||||
FfxFloat32x4 upscaledColorAndWeight = 0.0;
|
||||
pairedBox.finalizeUpscaledColor(upscaledColorAndWeight);
|
||||
|
||||
data.fUpsampledColor = FfxFloat32x3(upscaledColorAndWeight.rgb);
|
||||
data.fUpsampledWeight = FfxFloat32(upscaledColorAndWeight.w);
|
||||
}
|
||||
|
||||
FFX_MIN16_F2 aabbMinMaxR = Compute3x3SamplesMinMaxPaired(CenterR, TopCornerR, BotCornerR, HorzR, VertR);
|
||||
FFX_MIN16_F2 aabbMinMaxG = Compute3x3SamplesMinMaxPaired(CenterG, TopCornerG, BotCornerG, HorzG, VertG);
|
||||
FFX_MIN16_F2 aabbMinMaxB = Compute3x3SamplesMinMaxPaired(CenterB, TopCornerB, BotCornerB, HorzB, VertB);
|
||||
|
||||
data.clippingBox.boxCenter = FfxFloat32x3(boxCenterAndVecR.x, boxCenterAndVecG.x, boxCenterAndVecB.x);
|
||||
data.clippingBox.boxVec = FfxFloat32x3(boxCenterAndVecR.y, boxCenterAndVecG.y, boxCenterAndVecB.y);
|
||||
data.clippingBox.aabbMin = FfxFloat32x3(aabbMinMaxR.x, aabbMinMaxG.x, aabbMinMaxB.x);
|
||||
data.clippingBox.aabbMax = FfxFloat32x3(aabbMinMaxR.y, aabbMinMaxG.y, aabbMinMaxB.y);
|
||||
data.clippingBox.fBoxCenterWeight = FfxFloat32(boxCenterWeight);
|
||||
#else
|
||||
|
||||
iSampleIndex = 0;
|
||||
|
||||
FFX_UNROLL
|
||||
for (FfxInt32 row = 0; row < 3; row++)
|
||||
{
|
||||
FFX_UNROLL
|
||||
for (FfxInt32 col = 0; col < 3; col++)
|
||||
{
|
||||
const FfxInt32x2 sampleColRow = FfxInt32x2(bFlipCol ? (3 - col) : col, bFlipRow ? (3 - row) : row);
|
||||
const FfxFloat32x2 fOffset = fOffsetTL + FfxFloat32x2(sampleColRow);
|
||||
const FfxFloat32x2 fSrcSampleOffset = fBaseSampleOffset + fOffset;
|
||||
|
||||
const FfxInt32x2 iSrcSamplePos = FfxInt32x2(iSrcInputPos) + FfxInt32x2(offsetTL) + sampleColRow;
|
||||
const FfxFloat32 fOnScreenFactor = FfxFloat32(IsOnScreen(FfxInt32x2(iSrcSamplePos), FfxInt32x2(RenderSize())));
|
||||
|
||||
if (!bIsInitialSample)
|
||||
{
|
||||
const FfxFloat32 fSampleWeight = fOnScreenFactor * FfxFloat32(GetUpsampleLanczosWeight(fSrcSampleOffset, fKernelBias));
|
||||
|
||||
data.fUpsampledColor += fSamples[iSampleIndex] * fSampleWeight;
|
||||
data.fUpsampledWeight += fSampleWeight;
|
||||
}
|
||||
|
||||
// Update rectification box
|
||||
{
|
||||
const FfxFloat32 fRectificationCurveBias = -2.3f;
|
||||
const FfxFloat32 fSrcSampleOffsetSq = dot(fSrcSampleOffset, fSrcSampleOffset);
|
||||
const FfxFloat32 fBoxSampleWeight = exp(fRectificationCurveBias * fSrcSampleOffsetSq) * fOnScreenFactor;
|
||||
|
||||
const FfxBoolean bInitialSample = (row == 0) && (col == 0);
|
||||
RectificationBoxAddSample(bInitialSample, data.clippingBox, fSamples[iSampleIndex], fBoxSampleWeight);
|
||||
}
|
||||
++iSampleIndex;
|
||||
}
|
||||
}
|
||||
|
||||
#endif // #if FFX_FSR3UPSCALER_USE_XBOX_PAIRED_16BIT_MATH_OPTIMIZATIONS
|
||||
|
||||
RectificationBoxComputeVarianceBoxData(data.clippingBox);
|
||||
|
||||
data.fUpsampledWeight *= FfxFloat32(data.fUpsampledWeight > FSR3UPSCALER_EPSILON);
|
||||
|
||||
if (data.fUpsampledWeight > FSR3UPSCALER_EPSILON) {
|
||||
// Normalize for deringing (we need to compare colors)
|
||||
data.fUpsampledColor = data.fUpsampledColor / data.fUpsampledWeight;
|
||||
data.fUpsampledWeight *= fAverageLanczosWeightPerFrame;
|
||||
|
||||
Deringing(data.clippingBox, data.fUpsampledColor);
|
||||
}
|
||||
|
||||
// Initial samples using tonemapped upsampling
|
||||
if (bIsInitialSample) {
|
||||
#if FFX_FSR3UPSCALER_OPTION_HDR_COLOR_INPUT
|
||||
data.fUpsampledColor = RGBToYCoCg(InverseTonemap(YCoCgToRGB(data.clippingBox.boxCenter)));
|
||||
#else
|
||||
data.fUpsampledColor = data.clippingBox.boxCenter;
|
||||
#endif
|
||||
data.fUpsampledWeight = 1.0f;
|
||||
data.fHistoryWeight = 0.0f;
|
||||
}
|
||||
}
|
||||
55
third_party/fidelityfx-sdk/include/FidelityFX/gpu/opticalflow/CMakeCompileOpticalflowShaders.txt
vendored
Normal file
55
third_party/fidelityfx-sdk/include/FidelityFX/gpu/opticalflow/CMakeCompileOpticalflowShaders.txt
vendored
Normal file
@@ -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.
|
||||
|
||||
set(OPTICALFLOW_BASE_ARGS
|
||||
-reflection -deps=gcc -DFFX_GPU=1)
|
||||
|
||||
set(OPTICALFLOW_PERMUTATION_ARGS
|
||||
-DFFX_OPTICALFLOW_OPTION_HDR_COLOR_INPUT={0,1}
|
||||
)
|
||||
|
||||
set(OPTICALFLOW_INCLUDE_ARGS
|
||||
"${FFX_GPU_PATH}"
|
||||
"${FFX_GPU_PATH}/opticalflow")
|
||||
|
||||
if (NOT OPTICALFLOW_SHADER_EXT)
|
||||
set(OPTICALFLOW_SHADER_EXT *)
|
||||
endif()
|
||||
|
||||
file(GLOB OPTICALFLOW_SHADERS
|
||||
"shaders/opticalflow/ffx_opticalflow_prepare_luma_pass.${OPTICALFLOW_SHADER_EXT}"
|
||||
"shaders/opticalflow/ffx_opticalflow_compute_luminance_pyramid_pass.${OPTICALFLOW_SHADER_EXT}"
|
||||
"shaders/opticalflow/ffx_opticalflow_generate_scd_histogram_pass.${OPTICALFLOW_SHADER_EXT}"
|
||||
"shaders/opticalflow/ffx_opticalflow_compute_scd_divergence_pass.${OPTICALFLOW_SHADER_EXT}"
|
||||
"shaders/opticalflow/ffx_opticalflow_compute_optical_flow_advanced_pass_v5.${OPTICALFLOW_SHADER_EXT}"
|
||||
"shaders/opticalflow/ffx_opticalflow_filter_optical_flow_pass_v5.${OPTICALFLOW_SHADER_EXT}"
|
||||
"shaders/opticalflow/ffx_opticalflow_scale_optical_flow_advanced_pass_v5.${OPTICALFLOW_SHADER_EXT}"
|
||||
)
|
||||
|
||||
# compile all the shaders
|
||||
compile_shaders_with_depfile(
|
||||
"${FFX_SC_EXECUTABLE}"
|
||||
"${OPTICALFLOW_BASE_ARGS}" "${OPTICALFLOW_API_BASE_ARGS}" "${OPTICALFLOW_PERMUTATION_ARGS}" "${OPTICALFLOW_INCLUDE_ARGS}"
|
||||
"${OPTICALFLOW_SHADERS}" "${FFX_PASS_SHADER_OUTPUT_PATH}" OPTICALFLOW_PERMUTATION_OUTPUTS)
|
||||
|
||||
# add the header files they generate to the main list of dependencies
|
||||
add_shader_output("${OPTICALFLOW_PERMUTATION_OUTPUTS}")
|
||||
578
third_party/fidelityfx-sdk/include/FidelityFX/gpu/opticalflow/ffx_opticalflow_callbacks_glsl.h
vendored
Normal file
578
third_party/fidelityfx-sdk/include/FidelityFX/gpu/opticalflow/ffx_opticalflow_callbacks_glsl.h
vendored
Normal file
@@ -0,0 +1,578 @@
|
||||
// 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
|
||||
|
||||
#include "opticalflow/ffx_opticalflow_resources.h"
|
||||
|
||||
// no msad4 in glsl
|
||||
#define FFX_OPTICALFLOW_USE_MSAD4_INSTRUCTION 0
|
||||
#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
|
||||
|
||||
#if defined(FFX_GPU)
|
||||
#include "ffx_core.h"
|
||||
#endif // #if defined(FFX_GPU)
|
||||
|
||||
#if defined(FFX_GPU)
|
||||
#ifndef FFX_PREFER_WAVE64
|
||||
#define FFX_PREFER_WAVE64
|
||||
#endif // #if defined(FFX_GPU)
|
||||
|
||||
|
||||
#include "opticalflow/ffx_opticalflow_common.h"
|
||||
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_CB_COMMON)
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_CB_COMMON, std140) uniform cbOF_t
|
||||
{
|
||||
FfxInt32x2 iInputLumaResolution;
|
||||
FfxUInt32 uOpticalFlowPyramidLevel;
|
||||
FfxUInt32 uOpticalFlowPyramidLevelCount;
|
||||
|
||||
FfxUInt32 iFrameIndex;
|
||||
FfxUInt32 backbufferTransferFunction;
|
||||
FfxFloat32x2 minMaxLuminance;
|
||||
} cbOF;
|
||||
|
||||
FfxInt32x2 DisplaySize()
|
||||
{
|
||||
return cbOF.iInputLumaResolution;
|
||||
}
|
||||
|
||||
FfxUInt32 FrameIndex()
|
||||
{
|
||||
return cbOF.iFrameIndex;
|
||||
}
|
||||
|
||||
FfxUInt32 BackbufferTransferFunction()
|
||||
{
|
||||
return cbOF.backbufferTransferFunction;
|
||||
}
|
||||
|
||||
FfxFloat32x2 MinMaxLuminance()
|
||||
{
|
||||
return cbOF.minMaxLuminance;
|
||||
}
|
||||
|
||||
FfxBoolean CrossedSceneChangeThreshold(FfxFloat32 sceneChangeValue)
|
||||
{
|
||||
return sceneChangeValue > 0.45f;
|
||||
}
|
||||
|
||||
FfxUInt32 OpticalFlowPyramidLevel()
|
||||
{
|
||||
return cbOF.uOpticalFlowPyramidLevel;
|
||||
}
|
||||
|
||||
FfxUInt32 OpticalFlowPyramidLevelCount()
|
||||
{
|
||||
return cbOF.uOpticalFlowPyramidLevelCount;
|
||||
}
|
||||
|
||||
FfxInt32x2 OpticalFlowHistogramMaxVelocity()
|
||||
{
|
||||
const FfxInt32 searchRadius = 8;
|
||||
FfxInt32 scale = FfxInt32(1) << (OpticalFlowPyramidLevelCount() - 1 - OpticalFlowPyramidLevel());
|
||||
FfxInt32 maxVelocity = searchRadius * scale;
|
||||
return FfxInt32x2(maxVelocity, maxVelocity);
|
||||
}
|
||||
#endif //FFX_OPTICALFLOW_BIND_CB_COMMON
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_CB_SPD)
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_CB_SPD, std140) uniform cbOF_SPD_t
|
||||
{
|
||||
FfxUInt32 mips;
|
||||
FfxUInt32 numWorkGroups;
|
||||
FfxUInt32x2 workGroupOffset;
|
||||
FfxUInt32 numWorkGroupOpticalFlowInputPyramid;
|
||||
FfxUInt32 pad0_;
|
||||
FfxUInt32 pad1_;
|
||||
FfxUInt32 pad2_;
|
||||
} cbOF_SPD;
|
||||
|
||||
uint NumWorkGroups()
|
||||
{
|
||||
return cbOF_SPD.numWorkGroupOpticalFlowInputPyramid;
|
||||
}
|
||||
#endif // defined(FFX_OPTICALFLOW_BIND_CB_SPD)
|
||||
|
||||
#if defined FFX_OPTICALFLOW_BIND_SRV_INPUT_COLOR
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_SRV_INPUT_COLOR) uniform texture2D r_input_color;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_SRV_INPUT_MOTION_VECTORS
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_SRV_INPUT_MOTION_VECTORS) uniform texture2D r_input_motion_vectors;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_INPUT
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_INPUT) uniform utexture2D r_optical_flow_input;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_PREVIOUS_INPUT
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_PREVIOUS_INPUT) uniform utexture2D r_optical_flow_previous_input;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW) uniform itexture2D r_optical_flow;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_PREVIOUS
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_PREVIOUS) uniform itexture2D r_optical_flow_previous;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_ADDITIONAL_INFO
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_ADDITIONAL_INFO) uniform utexture2D r_optical_flow_additional_info;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_ADDITIONAL_INFO_PREVIOUS
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_ADDITIONAL_INFO_PREVIOUS) uniform utexture2D r_optical_flow_additional_info_previous;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_HISTOGRAM
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_HISTOGRAM) uniform utexture2D r_optical_flow_histogram;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH) uniform utexture2D r_optical_flow_global_motion_search;
|
||||
#endif
|
||||
|
||||
// UAV declarations
|
||||
#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT, r8ui) uniform uimage2D rw_optical_flow_input;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_1
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_1, r8ui) uniform uimage2D rw_optical_flow_input_level_1;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_2
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_2, r8ui) uniform uimage2D rw_optical_flow_input_level_2;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_3
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_3, r8ui) uniform uimage2D rw_optical_flow_input_level_3;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_4
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_4, r8ui) uniform uimage2D rw_optical_flow_input_level_4;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_5
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_5, r8ui) uniform uimage2D rw_optical_flow_input_level_5;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_6
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_6, r8ui) uniform uimage2D rw_optical_flow_input_level_6;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW, rg16i) uniform iimage2D rw_optical_flow;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_NEXT_LEVEL
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_NEXT_LEVEL, rg16i) uniform iimage2D rw_optical_flow_next_level;
|
||||
#endif
|
||||
//#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_ADDITIONAL_INFO
|
||||
// RWTexture2D<FfxUInt32x2> rw_optical_flow_additional_info : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_ADDITIONAL_INFO);
|
||||
// layout (set = 0, binding = FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_ADDITIONAL_INFO, r32ui) uniform uimage2D rw_optical_flow_additional_info;
|
||||
//#endif
|
||||
//#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_ADDITIONAL_INFO_NEXT_LEVEL
|
||||
// RWTexture2D<FfxUInt32x2> rw_optical_flow_additional_info_next_level : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_ADDITIONAL_INFO_NEXT_LEVEL);
|
||||
// layout (set = 0, binding = FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_ADDITIONAL_INFO_NEXT_LEVEL, r32ui) uniform uimage2D rw_optical_flow_additional_info_next_level;
|
||||
//#endif
|
||||
//#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_HISTOGRAM
|
||||
// RWTexture2D<FfxUInt32> rw_optical_flow_histogram : FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_HISTOGRAM);
|
||||
// layout (set = 0, binding = FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_HISTOGRAM, r32ui) uniform uimage2D rw_optical_flow_histogram;
|
||||
//#endif
|
||||
//#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH
|
||||
// globallycoherent RWTexture2D<FfxUInt32> rw_optical_flow_global_motion_search: FFX_OPTICALFLOW_DECLARE_UAV(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH);
|
||||
// layout (set = 0, binding = FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH, r32ui) coherent uniform uimage2D rw_optical_flow_global_motion_search;
|
||||
//#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_HISTOGRAM
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_HISTOGRAM, r32ui) uniform uimage2D rw_optical_flow_scd_histogram;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_PREVIOUS_HISTOGRAM
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_PREVIOUS_HISTOGRAM, r32f) uniform image2D rw_optical_flow_scd_previous_histogram;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_TEMP
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_TEMP, r32ui) uniform uimage2D rw_optical_flow_scd_temp;
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_OUTPUT
|
||||
layout (set = 0, binding = FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_OUTPUT, r32ui) uniform uimage2D rw_optical_flow_scd_output;
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_SRV_INPUT_COLOR)
|
||||
FfxFloat32x4 LoadInputColor(FfxUInt32x2 iPxHistory)
|
||||
{
|
||||
return texelFetch(r_input_color, FfxInt32x2(iPxHistory), 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_SRV_INPUT_MOTION_VECTORS)
|
||||
FfxFloat32x2 LoadGameMotionVector(FfxInt32x2 iPxPos)
|
||||
{
|
||||
FfxFloat32x2 positionScale = FfxFloat32x2(RenderSize()) / DisplaySize();
|
||||
return texelFetch(r_input_motion_vectors, FfxInt32x2(iPxPos * positionScale), 0).xy * motionVectorScale / positionScale;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT)
|
||||
void StoreOpticalFlowInput(FfxInt32x2 iPxPos, FfxUInt32 fLuma)
|
||||
{
|
||||
imageStore(rw_optical_flow_input, iPxPos, FfxUInt32x4(fLuma, 0, 0, 0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_INPUT)
|
||||
FfxUInt32 LoadOpticalFlowInput(FfxInt32x2 iPxPos)
|
||||
{
|
||||
#if FFX_OPTICALFLOW_USE_MSAD4_INSTRUCTION == 1
|
||||
return max(1, texelFetch(r_optical_flow_input, iPxPos, 0).x);
|
||||
#else
|
||||
return texelFetch(r_optical_flow_input, iPxPos, 0).x;
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT)
|
||||
FfxUInt32 LoadRwOpticalFlowInput(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return imageLoad(rw_optical_flow_input, iPxPos).x;
|
||||
}
|
||||
#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, texelFetch(r_optical_flow_previous_input, iPxPos, 0).x);
|
||||
#else
|
||||
return texelFetch(r_optical_flow_previous_input, iPxPos, 0).x;
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW)
|
||||
FfxInt32x2 LoadOpticalFlow(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_optical_flow, iPxPos, 0).xy;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW)
|
||||
FfxInt32x2 LoadRwOpticalFlow(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return imageLoad(rw_optical_flow, iPxPos).xy;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_PREVIOUS)
|
||||
FfxInt32x2 LoadPreviousOpticalFlow(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_optical_flow_previous, iPxPos, 0).xy;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW)
|
||||
void StoreOpticalFlow(FfxInt32x2 iPxPos, FfxInt32x2 motionVector)
|
||||
{
|
||||
imageStore(rw_optical_flow, iPxPos, FfxInt32x4(motionVector, 0, 0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_NEXT_LEVEL)
|
||||
void StoreOpticalFlowNextLevel(FfxInt32x2 iPxPos, FfxInt32x2 motionVector)
|
||||
{
|
||||
imageStore(rw_optical_flow_next_level, iPxPos, FfxInt32x4(motionVector, 0, 0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_ADDITIONAL_INFO)
|
||||
FfxUInt32x2 LoadOpticalFlowAdditionalInfo(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_optical_flow_additional_info, iPxPos, 0).xy;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_ADDITIONAL_INFO)
|
||||
FfxUInt32x2 LoadRwOpticalFlowAdditionalInfo(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return imageLoad(rw_optical_flow_additional_info, iPxPos).xy;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_ADDITIONAL_INFO_PREVIOUS)
|
||||
FfxUInt32x2 LoadPreviousOpticalFlowAdditionalInfo(FfxInt32x2 iPxPos)
|
||||
{
|
||||
return texelFetch(r_optical_flow_additional_info_previous, iPxPos, 0).xy;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_ADDITIONAL_INFO)
|
||||
void StoreOpticalFlowAdditionalInfo(FfxInt32x2 iPxPos, FfxUInt32x2 additionalInfo)
|
||||
{
|
||||
imageStore(rw_optical_flow_additional_info, iPxPos, FfxUInt32x4(additionalInfo, 0, 0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_ADDITIONAL_INFO_NEXT_LEVEL)
|
||||
void StoreOpticalFlowNextLevelAdditionalInfo(FfxInt32x2 iPxPos, FfxUInt32x2 additionalInfo)
|
||||
{
|
||||
imageStore(rw_optical_flow_additional_info_next_level, iPxPos, FfxUInt32x4(additionalInfo, 0, 0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_HISTOGRAM)
|
||||
FfxUInt32 LoadOpticalFlowHistogram(FfxInt32x2 iBucketId)
|
||||
{
|
||||
return texelFetch(r_optical_flow_histogram, iBucketId, 0).x;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_HISTOGRAM)
|
||||
void AtomicIncrementOpticalFlowHistogram(FfxInt32x2 iBucketId)
|
||||
{
|
||||
imageAtomicAdd(rw_optical_flow_histogram, iBucketId, 1);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH)
|
||||
FfxInt32x2 LoadGlobalMotionVector()
|
||||
{
|
||||
FfxInt32 vx = FfxInt32(texelFetch(r_optical_flow_global_motion_search, FfxInt32x2(0, 0), 0).x);
|
||||
FfxInt32 vy = FfxInt32(texelFetch(r_optical_flow_global_motion_search, FfxInt32x2(1, 0), 0).x);
|
||||
return FfxInt32x2(vx, vy);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH)
|
||||
FfxInt32x2 LoadRwGlobalMotionVector()
|
||||
{
|
||||
FfxInt32 vx = FfxInt32(imageLoad(rw_optical_flow_global_motion_search, FfxInt32x2(0, 0)).x);
|
||||
FfxInt32 vy = FfxInt32(imageLoad(rw_optical_flow_global_motion_search, FfxInt32x2(1, 0)).x);
|
||||
return FfxInt32x2(vx, vy);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH)
|
||||
FfxUInt32 LoadGlobalMotionValue(FfxInt32 index)
|
||||
{
|
||||
return imageLoad(rw_optical_flow_global_motion_search, FfxInt32x2(index, 0)).x;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH)
|
||||
void StoreGlobalMotionValue(FfxInt32 index, FfxUInt32 value)
|
||||
{
|
||||
imageStore(rw_optical_flow_global_motion_search, FfxInt32x2(index, 0), FfxUInt32x4(value, 0, 0, 0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_GLOBAL_MOTION_SEARCH)
|
||||
FfxUInt32 AtomicIncrementGlobalMotionValue(FfxInt32 index)
|
||||
{
|
||||
return imageAtomicAdd(rw_optical_flow_global_motion_search, FfxInt32x2(index, 0), 1);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_HISTOGRAM)
|
||||
FfxUInt32 LoadRwSCDHistogram(FfxInt32 iIndex)
|
||||
{
|
||||
return imageLoad(rw_optical_flow_scd_histogram, FfxInt32x2(iIndex, 0)).x;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_HISTOGRAM)
|
||||
void StoreSCDHistogram(FfxInt32 iIndex, FfxUInt32 value)
|
||||
{
|
||||
imageStore(rw_optical_flow_scd_histogram, FfxInt32x2(iIndex, 0), FfxUInt32x4(value, 0, 0, 0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_HISTOGRAM)
|
||||
void AtomicIncrementSCDHistogram(FfxInt32 iIndex, FfxUInt32 valueToAdd)
|
||||
{
|
||||
imageAtomicAdd(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 imageLoad(rw_optical_flow_scd_previous_histogram, FfxInt32x2(iIndex, 0)).x;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_PREVIOUS_HISTOGRAM)
|
||||
void StoreSCDPreviousHistogram(FfxInt32 iIndex, FfxFloat32 value)
|
||||
{
|
||||
imageStore(rw_optical_flow_scd_previous_histogram, FfxInt32x2(iIndex, 0), FfxFloat32x4(value, 0.0, 0.0, 0.0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_TEMP)
|
||||
FfxUInt32 LoadRwSCDTemp(FfxInt32 iIndex)
|
||||
{
|
||||
return imageLoad(rw_optical_flow_scd_temp, FfxInt32x2(iIndex, 0)).x;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_TEMP)
|
||||
void AtomicIncrementSCDTemp(FfxInt32 iIndex, FfxUInt32 valueToAdd)
|
||||
{
|
||||
imageAtomicAdd(rw_optical_flow_scd_temp, FfxInt32x2(iIndex, 0), valueToAdd);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_TEMP)
|
||||
void ResetSCDTemp()
|
||||
{
|
||||
imageStore(rw_optical_flow_scd_temp, FfxInt32x2(0, 0), FfxUInt32x4(0, 0, 0, 0));
|
||||
imageStore(rw_optical_flow_scd_temp, FfxInt32x2(1, 0), FfxUInt32x4(0, 0, 0, 0));
|
||||
imageStore(rw_optical_flow_scd_temp, FfxInt32x2(2, 0), FfxUInt32x4(0, 0, 0, 0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_OUTPUT)
|
||||
FfxUInt32 LoadRwSCDOutput(FfxInt32 iIndex)
|
||||
{
|
||||
return imageLoad(rw_optical_flow_scd_output, FfxInt32x2(iIndex, 0)).x;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_OUTPUT)
|
||||
void StoreSCDOutput(FfxInt32 iIndex, FfxUInt32 value)
|
||||
{
|
||||
imageStore(rw_optical_flow_scd_output, FfxInt32x2(iIndex, 0), FfxUInt32x4(value, 0, 0, 0));
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_SCD_OUTPUT)
|
||||
FfxUInt32 AtomicIncrementSCDOutput(FfxInt32 iIndex, FfxUInt32 valueToAdd)
|
||||
{
|
||||
return imageAtomicAdd(rw_optical_flow_scd_output, FfxInt32x2(iIndex, 0), valueToAdd);
|
||||
}
|
||||
#endif
|
||||
|
||||
//#if defined(FFX_OPTICALFLOW_BIND_UAV_DEBUG_VISUALIZATION)
|
||||
//void StoreDebugVisualization(FfxUInt32x2 iPxPos, FfxFloat32x3 fColor)
|
||||
//{
|
||||
// imageStore(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 true;
|
||||
}
|
||||
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(FfxInt32x2 iPxPos, FfxUInt32 index, FfxFloat32 value)
|
||||
{
|
||||
FfxUInt32x4 value4 = FfxUInt32x4(value, 0.0, 0.0, 0.0);
|
||||
switch (index)
|
||||
{
|
||||
case 0:
|
||||
#if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_1
|
||||
imageStore(rw_optical_flow_input_level_1, iPxPos, value4);
|
||||
#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
|
||||
imageStore(rw_optical_flow_input_level_2, iPxPos, value4);
|
||||
#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
|
||||
imageStore(rw_optical_flow_input_level_3, iPxPos, value4);
|
||||
#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
|
||||
imageStore(rw_optical_flow_input_level_4, iPxPos, value4);
|
||||
#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
|
||||
imageStore(rw_optical_flow_input_level_5, iPxPos, value4);
|
||||
#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
|
||||
imageStore(rw_optical_flow_input_level_6, iPxPos, value4);
|
||||
#endif // #if defined FFX_OPTICALFLOW_BIND_UAV_OPTICAL_FLOW_INPUT_LEVEL_6
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
#endif // #if defined(FFX_GPU)
|
||||
|
||||
#endif // FFX_OPTICALFLOW_CALLBACKS_HLSL_H
|
||||
634
third_party/fidelityfx-sdk/include/FidelityFX/gpu/opticalflow/ffx_opticalflow_callbacks_hlsl.h
vendored
Normal file
634
third_party/fidelityfx-sdk/include/FidelityFX/gpu/opticalflow/ffx_opticalflow_callbacks_hlsl.h
vendored
Normal file
@@ -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<FfxFloat32x4> r_input_color : FFX_OPTICALFLOW_DECLARE_SRV(FFX_OPTICALFLOW_BIND_SRV_INPUT_COLOR);
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_SRV_INPUT_MOTION_VECTORS
|
||||
Texture2D<FfxFloat32x2> 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<FfxUInt32> 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<FfxUInt32> 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<FfxInt32x2> r_optical_flow : FFX_OPTICALFLOW_DECLARE_SRV(FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW);
|
||||
#endif
|
||||
#if defined FFX_OPTICALFLOW_BIND_SRV_OPTICAL_FLOW_PREVIOUS
|
||||
Texture2D<FfxInt32x2> 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<FfxUInt32x2> 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<FfxUInt32x2> 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<FfxUInt32> 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<FfxUInt32> 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<FfxUInt32> 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<FfxUInt32> 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<FfxUInt32> 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<FfxUInt32> 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<FfxUInt32> 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<FfxUInt32> 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<FfxUInt32> 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<FfxInt32x2> 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<FfxInt32x2> 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<FfxUInt32x2> 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<FfxUInt32x2> 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<FfxUInt32> 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<FfxUInt32> 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<FfxUInt32> 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<FfxFloat32> 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<FfxUInt32> 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<FfxUInt32> 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
|
||||
99
third_party/fidelityfx-sdk/include/FidelityFX/gpu/opticalflow/ffx_opticalflow_common.h
vendored
Normal file
99
third_party/fidelityfx-sdk/include/FidelityFX/gpu/opticalflow/ffx_opticalflow_common.h
vendored
Normal file
@@ -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)
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
106
third_party/fidelityfx-sdk/include/FidelityFX/gpu/opticalflow/ffx_opticalflow_prepare_luma.h
vendored
Normal file
106
third_party/fidelityfx-sdk/include/FidelityFX/gpu/opticalflow/ffx_opticalflow_prepare_luma.h
vendored
Normal file
@@ -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
|
||||
74
third_party/fidelityfx-sdk/include/FidelityFX/gpu/opticalflow/ffx_opticalflow_resources.h
vendored
Normal file
74
third_party/fidelityfx-sdk/include/FidelityFX/gpu/opticalflow/ffx_opticalflow_resources.h
vendored
Normal file
@@ -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 )
|
||||
@@ -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
|
||||
1014
third_party/fidelityfx-sdk/include/FidelityFX/gpu/spd/ffx_spd.h
vendored
Normal file
1014
third_party/fidelityfx-sdk/include/FidelityFX/gpu/spd/ffx_spd.h
vendored
Normal file
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user