pub fn limits_support_compute(limits: &wgpu::Limits) -> bool {
limits.max_compute_workgroup_size_x > 0
&& limits.max_compute_workgroup_size_y > 0
&& limits.max_compute_invocations_per_workgroup > 0
&& limits.max_compute_workgroups_per_dimension > 0
}
pub fn limits_support_storage_buffers(limits: &wgpu::Limits) -> bool {
limits.max_storage_buffers_per_shader_stage > 0
}
pub fn supports_view_formats(device: &wgpu::Device) -> bool {
supports_compute(device)
}
pub fn supports_independent_blend(device: &wgpu::Device) -> bool {
supports_compute(device)
}
pub fn supports_multisampled_textures(device: &wgpu::Device) -> bool {
supports_compute(device)
}
pub fn supports_compute(device: &wgpu::Device) -> bool {
limits_support_compute(&device.limits())
}
pub fn supports_storage_buffers(device: &wgpu::Device) -> bool {
limits_support_storage_buffers(&device.limits())
}
pub fn supports_shader_material_volumes(device: &wgpu::Device) -> bool {
supports_storage_buffers(device)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_inferences_match_the_adapter() {
let mut d = wgpu::InstanceDescriptor::new_without_display_handle();
d.backends = wgpu::Backends::PRIMARY;
let instance = wgpu::Instance::new(d);
let Ok(adapter) =
pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::default(),
compatible_surface: None,
force_fallback_adapter: false,
apply_limit_buckets: false,
}))
else {
eprintln!("skipping: no GPU adapter");
return;
};
let flags = adapter.get_downlevel_capabilities().flags;
let Ok((device, _queue)) = pollster::block_on(adapter.request_device(
&wgpu::DeviceDescriptor {
label: Some("caps test device"),
required_features: wgpu::Features::empty(),
required_limits: adapter.limits(),
..Default::default()
},
)) else {
eprintln!("skipping: no device");
return;
};
for (name, inferred, reported) in [
(
"compute",
supports_compute(&device),
flags.contains(wgpu::DownlevelFlags::COMPUTE_SHADERS),
),
(
"independent blend",
supports_independent_blend(&device),
flags.contains(wgpu::DownlevelFlags::INDEPENDENT_BLEND),
),
(
"view formats",
supports_view_formats(&device),
flags.contains(wgpu::DownlevelFlags::VIEW_FORMATS),
),
] {
assert_eq!(
inferred, reported,
"{name}: inferred {inferred} from the limits, but the adapter \
reports {reported} — the inference in this module no longer \
holds on this backend ({:?})",
adapter.get_info().backend
);
}
}
#[test]
fn webgl2_limits_offer_neither_compute_nor_storage() {
let webgl2 = wgpu::Limits::downlevel_webgl2_defaults();
assert!(
!limits_support_compute(&webgl2),
"WebGL2 has no compute stage, but the limits say it does"
);
assert!(
!limits_support_storage_buffers(&webgl2),
"WebGL2 has no storage buffers, but the limits say it does"
);
}
#[test]
fn webgpu_defaults_offer_both() {
let full = wgpu::Limits::default();
assert!(limits_support_compute(&full));
assert!(limits_support_storage_buffers(&full));
}
#[test]
fn the_shader_modules_declare_no_storage_buffers() {
for (name, source) in [
("SHADER_SOURCE", crate::renderer::shader::legacy_shader_source()),
("POSTFX_SHADER", crate::renderer::shader::POSTFX_SHADER),
] {
assert!(
!source.contains("var<storage"),
"{name} declares a storage buffer, which a GLSL backend cannot \
compile — see the note on this test"
);
}
}
#[test]
fn the_native_downlevel_floor_keeps_compute() {
let downlevel = wgpu::Limits::downlevel_defaults();
assert!(
limits_support_compute(&downlevel),
"downlevel_defaults is a native floor and does have compute"
);
assert!(limits_support_storage_buffers(&downlevel));
}
}