# TextureFormat in maplibre::render::settings - Rust
Underlying texture data format.
Keywords: rust, rustlang, rust-lang, TextureFormat

# Enum maplibre::render::settings::TextureFormat

[−]

    #[repr(C)]
    pub enum TextureFormat {
    Show 72 variants    R8Unorm,
        R8Snorm,
        R8Uint,
        R8Sint,
        R16Uint,
        R16Sint,
        R16Unorm,
        R16Snorm,
        R16Float,
        Rg8Unorm,
        Rg8Snorm,
        Rg8Uint,
        Rg8Sint,
        R32Uint,
        R32Sint,
        R32Float,
        Rg16Uint,
        Rg16Sint,
        Rg16Unorm,
        Rg16Snorm,
        Rg16Float,
        Rgba8Unorm,
        Rgba8UnormSrgb,
        Rgba8Snorm,
        Rgba8Uint,
        Rgba8Sint,
        Bgra8Unorm,
        Bgra8UnormSrgb,
        Rgb10a2Unorm,
        Rg11b10Float,
        Rg32Uint,
        Rg32Sint,
        Rg32Float,
        Rgba16Uint,
        Rgba16Sint,
        Rgba16Unorm,
        Rgba16Snorm,
        Rgba16Float,
        Rgba32Uint,
        Rgba32Sint,
        Rgba32Float,
        Depth32Float,
        Depth32FloatStencil8,
        Depth24Plus,
        Depth24PlusStencil8,
        Depth24UnormStencil8,
        Rgb9e5Ufloat,
        Bc1RgbaUnorm,
        Bc1RgbaUnormSrgb,
        Bc2RgbaUnorm,
        Bc2RgbaUnormSrgb,
        Bc3RgbaUnorm,
        Bc3RgbaUnormSrgb,
        Bc4RUnorm,
        Bc4RSnorm,
        Bc5RgUnorm,
        Bc5RgSnorm,
        Bc6hRgbUfloat,
        Bc6hRgbSfloat,
        Bc7RgbaUnorm,
        Bc7RgbaUnormSrgb,
        Etc2Rgb8Unorm,
        Etc2Rgb8UnormSrgb,
        Etc2Rgb8A1Unorm,
        Etc2Rgb8A1UnormSrgb,
        Etc2Rgba8Unorm,
        Etc2Rgba8UnormSrgb,
        EacR11Unorm,
        EacR11Snorm,
        EacRg11Unorm,
        EacRg11Snorm,
        Astc {
            block: AstcBlock,
            channel: AstcChannel,
        },
    }

Expand description

Underlying texture data format.

If there is a conversion in the format (such as srgb -> linear), the conversion listed here is for loading from texture in a shader. When writing to the texture, the opposite conversion takes place.

Corresponds to WebGPU `GPUTextureFormat`.

## Variants

### `R8Unorm`

Red channel only. 8 bit integer per channel. [0, 255] converted to/from float [0, 1] in shader.

### `R8Snorm`

Red channel only. 8 bit integer per channel. [-127, 127] converted to/from float [-1, 1] in shader.

### `R8Uint`

Red channel only. 8 bit integer per channel. Unsigned in shader.

### `R8Sint`

Red channel only. 8 bit integer per channel. Signed in shader.

### `R16Uint`

Red channel only. 16 bit integer per channel. Unsigned in shader.

### `R16Sint`

Red channel only. 16 bit integer per channel. Signed in shader.

### `R16Unorm`

Red channel only. 16 bit integer per channel. [0, 65535] converted to/from float [0, 1] in shader.

`Features::TEXTURE_FORMAT_16BIT_NORM` must be enabled to use this texture format.

### `R16Snorm`

Red channel only. 16 bit integer per channel. [0, 65535] converted to/from float [-1, 1] in shader.

`Features::TEXTURE_FORMAT_16BIT_NORM` must be enabled to use this texture format.

### `R16Float`

Red channel only. 16 bit float per channel. Float in shader.

### `Rg8Unorm`

Red and green channels. 8 bit integer per channel. [0, 255] converted to/from float [0, 1] in shader.

### `Rg8Snorm`

Red and green channels. 8 bit integer per channel. [-127, 127] converted to/from float [-1, 1] in shader.

### `Rg8Uint`

Red and green channels. 8 bit integer per channel. Unsigned in shader.

### `Rg8Sint`

Red and green channels. 8 bit integer per channel. Signed in shader.

### `R32Uint`

Red channel only. 32 bit integer per channel. Unsigned in shader.

### `R32Sint`

Red channel only. 32 bit integer per channel. Signed in shader.

### `R32Float`

Red channel only. 32 bit float per channel. Float in shader.

### `Rg16Uint`

Red and green channels. 16 bit integer per channel. Unsigned in shader.

### `Rg16Sint`

Red and green channels. 16 bit integer per channel. Signed in shader.

### `Rg16Unorm`

Red and green channels. 16 bit integer per channel. [0, 65535] converted to/from float [0, 1] in shader.

`Features::TEXTURE_FORMAT_16BIT_NORM` must be enabled to use this texture format.

### `Rg16Snorm`

Red and green channels. 16 bit integer per channel. [0, 65535] converted to/from float [-1, 1] in shader.

`Features::TEXTURE_FORMAT_16BIT_NORM` must be enabled to use this texture format.

### `Rg16Float`

Red and green channels. 16 bit float per channel. Float in shader.

### `Rgba8Unorm`

Red, green, blue, and alpha channels. 8 bit integer per channel. [0, 255] converted to/from float [0, 1] in shader.

### `Rgba8UnormSrgb`

Red, green, blue, and alpha channels. 8 bit integer per channel. Srgb-color [0, 255] converted to/from linear-color float [0, 1] in shader.

### `Rgba8Snorm`

Red, green, blue, and alpha channels. 8 bit integer per channel. [-127, 127] converted to/from float [-1, 1] in shader.

### `Rgba8Uint`

Red, green, blue, and alpha channels. 8 bit integer per channel. Unsigned in shader.

### `Rgba8Sint`

Red, green, blue, and alpha channels. 8 bit integer per channel. Signed in shader.

### `Bgra8Unorm`

Blue, green, red, and alpha channels. 8 bit integer per channel. [0, 255] converted to/from float [0, 1] in shader.

### `Bgra8UnormSrgb`

Blue, green, red, and alpha channels. 8 bit integer per channel. Srgb-color [0, 255] converted to/from linear-color float [0, 1] in shader.

### `Rgb10a2Unorm`

Red, green, blue, and alpha channels. 10 bit integer for RGB channels, 2 bit integer for alpha channel. [0, 1023] ([0, 3] for alpha) converted to/from float [0, 1] in shader.

### `Rg11b10Float`

Red, green, and blue channels. 11 bit float with no sign bit for RG channels. 10 bit float with no sign bit for blue channel. Float in shader.

### `Rg32Uint`

Red and green channels. 32 bit integer per channel. Unsigned in shader.

### `Rg32Sint`

Red and green channels. 32 bit integer per channel. Signed in shader.

### `Rg32Float`

Red and green channels. 32 bit float per channel. Float in shader.

### `Rgba16Uint`

Red, green, blue, and alpha channels. 16 bit integer per channel. Unsigned in shader.

### `Rgba16Sint`

Red, green, blue, and alpha channels. 16 bit integer per channel. Signed in shader.

### `Rgba16Unorm`

Red, green, blue, and alpha channels. 16 bit integer per channel. [0, 65535] converted to/from float [0, 1] in shader.

`Features::TEXTURE_FORMAT_16BIT_NORM` must be enabled to use this texture format.

### `Rgba16Snorm`

Red, green, blue, and alpha. 16 bit integer per channel. [0, 65535] converted to/from float [-1, 1] in shader.

`Features::TEXTURE_FORMAT_16BIT_NORM` must be enabled to use this texture format.

### `Rgba16Float`

Red, green, blue, and alpha channels. 16 bit float per channel. Float in shader.

### `Rgba32Uint`

Red, green, blue, and alpha channels. 32 bit integer per channel. Unsigned in shader.

### `Rgba32Sint`

Red, green, blue, and alpha channels. 32 bit integer per channel. Signed in shader.

### `Rgba32Float`

Red, green, blue, and alpha channels. 32 bit float per channel. Float in shader.

### `Depth32Float`

Special depth format with 32 bit floating point depth.

### `Depth32FloatStencil8`

Special depth/stencil format with 32 bit floating point depth and 8 bits integer stencil.

### `Depth24Plus`

Special depth format with at least 24 bit integer depth.

### `Depth24PlusStencil8`

Special depth/stencil format with at least 24 bit integer depth and 8 bits integer stencil.

### `Depth24UnormStencil8`

Special depth/stencil format with 24 bit integer depth and 8 bits integer stencil.

### `Rgb9e5Ufloat`

Packed unsigned float with 9 bits mantisa for each RGB component, then a common 5 bits exponent

### `Bc1RgbaUnorm`

4x4 block compressed texture. 8 bytes per block (4 bit/px). 4 color + alpha pallet. 5 bit R + 6 bit G + 5 bit B + 1 bit alpha. [0, 63] ([0, 1] for alpha) converted to/from float [0, 1] in shader.

Also known as DXT1.

`Features::TEXTURE_COMPRESSION_BC` must be enabled to use this texture format.

### `Bc1RgbaUnormSrgb`

4x4 block compressed texture. 8 bytes per block (4 bit/px). 4 color + alpha pallet. 5 bit R + 6 bit G + 5 bit B + 1 bit alpha. Srgb-color [0, 63] ([0, 1] for alpha) converted to/from linear-color float [0, 1] in shader.

Also known as DXT1.

`Features::TEXTURE_COMPRESSION_BC` must be enabled to use this texture format.

### `Bc2RgbaUnorm`

4x4 block compressed texture. 16 bytes per block (8 bit/px). 4 color pallet. 5 bit R + 6 bit G + 5 bit B + 4 bit alpha. [0, 63] ([0, 15] for alpha) converted to/from float [0, 1] in shader.

Also known as DXT3.

`Features::TEXTURE_COMPRESSION_BC` must be enabled to use this texture format.

### `Bc2RgbaUnormSrgb`

4x4 block compressed texture. 16 bytes per block (8 bit/px). 4 color pallet. 5 bit R + 6 bit G + 5 bit B + 4 bit alpha. Srgb-color [0, 63] ([0, 255] for alpha) converted to/from linear-color float [0, 1] in shader.

Also known as DXT3.

`Features::TEXTURE_COMPRESSION_BC` must be enabled to use this texture format.

### `Bc3RgbaUnorm`

4x4 block compressed texture. 16 bytes per block (8 bit/px). 4 color pallet + 8 alpha pallet. 5 bit R + 6 bit G + 5 bit B + 8 bit alpha. [0, 63] ([0, 255] for alpha) converted to/from float [0, 1] in shader.

Also known as DXT5.

`Features::TEXTURE_COMPRESSION_BC` must be enabled to use this texture format.

### `Bc3RgbaUnormSrgb`

4x4 block compressed texture. 16 bytes per block (8 bit/px). 4 color pallet + 8 alpha pallet. 5 bit R + 6 bit G + 5 bit B + 8 bit alpha. Srgb-color [0, 63] ([0, 255] for alpha) converted to/from linear-color float [0, 1] in shader.

Also known as DXT5.

`Features::TEXTURE_COMPRESSION_BC` must be enabled to use this texture format.

### `Bc4RUnorm`

4x4 block compressed texture. 8 bytes per block (4 bit/px). 8 color pallet. 8 bit R. [0, 255] converted to/from float [0, 1] in shader.

Also known as RGTC1.

`Features::TEXTURE_COMPRESSION_BC` must be enabled to use this texture format.

### `Bc4RSnorm`

4x4 block compressed texture. 8 bytes per block (4 bit/px). 8 color pallet. 8 bit R. [-127, 127] converted to/from float [-1, 1] in shader.

Also known as RGTC1.

`Features::TEXTURE_COMPRESSION_BC` must be enabled to use this texture format.

### `Bc5RgUnorm`

4x4 block compressed texture. 16 bytes per block (8 bit/px). 8 color red pallet + 8 color green pallet. 8 bit RG. [0, 255] converted to/from float [0, 1] in shader.

Also known as RGTC2.

`Features::TEXTURE_COMPRESSION_BC` must be enabled to use this texture format.

### `Bc5RgSnorm`

4x4 block compressed texture. 16 bytes per block (8 bit/px). 8 color red pallet + 8 color green pallet. 8 bit RG. [-127, 127] converted to/from float [-1, 1] in shader.

Also known as RGTC2.

`Features::TEXTURE_COMPRESSION_BC` must be enabled to use this texture format.

### `Bc6hRgbUfloat`

4x4 block compressed texture. 16 bytes per block (8 bit/px). Variable sized pallet. 16 bit unsigned float RGB. Float in shader.

Also known as BPTC (float).

`Features::TEXTURE_COMPRESSION_BC` must be enabled to use this texture format.

### `Bc6hRgbSfloat`

4x4 block compressed texture. 16 bytes per block (8 bit/px). Variable sized pallet. 16 bit signed float RGB. Float in shader.

Also known as BPTC (float).

`Features::TEXTURE_COMPRESSION_BC` must be enabled to use this texture format.

### `Bc7RgbaUnorm`

4x4 block compressed texture. 16 bytes per block (8 bit/px). Variable sized pallet. 8 bit integer RGBA. [0, 255] converted to/from float [0, 1] in shader.

Also known as BPTC (unorm).

`Features::TEXTURE_COMPRESSION_BC` must be enabled to use this texture format.

### `Bc7RgbaUnormSrgb`

4x4 block compressed texture. 16 bytes per block (8 bit/px). Variable sized pallet. 8 bit integer RGBA. Srgb-color [0, 255] converted to/from linear-color float [0, 1] in shader.

Also known as BPTC (unorm).

`Features::TEXTURE_COMPRESSION_BC` must be enabled to use this texture format.

### `Etc2Rgb8Unorm`

4x4 block compressed texture. 8 bytes per block (4 bit/px). Complex pallet. 8 bit integer RGB. [0, 255] converted to/from float [0, 1] in shader.

`Features::TEXTURE_COMPRESSION_ETC2` must be enabled to use this texture format.

### `Etc2Rgb8UnormSrgb`

4x4 block compressed texture. 8 bytes per block (4 bit/px). Complex pallet. 8 bit integer RGB. Srgb-color [0, 255] converted to/from linear-color float [0, 1] in shader.

`Features::TEXTURE_COMPRESSION_ETC2` must be enabled to use this texture format.

### `Etc2Rgb8A1Unorm`

4x4 block compressed texture. 8 bytes per block (4 bit/px). Complex pallet. 8 bit integer RGB + 1 bit alpha. [0, 255] ([0, 1] for alpha) converted to/from float [0, 1] in shader.

`Features::TEXTURE_COMPRESSION_ETC2` must be enabled to use this texture format.

### `Etc2Rgb8A1UnormSrgb`

4x4 block compressed texture. 8 bytes per block (4 bit/px). Complex pallet. 8 bit integer RGB + 1 bit alpha. Srgb-color [0, 255] ([0, 1] for alpha) converted to/from linear-color float [0, 1] in shader.

`Features::TEXTURE_COMPRESSION_ETC2` must be enabled to use this texture format.

### `Etc2Rgba8Unorm`

4x4 block compressed texture. 16 bytes per block (8 bit/px). Complex pallet. 8 bit integer RGB + 8 bit alpha. [0, 255] converted to/from float [0, 1] in shader.

`Features::TEXTURE_COMPRESSION_ETC2` must be enabled to use this texture format.

### `Etc2Rgba8UnormSrgb`

4x4 block compressed texture. 16 bytes per block (8 bit/px). Complex pallet. 8 bit integer RGB + 8 bit alpha. Srgb-color [0, 255] converted to/from linear-color float [0, 1] in shader.

`Features::TEXTURE_COMPRESSION_ETC2` must be enabled to use this texture format.

### `EacR11Unorm`

4x4 block compressed texture. 8 bytes per block (4 bit/px). Complex pallet. 11 bit integer R. [0, 255] converted to/from float [0, 1] in shader.

`Features::TEXTURE_COMPRESSION_ETC2` must be enabled to use this texture format.

### `EacR11Snorm`

4x4 block compressed texture. 8 bytes per block (4 bit/px). Complex pallet. 11 bit integer R. [-127, 127] converted to/from float [-1, 1] in shader.

`Features::TEXTURE_COMPRESSION_ETC2` must be enabled to use this texture format.

### `EacRg11Unorm`

4x4 block compressed texture. 16 bytes per block (8 bit/px). Complex pallet. 11 bit integer R + 11 bit integer G. [0, 255] converted to/from float [0, 1] in shader.

`Features::TEXTURE_COMPRESSION_ETC2` must be enabled to use this texture format.

### `EacRg11Snorm`

4x4 block compressed texture. 16 bytes per block (8 bit/px). Complex pallet. 11 bit integer R + 11 bit integer G. [-127, 127] converted to/from float [-1, 1] in shader.

`Features::TEXTURE_COMPRESSION_ETC2` must be enabled to use this texture format.

### `Astc`

#### Fields

`block: AstcBlock`

compressed block dimensions

`channel: AstcChannel`

block compressed texture. 16 bytes per block.

Features `TEXTURE_COMPRESSION_ASTC_LDR` or `TEXTURE_COMPRESSION_ASTC_HDR` must be enabled to use this texture format.

## Implementations

### impl TextureFormat

#### pub fn describe(&self) -> TextureFormatInfo

Get useful information about the texture format.

## Trait Implementations

### impl Clone for TextureFormat

#### pub fn clone(&self) -> TextureFormat

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from `source`. Read more

### impl Debug for TextureFormat

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

Formats the value using the given formatter. Read more

### impl Hash for TextureFormat

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

Feeds this value into the given `Hasher`. Read more

1.3.0 · source

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

Feeds a slice of this type into the given `Hasher`. Read more

### impl PartialEq<TextureFormat> for TextureFormat

#### pub fn eq(&self, other: &TextureFormat) -> bool

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

#### pub fn ne(&self, other: &TextureFormat) -> bool

This method tests for `!=`.

### impl Copy for TextureFormat

### impl Eq for TextureFormat

### impl StructuralEq for TextureFormat

### impl StructuralPartialEq for TextureFormat

## Auto Trait Implementations

### impl RefUnwindSafe for TextureFormat

### impl Send for TextureFormat

### impl Sync for TextureFormat

### impl Unpin for TextureFormat

### impl UnwindSafe for TextureFormat

## Blanket Implementations

source

### impl<T> Any for T where
T: 'static + ?Sized,

source

#### pub fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

### impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

#### pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

### impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

#### pub fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

### impl<T> CallHasher for T where
T: Hash + ?Sized,

#### pub fn get_hash<H, B>(value: &H, build_hasher: &B) -> u64 where
H: Hash + ?Sized,
B: BuildHasher,

### impl<T> Downcast for T where
T: Any,

#### pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

Convert `Box<dyn Trait>` (where `Trait: Downcast`) to `Box<dyn Any>`. `Box<dyn Any>` can then be further `downcast` into `Box<ConcreteType>` where `ConcreteType` implements `Trait`. Read more

#### pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>

Convert `Rc<Trait>` (where `Trait: Downcast`) to `Rc<Any>`. `Rc<Any>` can then be further `downcast` into `Rc<ConcreteType>` where `ConcreteType` implements `Trait`. Read more

#### pub fn as_any(&self) -> &(dyn Any + 'static)

Convert `&Trait` (where `Trait: Downcast`) to `&Any`. This is needed since Rust cannot generate `&Any`’s vtable from `&Trait`’s. Read more

#### pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert `&mut Trait` (where `Trait: Downcast`) to `&Any`. This is needed since Rust cannot generate `&mut Any`’s vtable from `&mut Trait`’s. Read more

### impl<T> Downcast<T> for T

#### pub fn downcast(&self) -> &T

### impl<T> DowncastSync for T where
T: Any + Send + Sync,

#### pub fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync + 'static>

Convert `Arc<Trait>` (where `Trait: Downcast`) to `Arc<Any>`. `Arc<Any>` can then be further `downcast` into `Arc<ConcreteType>` where `ConcreteType` implements `Trait`. Read more

source

### impl<T> DynEq for T where
T: Any + Eq,

source

#### fn as_any(&self) -> &dyn Any

source

#### fn dyn_eq(&self, other: &dyn DynEq) -> bool

source

### impl<T> DynHash for T where
T: DynEq + Hash,

source

#### fn as_dyn_eq(&self) -> &dyn DynEq

source

#### fn dyn_hash(&self, state: &mut dyn Hasher)

source

### impl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,

source

#### pub fn equivalent(&self, key: &K) -> bool

Compare self to `key` and return `true` if they are equal.

source

### impl<T> From<T> for T

const: unstable · source

#### pub fn from(t: T) -> T

Returns the argument unchanged.

source

### impl<T> Instrument for T

source

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more

source

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more

source

### impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

#### pub fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source

### impl<T> Same<T> for T

#### type Output = T

Should always be `Self`

source

### impl<T> ToOwned for T where
T: Clone,

#### type Owned = T

The resulting type after obtaining ownership.

source

#### pub fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

#### pub fn clone_into(&self, target: &mut T)

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

#### pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

source

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

#### pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

### impl<T> Upcast<T> for T

#### pub fn upcast(&self) -> Option<&T>

source

### impl<T> WithSubscriber for T

source

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more

source

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more