==============================================================================================================================

==============================================================================================================================

Compute an approximate conversion from gamma2 to PQ space. PQ is very close to x^(1/8). The functions below Use the fast FfxFloat32 approximation met

Compute a high accuracy approximate conversion from gamma2 to PQ space. PQ is very close to x^(1/8). The functions below Use the fast FfxFloat32 appr

Compute a more accurate approximate conversion from gamma2 to PQ space. PQ is very close to x^(1/8). The functions below Use the fast FfxFloat32 appr

Compute an approximate conversion from linear to PQ space. PQ is very close to x^(1/8). The functions below Use the fast FfxFloat32 approximation met

Compute a very accurate approximate conversion from linear to PQ space. PQ is very close to x^(1/8). The functions below Use the fast FfxFloat32 appr

Compute a more accurate approximate conversion from linear to PQ space. PQ is very close to x^(1/8). The functions below Use the fast FfxFloat32 appr

Compute an approximate conversion from PQ to Gamma2 space. PQ is very close to x^(1/8). The functions below Use the fast FfxFloat32 approximation met

Compute an approximate conversion from PQ to linear space. PQ is very close to x^(1/8). The functions below Use the fast FfxFloat32 approximation met

Calculate a low-quality approximation for the square root of a value. For additional information on the approximation family of functions, you can re

Calculate a half-precision low-quality approximation for the square root of a value. For additional information on the approximation family of functi

Interprets the bit pattern of x as a floating-point number. @param [in] x The input value. @returns The input interpreted as a floatin

Interprets the bit pattern of x as an unsigned integer. @param [in] x The input value. @returns The input interpreted as an unsigned i

------------------------------------------------------------------------------------------------------------------------------

Broadcast a scalar value to a 2-dimensional floating point vector. @param [in] value The value to to broadcast. @returns A 2-dimension

Broadcast a scalar value to a 3-dimensional floating point vector. @param [in] value The value to to broadcast. @returns A 3-dimension

Broadcast a scalar value to a 4-dimensional floating point vector. @param [in] value The value to to broadcast. @returns A 4-dimension

==============================================================================================================================

------------------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------------------------------------

Copy the sign bit from 's' to positive 'd'. @param [in] d The value to copy the sign bit into. @param [in] s The

Copy the sign bit from 's' to positive 'd'. @param [in] d The value to copy the sign bit into. @param [in] s The

Compute the cube root of a value. @param [in] c The value to compute the cube root for. @returns A cube root of the input value. @ingroup

Calculate dot product of 'a' and 'b'. @param [in] a First vector input. @param [in] b Second vector input. @retu

Calculate dot product of 'a' and 'b'. @param [in] a First vector input. @param [in] b Second vector input. @retu

Calculate dot product of 'a' and 'b'. @param [in] a First vector input. @param [in] b Second vector input. @retu

Convert a 32bit floating point value to sortable integer. - If sign bit=0, flip the sign bit (positives). - If sign bit=1, flip all bits (negativ

Convert a 16bit floating point value to sortable integer. - If sign bit=0, flip the sign bit (positives). - If sign bit=1, flip all bits (negativ

Compute the factional part of a decimal value. This function calculates <c><i>x - floor(x)</i></c>. Where <c><i>floor</i></c> is the intrinsic HLSL f

Apply edge-aware spatial upsampling using 32bit floating point precision calculations. @param [out] outPixel The computed color of a pi

Setup required constant values for EASU (works on CPU or GPU). @param [out] con0 @param [out] con1 @param [out] con2 @param [out] con3 @param [in] in

Compute a gamma value from a linear value. Typically 2.2 for some PC displays, or 2.4-2.5 for CRTs, or 2.2 FreeSync2 native. Note: 'rcpX' is '1/x',

Compute a gamma value from a linear value. Typically 2.2 for some PC displays, or 2.4-2.5 for CRTs, or 2.2 FreeSync2 native. Note: 'rcpX' is '1/x',

@brief Inverts the value while avoiding division by zero. If the value is zero, zero is returned. @param v Value to invert. @return If v = 0 returns 0

@brief Inverts the value while avoiding division by zero. If the value is zero, zero is returned. @param v Value to invert. @return If v = 0 returns 0

A single operation to return the following: m = NaN := 0 m >= 0 := 0 m < 0 := 1 Uses the following useful floating point logic, saturate(+a*(-INF)

A single operation to return the following: m = NaN := 0 m >= 0 := 0 m < 0 := 1 Uses the following useful floating point logic, saturate(+a*(-INF)

Compute the linear interopation between two values. Implemented by calling the GLSL <c><i>mix</i></c> intrinsic function. Implements the following ma

Compute the linear interopation between two values. Implemented by calling the HLSL <c><i>mix</i></c> intrinsic function. Implements the following ma

Compute a linear value from a value in a gamma space. Typically 2.2 for some PC displays, or 2.4-2.5 for CRTs, or 2.2 FreeSync2 native. @param [in]

Compute a linear value from a value in a gamma space. Typically 2.2 for some PC displays, or 2.4-2.5 for CRTs, or 2.2 FreeSync2 native. @param [in]

Compute a linear value from a value in a PQ space. Typically 2.2 for some PC displays, or 2.4-2.5 for CRTs, or 2.2 FreeSync2 native. @param [in] val

Compute a linear value from a REC.709 value. @param [in] color The value to convert to linear from REC.709. @returns A value in linear spa

Compute a linear value from a REC.709 value. @param [in] c The value to convert to linear from REC.709. @returns A value in linear space.

Compute a linear value from a value in a SRGB space. Typically 2.2 for some PC displays, or 2.4-2.5 for CRTs, or 2.2 FreeSync2 native. @param [in] v

Compute a linear value from a value in a SRGB space. Typically 2.2 for some PC displays, or 2.4-2.5 for CRTs, or 2.2 FreeSync2 native. @param [in] c

Compute the max of two values. @param [in] x The first value to compute the max of. @param [in] y The second valu

Compute the max of two values. @param [in] x The first value to compute the max of. @param [in] y The second valu

Compute the maximum of three values. NOTE: This function should compile down to a single <c><i>V_MAX3_F32</i></c> operation on GCN/RDNA hardware. @p

------------------------------------------------------------------------------------------------------------------------------

Compute the median of three values. NOTE: This function should compile down to a single <c><i>V_MED3_F32</i></c> operation on GCN/RDNA hardware. @pa

Compute the median of three values. NOTE: This function should compile down to a single <c><i>V_MED3_F32</i></c> operation on GCN/RDNA hardware. @pa

------------------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------------------------------------

Compute the min of two values. @param [in] x The first value to compute the min of. @param [in] y The second valu

Compute the minimum of three values. NOTE: This function should compile down to a single <c><i>V_MIN3_F32</i></c> operation on GCN/RDNA hardware. @p

------------------------------------------------------------------------------------------------------------------------------

Compute a PQ value from a linear value. @param [in] value The value to convert to PQ from linear. @returns A value in linear space. @ingr

Packs the bytes from the X and Y components of a FfxUInt32x2 into a single 32-bit integer. The resulting integer will contain bytes in the following