Type Alias TextureDescriptor

pub type TextureDescriptor<'a> = TextureDescriptor<Label<'a>, &'a [TextureFormat]>;

Describes a Texture.

For use with Device::create_texture.

Corresponds to WebGPU GPUTextureDescriptor.

Aliased Type

struct TextureDescriptor<'a> {
    pub label: Option<&'a str>,
    pub size: Extent3d,
    pub mip_level_count: u32,
    pub sample_count: u32,
    pub dimension: TextureDimension,
    pub format: TextureFormat,
    pub usage: TextureUsages,
    pub view_formats: &'a [TextureFormat],
}

Fields

label: Option<&'a str>

Debug label of the texture. This will show up in graphics debuggers for easy identification.

size: Extent3d

Size of the texture. All components must be greater than zero. For a regular 1D/2D texture, the unused sizes will be 1. For 2DArray textures, Z is the number of 2D textures in that array.

mip_level_count: u32

Mip count of texture. For a texture with no extra mips, this must be 1.

sample_count: u32

Sample count of texture. If this is not 1, texture must have [BindingType::Texture::multisampled] set to true.

dimension: TextureDimension

Dimensions of the texture.

format: TextureFormat

Format of the texture.

usage: TextureUsages

Allowed usages of the texture. If used in other ways, the operation will panic.

view_formats: &'a [TextureFormat]

Specifies what view formats will be allowed when calling Texture::create_view on this texture.

View formats of the same format as the texture are always allowed.

Note: currently, only the srgb-ness is allowed to change. (ex: Rgba8Unorm texture + Rgba8UnormSrgb view)

Implementations

impl<L, V> TextureDescriptor<L, V>

pub fn map_label<K>(&self, fun: impl FnOnce(&L) -> K) -> TextureDescriptor<K, V>

where V: Clone,

Takes a closure and maps the label of the texture descriptor into another.

pub fn map_label_and_view_formats<K, M>( &self, l_fun: impl FnOnce(&L) -> K, v_fun: impl FnOnce(V) -> M, ) -> TextureDescriptor<K, M>

where V: Clone,

Maps the label and view formats of the texture descriptor into another.

pub fn mip_level_size(&self, level: u32) -> Option<Extent3d>

Calculates the extent at a given mip level.

If the given mip level is larger than possible, returns None.

Treats the depth as part of the mipmaps. If calculating for a 2DArray texture, which does not mipmap depth, set depth to 1.

let desc  = TextureDescriptor {
  label: (),
  size: wgpu::Extent3d { width: 100, height: 60, depth_or_array_layers: 1 },
  mip_level_count: 7,
  sample_count: 1,
  dimension: wgpu::TextureDimension::D3,
  format: wgpu::TextureFormat::Rgba8Sint,
  usage: wgpu::TextureUsages::empty(),
  view_formats: &[],
};

assert_eq!(desc.mip_level_size(0), Some(wgpu::Extent3d { width: 100, height: 60, depth_or_array_layers: 1 }));
assert_eq!(desc.mip_level_size(1), Some(wgpu::Extent3d { width: 50, height: 30, depth_or_array_layers: 1 }));
assert_eq!(desc.mip_level_size(2), Some(wgpu::Extent3d { width: 25, height: 15, depth_or_array_layers: 1 }));
assert_eq!(desc.mip_level_size(3), Some(wgpu::Extent3d { width: 12, height: 7, depth_or_array_layers: 1 }));
assert_eq!(desc.mip_level_size(4), Some(wgpu::Extent3d { width: 6, height: 3, depth_or_array_layers: 1 }));
assert_eq!(desc.mip_level_size(5), Some(wgpu::Extent3d { width: 3, height: 1, depth_or_array_layers: 1 }));
assert_eq!(desc.mip_level_size(6), Some(wgpu::Extent3d { width: 1, height: 1, depth_or_array_layers: 1 }));
assert_eq!(desc.mip_level_size(7), None);

pub fn compute_render_extent(&self, mip_level: u32) -> Extent3d

Computes the render extent of this texture.

https://gpuweb.github.io/gpuweb/#abstract-opdef-compute-render-extent

pub fn array_layer_count(&self) -> u32

Returns the number of array layers.

https://gpuweb.github.io/gpuweb/#abstract-opdef-array-layer-count

Trait Implementations

impl<L, V> Clone for TextureDescriptor<L, V>

where L: Clone, V: Clone,

fn clone(&self) -> TextureDescriptor<L, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L, V> Debug for TextureDescriptor<L, V>

where L: Debug, V: Debug,

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

Formats the value using the given formatter.

impl<'de, L, V> Deserialize<'de> for TextureDescriptor<L, V>

where L: Deserialize<'de>, V: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<TextureDescriptor<L, V>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<L, V> Hash for TextureDescriptor<L, V>

where L: Hash, V: Hash,

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

where __H: Hasher,

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<L, V> PartialEq for TextureDescriptor<L, V>

where L: PartialEq, V: PartialEq,

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

where L: Serialize, V: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<L, V> Eq for TextureDescriptor<L, V>

where L: Eq, V: Eq,

impl<L, V> StructuralPartialEq for TextureDescriptor<L, V>