[fix] warnings inside the platform crate.

Author: vmarcella

crates/lambda-rs-platform/Cargo.toml

@@ -54,7 +54,3 @@ wgpu-with-vulkan = ["wgpu"]
 wgpu-with-metal = ["wgpu", "wgpu/metal"]
 wgpu-with-dx12 = ["wgpu", "wgpu/dx12"]
 wgpu-with-gl = ["wgpu", "wgpu/webgl"]
-
-[profile.dev]
-crate-type = ["cdylib", "rlib"]
-incremental = true

crates/lambda-rs-platform/src/shader/naga.rs

@@ -29,6 +29,12 @@ impl ShaderCompilerBuilder {
   }
 }
 
+impl Default for ShaderCompilerBuilder {
+  fn default() -> Self {
+    return Self::new();
+  }
+}
+
 /// A shader compiler that uses naga to translate shader sources into SPIR-V.
 pub struct ShaderCompiler {}
 
@@ -90,9 +96,11 @@ impl ShaderCompiler {
       .validate(&module)
       .expect("Failed to validate shader module.");
 
-    let mut options = spv::Options::default();
-    options.lang_version = (1, 5);
-    options.flags = spv::WriterFlags::empty();
+    let options = spv::Options {
+      lang_version: (1, 5),
+      flags: spv::WriterFlags::empty(),
+      ..Default::default()
+    };
 
     let pipeline_options = spv::PipelineOptions {
       shader_stage: stage,

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

@@ -111,7 +111,7 @@ mod tests {
         multisampled,
       } => {
         assert_eq!(view_dimension, wgpu::TextureViewDimension::D2);
-        assert_eq!(multisampled, false);
+        assert!(!multisampled);
         match sample_type {
           wgpu::TextureSampleType::Float { filterable } => assert!(filterable),
           _ => panic!("expected float sample type"),

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

@@ -124,7 +124,7 @@ impl GpuBuilder {
   ///
   /// Returns an error if no adapter is available, required features are
   /// missing, or device creation fails.
-  pub fn build<'surface, 'window>(
+  pub fn build<'surface>(
     self,
     instance: &Instance,
     surface: Option<&Surface<'surface>>,
@@ -160,12 +160,17 @@ impl GpuBuilder {
       adapter,
       device,
       queue,
-      features: descriptor.required_features,
       limits: descriptor.required_limits,
     });
   }
 }
 
+impl Default for GpuBuilder {
+  fn default() -> Self {
+    return Self::new();
+  }
+}
+
 /// Errors emitted while building a `Gpu`.
 #[derive(Debug)]
 pub enum GpuBuildError {
@@ -187,13 +192,12 @@ impl From<wgpu::RequestDeviceError> for GpuBuildError {
 }
 
 /// Holds the chosen adapter along with its logical device and submission queue
-/// plus immutable copies of features and limits used to create the device.
+/// plus an immutable copy of the limits used to create the device.
 #[derive(Debug)]
 pub struct Gpu {
   adapter: wgpu::Adapter,
   device: wgpu::Device,
   queue: wgpu::Queue,
-  features: wgpu::Features,
   limits: wgpu::Limits,
 }
 
@@ -237,11 +241,6 @@ impl Gpu {
     &self.queue
   }
 
-  /// Features that were required and enabled during device creation.
-  pub(crate) fn features(&self) -> wgpu::Features {
-    self.features
-  }
-
   /// Limits captured at device creation time.
   pub fn limits(&self) -> GpuLimits {
     return GpuLimits {
@@ -307,7 +306,6 @@ mod tests {
   use super::*;
   use crate::wgpu::{
     instance,
-    surface,
     texture,
   };
 

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

@@ -176,6 +176,12 @@ impl InstanceBuilder {
   }
 }
 
+impl Default for InstanceBuilder {
+  fn default() -> Self {
+    return Self::new();
+  }
+}
+
 #[derive(Debug)]
 /// Thin wrapper over `wgpu::Instance` that preserves a user label and exposes
 /// a blocking `request_adapter` convenience.

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

@@ -206,6 +206,11 @@ impl ShaderModule {
   pub fn raw(&self) -> &wgpu::ShaderModule {
     &self.raw
   }
+
+  /// Optional debug label used during creation.
+  pub fn label(&self) -> Option<&str> {
+    return self.label.as_deref();
+  }
 }
 
 /// Wrapper around `wgpu::PipelineLayout`.
@@ -220,6 +225,11 @@ impl PipelineLayout {
   pub fn raw(&self) -> &wgpu::PipelineLayout {
     return &self.raw;
   }
+
+  /// Optional debug label used during creation.
+  pub fn label(&self) -> Option<&str> {
+    return self.label.as_deref();
+  }
 }
 
 /// Builder for creating a `PipelineLayout`.
@@ -229,6 +239,12 @@ pub struct PipelineLayoutBuilder<'a> {
   immediate_data_ranges: Vec<ImmediateDataRange>,
 }
 
+impl<'a> Default for PipelineLayoutBuilder<'a> {
+  fn default() -> Self {
+    return Self::new();
+  }
+}
+
 /// Align a `u32` value up to the provided power-of-two alignment.
 fn align_up_u32(value: u32, alignment: u32) -> u32 {
   if alignment == 0 {
@@ -459,10 +475,6 @@ impl RenderPipeline {
   pub(crate) fn raw(&self) -> &wgpu::RenderPipeline {
     return &self.raw;
   }
-  /// Consume and return the raw pipeline.
-  pub(crate) fn into_raw(self) -> wgpu::RenderPipeline {
-    return self.raw;
-  }
   /// Pipeline label if provided.
   pub fn label(&self) -> Option<&str> {
     return self.label.as_deref();
@@ -480,6 +492,12 @@ pub struct RenderPipelineBuilder<'a> {
   sample_count: u32,
 }
 
+impl<'a> Default for RenderPipelineBuilder<'a> {
+  fn default() -> Self {
+    return Self::new();
+  }
+}
+
 impl<'a> RenderPipelineBuilder<'a> {
   /// New builder with defaults.
   pub fn new() -> Self {

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

@@ -115,12 +115,6 @@ pub struct RenderPass<'a> {
   pub(super) raw: wgpu::RenderPass<'a>,
 }
 
-#[derive(Debug)]
-struct RenderPassKeepAlive<'a> {
-  color_attachments: [Option<wgpu::RenderPassColorAttachment<'a>>; 1],
-  label: Option<String>,
-}
-
 impl<'a> RenderPass<'a> {
   /// Set the active render pipeline.
   pub fn set_pipeline(&mut self, pipeline: &pipeline::RenderPipeline) {
@@ -254,10 +248,8 @@ impl<'a> RenderColorAttachments<'a> {
     &mut self,
     operations: wgpu::Operations<wgpu::Color>,
   ) {
-    for attachment in &mut self.attachments {
-      if let Some(ref mut a) = attachment {
-        a.ops = operations;
-      }
+    for a in self.attachments.iter_mut().flatten() {
+      a.ops = operations;
     }
   }
 

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

@@ -84,23 +84,6 @@ impl SurfaceConfig {
         .collect(),
     };
   }
-
-  pub(crate) fn to_wgpu(&self) -> wgpu::SurfaceConfiguration {
-    let mut view_formats: Vec<wgpu::TextureFormat> = Vec::new();
-    for vf in &self.view_formats {
-      view_formats.push(vf.to_wgpu());
-    }
-    return wgpu::SurfaceConfiguration {
-      usage: self.usage.to_wgpu(),
-      format: self.format.to_wgpu(),
-      width: self.width,
-      height: self.height,
-      present_mode: self.present_mode.to_wgpu(),
-      desired_maximum_frame_latency: 2,
-      alpha_mode: wgpu::CompositeAlphaMode::Opaque,
-      view_formats,
-    };
-  }
 }
 
 /// Error wrapper for surface acquisition and presentation errors.
@@ -154,10 +137,10 @@ impl SurfaceBuilder {
   /// Safety: we use `create_surface_unsafe` by forwarding raw window/display
   /// handles from `winit`. Lambda guarantees the window outlives the surface
   /// for the duration of the runtime.
-  pub fn build<'window>(
+  pub fn build(
     self,
     instance: &Instance,
-    window: &'window WindowHandle,
+    window: &WindowHandle,
   ) -> Result<Surface<'static>, CreateSurfaceError> {
     // SAFETY: We ensure the raw window/display handles outlive the surface by
     // keeping the window alive for the duration of the application runtime.
@@ -192,6 +175,12 @@ impl SurfaceBuilder {
   }
 }
 
+impl Default for SurfaceBuilder {
+  fn default() -> Self {
+    return Self::new();
+  }
+}
+
 /// Opaque error returned when surface creation fails.
 #[derive(Debug)]
 pub struct CreateSurfaceError;
@@ -351,11 +340,6 @@ impl Frame {
     return TextureViewRef { raw: &self.view };
   }
 
-  /// Consume and return the underlying parts.
-  pub(crate) fn into_parts(self) -> (wgpu::SurfaceTexture, wgpu::TextureView) {
-    return (self.texture, self.view);
-  }
-
   /// Present the frame to the swapchain.
   pub fn present(self) {
     self.texture.present();

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

@@ -253,6 +253,11 @@ impl DepthTexture {
     return self.format;
   }
 
+  /// Optional debug label used during creation.
+  pub fn label(&self) -> Option<&str> {
+    return self.label.as_deref();
+  }
+
   /// Convenience: return a `TextureViewRef` for use in render pass attachments.
   pub fn view_ref(&self) -> crate::wgpu::surface::TextureViewRef<'_> {
     return crate::wgpu::surface::TextureViewRef { raw: &self.view };
@@ -278,6 +283,11 @@ impl ColorAttachmentTexture {
     return &self.view;
   }
 
+  /// Optional debug label used during creation.
+  pub fn label(&self) -> Option<&str> {
+    return self.label.as_deref();
+  }
+
   /// Convenience: return a `TextureViewRef` for use in render pass attachments.
   pub fn view_ref(&self) -> crate::wgpu::surface::TextureViewRef<'_> {
     return crate::wgpu::surface::TextureViewRef { raw: &self.view };
@@ -371,6 +381,12 @@ pub struct DepthTextureBuilder {
   sample_count: u32,
 }
 
+impl Default for DepthTextureBuilder {
+  fn default() -> Self {
+    return Self::new();
+  }
+}
+
 impl DepthTextureBuilder {
   /// Create a builder with no size and `Depth32Float` format.
   pub fn new() -> Self {
@@ -514,6 +530,12 @@ pub struct SamplerBuilder {
   lod_max: f32,
 }
 
+impl Default for SamplerBuilder {
+  fn default() -> Self {
+    return Self::new();
+  }
+}
+
 impl SamplerBuilder {
   /// Create a new builder with nearest filtering and clamp addressing.
   pub fn new() -> Self {

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

@@ -12,13 +12,6 @@ pub enum ColorFormat {
 }
 
 impl ColorFormat {
-  pub(crate) fn to_texture_format(self) -> wgpu::TextureFormat {
-    return match self {
-      ColorFormat::Rgb32Sfloat => wgpu::TextureFormat::Rgba32Float,
-      ColorFormat::Rgba8Srgb => wgpu::TextureFormat::Rgba8UnormSrgb,
-    };
-  }
-
   pub(crate) fn to_vertex_format(self) -> wgpu::VertexFormat {
     return match self {
       ColorFormat::Rgb32Sfloat => wgpu::VertexFormat::Float32x3,