Takes two Float16x2 values x and y, normalizes them and builds a single Uint16x2 value in the format {{x0,y0},{x1,y1}}. @param [in] x

Takes two Float16x2 values x and y, normalizes them and builds a single Uint16x2 value in the format {{x0,y0},{x1,y1}}. @param [in] x

An approximation of cosine. Valid input range is {-1 to 1} representing {0 to 2 pi}, and the output range is {-1/4 to 1/4} representing {-1 to 1}. @

An approximation of cosine. Valid input range is {-1 to 1} representing {0 to 2 pi}, and the output range is {-1/4 to 1/4} representing {-1 to 1}. @

An approximation of both sine and cosine. Valid input range is {-1 to 1} representing {0 to 2 pi}, and the output range is {-1/4 to 1/4} representing

An approximation of both sine and cosine. Valid input range is {-1 to 1} representing {0 to 2 pi}, and the output range is {-1/4 to 1/4} representing

Given a FfxUInt32x2 value d, Float16x2 value i and a resulting FfxUInt32x2 value r, this function packs d.x[0:7] into r.x[0:7], d.y[0:7] into r.y[0:7]

Given a FfxUInt32x2 value i and a resulting Float16x2 value r, this function packs i.x[0:7] into r.x[0:7] and i.y[0:7] into r.y[0:7] using 2 ops. Han

Given a FfxUInt32x2 value d, Float16x2 value i and a resulting FfxUInt32x2 value r, this function packs d.x[0:7] into r.x[8:15], d.y[0:7] into r.y[8:1

Given a FfxUInt32x2 value i and a resulting Float16x2 value r, this function packs i.x[8:15] into r.x[0:7] and i.y[8:15] into r.y[0:7] using 2 ops. H

Given a FfxUInt32x2 value d, Float16x2 value i and a resulting FfxUInt32x2 value r, this function packs d.x[0:7] into r.x[16:23], d.y[0:7] into r.y[16

Given a FfxUInt32x2 value i and a resulting Float16x2 value r, this function packs i.x[16:23] into r.x[0:7] and i.y[16:23] into r.y[0:7] using 2 ops.

Given a FfxUInt32x2 value d, Float16x2 value i and a resulting FfxUInt32x2 value r, this function packs d.x[0:7] into r.x[24:31], d.y[0:7] into r.y[24

Given a FfxUInt32x2 value i and a resulting Float16x2 value r, this function packs i.x[24:31] into r.x[0:7] and i.y[24:31] into r.y[0:7] using 2 ops.

Given a FfxUInt32x2 value d, Float16x2 value i and a resulting FfxUInt32x2 value r, this function packs d.x[0:7] into r.x[0:7], d.y[0:7] into r.y[0:7]

Given a FfxUInt32x2 value i and a resulting Float16x2 value r, this function packs i.x[0:7] into r.x[0:7] and i.y[0:7] into r.y[0:7] using 2 ops. @pa

Given a FfxUInt32x2 value d, Float16x2 value i and a resulting FfxUInt32x2 value r, this function packs d.x[0:7] into r.x[8:15], d.y[0:7] into r.y[8:1

Given a FfxUInt32x2 value i and a resulting Float16x2 value r, this function packs i.x[8:15] into r.x[0:7] and i.y[8:15] into r.y[0:7] using 2 ops. @

Given a FfxUInt32x2 value d, Float16x2 value i and a resulting FfxUInt32x2 value r, this function packs d.x[0:7] into r.x[16:23], d.y[0:7] into r.y[16

Given a FfxUInt32x2 value i and a resulting Float16x2 value r, this function packs i.x[16:23] into r.x[0:7] and i.y[16:23] into r.y[0:7] using 2 ops.

Given a FfxUInt32x2 value d, Float16x2 value i and a resulting FfxUInt32x2 value r, this function packs d.x[0:7] into r.x[24:31], d.y[0:7] into r.y[24

Given a FfxUInt32x2 value i and a resulting Float16x2 value r, this function packs i.x[24:31] into r.x[0:7] and i.y[24:31] into r.y[0:7] using 2 ops.

Given a FfxUInt32x2 value d, Float16x2 value i and a resulting FfxUInt32x2 value r, this function packs d.x[0:7] into r.x[0:7], d.y[0:7] into r.y[0:7]

Given a FfxUInt32x2 value i and a resulting Float16x2 value r, this function packs i.x[0:7] into r.x[0:7] and i.y[0:7] into r.y[0:7] using 2 ops. Han

Given a FfxUInt32x2 value d, Float16x2 value i and a resulting FfxUInt32x2 value r, this function packs d.x[0:7] into r.x[8:15], d.y[0:7] into r.y[8:1

Given a FfxUInt32x2 value i and a resulting Float16x2 value r, this function packs i.x[8:15] into r.x[0:7] and i.y[8:15] into r.y[0:7] using 2 ops. H

Given a FfxUInt32x2 value d, Float16x2 value i and a resulting FfxUInt32x2 value r, this function packs d.x[0:7] into r.x[16:23], d.y[0:7] into r.y[16

Given a FfxUInt32x2 value i and a resulting Float16x2 value r, this function packs i.x[16:23] into r.x[0:7] and i.y[16:23] into r.y[0:7] using 2 ops.

Given a FfxUInt32x2 value d, Float16x2 value i and a resulting FfxUInt32x2 value r, this function packs d.x[0:7] into r.x[24:31], d.y[0:7] into r.y[24

Given a FfxUInt32x2 value i and a resulting Float16x2 value r, this function packs i.x[24:31] into r.x[0:7] and i.y[24:31] into r.y[0:7] using 2 ops.

Compute the value of the first parameter raised to the power of the second. @param [in] x The value to raise to the power y. @param

Compute the value of the first parameter raised to the power of the second. @param [in] x The value to raise to the power y. @param

Compute a Rec.709 color space. Rec.709 is used for some HDTVs. Both Rec.709 and sRGB have a linear segment which as spec'ed would intersect the curv

Compute a Rec.709 color space. Rec.709 is used for some HDTVs. Both Rec.709 and sRGB have a linear segment which as spec'ed would intersect the curv

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

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

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

A remapping of 64x1 to 8x8 imposing rotated 2x2 pixel quads in quad linear. 543210 ====== ..xxx. yy...y @param [in] a The input 1D coordinates

A remapping of 64x1 to 8x8 imposing rotated 2x2 pixel quads in quad linear. 543210 ====== ..xxx. yy...y @param [in] a The input 1D coordinates

A helper function performing a remap 64x1 to 8x8 remapping which is necessary for 2D wave reductions. The 64-wide lane indices to 8x8 remapping is pe

A helper function performing a remap 64x1 to 8x8 remapping which is necessary for 2D wave reductions. The 64-wide lane indices to 8x8 remapping is pe

Clamp a value to a [0..1] range. @param [in] x The value to clamp to [0..1] range. @returns The clamped version of <c><i>x</i></c>. @

Conditional free logic AND NOT operation using two half-precision values. @param [in] x The first value to be fed into the AND NOT operator

Convert a sortable integer to a 32bit floating point value. The function has the side effects that: - If sign bit=1, flip the sign bit (positives). -

Convert a sortable integer to a 16bit floating point value. The function has the side effects that: - If sign bit=1, flip the sign bit (positives). -

Compute the square root of a value. @param [in] x The first value to compute the min of. @returns The the square root of <c><i>x</

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

Compute an SRGB value from a linear value. @param [in] c The value to convert to SRGB from linear. @returns A value in SRGB space. @ingro

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

Conditional free logic AND operation using values. @param [in] x The first value to be fed into the AND operator. @param [in] y T

Conditional free logic AND operation using two half-precision values. @param [in] x The first value to be fed into the AND operator. @param

Conditional free logic AND operation using two values followed by a NOT operation using the resulting value and a third value. @param [in] x

Conditional free logic AND operation using two half-precision values followed by a NOT operation using the resulting value and a third half-precision

Conditional free logic signed NOT operation using two half-precision FfxFloat32 values. @param [in] x The first value to be fed into the AN

Conditional free logic signed NOT operation using two half-precision FfxFloat32 values. @param [in] x The first value to be fed into the AN

Conditional free logic signed NOT operation using two half-precision FfxFloat32 values. @param [in] x The first value to be fed into the AN

Conditional free logic signed NOT operation using two half-precision FfxFloat32 values. @param [in] x The first value to be fed into the AN

Convert a half-precision FfxFloat32 value between 0.0f and 1.0f to a half-precision Uint. @param [in] x The value to converted to a Uint.

Convert a half-precision FfxFloat32 value between 0.0f and 1.0f to a half-precision Uint. @param [in] x The value to converted to a Uint.

Convert a half-precision FfxFloat32 value between 0.0f and 1.0f to a half-precision Uint. @param [in] x The value to converted to a Uint.

Convert a half-precision FfxFloat32 value between 0.0f and 1.0f to a half-precision Uint. @param [in] x The value to converted to a Uint.

Given a value, returns 1.0 if greater than zero and 0.0 if not. @param [in] x The value to be compared. @returns Result of the greater tha

Given a half-precision value, returns 1.0 if greater than zero and 0.0 if not. @param [in] x The value to be compared. @returns Result of

Conditional free logic NOT operation using two half-precision values. @param [in] x The first value to be fed into the NOT operator. @param

Conditional free logic OR operation using two values. @param [in] x The first value to be fed into the OR operator. @param [in] y

Conditional free logic OR operation using two half-precision values. @param [in] x The first value to be fed into the OR operator. @param [

Convert a half-precision FfxUInt32 value between 0 and 1 to a half-precision FfxFloat32. @param [in] x The value to converted to a half-pre

Convert a half-precision FfxUInt32 value between 0 and 1 to a half-precision FfxFloat32. @param [in] x The value to converted to a half-pre

Convert a half-precision FfxUInt32 value between 0 and 1 to a half-precision FfxFloat32. @param [in] x The value to converted to a half-pre

Convert a half-precision FfxUInt32 value between 0 and 1 to a half-precision FfxFloat32. @param [in] x The value to converted to a half-pre