Enum spirv_std::image::ImageFormat

#[repr(u32)]
pub enum ImageFormat {
    Unknown = 0,
    Rgba32f = 1,
    Rgba16f = 2,
    R32f = 3,
    Rgba8 = 4,
    Rgba8Snorm = 5,
    Rg32f = 6,
    Rg16f = 7,
    R11fG11fB10f = 8,
    R16f = 9,
    Rgba16 = 10,
    Rgb10A2 = 11,
    Rg16 = 12,
    Rg8 = 13,
    R16 = 14,
    R8 = 15,
    Rgba16Snorm = 16,
    Rg16Snorm = 17,
    Rg8Snorm = 18,
    R16Snorm = 19,
    R8Snorm = 20,
    Rgba32i = 21,
    Rgba16i = 22,
    Rgba8i = 23,
    R32i = 24,
    Rg32i = 25,
    Rg16i = 26,
    Rg8i = 27,
    R16i = 28,
    R8i = 29,
    Rgba32ui = 30,
    Rgba16ui = 31,
    Rgba8ui = 32,
    R32ui = 33,
    Rgb10A2ui = 34,
    Rg32ui = 35,
    Rg16ui = 36,
    Rg8ui = 37,
    R16ui = 38,
    R8ui = 39,
    R64ui = 40,
    R64i = 41,
}

The underlying internal representation of the image.

Variants

Unknown = 0

Representation not known at compile time.

Rgba32f = 1

RGBA channels, 32 bit floating point per channel.

Rgba16f = 2

RGBA channels, 16 bit floating point per channel.

R32f = 3

Single red channel, 32 bit floating point.

Rgba8 = 4

RGBA channels, 8 bit unsigned normalized integer per channel.

Rgba8Snorm = 5

RGBA channels, 8 bit signed normalized integer per channel.

Rg32f = 6

Red+Green channels, 32 bit floating point per channel.

Rg16f = 7

Red+Green channels, 16 bit floating point per channel.

R11fG11fB10f = 8

32 bits containing two 11 bit floating point numbers for the Red and Green channels, and a 10 bit floating point number for the Blue channel.

R16f = 9

Single red channel, 16 bit floating point.

Rgba16 = 10

RGBA channels, 16 bit unsigned normalized integer per channel.

Rgb10A2 = 11

32 bits containing three 10 bit unsigned normalized integers for the Red, Green, and Blue channels, and a 2 bit unsigned normalized integer for the Alpha channel.

Rg16 = 12

Red+Green channels, 16 bit unsigned normalized integer per channel.

Rg8 = 13

Red+Green channels, 8 bit unsigned normalized integer per channel.

R16 = 14

Single red channel, 16 bit unsigned normalized integer.

R8 = 15

Single red channel, 8 bit unsigned normalized integer.

Rgba16Snorm = 16

RGBA channels, 16 bit signed normalized integer per channel.

Rg16Snorm = 17

Red+Green channels, 16 bit signed normalized integer per channel.

Rg8Snorm = 18

Red+Green channels, 8 bit signed normalized integer per channel.

R16Snorm = 19

Single red channel, 16 bit signed normalized integer.

R8Snorm = 20

Single red channel, 8 bit signed normalized integer.

Rgba32i = 21

RGBA channels, 32 bit signed integer per channel (not normalized).

Rgba16i = 22

RGBA channels, 16 bit signed integer per channel (not normalized).

Rgba8i = 23

RGBA channels, 8 bit signed integer per channel (not normalized).

R32i = 24

Single red channel, 32 bit signed integer (not normalized).

Rg32i = 25

Red+Green channels, 32 bit signed integer per channel (not normalized).

Rg16i = 26

Red+Green channels, 16 bit signed integer per channel (not normalized).

Rg8i = 27

Red+Green channels, 8 bit signed integer per channel (not normalized).

R16i = 28

Single red channel, 16 bit signed integer (not normalized).

R8i = 29

Single red channel, 8 bit signed integer (not normalized).

Rgba32ui = 30

RGBA channels, 32 bit unsigned integer per channel (not normalized).

Rgba16ui = 31

RGBA channels, 16 bit unsigned integer per channel (not normalized).

Rgba8ui = 32

RGBA channels, 8 bit unsigned integer per channel (not normalized).

R32ui = 33

Single red channel, 32 bit unsigned integer (not normalized).

Rgb10A2ui = 34

32 bits containing three 10 bit unsigned integers for the Red, Green, and Blue channels, and a 2 bit unsigned integer for the Alpha channel.

Rg32ui = 35

Red+Green channels, 32 bit unsigned integer per channel (not normalized).

Rg16ui = 36

Red+Green channels, 16 bit unsigned integer per channel (not normalized).

Rg8ui = 37

Red+Green channels, 8 bit unsigned integer per channel (not normalized).

R16ui = 38

Single red channel, 16 bit unsigned integer (not normalized).

R8ui = 39

Single red channel, 8 bit unsigned integer (not normalized).

R64ui = 40

Single red channel, 64 bit unsigned integer (not normalized).

R64i = 41

Single red channel, 64 bit signed integer (not normalized).

Trait Implementations

impl PartialEq for ImageFormat

fn eq(&self, other: &ImageFormat) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ImageFormat

impl StructuralPartialEq for ImageFormat