[add] device validation for sample counts, headless gpu for testing, and tests for the validation.

Author: vmarcella

crates/lambda-rs-platform/src/wgpu/gpu.rs

@@ -4,6 +4,7 @@ use super::{
   command::CommandBuffer,
   instance::Instance,
   surface::Surface,
+  texture,
 };
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -197,6 +198,24 @@ pub struct Gpu {
 }
 
 impl Gpu {
+  /// Whether the provided surface format supports the sample count for render attachments.
+  pub fn supports_sample_count_for_surface(
+    &self,
+    format: super::surface::SurfaceFormat,
+    sample_count: u32,
+  ) -> bool {
+    return self.supports_sample_count(format.to_wgpu(), sample_count);
+  }
+
+  /// Whether the provided depth format supports the sample count for render attachments.
+  pub fn supports_sample_count_for_depth(
+    &self,
+    format: texture::DepthFormat,
+    sample_count: u32,
+  ) -> bool {
+    return self.supports_sample_count(format.to_wgpu(), sample_count);
+  }
+
   /// Borrow the adapter used to create the device.
   ///
   /// Crate-visible to avoid exposing raw `wgpu` to higher layers.
@@ -245,11 +264,50 @@ impl Gpu {
     let iter = list.into_iter().map(|cb| cb.into_raw());
     self.queue.submit(iter);
   }
+
+  fn supports_sample_count(
+    &self,
+    format: wgpu::TextureFormat,
+    sample_count: u32,
+  ) -> bool {
+    if sample_count <= 1 {
+      return true;
+    }
+
+    let features = self.adapter.get_texture_format_features(format);
+    if !features
+      .allowed_usages
+      .contains(wgpu::TextureUsages::RENDER_ATTACHMENT)
+    {
+      return false;
+    }
+
+    match sample_count {
+      2 => features
+        .flags
+        .contains(wgpu::TextureFormatFeatureFlags::MULTISAMPLE_X2),
+      4 => features
+        .flags
+        .contains(wgpu::TextureFormatFeatureFlags::MULTISAMPLE_X4),
+      8 => features
+        .flags
+        .contains(wgpu::TextureFormatFeatureFlags::MULTISAMPLE_X8),
+      16 => features
+        .flags
+        .contains(wgpu::TextureFormatFeatureFlags::MULTISAMPLE_X16),
+      _ => false,
+    }
+  }
 }
 
 #[cfg(test)]
 mod tests {
   use super::*;
+  use crate::wgpu::{
+    instance,
+    surface,
+    texture,
+  };
 
   #[test]
   fn gpu_build_error_wraps_request_device_error() {
@@ -260,4 +318,121 @@ mod tests {
     fn assert_from_impl<T: From<wgpu::RequestDeviceError>>() {}
     assert_from_impl::<GpuBuildError>();
   }
+
+  /// Create an offscreen GPU for sample-count support tests.
+  ///
+  /// Returns `None` when no compatible adapter is available so tests can be
+  /// skipped instead of failing.
+  fn create_test_gpu() -> Option<Gpu> {
+    let instance = instance::InstanceBuilder::new()
+      .with_label("gpu-test-instance")
+      .build();
+    return GpuBuilder::new()
+      .with_label("gpu-test-device")
+      .build(&instance, None)
+      .ok();
+  }
+
+  /// Accepts zero or single-sample attachments for any format.
+  #[test]
+  fn single_sample_always_supported() {
+    let gpu = match create_test_gpu() {
+      Some(gpu) => gpu,
+      None => {
+        eprintln!(
+          "Skipping single_sample_always_supported: no compatible GPU adapter"
+        );
+        return;
+      }
+    };
+    let surface_format =
+      surface::SurfaceFormat::from_wgpu(wgpu::TextureFormat::Bgra8UnormSrgb);
+    let depth_format = texture::DepthFormat::Depth32Float;
+
+    assert!(gpu.supports_sample_count_for_surface(surface_format, 1));
+    assert!(gpu.supports_sample_count_for_surface(surface_format, 0));
+    assert!(gpu.supports_sample_count_for_depth(depth_format, 1));
+    assert!(gpu.supports_sample_count_for_depth(depth_format, 0));
+  }
+
+  /// Rejects sample counts that are outside the supported set.
+  #[test]
+  fn unsupported_sample_count_rejected() {
+    let gpu = match create_test_gpu() {
+      Some(gpu) => gpu,
+      None => {
+        eprintln!(
+          "Skipping unsupported_sample_count_rejected: no compatible GPU adapter"
+        );
+        return;
+      }
+    };
+    let surface_format =
+      surface::SurfaceFormat::from_wgpu(wgpu::TextureFormat::Bgra8Unorm);
+    let depth_format = texture::DepthFormat::Depth32Float;
+
+    assert!(!gpu.supports_sample_count_for_surface(surface_format, 3));
+    assert!(!gpu.supports_sample_count_for_depth(depth_format, 3));
+  }
+
+  /// Mirrors the adapter's texture feature flags for surface formats.
+  #[test]
+  fn surface_support_matches_texture_features() {
+    let gpu = match create_test_gpu() {
+      Some(gpu) => gpu,
+      None => {
+        eprintln!(
+          "Skipping surface_support_matches_texture_features: \
+no compatible GPU adapter"
+        );
+        return;
+      }
+    };
+    let surface_format =
+      surface::SurfaceFormat::from_wgpu(wgpu::TextureFormat::Bgra8UnormSrgb);
+    let features = gpu
+      .adapter
+      .get_texture_format_features(surface_format.to_wgpu());
+    let expected = features
+      .allowed_usages
+      .contains(wgpu::TextureUsages::RENDER_ATTACHMENT)
+      && features
+        .flags
+        .contains(wgpu::TextureFormatFeatureFlags::MULTISAMPLE_X4);
+
+    assert_eq!(
+      gpu.supports_sample_count_for_surface(surface_format, 4),
+      expected
+    );
+  }
+
+  /// Mirrors the adapter's texture feature flags for depth formats.
+  #[test]
+  fn depth_support_matches_texture_features() {
+    let gpu = match create_test_gpu() {
+      Some(gpu) => gpu,
+      None => {
+        eprintln!(
+          "Skipping depth_support_matches_texture_features: \
+no compatible GPU adapter"
+        );
+        return;
+      }
+    };
+    let depth_format = texture::DepthFormat::Depth32Float;
+    let features = gpu
+      .adapter
+      .get_texture_format_features(depth_format.to_wgpu());
+    let expected = features
+      .allowed_usages
+      .contains(wgpu::TextureUsages::RENDER_ATTACHMENT)
+      && features
+        .flags
+        .contains(wgpu::TextureFormatFeatureFlags::MULTISAMPLE_X4);
+
+    assert_eq!(
+      gpu.supports_sample_count_for_depth(depth_format, 4),
+      expected
+    );
+  }
 }

crates/lambda-rs-platform/src/wgpu/surface.rs

@@ -93,6 +93,10 @@ impl std::ops::BitOr for TextureUsages {
 pub struct SurfaceFormat(wgpu::TextureFormat);
 
 impl SurfaceFormat {
+  /// Common sRGB swapchain format used for windowed rendering.
+  pub const BGRA8_UNORM_SRGB: SurfaceFormat =
+    SurfaceFormat(wgpu::TextureFormat::Bgra8UnormSrgb);
+
   pub(crate) fn to_wgpu(self) -> wgpu::TextureFormat {
     return self.0;
   }

crates/lambda-rs/src/render/mod.rs

@@ -347,6 +347,29 @@ impl RenderContext {
     return self.config.format;
   }
 
+  pub(crate) fn depth_format(&self) -> platform::texture::DepthFormat {
+    return self.depth_format;
+  }
+
+  pub(crate) fn supports_surface_sample_count(
+    &self,
+    sample_count: u32,
+  ) -> bool {
+    return self
+      .gpu
+      .supports_sample_count_for_surface(self.config.format, sample_count);
+  }
+
+  pub(crate) fn supports_depth_sample_count(
+    &self,
+    format: platform::texture::DepthFormat,
+    sample_count: u32,
+  ) -> bool {
+    return self
+      .gpu
+      .supports_sample_count_for_depth(format, sample_count);
+  }
+
   /// Device limit: maximum bytes that can be bound for a single uniform buffer binding.
   pub fn limit_max_uniform_buffer_binding_size(&self) -> u64 {
     return self.gpu.limits().max_uniform_buffer_binding_size;