#[auto_enum(u32, checked)]
/// Resource data formats, including fully-typed and typeless formats. A
/// list of modifiers at the bottom of the page more fully describes each
/// format type.
///
/// ## Remarks
///
/// ### Byte Order (LSB/MSB)
/// Most formats have byte-aligned components, and the components are in
/// C-array order (the least address comes first). For those formats that
/// don't have power-of-2-aligned components, the first named component is
/// in the least-significant bits.
///
/// ### Portable Coding for Endian-Independence
/// Rather than adjusting for whether a system uses big-endian or
/// little-endian byte ordering, you should write portable code, as follows.
///
/// ```
/// # let mut something = [0.0; 4];
/// // Format::R32G32B32A32Float
/// let slice: &mut [f32] = &mut something;
/// slice[0] = 1.0; // R
/// slice[1] = 0.0; // G
/// slice[2] = 0.0; // B
/// slice[3] = 0.5; // A
///
/// // Format::R10G10B10A2Unorm
/// let value: u32 = 0x3ff | (0x1 << 30); // R=0x3ff, and A=0x1
/// ```
///
/// ### Restrictions and notes on formats
///
/// 1. A resource declared with the R32G32B32 family of formats cannot be
/// used simultaneously for vertex and texture data. That is, you may not
/// create a buffer resource with the R32G32B32 family of formats that uses
/// any of the following bind flags: [`VERTEX_BUFFER`][1],
/// [`INDEX_BUFFER`][2], [`CONSTANT_BUFFER`][3], or [`STREAM_OUTPUT`][4].
/// 2. R1Unorm is designed specifically for text filtering,
/// and must be used with a format-specific, configurable 8x8 filter mode.
/// When calling an HLSL sampling function using this format, the address
/// offset parameter must be set to (0,0).
/// 3. A resource using a sub-sampled format (such as [`R8G8_B8G8Unorm`][5])
/// must have a size that is a multiple of 2 in the x dimension.
/// 4. Format is not available in Direct3D 10 and Direct3D 10.1
/// 5. These float formats have an implied 1 added to their mantissa. If
/// the exponent is not 0, 1.0 is added to the mantissa before applying the
/// exponent.
/// 6. These float formats do not have an implied 1 added to their mantissa.
/// 7. Denorm support: the 9, 10, 11 and 16 bit float formats support denorms.
/// 8. No denorm support: the 32 and 64 bit float formats flush denorms to zero.
///
/// The following topics provide lists of the formats that particular
/// hardware [feature levels][6] support:
///
/// * [DXGI Format Support for Direct3D Feature Level 12.1 Hardware][7]
/// * [DXGI Format Support for Direct3D Feature Level 12.0 Hardware][8]
/// * [DXGI Format Support for Direct3D Feature Level 11.1 Hardware][9]
/// * [DXGI Format Support for Direct3D Feature Level 11.0 Hardware][10]
/// * [Hardware Support for Direct3D 10Level9 Formats][11]
/// * [Hardware Support for Direct3D 10.1 Formats][12]
/// * [Hardware Support for Direct3D 10 Formats][13]
///
/// ### Format Modifiers
///
/// Each enumeration value contains a format modifier which describes
/// the data type.
///
/// <table>
/// <tr>
/// <td>Float</td>
/// <td>A floating-point value; 32-bit floating-point formats use IEEE 754
/// single-precision (s23e8 format): sign bit, 8-bit biased (127) exponent,
/// and 23-bit mantissa. 16-bit floating-point formats use half-precision
/// (s10e5 format): sign bit, 5-bit biased (15) exponent, and 10-bit
/// mantissa.</td>
/// </tr>
/// <tr>
/// <td>Sint</td>
/// <td>Two's complement signed integer. For example, a 3-bit Sint
/// represents the values -4, -3, -2, -1, 0, 1, 2, 3.</td>
/// </tr>
/// <tr>
/// <td>Snorm</td>
/// <td>Signed normalized integer; which is interpreted in a resource as a
/// signed integer, and is interpreted in a shader as a signed normalized
/// floating-point value in the range `[-1, 1]`. For an 2's complement
/// number, the maximum value is 1.0f (a 5-bit value `01111` maps to `1.0`),
/// and the minimum value is -1.0f (a 5-bit value `10000` maps to `-1.0`).
/// In addition, the second-minimum number maps to -1.0f (a 5-bit value
/// `10001` maps to `-1.0`). The resulting integer representations are
/// evenly spaced floating-point values in the range `(-1.0...0.0)`, and
/// also a complementary set of representations for numbers in the range
/// `(0.0f...1.0f)`.</td>
/// </tr>
/// <tr>
/// <td>Srgb</td>
/// <td>Standard RGB data, which roughly displays colors in a linear ramp of
/// luminosity levels such that an average observer, under average viewing
/// conditions, can view them on an average display.
///
/// All 0's maps to 0.0f, and all 1's maps to 1.0f. The sequence of unsigned
/// integer encodings between all 0's and all 1's represent a nonlinear
/// progression in the floating-point interpretation of the numbers between
/// 0.0f to 1.0f. For more detail, see the SRGB color standard, IEC
/// 61996-2-1, at IEC (International Electrotechnical Commission).</td>
/// </tr>
/// <tr>
/// <td>Typeless</td>
/// <td>Typeless data, with a defined number of bits. Typeless formats are
/// designed for creating typeless resources; that is, a resource whose size
/// is known, but whose data type is not yet fully defined. When a typeless
/// resource is bound to a shader, the application or shader must resolve
/// the format type (which must match the number of bits per component in
/// the typeless format).
///
/// A typeless format contains one or more subformats; each subformat
/// resolves the data type. For example, in the R32G32B32 group, which
/// defines types for three-component 96-bit data, there is one typeless
/// format and three fully typed subformats.</td>
/// </tr>
/// <tr>
/// <td>Uint</td>
/// <td>Unsigned integer. For instance, a 3-bit UINT represents the values
/// 0, 1, 2, 3, 4, 5, 6, 7.</td>
/// </tr>
/// <tr>
/// <td>Unorm</td>
/// <td>Unsigned normalized integer; which is interpreted in a resource as
/// an unsigned integer, and is interpreted in a shader as an unsigned
/// normalized floating-point value in the range [0, 1]. All 0's maps to
/// 0.0f, and all 1's maps to 1.0f. A sequence of evenly spaced
/// floating-point values from 0.0f to 1.0f are represented. For instance,
/// a 2-bit UNORM represents 0.0f, 1/3, 2/3, and 1.0f.</td>
/// </tr>
/// <tr>
/// <td>SharedExponent</td>
/// <td>A shared exponent. All the floating point representations in the
/// format share the one exponent.</td>
/// </tr>
/// </table>
///
/// ### New Resource Formats
///
/// Direct3D 10 offers new data compression formats for compressing
/// high-dynamic range (HDR) lighting data, normal maps and heightfields
/// to a fraction of their original size. These compression types include:
///
/// * Shared-Exponent high-dynamic range (HDR) format (RGBE)
/// * New Block-Compressed 1-2 channel Unorm/Snorm formats
///
/// The block compression formats can be used for any of the 2D or 3D
/// texture types (Texture2D, Texture2DArray, Texture3D, or TextureCube)
/// including mipmap surfaces. The block compression techniques require
/// texture dimensions to be a multiple of 4 (since the implementation
/// compresses on blocks of 4x4 texels). In the texture sampler, compressed
/// formats are always decompressed before texture filtering.
///
/// [1]: struct.BindFlags.html#VERTEX_BUFFER
/// [2]: struct.BindFlags.html#INDEX_BUFFER
/// [3]: struct.BindFlags.html#CONSTANT_BUFFER
/// [4]: struct.BindFlags.html#STREAM_OUTPUT
/// [5]: #variant.R8G8_B8G8Unorm
/// [6]: https://msdn.microsoft.com/en-us/library/windows/desktop/ff476876(v=vs.85).aspx#Overview
/// [7]: https://msdn.microsoft.com/en-us/library/windows/desktop/mt426648(v=vs.85).aspx
/// [8]: https://msdn.microsoft.com/en-us/library/windows/desktop/mt426647(v=vs.85).aspx
/// [9]: https://msdn.microsoft.com/en-us/library/windows/desktop/mt427456(v=vs.85).aspx
/// [10]: https://msdn.microsoft.com/en-us/library/windows/desktop/mt427455(v=vs.85).aspx
/// [11]: https://msdn.microsoft.com/en-us/library/windows/desktop/ff471324(v=vs.85).aspx
/// [12]: https://msdn.microsoft.com/en-us/library/windows/desktop/cc627091(v=vs.85).aspx
/// [13]: https://msdn.microsoft.com/en-us/library/windows/desktop/cc627090(v=vs.85).aspx
pub enum Format {
    /// The format is not known.
    Unknown = 0,
    /// A four-component, 128-bit typeless format that supports 32 bits per
    /// channel including alpha.
    /// <sup>[1](#restrictions-and-notes-on-formats)</sup>
    R32G32B32A32Typeless = 1,

    /// A four-component, 128-bit floating-point format that supports 32
    /// bits per channel including alpha.
    /// <sup>[1,5,8](#restrictions-and-notes-on-formats)</sup>
    R32G32B32A32Float = 2,

    /// A four-component, 128-bit unsigned-integer format that supports 32
    /// bits per channel including alpha.
    /// <sup>[1](#restrictions-and-notes-on-formats)</sup>
    R32G32B32A32Uint = 3,

    /// A four-component, 128-bit signed-integer format that supports 32
    /// bits per channel including alpha.
    /// <sup>[1](#restrictions-and-notes-on-formats)</sup>
    R32G32B32A32Sint = 4,

    /// A three-component, 96-bit typeless format that supports 32 bits per
    /// color channel.
    R32G32B32Typeless = 5,

    /// A three-component, 96-bit floating-point format that supports 32
    /// bits per color channel.
    /// <sup>[5,8](#restrictions-and-notes-on-formats)</sup>
    R32G32B32Float = 6,

    /// A three-component, 96-bit unsigned-integer format that supports 32
    /// bits per color channel.
    R32G32B32Uint = 7,

    /// A three-component, 96-bit signed-integer format that supports 32
    /// bits per color channel.
    R32G32B32Sint = 8,

    /// A four-component, 64-bit typeless format that supports 16 bits per
    /// channel including alpha.
    R16G16B16A16Typeless = 9,

    /// A four-component, 64-bit floating-point format that supports 16
    /// bits per channel including alpha.
    /// <sup>[5,7](#restrictions-and-notes-on-formats)</sup>
    R16G16B16A16Float = 10,

    /// A four-component, 64-bit unsigned-normalized-integer format that
    /// supports 16 bits per channel including alpha.
    R16G16B16A16Unorm = 11,

    /// A four-component, 64-bit unsigned-integer format that supports 16
    /// bits per channel including alpha.
    R16G16B16A16Uint = 12,

    /// A four-component, 64-bit signed-normalized-integer format that
    /// supports 16 bits per channel including alpha.
    R16G16B16A16Snorm = 13,

    /// A four-component, 64-bit signed-integer format that supports 16
    /// bits per channel including alpha.
    R16G16B16A16Sint = 14,

    /// A two-component, 64-bit typeless format that supports 32 bits for
    /// the red channel and 32 bits for the green channel.
    R32G32Typeless = 15,

    /// A two-component, 64-bit floating-point format that supports 32 bits
    /// for the red channel and 32 bits for the green channel.
    /// <sup>[5,8](#restrictions-and-notes-on-formats)</sup>
    R32G32Float = 16,

    /// A two-component, 64-bit unsigned-integer format that supports 32
    /// bits for the red channel and 32 bits for the green channel.
    R32G32Uint = 17,

    /// A two-component, 64-bit signed-integer format that supports 32 bits
    /// for the red channel and 32 bits for the green channel.
    R32G32Sint = 18,

    /// A two-component, 64-bit typeless format that supports 32 bits for
    /// the red channel, 8 bits for the green channel, and 24 bits are unused.
    R32G8X24Typeless = 19,

    /// A 32-bit floating-point component, and two unsigned-integer
    /// components (with an additional 32 bits). This format supports
    /// 32-bit depth, 8-bit stencil, and 24 bits are unused.
    /// <sup>[5](#restrictions-and-notes-on-formats)</sup>
    D32FloatS8X24Uint = 20,

    /// A 32-bit floating-point component, and two typeless components
    /// (with an additional 32 bits). This format supports 32-bit red
    /// channel, 8 bits are unused, and 24 bits are unused.
    /// <sup>[5](#restrictions-and-notes-on-formats)</sup>
    R32FloatX8X24Typeless = 21,

    /// A 32-bit typeless component, and two unsigned-integer components
    /// (with an additional 32 bits). This format has 32 bits unused, 8
    /// bits for green channel, and 24 bits are unused.
    X32TypelessG8X24Uint = 22,

    /// A four-component, 32-bit typeless format that supports 10 bits for
    /// each color and 2 bits for alpha.
    R10G10B10A2Typeless = 23,

    /// A four-component, 32-bit unsigned-normalized-integer format that
    /// supports 10 bits for each color and 2 bits for alpha.
    R10G10B10A2Unorm = 24,

    /// A four-component, 32-bit unsigned-integer format that supports 10
    /// bits for each color and 2 bits for alpha.
    R10G10B10A2Uint = 25,

    /// Three partial-precision floating-point numbers encoded into a single
    /// 32-bit value (a variant of s10e5, which is sign bit, 10-bit mantissa,
    /// and 5-bit biased (15) exponent). There are no sign bits, and there
    /// is a 5-bit biased (15) exponent for each channel, 6-bit mantissa for
    /// R and G, and a 5-bit mantissa for B, as shown in the following
    /// illustration.
    /// <sup>[5,7](#restrictions-and-notes-on-formats)</sup>
    ///
    /// ![Illustration of the bits in three partial-precision floating point numbers][1]
    ///
    /// [1]: https://msdn.microsoft.com/dynimg/IC534131.png
    R11G11B10Float = 26,

    /// A four-component, 32-bit typeless format that supports 8 bits per
    /// channel including alpha.
    R8G8B8A8Typeless = 27,

    /// A four-component, 32-bit unsigned-normalized-integer format that
    /// supports 8 bits per channel including alpha.
    R8G8B8A8Unorm = 28,

    /// A four-component, 32-bit unsigned-normalized integer sRGB format
    /// that supports 8 bits per channel including alpha.
    R8G8B8A8UnormSrgb = 29,

    /// A four-component, 32-bit unsigned-integer format that supports 8
    /// bits per channel including alpha.
    R8G8B8A8Uint = 30,

    /// A four-component, 32-bit signed-normalized-integer format that
    /// supports 8 bits per channel including alpha.
    R8G8B8A8Snorm = 31,

    /// A four-component, 32-bit signed-integer format that supports 8
    /// bits per channel including alpha.
    R8G8B8A8Sint = 32,

    /// A two-component, 32-bit typeless format that supports 16 bits for
    /// the red channel and 16 bits for the green channel.
    R16G16Typeless = 33,

    /// A two-component, 32-bit floating-point format that supports 16
    /// bits for the red channel and 16 bits for the green channel.
    /// <sup>[5,7](#restrictions-and-notes-on-formats)</sup>
    R16G16Float = 34,

    /// A two-component, 32-bit unsigned-normalized-integer format that
    /// supports 16 bits each for the green and red channels.
    R16G16Unorm = 35,

    /// A two-component, 32-bit unsigned-integer format that supports 16
    /// bits for the red channel and 16 bits for the green channel.
    R16G16Uint = 36,

    /// A two-component, 32-bit signed-normalized-integer format that
    /// supports 16 bits for the red channel and 16 bits for the green
    /// channel.
    R16G16Snorm = 37,

    /// A two-component, 32-bit signed-integer format that supports 16
    /// bits for the red channel and 16 bits for the green channel.
    R16G16Sint = 38,

    /// A single-component, 32-bit typeless format that supports 32 bits
    /// for the red channel.
    R32Typeless = 39,

    /// A single-component, 32-bit floating-point format that supports 32
    /// bits for depth.
    /// <sup>[5,8](#restrictions-and-notes-on-formats)</sup>
    D32Float = 40,

    /// A single-component, 32-bit floating-point format that supports 32
    /// bits for the red channel.
    /// <sup>[5,8](#restrictions-and-notes-on-formats)</sup>
    R32Float = 41,

    /// A single-component, 32-bit unsigned-integer format that supports 32
    /// bits for the red channel.
    R32Uint = 42,

    /// A single-component, 32-bit signed-integer format that supports 32
    /// bits for the red channel.
    R32Sint = 43,

    /// A two-component, 32-bit typeless format that supports 24 bits for
    /// the red channel and 8 bits for the green channel.
    R24G8Typeless = 44,

    /// A 32-bit z-buffer format that supports 24 bits for depth and 8 bits
    /// for stencil.
    D24UnormS8Uint = 45,

    /// A 32-bit format, that contains a 24 bit, single-component,
    /// unsigned-normalized integer, with an additional typeless 8 bits.
    /// This format has 24 bits red channel and 8 bits unused.
    R24UnormX8Typeless = 46,

    /// A 32-bit format, that contains a 24 bit, single-component, typeless
    /// format, with an additional 8 bit unsigned integer component. This
    /// format has 24 bits unused and 8 bits green channel.
    X24TypelessG8Uint = 47,

    /// A two-component, 16-bit typeless format that supports 8 bits for
    /// the red channel and 8 bits for the green channel.
    R8G8Typeless = 48,

    /// A two-component, 16-bit unsigned-normalized-integer format that
    /// supports 8 bits for the red channel and 8 bits for the green
    /// channel.
    R8G8Unorm = 49,

    /// A two-component, 16-bit unsigned-integer format that supports 8
    /// bits for the red channel and 8 bits for the green channel.
    R8G8Uint = 50,

    /// A two-component, 16-bit signed-normalized-integer format that
    /// supports 8 bits for the red channel and 8 bits for the green
    /// channel.
    R8G8Snorm = 51,

    /// A two-component, 16-bit signed-integer format that supports 8 bits
    /// for the red channel and 8 bits for the green channel.
    R8G8Sint = 52,

    /// A single-component, 16-bit typeless format that supports 16 bits
    /// for the red channel.
    R16Typeless = 53,

    /// A single-component, 16-bit floating-point format that supports 16
    /// bits for the red channel.
    /// <sup>[5,7](#restrictions-and-notes-on-formats)</sup>
    R16Float = 54,

    /// A single-component, 16-bit unsigned-normalized-integer format that
    /// supports 16 bits for depth.
    D16Unorm = 55,

    /// A single-component, 16-bit unsigned-normalized-integer format that
    /// supports 16 bits for the red channel.
    R16Unorm = 56,

    /// A single-component, 16-bit unsigned-integer format that supports
    /// 16 bits for the red channel.
    R16Uint = 57,

    /// A single-component, 16-bit signed-normalized-integer format that
    /// supports 16 bits for the red channel.
    R16Snorm = 58,

    /// A single-component, 16-bit signed-integer format that supports 16
    /// bits for the red channel.
    R16Sint = 59,

    /// A single-component, 8-bit typeless format that supports 8 bits for
    /// the red channel.
    R8Typeless = 60,

    /// A single-component, 8-bit unsigned-normalized-integer format that
    /// supports 8 bits for the red channel.
    R8Unorm = 61,

    /// A single-component, 8-bit unsigned-integer format that supports 8
    /// bits for the red channel.
    R8Uint = 62,

    /// A single-component, 8-bit signed-normalized-integer format that
    /// supports 8 bits for the red channel.
    R8Snorm = 63,

    /// A single-component, 8-bit signed-integer format that supports 8
    /// bits for the red channel.
    R8Sint = 64,

    /// A single-component, 8-bit unsigned-normalized-integer format for
    /// alpha only.
    A8Unorm = 65,

    /// A single-component, 1-bit unsigned-normalized integer format that
    /// supports 1 bit for the red channel.
    /// <sup>[2](#restrictions-and-notes-on-formats)</sup>
    R1Unorm = 66,

    /// Three partial-precision floating-point numbers encoded into a
    /// single 32-bit value all sharing the same 5-bit exponent (variant
    /// of s10e5, which is sign bit, 10-bit mantissa, and 5-bit biased
    /// (15) exponent). There is no sign bit, and there is a shared 5-bit
    /// biased (15) exponent and a 9-bit mantissa for each channel, as
    /// shown in the following illustration.
    /// <sup>[2,6,7](#restrictions-and-notes-on-formats)</sup>
    ///
    /// ![Illustration of the bits in the three partial-precision floating-point numbers][1]
    ///
    /// [1]: https://msdn.microsoft.com/dynimg/IC534132.png
    R9G9B9E5SharedExponent = 67,

    /// A four-component, 32-bit unsigned-normalized-integer format. This
    /// packed RGB format is analogous to the UYVY format. Each 32-bit
    /// block describes a pair of pixels: (R8, G8, B8) and (R8, G8, B8)
    /// where the R8/B8 values are repeated, and the G8 values are unique
    /// to each pixel.
    /// <sup>[3](#restrictions-and-notes-on-formats)</sup>
    ///
    /// Width must be even.
    #[allow(non_camel_case_types)]
    R8G8_B8G8Unorm = 68,

    /// A four-component, 32-bit unsigned-normalized-integer format. This
    /// packed RGB format is analogous to the YUY2 format. Each 32-bit
    /// block describes a pair of pixels: (R8, G8, B8) and (R8, G8, B8)
    /// where the R8/B8 values are repeated, and the G8 values are unique
    /// to each pixel.
    /// <sup>[3](#restrictions-and-notes-on-formats)</sup>
    ///
    /// Width must be even.
    #[allow(non_camel_case_types)]
    G8R8_G8B8Unorm = 69,

    /// Four-component typeless block-compression format.
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc1Typeless = 70,

    /// Four-component block-compression format.
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc1Unorm = 71,

    /// Four-component block-compression format for sRGB data.
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc1UnormSrgb = 72,

    /// Four-component typeless block-compression format.
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc2Typeless = 73,

    /// Four-component block-compression format.
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc2Unorm = 74,

    /// Four-component block-compression format for sRGB data.
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc2UnormSrgb = 75,

    /// Four-component typeless block-compression format.
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc3Typeless = 76,

    /// Four-component block-compression format.
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc3Unorm = 77,

    /// Four-component block-compression format for sRGB data.
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc3UnormSrgb = 78,

    /// One-component typeless block-compression format.
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc4Typeless = 79,

    /// One-component block-compression format.
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc4Unorm = 80,

    /// One-component block-compression format.
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc4Snorm = 81,

    /// Two-component typeless block-compression format.
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc5Typeless = 82,

    /// Two-component block-compression format.
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc5Unorm = 83,

    /// Two-component block-compression format.
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc5Snorm = 84,

    /// A three-component, 16-bit unsigned-normalized-integer format that
    /// supports 5 bits for blue, 6 bits for green, and 5 bits for red.
    ///
    /// **Direct3D 10 through Direct3D 11:** This value is defined for
    /// DXGI. However, Direct3D 10, 10.1, or 11 devices do not support
    /// this format.
    ///
    /// **Direct3D 11.1:** This value is not supported until Windows 8.
    B5G6R5Unorm = 85,

    /// A four-component, 16-bit unsigned-normalized-integer format that
    /// supports 5 bits for each color channel and 1-bit alpha.
    ///
    /// **Direct3D 10 through Direct3D 11:** This value is defined for
    /// DXGI. However, Direct3D 10, 10.1, or 11 devices do not support
    /// this format.
    ///
    /// **Direct3D 11.1:** This value is not supported until Windows 8.
    B5G5R5A1Unorm = 86,

    /// A four-component, 32-bit unsigned-normalized-integer format that
    /// supports 8 bits for each color channel and 8-bit alpha.
    B8G8R8A8Unorm = 87,

    /// A four-component, 32-bit unsigned-normalized-integer format that
    /// supports 8 bits for each color channel and 8 bits unused.
    B8G8R8X8Unorm = 88,

    /// A four-component, 32-bit 2.8-biased fixed-point format that
    /// supports 10 bits for each color channel and 2-bit alpha.
    R10G10B10XrBiasA2Unorm = 89,

    /// A four-component, 32-bit typeless format that supports 8 bits
    /// for each channel including alpha.
    /// <sup>[4](#restrictions-and-notes-on-formats)</sup>
    B8G8R8A8Typeless = 90,

    /// A four-component, 32-bit unsigned-normalized standard RGB format
    /// that supports 8 bits for each channel including alpha.
    /// <sup>[3](#restrictions-and-notes-on-formats)</sup>
    B8G8R8A8UnormSrgb = 91,

    /// A four-component, 32-bit typeless format that supports 8 bits for
    /// each color channel, and 8 bits are unused.
    /// <sup>[3](#restrictions-and-notes-on-formats)</sup>
    B8G8R8X8Typeless = 92,

    /// A four-component, 32-bit unsigned-normalized standard RGB format
    /// that supports 8 bits for each color channel, and 8 bits are unused.
    /// <sup>[3](#restrictions-and-notes-on-formats)</sup>
    B8G8R8X8UnormSrgb = 93,

    /// A typeless block-compression format.
    /// <sup>[4](#restrictions-and-notes-on-formats)</sup>
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc6hTypeless = 94,

    /// A block-compression format.
    /// <sup>[4](#restrictions-and-notes-on-formats)</sup>
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    /// <sup>[5](#restrictions-and-notes-on-formats)</sup>
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc6hUf16 = 95,

    /// A block-compression format.
    /// <sup>[4](#restrictions-and-notes-on-formats)</sup>
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    /// <sup>[5](#restrictions-and-notes-on-formats)</sup>
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc6hSf16 = 96,

    /// A typeless block-compression format.
    /// <sup>[4](#restrictions-and-notes-on-formats)</sup>
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc7Typeless = 97,

    /// A block-compression format.
    /// <sup>[4](#restrictions-and-notes-on-formats)</sup>
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc7Unorm = 98,

    /// A block-compression format.
    /// <sup>[4](#restrictions-and-notes-on-formats)</sup>
    /// For information about block-compression formats, see
    /// [Texture Block Compression in Direct3D 11.][1]
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955(v=vs.85).aspx
    Bc7UnormSrgb = 99,

    /// Most common YUV 4:4:4 video resource format. Valid view formats
    /// for this video resource format are
    /// [R8G8B8A8Unorm](#variant.R8G8B8A8Unorm) and
    /// [R8G8B8A8Uint](#variant.R8G8B8A8Uint). For UAVs, an additional
    /// valid view format is [R32Uint](#variant.R32Uint). By using
    /// [R32Uint](#variant.R32Uint) for UAVs, you can both read and write
    /// as opposed to just write for [R8G8B8A8Unorm](#variant.R8G8B8A8Unorm)
    /// and [R8G8B8A8Uint](#variant.R8G8B8A8Uint). Supported view types are
    /// SRV, RTV, and UAV. One view provides a straightforward mapping of
    /// the entire surface. The mapping to the view channel is V->R8, U->G8,
    /// Y->B8, and A->A8.
    ///
    /// For more info about YUV formats for video rendering, see
    /// [Recommended 8-Bit YUV Formats for Video Rendering.][1]
    ///
    /// **Direct3D 11.1:** This value is not supported until Windows 8.
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/dd206750(v=vs.85).aspx
    Ayuv = 100,

    /// 10-bit per channel packed YUV 4:4:4 video resource format. Valid
    /// view formats for this video resource format are
    /// [R10G10B10A2Unorm](#variant.R10G10B10A2Unorm) and
    /// [R10G10B10A2Uint](#variant.R10G10B10A2Uint). For UAVs, an additional
    /// valid view format is [R32Uint](#variant.R32Uint). By using
    /// [R32Uint](#variant.R32Uint) for UAVs, you can both read and write as
    /// opposed to just write for [R10G10B10A2Unorm](#variant.R10G10B10A2Unorm)
    /// and [R10G10B10A2Uint](#variant.R10G10B10A2Uint). Supported view types
    /// are SRV and UAV. One view provides a straightforward mapping of the
    /// entire surface. The mapping to the view channel is U->R10, Y->G10,
    /// V->B10, and A->A2.
    ///
    /// For more info about YUV formats for video rendering, see
    /// [Recommended 8-Bit YUV Formats for Video Rendering.][1]
    ///
    /// **Direct3D 11.1:** This value is not supported until Windows 8.
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/dd206750(v=vs.85).aspx
    Y410 = 101,

    /// 16-bit per channel packed YUV 4:4:4 video resource format. Valid
    /// view formats for this video resource format are
    /// [R16G16B16A16Unorm](#variant.R16G16B16A16Unorm) and
    /// [R16G16B16A16Uint](#variant.R16G16B16A16Uint). Supported view types
    /// are SRV and UAV. One view provides a straightforward mapping of the
    /// entire surface. The mapping to the view channel is U->R16, Y->G16,
    /// V->B16, and A->A16.
    ///
    /// For more info about YUV formats for video rendering, see
    /// [Recommended 8-Bit YUV Formats for Video Rendering.][1]
    ///
    /// **Direct3D 11.1:** This value is not supported until Windows 8.
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/dd206750(v=vs.85).aspx
    Y416 = 102,

    /// Most common YUV 4:2:0 video resource format. Valid luminance data
    /// view formats for this video resource format are
    /// [R8Unorm](#variant.R8Unorm) and [R8Uint](#variant.R8Uint). Valid
    /// chrominance data view formats (width and height are each 1/2 of
    /// luminance view) for this video resource format are
    /// [R8G8Unorm](#variant.R8G8Unorm) and [R8G8Uint](#variant.R8G8Uint).
    /// Supported view types are SRV, RTV, and UAV. For luminance data view,
    /// the mapping to the view channel is Y->R8. For chrominance data view,
    /// the mapping to the view channel is U->R8 and V->G8.
    ///
    /// For more info about YUV formats for video rendering, see
    /// [Recommended 8-Bit YUV Formats for Video Rendering.][1]
    ///
    /// Width and height must be even. Direct3D 11 staging resources and
    /// initData parameters for this format use
    /// `(rowPitch * (height + (height / 2)))` bytes. The first
    /// `(SysMemPitch * height)` bytes are the Y plane, the remaining
    /// `(SysMemPitch * (height / 2))` bytes are the UV plane.
    ///
    /// An app using the YUY 4:2:0 formats must map the luma (Y) plane
    /// separately from the chroma (UV) planes. Developers do this by
    /// calling [ID3D12Device::CreateShaderResourceView][2] twice for the
    /// same texture and passing in 1-channel and 2-channel formats.
    /// Passing in a 1-channel format compatible with the Y plane maps
    /// only the Y plane. Passing in a 2-channel format compatible with
    /// the UV planes (together) maps only the U and V planes as a single
    /// resource view.
    ///
    /// **Direct3D 11.1:** This value is not supported until Windows 8.
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/dd206750(v=vs.85).aspx
    /// [2]: https://msdn.microsoft.com/en-us/library/windows/desktop/dn788672(v=vs.85).aspx
    Nv12 = 103,

    /// 10-bit per channel planar YUV 4:2:0 video resource format. Valid
    /// luminance data view formats for this video resource format are
    /// [R16Unorm](#variant.R16Unorm) and [R16Uint](#variant.R16Uint).
    /// The runtime does not enforce whether the lowest 6 bits are 0
    /// (given that this video resource format is a 10-bit format that
    /// uses 16 bits). If required, application shader code would have to
    /// enforce this manually. From the runtime's point of view,
    /// [P010](#variant.P010) is no different than [P016](#variant.P016).
    /// Valid chrominance data view formats (width and height are each 1/2
    /// of luminance view) for this video resource format are
    /// [R16G16Unorm](#variant.R16G16Unorm) and
    /// [R16G16Uint](#variant.R16G16Uint). For UAVs, an additional valid
    /// chrominance data view format is [R32Uint](#variant.R32Uint). By
    /// using [R32Uint](#variant.R32Uint) for UAVs, you can both read and
    /// write as opposed to just write for
    /// [R16G16Unorm](#variant.R16G16Unorm) and
    /// [R16G16Uint](#variant.R16G16Uint). Supported view types are SRV,
    /// RTV, and UAV. For luminance data view, the mapping to the view
    /// channel is Y->R16. For chrominance data view, the mapping to the
    /// view channel is U->R16 and V->G16.
    ///
    /// For more info about YUV formats for video rendering, see
    /// [Recommended 8-Bit YUV Formats for Video Rendering.][1]
    ///
    /// Width and height must be even. Direct3D 11 staging resources and
    /// initData parameters for this format use
    /// `(rowPitch * (height + (height / 2)))` bytes. The first
    /// `(SysMemPitch * height)` bytes are the Y plane, the remaining
    /// `(SysMemPitch * (height / 2))` bytes are the UV plane.
    ///
    /// An app using the YUY 4:2:0 formats must map the luma (Y) plane
    /// separately from the chroma (UV) planes. Developers do this by
    /// calling [ID3D12Device::CreateShaderResourceView][2] twice for the
    /// same texture and passing in 1-channel and 2-channel formats.
    /// Passing in a 1-channel format compatible with the Y plane maps
    /// only the Y plane. Passing in a 2-channel format compatible with
    /// the UV planes (together) maps only the U and V planes as a single
    /// resource view.
    ///
    /// **Direct3D 11.1:** This value is not supported until Windows 8.
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/dd206750(v=vs.85).aspx
    /// [2]: https://msdn.microsoft.com/en-us/library/windows/desktop/dn788672(v=vs.85).aspx
    P010 = 104,

    /// 16-bit per channel planar YUV 4:2:0 video resource format. Valid
    /// luminance data view formats for this video resource format are
    /// [R16Unorm](#variant.R16Unorm) and [R16Uint](#variant.R16Uint).
    /// Valid chrominance data view formats (width and height are each 1/2
    /// of luminance view) for this video resource format are
    /// [R16G16Unorm](#variant.R16G16Unorm) and
    /// [R16G16Uint](#variant.R16G16Uint). For UAVs, an additional valid
    /// chrominance data view format is [R32Uint](#variant.R32Uint). By
    /// using [R32Uint](#variant.R32Uint) for UAVs, you can both read and
    /// write as opposed to just write for
    /// [R16G16Unorm](#variant.R16G16Unorm) and
    /// [R16G16Uint](#variant.R16G16Uint). Supported view types are SRV,
    /// RTV, and UAV. For luminance data view, the mapping to the view
    /// channel is Y->R16. For chrominance data view, the mapping to the
    /// view channel is U->R16 and V->G16.
    ///
    /// For more info about YUV formats for video rendering, see
    /// [Recommended 8-Bit YUV Formats for Video Rendering.][1]
    ///
    /// Width and height must be even. Direct3D 11 staging resources and
    /// initData parameters for this format use
    /// `(rowPitch * (height + (height / 2)))` bytes. The first
    /// `(SysMemPitch * height)` bytes are the Y plane, the remaining
    /// `(SysMemPitch * (height / 2))` bytes are the UV plane.
    ///
    /// An app using the YUY 4:2:0 formats must map the luma (Y) plane
    /// separately from the chroma (UV) planes. Developers do this by
    /// calling [ID3D12Device::CreateShaderResourceView][2] twice for the
    /// same texture and passing in 1-channel and 2-channel formats.
    /// Passing in a 1-channel format compatible with the Y plane maps
    /// only the Y plane. Passing in a 2-channel format compatible with
    /// the UV planes (together) maps only the U and V planes as a single
    /// resource view.
    ///
    /// **Direct3D 11.1:** This value is not supported until Windows 8.
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/dd206750(v=vs.85).aspx
    /// [2]: https://msdn.microsoft.com/en-us/library/windows/desktop/dn788672(v=vs.85).aspx
    P016 = 105,

    /// 8-bit per channel planar YUV 4:2:0 video resource format. This
    /// format is subsampled where each pixel has its own Y value, but
    /// each 2x2 pixel block shares a single U and V value. The runtime
    /// requires that the width and height of all resources that are
    /// created with this format are multiples of 2. The runtime also
    /// requires that the left, right, top, and bottom members of any
    /// `RECT` that are used for this format are multiples of 2. This
    /// format differs from [Nv12](#variant.Nv12) in that the layout of
    /// the data within the resource is completely opaque to applications.
    /// Applications cannot use the CPU to map the resource and then
    /// access the data within the resource. You cannot use shaders with
    /// this format. Because of this behavior, legacy hardware that
    /// supports a non-NV12 4:2:0 layout (for example, YV12, and so on)
    /// can be used. Also, new hardware that has a 4:2:0 implementation
    /// better than NV12 can be used when the application does not need
    /// the data to be in a standard layout.
    ///
    /// For more info about YUV formats for video rendering, see
    /// [Recommended 8-Bit YUV Formats for Video Rendering.][1]
    ///
    /// Width and height must be even. Direct3D 11 staging resources and
    /// initData parameters for this format use
    /// `(rowPitch * (height + (height / 2)))` bytes. The first
    /// `(SysMemPitch * height)` bytes are the Y plane, the remaining
    /// `(SysMemPitch * (height / 2))` bytes are the UV plane.
    ///
    /// An app using the YUY 4:2:0 formats must map the luma (Y) plane
    /// separately from the chroma (UV) planes. Developers do this by
    /// calling [ID3D12Device::CreateShaderResourceView][2] twice for the
    /// same texture and passing in 1-channel and 2-channel formats.
    /// Passing in a 1-channel format compatible with the Y plane maps
    /// only the Y plane. Passing in a 2-channel format compatible with
    /// the UV planes (together) maps only the U and V planes as a single
    /// resource view.
    ///
    /// **Direct3D 11.1:** This value is not supported until Windows 8.
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/dd206750(v=vs.85).aspx
    /// [2]: https://msdn.microsoft.com/en-us/library/windows/desktop/dn788672(v=vs.85).aspx
    Yuv420Opaque = 106,

    /// Most common YUV 4:2:2 video resource format. Valid view formats
    /// for this video resource format are
    /// [R8G8B8A8Unorm](#variant.R8G8B8A8Unorm) and
    /// [R8G8B8A8Uint](#variant.R8G8B8A8Uint). For UAVs, an additional
    /// valid view format is [R32Uint](#variant.R32Uint). By using
    /// [R32Uint](#variant.R32Uint) for UAVs, you can both read and write
    /// as opposed to just write for
    /// [R8G8B8A8Unorm](#variant.R8G8B8A8Unorm) and
    /// [R8G8B8A8Uint](#variant.R8G8B8A8Uint). Supported view types are
    /// SRV and UAV. One view provides a straightforward mapping of the
    /// entire surface. The mapping to the view channel is Y0->R8, U0->G8,
    /// Y1->B8, and V0->A8.
    ///
    /// A unique valid view format for this video resource format is
    /// [R8G8_B8G8Unorm](#variant.R8G8_B8G8Unorm). With this view format,
    /// the width of the view appears to be twice what the
    /// [R8G8B8A8Unorm](#variant.R8G8B8A8Unorm) or
    /// [R8G8B8A8Uint](#variant.R8G8B8A8Uint) view would be when hardware
    /// reconstructs RGBA automatically on read and before filtering. This
    /// Direct3D hardware behavior is legacy and is likely not useful any
    /// more. With this view format, the mapping to the view channel is
    /// Y0->R8, U0->G8[0], Y1->B8, and V0->G8[1].
    ///
    /// For more info about YUV formats for video rendering, see
    /// [Recommended 8-Bit YUV Formats for Video Rendering.][1]
    ///
    /// Width must be even.
    ///
    /// **Direct3D 11.1:** This value is not supported until Windows 8.
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/dd206750(v=vs.85).aspx
    Yuy2 = 107,

    /// 10-bit per channel packed YUV 4:2:2 video resource format. Valid
    /// view formats for this video resource format are
    /// [R16G16B16A16Unorm](#variant.R16G16B16A16Unorm) and
    /// [R16G16B16A16Uint](#variant.R16G16B16A16Uint). The runtime does
    /// not enforce whether the lowest 6 bits are 0 (given that this video
    /// resource format is a 10-bit format that uses 16 bits). If required,
    /// application shader code would have to enforce this manually. From
    /// the runtime's point of view, [Y210](#variant.Y210) is no different
    /// than [Y216](#variant.Y216). Supported view types are SRV and UAV.
    /// One view provides a straightforward mapping of the entire surface.
    /// The mapping to the view channel is Y0->R16, U->G16, Y1->B16, and
    /// V->A16.
    ///
    /// For more info about YUV formats for video rendering, see
    /// [Recommended 8-Bit YUV Formats for Video Rendering.][1]
    ///
    /// Width must be even.
    ///
    /// **Direct3D 11.1:** This value is not supported until Windows 8.
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/dd206750(v=vs.85).aspx
    Y210 = 108,

    /// 16-bit per channel packed YUV 4:2:2 video resource format. Valid
    /// view formats for this video resource format are
    /// [R16G16B16A16Unorm](#variant.R16G16B16A16Unorm) and
    /// [R16G16B16A16Uint](#variant.R16G16B16A16Uint). Supported view types
    /// are SRV and UAV. One view provides a straightforward mapping of the
    /// entire surface. The mapping to the view channel is Y0->R16, U->G16,
    /// Y1->B16, and V->A16.
    ///
    /// For more info about YUV formats for video rendering, see
    /// [Recommended 8-Bit YUV Formats for Video Rendering.][1]
    ///
    /// Width must be even.
    ///
    /// **Direct3D 11.1:** This value is not supported until Windows 8.
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/dd206750(v=vs.85).aspx
    Y216 = 109,

    /// Most common planar YUV 4:1:1 video resource format. Valid luminance
    /// data view formats for this video resource format are
    /// [R8Unorm](#variant.R8Unorm) and [R8Uint](#variant.R8Uint). Valid
    /// chrominance data view formats (width and height are each 1/4 of
    /// luminance view) for this video resource format are
    /// [R8G8Unorm](#variant.R8G8Unorm) and [R8G8Uint](#variant.R8G8Uint).
    /// Supported view types are SRV, RTV, and UAV. For luminance data
    /// view, the mapping to the view channel is Y->R8. For chrominance
    /// data view, the mapping to the view channel is U->R8 and V->G8.
    ///
    /// For more info about YUV formats for video rendering, see
    /// [Recommended 8-Bit YUV Formats for Video Rendering.][1]
    ///
    /// Width must be a multiple of 4. Direct3D11 staging resources and
    /// initData parameters for this format use `(rowPitch * height * 2)`
    /// bytes. The first `(SysMemPitch * height)` bytes are the Y plane,
    /// the next `((SysMemPitch / 2) * height)` bytes are the UV plane,
    /// and the remainder is padding.
    ///
    /// **Direct3D 11.1:** This value is not supported until Windows 8.
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/dd206750(v=vs.85).aspx
    Nv11 = 110,

    /// 4-bit palletized YUV format that is commonly used for DVD subpicture.
    ///
    /// For more info about YUV formats for video rendering, see
    /// [Recommended 8-Bit YUV Formats for Video Rendering.][1]
    ///
    /// **Direct3D 11.1:** This value is not supported until Windows 8.
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/dd206750(v=vs.85).aspx
    Ai44 = 111,

    /// 4-bit palletized YUV format that is commonly used for DVD subpicture.
    ///
    /// For more info about YUV formats for video rendering, see
    /// [Recommended 8-Bit YUV Formats for Video Rendering.][1]
    ///
    /// **Direct3D 11.1:** This value is not supported until Windows 8.
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/dd206750(v=vs.85).aspx
    Ia44 = 112,

    /// 8-bit palletized format that is used for palletized RGB data when
    /// the processor processes ISDB-T data and for palletized YUV data
    /// when the processor processes BluRay data.
    ///
    /// For more info about YUV formats for video rendering, see
    /// [Recommended 8-Bit YUV Formats for Video Rendering.][1]
    ///
    /// **Direct3D 11.1:** This value is not supported until Windows 8.
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/dd206750(v=vs.85).aspx
    P8 = 113,

    /// 8-bit palletized format with 8 bits of alpha that is used for
    /// palletized YUV data when the processor processes BluRay data.
    ///
    /// For more info about YUV formats for video rendering, see
    /// [Recommended 8-Bit YUV Formats for Video Rendering.][1]
    ///
    /// **Direct3D 11.1:** This value is not supported until Windows 8.
    ///
    /// [1]: https://msdn.microsoft.com/en-us/library/windows/desktop/dd206750(v=vs.85).aspx
    A8P8 = 114,

    /// A four-component, 16-bit unsigned-normalized integer format that
    /// supports 4 bits for each channel including alpha.
    ///
    /// **Direct3D 11.1:** This value is not supported until Windows 8.
    B4G4R4A4Unorm = 115,

    /// A video format; an 8-bit version of a hybrid planar 4:2:2 format.
    P208 = 130,

    /// An 8 bit YCbCrA 4:4 rendering format.
    V208 = 131,

    /// An 8 bit YCbCrA 4:4:4:4 rendering format.
    V408 = 132,
}

impl Format {
    /// Gets the number of bytes per pixel in a texture with this format.
    /// Returns `0` if the format does not have a simple answer to this
    /// question.
    pub fn pixel_size(self) -> usize {
        use self::Format::*;
        match self {
            Unknown => 0,
            R32G32B32A32Typeless => 16,
            R32G32B32A32Float => 16,
            R32G32B32A32Uint => 16,
            R32G32B32A32Sint => 16,
            R32G32B32Typeless => 12,
            R32G32B32Float => 12,
            R32G32B32Uint => 12,
            R32G32B32Sint => 12,
            R16G16B16A16Typeless => 8,
            R16G16B16A16Float => 8,
            R16G16B16A16Unorm => 8,
            R16G16B16A16Uint => 8,
            R16G16B16A16Snorm => 8,
            R16G16B16A16Sint => 8,
            R32G32Typeless => 8,
            R32G32Float => 8,
            R32G32Uint => 8,
            R32G32Sint => 8,
            R32G8X24Typeless => 8,
            D32FloatS8X24Uint => 8,
            R32FloatX8X24Typeless => 8,
            X32TypelessG8X24Uint => 8,
            R10G10B10A2Typeless => 4,
            R10G10B10A2Unorm => 4,
            R10G10B10A2Uint => 4,
            R11G11B10Float => 4,
            R8G8B8A8Typeless => 4,
            R8G8B8A8Unorm => 4,
            R8G8B8A8UnormSrgb => 4,
            R8G8B8A8Uint => 4,
            R8G8B8A8Snorm => 4,
            R8G8B8A8Sint => 4,
            R16G16Typeless => 4,
            R16G16Float => 4,
            R16G16Unorm => 4,
            R16G16Uint => 4,
            R16G16Snorm => 4,
            R16G16Sint => 4,
            R32Typeless => 4,
            D32Float => 4,
            R32Float => 4,
            R32Uint => 4,
            R32Sint => 4,
            R24G8Typeless => 4,
            D24UnormS8Uint => 4,
            R24UnormX8Typeless => 4,
            X24TypelessG8Uint => 4,
            R8G8Typeless => 2,
            R8G8Unorm => 2,
            R8G8Uint => 2,
            R8G8Snorm => 2,
            R8G8Sint => 2,
            R16Typeless => 2,
            R16Float => 2,
            D16Unorm => 2,
            R16Unorm => 2,
            R16Uint => 2,
            R16Snorm => 2,
            R16Sint => 2,
            R8Typeless => 1,
            R8Unorm => 1,
            R8Uint => 1,
            R8Snorm => 1,
            R8Sint => 1,
            A8Unorm => 1,
            R1Unorm => 0,
            R9G9B9E5SharedExponent => 4,
            R8G8_B8G8Unorm => 4,
            G8R8_G8B8Unorm => 4,
            Bc1Typeless => 0,
            Bc1Unorm => 0,
            Bc1UnormSrgb => 0,
            Bc2Typeless => 0,
            Bc2Unorm => 0,
            Bc2UnormSrgb => 0,
            Bc3Typeless => 0,
            Bc3Unorm => 0,
            Bc3UnormSrgb => 0,
            Bc4Typeless => 0,
            Bc4Unorm => 0,
            Bc4Snorm => 0,
            Bc5Typeless => 0,
            Bc5Unorm => 0,
            Bc5Snorm => 0,
            B5G6R5Unorm => 2,
            B5G5R5A1Unorm => 2,
            B8G8R8A8Unorm => 4,
            B8G8R8X8Unorm => 4,
            R10G10B10XrBiasA2Unorm => 4,
            B8G8R8A8Typeless => 4,
            B8G8R8A8UnormSrgb => 4,
            B8G8R8X8Typeless => 4,
            B8G8R8X8UnormSrgb => 4,
            Bc6hTypeless => 0,
            Bc6hUf16 => 0,
            Bc6hSf16 => 0,
            Bc7Typeless => 0,
            Bc7Unorm => 0,
            Bc7UnormSrgb => 0,
            Ayuv => 0,
            Y410 => 0,
            Y416 => 0,
            Nv12 => 0,
            P010 => 0,
            P016 => 0,
            Yuv420Opaque => 0,
            Yuy2 => 0,
            Y210 => 0,
            Y216 => 0,
            Nv11 => 0,
            Ai44 => 0,
            Ia44 => 0,
            P8 => 0,
            A8P8 => 0,
            B4G4R4A4Unorm => 2,
            P208 => 0,
            V208 => 0,
            V408 => 0,
        }
    }
}
