Enum three_d::core::texture::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.

Trait Implementations

impl Clone for TextureData

fn clone(&self) -> TextureData

Returns a copy 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<(), Error>

Formats the value using the given formatter.

impl PartialEq for TextureData

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