Enum CUarray_format 

#[non_exhaustive]
#[repr(u32)]
pub enum CUarray_format {
    UnsignedInt8 = 1,
    UnsignedInt16 = 2,
    UnsignedInt32 = 3,
    SignedInt8 = 8,
    SignedInt16 = 9,
    SignedInt32 = 10,
    Half = 16,
    Float = 32,
    Nv12 = 176,
    UnormInt8X1 = 192,
    UnormInt8X2 = 193,
    UnormInt8X4 = 194,
    UnormInt16X1 = 195,
    UnormInt16X2 = 196,
    UnormInt16X4 = 197,
    SnormInt8X1 = 198,
    SnormInt8X2 = 199,
    SnormInt8X4 = 200,
    SnormInt16X1 = 201,
    SnormInt16X2 = 202,
    SnormInt16X4 = 203,
    Bc1Unorm = 145,
    Bc1UnormSrgb = 146,
    Bc2Unorm = 147,
    Bc2UnormSrgb = 148,
    Bc3Unorm = 149,
    Bc3UnormSrgb = 150,
    Bc4Unorm = 151,
    Bc4Snorm = 152,
    Bc5Unorm = 153,
    Bc5Snorm = 154,
    Bc6hUf16 = 155,
    Bc6hSf16 = 156,
    Bc7Unorm = 157,
    Bc7UnormSrgb = 158,
}

Element format for CUDA arrays. Mirrors CUarray_format_enum in the CUDA driver API header.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

UnsignedInt8 = 1

8-bit unsigned integer channel.

UnsignedInt16 = 2

16-bit unsigned integer channel.

UnsignedInt32 = 3

32-bit unsigned integer channel.

SignedInt8 = 8

8-bit signed integer channel.

SignedInt16 = 9

16-bit signed integer channel.

SignedInt32 = 10

32-bit signed integer channel.

Half = 16

16-bit IEEE 754 half-precision float channel.

Float = 32

32-bit IEEE 754 single-precision float channel.

Nv12 = 176

NV12 planar YUV format (special 2-plane layout).

UnormInt8X1 = 192

8-bit unsigned normalized integer (1 channel).

UnormInt8X2 = 193

8-bit unsigned normalized integer (2 channels).

UnormInt8X4 = 194

8-bit unsigned normalized integer (4 channels).

UnormInt16X1 = 195

16-bit unsigned normalized integer (1 channel).

UnormInt16X2 = 196

16-bit unsigned normalized integer (2 channels).

UnormInt16X4 = 197

16-bit unsigned normalized integer (4 channels).

SnormInt8X1 = 198

8-bit signed normalized integer (1 channel).

SnormInt8X2 = 199

8-bit signed normalized integer (2 channels).

SnormInt8X4 = 200

8-bit signed normalized integer (4 channels).

SnormInt16X1 = 201

16-bit signed normalized integer (1 channel).

SnormInt16X2 = 202

16-bit signed normalized integer (2 channels).

SnormInt16X4 = 203

16-bit signed normalized integer (4 channels).

Bc1Unorm = 145

BC1 compressed (DXT1) unsigned.

Bc1UnormSrgb = 146

BC1 compressed (DXT1) unsigned, sRGB.

Bc2Unorm = 147

BC2 compressed (DXT3) unsigned.

Bc2UnormSrgb = 148

BC2 compressed (DXT3) unsigned, sRGB.

Bc3Unorm = 149

BC3 compressed (DXT5) unsigned.

Bc3UnormSrgb = 150

BC3 compressed (DXT5) unsigned, sRGB.

Bc4Unorm = 151

BC4 unsigned.

Bc4Snorm = 152

BC4 signed.

Bc5Unorm = 153

BC5 unsigned.

Bc5Snorm = 154

BC5 signed.

Bc6hUf16 = 155

BC6H unsigned 16-bit float.

Bc6hSf16 = 156

BC6H signed 16-bit float.

Bc7Unorm = 157

BC7 unsigned.

Bc7UnormSrgb = 158

BC7 unsigned, sRGB.

Trait Implementations

impl Clone for CUarray_format

fn clone(&self) -> CUarray_format

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CUarray_format

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for CUarray_format

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CUarray_format

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for CUarray_format

impl Eq for CUarray_format

impl StructuralPartialEq for CUarray_format