Enum TextureData 

pub enum TextureData {
    RU8(Vec<u8>),
    RgU8(Vec<[u8; 2]>),
    RgbU8(Vec<[u8; 3]>),
    RgbaU8(Vec<[u8; 4]>),
    RF16(Vec<f16>),
    RgF16(Vec<[f16; 2]>),
    RgbF16(Vec<[f16; 3]>),
    RgbaF16(Vec<[f16; 4]>),
    RF32(Vec<f32>),
    RgF32(Vec<[f32; 2]>),
    RgbF32(Vec<[f32; 3]>),
    RgbaF32(Vec<[f32; 4]>),
}

The pixel/texel data for a Texture2D or Texture3D.

If 2D data, the data array should start with the top left texel and then one row at a time. The indices (row, column) into the 2D data would look like

[
(0, 0), (1, 0), .., // First row
(0, 1), (1, 1), .., // Second row
..
]

If 3D data, the data array would look like the 2D data, one layer/image at a time. The indices (row, column, layer) into the 3D data would look like

[
(0, 0, 0), (1, 0, 0), .., // First row in first layer
(0, 1, 0), (1, 1, 0), .., // Second row in first layer
..
(0, 0, 1), (1, 0, 1), .., // First row in second layer
(0, 1, 1), (1, 1, 1), ..,  // Second row in second layer
..
]

Variants

RU8(Vec<u8>)

One byte in the red channel.

RgU8(Vec<[u8; 2]>)

One byte in the red and green channel.

RgbU8(Vec<[u8; 3]>)

One byte in the red, green and blue channel.

RgbaU8(Vec<[u8; 4]>)

One byte in the red, green, blue and alpha channel.

RF16(Vec<f16>)

16-bit float in the red channel.

RgF16(Vec<[f16; 2]>)

16-bit float in the red and green channel.

RgbF16(Vec<[f16; 3]>)

16-bit float in the red, green and blue channel.

RgbaF16(Vec<[f16; 4]>)

16-bit float in the red, green, blue and alpha channel.

RF32(Vec<f32>)

32-bit float in the red channel.

RgF32(Vec<[f32; 2]>)

32-bit float in the red and green channel.

RgbF32(Vec<[f32; 3]>)

32-bit float in the red, green and blue channel.

RgbaF32(Vec<[f32; 4]>)

32-bit float in the red, green, blue and alpha channel.

Implementations

impl TextureData

pub fn to_linear_srgb(&mut self)

Converts the texture data to linear sRGB color space if the data is either TextureData::RgbU8 (assuming sRGB color space) or TextureData::RgbaU8 (assuming sRGB color space with an alpha channel). Does nothing if the data is any other data type.

pub fn to_color(&mut self)

Converts the texture data to color TextureData::RgbU8 if the data is TextureData::RU8 (assuming gray scale colors). Does nothing if the data is any other data type.

Trait Implementations

impl Clone for TextureData

fn clone(&self) -> TextureData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TextureData

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TextureData

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for TextureData

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for TextureData