# Limits in maplibre::render::settings - Rust
Represents the sets of limits an adapter/device supports.
Keywords: rust, rustlang, rust-lang, Limits

# Struct maplibre::render::settings::Limits

[−]

    #[repr(C)]pub struct Limits {Show 27 fields
        pub max_texture_dimension_1d: u32,
        pub max_texture_dimension_2d: u32,
        pub max_texture_dimension_3d: u32,
        pub max_texture_array_layers: u32,
        pub max_bind_groups: u32,
        pub max_dynamic_uniform_buffers_per_pipeline_layout: u32,
        pub max_dynamic_storage_buffers_per_pipeline_layout: u32,
        pub max_sampled_textures_per_shader_stage: u32,
        pub max_samplers_per_shader_stage: u32,
        pub max_storage_buffers_per_shader_stage: u32,
        pub max_storage_textures_per_shader_stage: u32,
        pub max_uniform_buffers_per_shader_stage: u32,
        pub max_uniform_buffer_binding_size: u32,
        pub max_storage_buffer_binding_size: u32,
        pub max_vertex_buffers: u32,
        pub max_vertex_attributes: u32,
        pub max_vertex_buffer_array_stride: u32,
        pub max_push_constant_size: u32,
        pub min_uniform_buffer_offset_alignment: u32,
        pub min_storage_buffer_offset_alignment: u32,
        pub max_inter_stage_shader_components: u32,
        pub max_compute_workgroup_storage_size: u32,
        pub max_compute_invocations_per_workgroup: u32,
        pub max_compute_workgroup_size_x: u32,
        pub max_compute_workgroup_size_y: u32,
        pub max_compute_workgroup_size_z: u32,
        pub max_compute_workgroups_per_dimension: u32,
    }

Expand description

Represents the sets of limits an adapter/device supports.

We provide three different defaults.

- `Limits::downlevel_defaults()`. This is a set of limits that is guaranteed to work on almost all backends, including “downlevel” backends such as OpenGL and D3D11, other than WebGL. For most applications we recommend using these limits, assuming they are high enough for your application, and you do not intent to support WebGL.
- `Limits::downlevel_webgl2_defaults()` This is a set of limits that is lower even than the `downlevel_defaults()`, configured to be low enough to support running in the browser using WebGL2.
- `Limits::default()`. This is the set of limits that is guarenteed to work on all modern backends and is guarenteed to be supported by WebGPU. Applications needing more modern features can use this as a reasonable set of limits if they are targetting only desktop and modern mobile devices.

We recommend starting with the most restrictive limits you can and manually increasing the limits you need boosted. This will let you stay running on all hardware that supports the limits you need.

Limits “better” than the default must be supported by the adapter and requested when requesting a device. If limits “better” than the adapter supports are requested, requesting a device will panic. Once a device is requested, you may only use resources up to the limits requested even if the adapter supports “better” limits.

Requesting limits that are “better” than you need may cause performance to decrease because the implementation needs to support more than is needed. You should ideally only request exactly what you need.

Corresponds to WebGPU `GPUSupportedLimits`.

## Fields

`max_texture_dimension_1d: u32`

Maximum allowed value for the `size.width` of a texture created with `TextureDimension::D1`. Defaults to 8192. Higher is “better”.

`max_texture_dimension_2d: u32`

Maximum allowed value for the `size.width` and `size.height` of a texture created with `TextureDimension::D2`. Defaults to 8192. Higher is “better”.

`max_texture_dimension_3d: u32`

Maximum allowed value for the `size.width`, `size.height`, and `size.depth_or_array_layers` of a texture created with `TextureDimension::D3`. Defaults to 2048. Higher is “better”.

`max_texture_array_layers: u32`

Maximum allowed value for the `size.depth_or_array_layers` of a texture created with `TextureDimension::D1` or `TextureDimension::D2`. Defaults to 256. Higher is “better”.

`max_bind_groups: u32`

Amount of bind groups that can be attached to a pipeline at the same time. Defaults to 4. Higher is “better”.

`max_dynamic_uniform_buffers_per_pipeline_layout: u32`

Amount of uniform buffer bindings that can be dynamic in a single pipeline. Defaults to 8. Higher is “better”.

`max_dynamic_storage_buffers_per_pipeline_layout: u32`

Amount of storage buffer bindings that can be dynamic in a single pipeline. Defaults to 4. Higher is “better”.

`max_sampled_textures_per_shader_stage: u32`

Amount of sampled textures visible in a single shader stage. Defaults to 16. Higher is “better”.

`max_samplers_per_shader_stage: u32`

Amount of samplers visible in a single shader stage. Defaults to 16. Higher is “better”.

`max_storage_buffers_per_shader_stage: u32`

Amount of storage buffers visible in a single shader stage. Defaults to 8. Higher is “better”.

`max_storage_textures_per_shader_stage: u32`

Amount of storage textures visible in a single shader stage. Defaults to 8. Higher is “better”.

`max_uniform_buffers_per_shader_stage: u32`

Amount of uniform buffers visible in a single shader stage. Defaults to 12. Higher is “better”.

`max_uniform_buffer_binding_size: u32`

Maximum size in bytes of a binding to a uniform buffer. Defaults to 64 KB. Higher is “better”.

`max_storage_buffer_binding_size: u32`

Maximum size in bytes of a binding to a storage buffer. Defaults to 128 MB. Higher is “better”.

`max_vertex_buffers: u32`

Maximum length of `VertexState::buffers` when creating a `RenderPipeline`. Defaults to 8. Higher is “better”.

`max_vertex_attributes: u32`

Maximum length of `VertexBufferLayout::attributes`, summed over all `VertexState::buffers`, when creating a `RenderPipeline`. Defaults to 16. Higher is “better”.

`max_vertex_buffer_array_stride: u32`

Maximum value for `VertexBufferLayout::array_stride` when creating a `RenderPipeline`. Defaults to 2048. Higher is “better”.

`max_push_constant_size: u32`

Amount of storage available for push constants in bytes. Defaults to 0. Higher is “better”. Requesting more than 0 during device creation requires `Features::PUSH_CONSTANTS` to be enabled.

Expect the size to be:

- Vulkan: 128-256 bytes
- DX12: 256 bytes
- Metal: 4096 bytes
- DX11 & OpenGL don’t natively support push constants, and are emulated with uniforms, so this number is less useful but likely 256.

`min_uniform_buffer_offset_alignment: u32`

Required `BufferBindingType::Uniform` alignment for `BufferBinding::offset` when creating a `BindGroup`, or for `set_bind_group` `dynamicOffsets`. Defaults to 256. Lower is “better”.

`min_storage_buffer_offset_alignment: u32`

Required `BufferBindingType::Storage` alignment for `BufferBinding::offset` when creating a `BindGroup`, or for `set_bind_group` `dynamicOffsets`. Defaults to 256. Lower is “better”.

`max_inter_stage_shader_components: u32`

Maximum allowed number of components (scalars) of input or output locations for inter-stage communication (vertex outputs to fragment inputs). Defaults to 60.

`max_compute_workgroup_storage_size: u32`

Maximum number of bytes used for workgroup memory in a compute entry point. Defaults to 16352.

`max_compute_invocations_per_workgroup: u32`

Maximum value of the product of the `workgroup_size` dimensions for a compute entry-point. Defaults to 256.

`max_compute_workgroup_size_x: u32`

The maximum value of the workgroup_size X dimension for a compute stage `ShaderModule` entry-point. Defaults to 256.

`max_compute_workgroup_size_y: u32`

The maximum value of the workgroup_size Y dimension for a compute stage `ShaderModule` entry-point. Defaults to 256.

`max_compute_workgroup_size_z: u32`

The maximum value of the workgroup_size Z dimension for a compute stage `ShaderModule` entry-point. Defaults to 64.

`max_compute_workgroups_per_dimension: u32`

The maximum value for each dimension of a `ComputePass::dispatch(x, y, z)` operation. Defaults to 65535.

## Implementations

### impl Limits

#### pub fn downlevel_defaults() -> Limits

These default limits are guarenteed to be compatible with GLES-3.1, and D3D11

#### pub fn downlevel_webgl2_defaults() -> Limits

These default limits are guarenteed to be compatible with GLES-3.0, and D3D11, and WebGL2

#### pub fn using_resolution(self, other: Limits) -> Limits

Modify the current limits to use the resolution limits of the other.

This is useful because the swapchain might need to be larger than any other image in the application.

If your application only needs 512x512, you might be running on a 4k display and need extremely high resolution limits.

#### pub fn using_alignment(self, other: Limits) -> Limits

Modify the current limits to use the buffer alignment limits of the adapter.

This is useful for when you’d like to dynamically use the “best” supported buffer alignments.

#### pub fn check_limits(&self, allowed: &Limits) -> bool

Compares every limits within self is within the limits given in `allowed`.

If you need detailed information on failures, look at `Limits::check_limits_with_fail_fn`.

#### pub fn check_limits_with_fail_fn(
&self,
allowed: &Limits,
fatal: bool,
fail_fn: impl FnMut(&'static str, u32, u32)
)

Compares every limits within self is within the limits given in `allowed`. For an easy to use binary choice, use `Limits::check_limits`.

If a value is not within the allowed limit, this function calls the `fail_fn` with the:

- limit name
- self’s limit
- allowed’s limit.

If fatal is true, a single failure bails out the comparison after a single failure.

## Trait Implementations

### impl Clone for Limits

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

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 Limits

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

Formats the value using the given formatter. Read more

### impl Default for Limits

#### pub fn default() -> Limits

Returns the “default value” for a type. Read more

### impl Hash for Limits

#### 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<Limits> for Limits

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

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

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

This method tests for `!=`.

### impl Eq for Limits

### impl StructuralEq for Limits

### impl StructuralPartialEq for Limits

## Auto Trait Implementations

### impl RefUnwindSafe for Limits

### impl Send for Limits

### impl Sync for Limits

### impl Unpin for Limits

### impl UnwindSafe for Limits

## 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