Enum TexturePixelKind 

#[repr(u32)]
pub enum TexturePixelKind {
    R8 = 0,
    RGB8 = 1,
    RGBA8 = 2,
    RG8 = 3,
    R16 = 4,
    RG16 = 5,
    BGR8 = 6,
    BGRA8 = 7,
    RGB16 = 8,
    RGBA16 = 9,
    DXT1RGB = 10,
    DXT1RGBA = 11,
    DXT3RGBA = 12,
    DXT5RGBA = 13,
    R8RGTC = 14,
    RG8RGTC = 15,
    RGB32F = 16,
    RGBA32F = 17,
    Luminance8 = 18,
    LuminanceAlpha8 = 19,
    Luminance16 = 20,
    LuminanceAlpha16 = 21,
    RGB16F = 22,
    R32F = 23,
    R16F = 24,
    SRGBA8 = 25,
    SRGB8 = 26,
}

Texture kind defines pixel format of texture.

Variants

R8 = 0

1 byte red.

RGB8 = 1

Red, green, and blue components, each by 1 byte.

RGBA8 = 2

Red, green, blue, and alpha components, each by 1 byte.

RG8 = 3

Red and green, each by 1 byte.

R16 = 4

2 byte red.

RG16 = 5

Red and green, each by 2 byte.

BGR8 = 6

Blue, green, and red components, each by 1 byte.

BGRA8 = 7

Blue, green, red and alpha components, each by 1 byte.

RGB16 = 8

Red, green, and blue components, each by 2 byte.

RGBA16 = 9

Red, green, blue, and alpha components, each by 2 byte.

DXT1RGB = 10

Compressed S3TC DXT1 RGB (no alpha).

DXT1RGBA = 11

Compressed S3TC DXT1 RGBA.

DXT3RGBA = 12

Compressed S3TC DXT3 RGBA.

DXT5RGBA = 13

Compressed S3TC DXT5 RGBA.

R8RGTC = 14

Compressed R8 texture (RGTC).

RG8RGTC = 15

Compressed RG8 texture (RGTC).

RGB32F = 16

Floating-point RGB texture with 32bit depth.

RGBA32F = 17

Floating-point RGBA texture with 32bit depth.

Luminance8 = 18

1 byte luminance texture where pixels will have (L, L, L, 1.0) value on fetching.

Platform-specific

• WebAssembly - not supported, the image will act like Self::R8 format, which will have (R, 0.0, 0.0, 1.0) pixels.

LuminanceAlpha8 = 19

1 byte for luminance and 1 for alpha, where all pixels will have (L, L, L, A) value on fetching.

Platform-specific

• WebAssembly - not supported, the image will act like Self::RG8 format, which will have (R, G, R, G) pixels.

Luminance16 = 20

2 byte luminance texture where pixels will have (L, L, L, 1.0) value on fetching.

Platform-specific

• WebAssembly - not supported, the image will act like Self::R8 format, which will have (R, 0.0, 0.0, 1.0) pixels.

LuminanceAlpha16 = 21

2 byte for luminance and 2 for alpha, where all pixels will have (L, L, L, A) value on fetching.

Platform-specific

• WebAssembly - not supported, the image will act like Self::RG16 format, which will have (R, G, R, G) pixels.

RGB16F = 22

Red, green, blue components, each by 2 byte half-precision float.

R32F = 23

Red component as 4-byte, medium-precision float.

R16F = 24

Red component as 2-byte, half-precision float.

SRGBA8 = 25

SRGB8 = 26

Implementations

impl TexturePixelKind

pub fn size_in_bytes(&self) -> Option<usize>

Tries to get size of the pixel in bytes. Pixels of compressed textures consumes less than a byte, so there’s no way to express their size on whole number of bytes, in this case None is returned.

Trait Implementations

impl AsRef<str> for TexturePixelKind

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for TexturePixelKind

fn clone(&self) -> TexturePixelKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TexturePixelKind

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

Formats the value using the given formatter.

impl FromStr for TexturePixelKind

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str( s: &str, ) -> Result<TexturePixelKind, <TexturePixelKind as FromStr>::Err>

Parses a string s to return a value of this type.

impl PartialEq for TexturePixelKind

fn eq(&self, other: &TexturePixelKind) -> 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 Reflect for TexturePixelKind

where TexturePixelKind: 'static,

fn source_path() -> &'static str

fn try_clone_box(&self) -> Option<Box<dyn Reflect>>

fn type_name(&self) -> &'static str

fn derived_types() -> &'static [TypeId]

fn query_derived_types(&self) -> &'static [TypeId]

fn doc(&self) -> &'static str

fn assembly_name(&self) -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn type_assembly_name() -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn fields_ref(&self, func: &mut dyn FnMut(&[FieldRef<'_, '_>]))

fn fields_mut(&mut self, func: &mut dyn FnMut(&mut [FieldMut<'_, '_>]))

fn into_any(self: Box<TexturePixelKind>) -> Box<dyn Any>

fn set( &mut self, value: Box<dyn Reflect>, ) -> Result<Box<dyn Reflect>, Box<dyn Reflect>>

fn as_any(&self, func: &mut dyn FnMut(&(dyn Any + 'static)))

fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Any + 'static)))

fn as_reflect(&self, func: &mut dyn FnMut(&(dyn Reflect + 'static)))

fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Reflect + 'static)))

fn set_field( &mut self, field_name: &str, value: Box<dyn Reflect>, func: &mut dyn FnMut(Result<Box<dyn Reflect>, SetFieldError>), )

Calls user method specified with #[reflect(setter = ..)] or falls back to Reflect::field_mut

fn field( &self, name: &str, func: &mut dyn FnMut(Option<&(dyn Reflect + 'static)>), )

fn field_mut( &mut self, name: &str, func: &mut dyn FnMut(Option<&mut (dyn Reflect + 'static)>), )

fn as_array(&self, func: &mut dyn FnMut(Option<&(dyn ReflectArray + 'static)>))

fn as_array_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectArray + 'static)>), )

fn as_list(&self, func: &mut dyn FnMut(Option<&(dyn ReflectList + 'static)>))

fn as_list_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectList + 'static)>), )

fn as_inheritable_variable( &self, func: &mut dyn FnMut(Option<&(dyn ReflectInheritableVariable + 'static)>), )

fn as_inheritable_variable_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectInheritableVariable + 'static)>), )

fn as_hash_map( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHashMap + 'static)>), )

fn as_hash_map_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHashMap + 'static)>), )

fn as_handle( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHandle + 'static)>), )

fn as_handle_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHandle + 'static)>), )

impl TryFrom<&str> for TexturePixelKind

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from( s: &str, ) -> Result<TexturePixelKind, <TexturePixelKind as TryFrom<&str>>::Error>

Performs the conversion.

impl TypeUuidProvider for TexturePixelKind

fn type_uuid() -> Uuid

Return type UUID.

impl VariantNames for TexturePixelKind

const VARIANTS: &'static [&'static str]

Names of the variants of this enum

impl Visit for TexturePixelKind

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> Result<(), VisitError>

Read or write this value, depending on whether Visitor::is_reading() is true or false.

impl Copy for TexturePixelKind

impl Eq for TexturePixelKind

impl StructuralPartialEq for TexturePixelKind