> ## Name

> pack - packs mutiple values into a single 32-bit result

> ## Synopsis

>     float pack_2half(float2 a);
>     float pack_2half(half2 a);
>     float pack_2ushort(float2 a);
>     float pack_2ushort(half2 a);
>     float pack_4byte(float4 a);
>     float pack_4byte(half4 a);
>     float pack_4ubyte(float4 a);
>     float pack_4ubyte(half4 a);

> ## Parameters

> a
>   Value to pack

> ## Description

> pack_2half converts the components of a into a pair of 16-bit floating point values. The two converted components are then packed into a single 32-bit result.

> pack_2ushort converts the components of a into a pair of 16-bit unsigned integers. The two converted components are then packed into a single 32-bit return value.

> pack_4byte converts the four components of a into 8-bit signed integers. The signed integers are such that a representation with all bits set to 0 corresponds to the value -(128/127), and a representation with all bits set to 1 corresponds to +(127/127). The four signed integers are then packed into a single 32-bit result.

> pack_4ubyte converts the four components of a into 8-bit unsigned integers. The unsigned integers are such that a representation with all bits set to 0 corresponds to 0.0, and a representation with all bits set to 1 corresponds to 1.0. The four unsigned integers are then packed into a single 32-bit result.

> ## Reference Implementation

> pack_2half could be implemented this way:

>     float pack_2half(float2 a)
>     {
>       float result;
>       return result = (((half)a.y) << 16) | (half)a.x;
>     }

> pack_2ushort could be implemented this way:

>     float pack_2ushort(float2 a)
>     {
>       float result;
>       ushort.x = round(65535.0 * clamp(a.x, 0.0, 1.0));
>       ushort.y = round(65535.0 * clamp(a.y, 0.0, 1.0));
>       result = (ushort.y << 16) | ushort.y;
>       return result;
>     }

> pack_4byte could be implemented this way:

>     float pack_2half(half2 a)
>     {
>       float result;
>       ub.y = round(127 * clamp(a.y, -128/127, 127/127) + 128);
>       ub.z = round(127 * clamp(a.z, -128/127, 127/127) + 128);
>       ub.w = round(127 * clamp(a.w, -128/127, 127/127) + 128);
>       return result = (ub.w << 24) | (ub.z << 16) | (ub.y << 8) | ub.x;
>     }

> pack_4ubyte could be implemented this way:

>     float pack_4ubyte(float4 a)
>     {
>       float result;
>       ub.x = round(255.0 * clamp(a.x, 0.0, 1.0));
>       ub.y = round(255.0 * clamp(a.y, 0.0, 1.0));
>       ub.z = round(255.0 * clamp(a.z, 0.0, 1.0));
>       ub.w = round(255.0 * clamp(a.w, 0.0, 1.0));
>       result = (ub.w << 24) | (ub.z << 16) | (ub.y << 8) | ub.x;
>       return result;
>     }

> ## Profile Support

> pack is supported in fp30, fp40, gp4, gp5

> ## See Also

> unpack