[fix] render warnings.

Author: vmarcella

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

@@ -135,6 +135,12 @@ pub struct BindGroupLayoutBuilder {
   samplers: Vec<(u32, BindingVisibility)>,
 }
 
+impl Default for BindGroupLayoutBuilder {
+  fn default() -> Self {
+    return Self::new();
+  }
+}
+
 impl BindGroupLayoutBuilder {
   /// Create a new builder with no bindings.
   pub fn new() -> Self {
@@ -300,6 +306,12 @@ pub struct BindGroupBuilder<'a> {
   samplers: Vec<(u32, Rc<lambda_platform::wgpu::texture::Sampler>)>,
 }
 
+impl<'a> Default for BindGroupBuilder<'a> {
+  fn default() -> Self {
+    return Self::new();
+  }
+}
+
 impl<'a> BindGroupBuilder<'a> {
   /// Create a new builder with no layout.
   pub fn new() -> Self {

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

@@ -25,7 +25,6 @@ use lambda_platform::wgpu::buffer as platform_buffer;
 use super::{
   gpu::Gpu,
   mesh::Mesh,
-  vertex::Vertex,
   RenderContext,
 };
 
@@ -237,6 +236,12 @@ pub struct BufferBuilder {
   label: Option<String>,
 }
 
+impl Default for BufferBuilder {
+  fn default() -> Self {
+    return Self::new();
+  }
+}
+
 impl BufferBuilder {
   /// Creates a new buffer builder of type vertex.
   pub fn new() -> Self {
@@ -324,7 +329,7 @@ impl BufferBuilder {
   ) -> Result<Buffer, &'static str> {
     let builder = Self::new();
     return builder
-      .with_length(mesh.vertices().len() * std::mem::size_of::<Vertex>())
+      .with_length(std::mem::size_of_val(mesh.vertices()))
       .with_usage(Usage::VERTEX)
       .with_properties(Properties::CPU_VISIBLE)
       .with_buffer_type(BufferType::Vertex)

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

@@ -44,7 +44,6 @@ use super::{
   },
   color_attachments::RenderColorAttachments,
   command::IndexFormat,
-  pipeline,
   pipeline::RenderPipeline,
   render_pass::RenderPass,
   texture::{
@@ -211,9 +210,6 @@ pub struct RenderPassEncoder<'pass> {
 #[derive(Clone)]
 struct CurrentPipeline {
   label: String,
-  has_color_targets: bool,
-  expects_depth_stencil: bool,
-  uses_stencil: bool,
   per_instance_slots: Vec<bool>,
 }
 
@@ -374,10 +370,7 @@ impl<'pass> RenderPassEncoder<'pass> {
     {
       let label = pipeline.pipeline().label().unwrap_or("unnamed").to_string();
       self.current_pipeline = Some(CurrentPipeline {
-        label: label.clone(),
-        has_color_targets: pipeline.has_color_targets(),
-        expects_depth_stencil: pipeline.expects_depth_stencil(),
-        uses_stencil: pipeline.uses_stencil(),
+        label,
         per_instance_slots: pipeline.per_instance_slots().clone(),
       });
     }
@@ -517,7 +510,7 @@ impl<'pass> RenderPassEncoder<'pass> {
       }
 
       let buffer_size = buffer.raw().size();
-      if buffer_size % element_size != 0 {
+      if !buffer_size.is_multiple_of(element_size) {
         return Err(RenderPassError::Validation(format!(
           "Index buffer size {} bytes is not a multiple of element size {} \
            for format {:?}",

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

@@ -47,6 +47,12 @@ pub struct MeshBuilder {
   attributes: Vec<VertexAttribute>,
 }
 
+impl Default for MeshBuilder {
+  fn default() -> Self {
+    return Self::new();
+  }
+}
+
 impl MeshBuilder {
   /// Creates a new mesh builder.
   pub fn new() -> Self {

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

@@ -219,6 +219,7 @@ impl RenderContextBuilder {
 ///   reconfiguration with preserved present mode and usage.
 pub struct RenderContext {
   label: String,
+  #[allow(dead_code)]
   instance: instance::Instance,
   surface: targets::surface::WindowSurface,
   gpu: gpu::Gpu,
@@ -243,6 +244,11 @@ pub struct RenderContext {
 pub type ResourceId = usize;
 
 impl RenderContext {
+  /// Optional label assigned when constructing the context.
+  pub fn label(&self) -> &str {
+    return self.label.as_str();
+  }
+
   /// Current surface size in pixels.
   ///
   /// This reflects the most recent configured surface dimensions and is used
@@ -428,25 +434,6 @@ impl RenderContext {
     return self.depth_format;
   }
 
-  pub(crate) fn supports_surface_sample_count(
-    &self,
-    sample_count: u32,
-  ) -> bool {
-    return self
-      .gpu
-      .supports_sample_count_for_format(self.config.format, sample_count);
-  }
-
-  pub(crate) fn supports_depth_sample_count(
-    &self,
-    format: 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.limit_max_uniform_buffer_binding_size();
@@ -519,10 +506,7 @@ impl RenderContext {
         targets::surface::SurfaceError::Lost
         | targets::surface::SurfaceError::Outdated => {
           self.reconfigure_surface(self.size)?;
-          self
-            .surface
-            .acquire_frame()
-            .map_err(|e| RenderError::Surface(e))?
+          self.surface.acquire_frame().map_err(RenderError::Surface)?
         }
         _ => return Err(RenderError::Surface(err)),
       },
@@ -836,14 +820,14 @@ impl RenderContext {
     command_iter: &mut std::vec::IntoIter<RenderCommand>,
     rp_encoder: &mut encoder::RenderPassEncoder<'_>,
     initial_viewport: &viewport::Viewport,
-    render_pipelines: &Vec<RenderPipeline>,
-    bind_groups: &Vec<bind::BindGroup>,
-    buffers: &Vec<Rc<buffer::Buffer>>,
+    render_pipelines: &[RenderPipeline],
+    bind_groups: &[bind::BindGroup],
+    buffers: &[Rc<buffer::Buffer>],
     min_uniform_buffer_offset_alignment: u32,
   ) -> Result<(), RenderPassError> {
     rp_encoder.set_viewport(initial_viewport);
 
-    while let Some(cmd) = command_iter.next() {
+    for cmd in command_iter.by_ref() {
       match cmd {
         RenderCommand::EndRenderPass => return Ok(()),
         RenderCommand::SetStencilReference { reference } => {
@@ -896,7 +880,7 @@ impl RenderContext {
                 "Vertex buffer index {buffer} not found for pipeline {pipeline}"
               ))
             })?;
-          rp_encoder.set_vertex_buffer(buffer as u32, buffer_ref);
+          rp_encoder.set_vertex_buffer(buffer, buffer_ref);
         }
         RenderCommand::BindIndexBuffer { buffer, format } => {
           let buffer_ref = buffers.get(buffer).ok_or_else(|| {

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

@@ -270,6 +270,12 @@ pub struct RenderPipelineBuilder {
   depth_write_enabled: Option<bool>,
 }
 
+impl Default for RenderPipelineBuilder {
+  fn default() -> Self {
+    return Self::new();
+  }
+}
+
 impl RenderPipelineBuilder {
   /// Creates a new render pipeline builder.
   pub fn new() -> Self {

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

@@ -135,7 +135,6 @@ impl DepthOperations {
 /// The pass defines the initial clear for the color attachment and an optional
 /// label. Depth/stencil may be added in a future iteration.
 pub struct RenderPass {
-  clear_color: [f64; 4],
   label: Option<String>,
   color_operations: ColorOperations,
   depth_operations: Option<DepthOperations>,
@@ -148,10 +147,6 @@ impl RenderPass {
   /// Destroy the pass. Kept for symmetry with other resources.
   pub fn destroy(self, _gpu: &Gpu) {}
 
-  pub(crate) fn clear_color(&self) -> [f64; 4] {
-    return self.clear_color;
-  }
-
   pub(crate) fn label(&self) -> Option<&str> {
     self.label.as_deref()
   }
@@ -193,6 +188,12 @@ pub struct RenderPassBuilder {
   use_color: bool,
 }
 
+impl Default for RenderPassBuilder {
+  fn default() -> Self {
+    return Self::new();
+  }
+}
+
 impl RenderPassBuilder {
   /// Creates a new render pass builder.
   pub fn new() -> Self {
@@ -356,7 +357,6 @@ impl RenderPassBuilder {
     );
 
     return RenderPass {
-      clear_color: self.clear_color,
       label: self.label,
       color_operations: self.color_operations,
       depth_operations: self.depth_operations,

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

@@ -192,6 +192,7 @@ pub fn compute_model_view_projection_matrix(
 
 /// Compute a full model-view-projection matrix for a rotation around a specific
 /// local-space pivot point.
+#[allow(clippy::too_many_arguments)]
 pub fn compute_model_view_projection_matrix_about_pivot(
   camera: &SimpleCamera,
   viewport_width: u32,
@@ -246,20 +247,12 @@ mod tests {
     let mut expected: [[f32; 4]; 4] = m::identity_matrix(4, 4);
     expected = m::rotate_matrix(expected, axis, angle_in_turns);
 
-    let mut s: [[f32; 4]; 4] = [[0.0; 4]; 4];
-    for i in 0..4 {
-      for j in 0..4 {
-        s[i][j] = if i == j {
-          if i == 3 {
-            1.0
-          } else {
-            scale
-          }
-        } else {
-          0.0
-        };
-      }
-    }
+    let s: [[f32; 4]; 4] = [
+      [scale, 0.0, 0.0, 0.0],
+      [0.0, scale, 0.0, 0.0],
+      [0.0, 0.0, scale, 0.0],
+      [0.0, 0.0, 0.0, 1.0],
+    ];
     expected = expected.multiply(&s);
 
     let t: [[f32; 4]; 4] = m::translation_matrix(translation);

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

@@ -35,6 +35,12 @@ pub struct ShaderBuilder {
   compiler: ShaderCompiler,
 }
 
+impl Default for ShaderBuilder {
+  fn default() -> Self {
+    return Self::new();
+  }
+}
+
 impl ShaderBuilder {
   /// Creates a new shader builder that can be reused for compiling shaders.
   pub fn new() -> Self {
@@ -78,4 +84,9 @@ impl Shader {
   pub fn as_binary(&self) -> Vec<u32> {
     return self.binary.clone();
   }
+
+  /// Borrow the `VirtualShader` used to compile this shader.
+  pub fn virtual_shader(&self) -> &VirtualShader {
+    return &self.virtual_shader;
+  }
 }

crates/lambda-rs/src/render/targets/offscreen.rs

@@ -60,9 +60,7 @@ impl OffscreenTarget {
   }
 
   /// Access the multi-sampled color attachment used for rendering.
-  pub(crate) fn msaa_color_texture(
-    &self,
-  ) -> Option<&texture::ColorAttachmentTexture> {
+  pub fn msaa_color_texture(&self) -> Option<&texture::ColorAttachmentTexture> {
     return self.msaa_color.as_ref();
   }
 
@@ -75,7 +73,7 @@ impl OffscreenTarget {
   }
 
   /// Optional debug label assigned at creation time.
-  pub(crate) fn label(&self) -> Option<&str> {
+  pub fn label(&self) -> Option<&str> {
     return self.label.as_deref();
   }
 
@@ -141,6 +139,12 @@ pub struct OffscreenTargetBuilder {
   sample_count: u32,
 }
 
+impl Default for OffscreenTargetBuilder {
+  fn default() -> Self {
+    return Self::new();
+  }
+}
+
 impl OffscreenTargetBuilder {
   /// Create a new builder with no attachments configured.
   pub fn new() -> Self {
@@ -198,7 +202,7 @@ impl OffscreenTargetBuilder {
     let (width, height) = self.resolve_size()?;
 
     let sample_count = self.sample_count.max(1);
-    if let Err(_) = validation::validate_sample_count(sample_count) {
+    if validation::validate_sample_count(sample_count).is_err() {
       return Err(OffscreenTargetError::UnsupportedSampleCount {
         requested: sample_count,
       });