From 1a6ab97dd06cc832df08ef2cf49cabad731d4597 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marcel=20M=C3=A4rtens?= Date: Tue, 14 May 2024 10:41:01 +0200 Subject: [PATCH] some cargo clippy improvements (ignored some, because they make sense, e.g. allignment '+ 0') --- src/pipeline.rs | 9 ++++--- src/rasterizer/lines.rs | 40 ++++++++++++++-------------- src/rasterizer/mod.rs | 9 ++----- src/rasterizer/triangles.rs | 52 ++++++++++++++++++------------------- src/sampler/linear.rs | 2 +- src/sampler/nearest.rs | 2 +- src/texture.rs | 8 +++--- 7 files changed, 56 insertions(+), 66 deletions(-) diff --git a/src/pipeline.rs b/src/pipeline.rs index 7099131..8268d27 100644 --- a/src/pipeline.rs +++ b/src/pipeline.rs @@ -294,10 +294,9 @@ pub trait Pipeline<'r>: Sized { }; #[cfg(not(feature = "par"))] - let r = render_seq(self, fetch_vertex, target_size, pixel, depth, msaa_level); + render_seq(self, fetch_vertex, target_size, pixel, depth, msaa_level); #[cfg(feature = "par")] - let r = render_par(self, fetch_vertex, target_size, pixel, depth, msaa_level); - r + render_par(self, fetch_vertex, target_size, pixel, depth, msaa_level); } } @@ -320,7 +319,9 @@ fn render_par<'r, Pipe, S, P, D>( // TODO: Don't pull all vertices at once let vertices = fetch_vertex.collect::>(); - let threads = std::thread::available_parallelism().map(|cpu| cpu.into()).unwrap_or(1usize); + let threads = std::thread::available_parallelism() + .map(|cpu| cpu.into()) + .unwrap_or(1usize); let row = AtomicUsize::new(0); const FRAGMENTS_PER_GROUP: usize = 20_000; // Magic number, maybe make this configurable? diff --git a/src/rasterizer/lines.rs b/src/rasterizer/lines.rs index 32c31e9..8e36bed 100644 --- a/src/rasterizer/lines.rs +++ b/src/rasterizer/lines.rs @@ -58,10 +58,10 @@ impl Rasterizer for Lines { let screen_min = Vec2::::from(tgt_min).map(|e| e as f32); let screen_max = Vec2::::from(tgt_max).map(|e| e as f32); let bounds_clamped = Aabr:: { - min: (verts_screen.reduce(|a, b| Vec2::partial_min(a, b)) + 0.0) + min: (verts_screen.reduce(Vec2::partial_min) + 0.0) .clamped(screen_min, screen_max) .as_(), - max: (verts_screen.reduce(|a, b| Vec2::partial_max(a, b)) + 1.0) + max: (verts_screen.reduce(Vec2::partial_max) + 1.0) .clamped(screen_min, screen_max) .as_(), }; @@ -95,25 +95,23 @@ impl Rasterizer for Lines { // Calculate the interpolated z coordinate for the depth target let z = Lerp::lerp(verts_euc.x.z, verts_euc.y.z, frac); - if coords.passes_z_clip(z) { - if blitter.test_fragment(x, y, z) { - let get_v_data = |x: f32, y: f32| { - let frac = if use_x { - x - verts_screen.x.x - } else { - y - verts_screen.x.y - } * norm; - - V::weighted_sum2( - verts_out.x.clone(), - verts_out.y.clone(), - 1.0 - frac, - frac, - ) - }; - - blitter.emit_fragment(x, y, get_v_data, z); - } + if coords.passes_z_clip(z) && blitter.test_fragment(x, y, z) { + let get_v_data = |x: f32, y: f32| { + let frac = if use_x { + x - verts_screen.x.x + } else { + y - verts_screen.x.y + } * norm; + + V::weighted_sum2( + verts_out.x.clone(), + verts_out.y.clone(), + 1.0 - frac, + frac, + ) + }; + + blitter.emit_fragment(x, y, get_v_data, z); } }, ); diff --git a/src/rasterizer/mod.rs b/src/rasterizer/mod.rs index 67215a3..50ffe44 100644 --- a/src/rasterizer/mod.rs +++ b/src/rasterizer/mod.rs @@ -6,22 +6,17 @@ pub use self::{lines::Lines, triangles::Triangles}; use crate::{math::WeightedSum, CoordinateMode}; /// The face culling strategy used during rendering. -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] +#[derive(Default, Copy, Clone, Debug, PartialEq, Eq, Hash)] pub enum CullMode { /// Do not cull triangles regardless of their winding order None, /// Cull clockwise triangles + #[default] Back, /// Cull counter-clockwise triangles Front, } -impl Default for CullMode { - fn default() -> Self { - CullMode::Back - } -} - /// A trait for types that define an interface for blitting fragments to surfaces #[doc(hidden)] pub trait Blitter: Sized { diff --git a/src/rasterizer/triangles.rs b/src/rasterizer/triangles.rs index b6232ab..0dfa912 100644 --- a/src/rasterizer/triangles.rs +++ b/src/rasterizer/triangles.rs @@ -118,10 +118,10 @@ impl Rasterizer for Triangles { let screen_min = Vec2::::from(tgt_min).map(|e| e as f32); let screen_max = Vec2::::from(tgt_max).map(|e| e as f32); let bounds_clamped = Aabr:: { - min: (verts_screen.reduce(|a, b| Vec2::partial_min(a, b)) + 0.0) + min: (verts_screen.reduce(Vec2::partial_min) + 0.0) .map3(screen_min, screen_max, |e, min, max| e.max(min).min(max)) .as_(), - max: (verts_screen.reduce(|a, b| Vec2::partial_max(a, b)) + 1.0) + max: (verts_screen.reduce(Vec2::partial_max) + 1.0) .map3(screen_min, screen_max, |e, min, max| e.max(min).min(max)) .as_(), }; @@ -147,6 +147,7 @@ impl Rasterizer for Triangles { Vec3::new(verts_screen.y, verts_screen.z, verts_screen.x) } } else { + #[allow(clippy::collapsible_else_if)] if verts_screen.x.y < verts_screen.y.y { Vec3::new(verts_screen.z, verts_screen.x, verts_screen.y) } else { @@ -242,31 +243,28 @@ impl Rasterizer for Triangles { // Calculate the interpolated z coordinate for the depth target let z = verts_hom.map(|v| v.z).dot(w_unbalanced); - if NO_VERTS_CLIPPED || coords.passes_z_clip(z) { - if blitter.test_fragment(x, y, z) { - let get_v_data = |x: f32, y: f32| { - let w_hom = w_hom_origin + w_hom_dy * y + w_hom_dx * x; - - // Calculate vertex weights to determine vs_out lerping and intersection - let w_unbalanced = Vec3::new( - w_hom.x, - w_hom.y, - w_hom.z - w_hom.x - w_hom.y, - ); - let w = w_unbalanced * w_hom.z.recip(); - - V::weighted_sum3( - verts_out.x.clone(), - verts_out.y.clone(), - verts_out.z.clone(), - w.x, - w.y, - w.z, - ) - }; - - blitter.emit_fragment(x, y, get_v_data, z); - } + if (NO_VERTS_CLIPPED || coords.passes_z_clip(z)) + && blitter.test_fragment(x, y, z) + { + let get_v_data = |x: f32, y: f32| { + let w_hom = w_hom_origin + w_hom_dy * y + w_hom_dx * x; + + // Calculate vertex weights to determine vs_out lerping and intersection + let w_unbalanced = + Vec3::new(w_hom.x, w_hom.y, w_hom.z - w_hom.x - w_hom.y); + let w = w_unbalanced * w_hom.z.recip(); + + V::weighted_sum3( + verts_out.x.clone(), + verts_out.y.clone(), + verts_out.z.clone(), + w.x, + w.y, + w.z, + ) + }; + + blitter.emit_fragment(x, y, get_v_data, z); } } diff --git a/src/sampler/linear.rs b/src/sampler/linear.rs index e7d51ce..316c812 100644 --- a/src/sampler/linear.rs +++ b/src/sampler/linear.rs @@ -10,7 +10,7 @@ use micromath::F32Ext; /// A sampler that uses nearest-neighbor sampling. pub struct Linear(pub(crate) T, pub(crate) PhantomData); -impl<'a, T> Sampler<2> for Linear +impl Sampler<2> for Linear where T: Texture<2, Index = usize>, T::Texel: Mul + Add, diff --git a/src/sampler/nearest.rs b/src/sampler/nearest.rs index 70d8cb9..7a5030c 100644 --- a/src/sampler/nearest.rs +++ b/src/sampler/nearest.rs @@ -7,7 +7,7 @@ pub struct Nearest { pub(crate) phantom: PhantomData, } -impl<'a, T, I, const N: usize> Sampler for Nearest +impl Sampler for Nearest where T: Texture, I: Clone + Mul + Denormalize, diff --git a/src/texture.rs b/src/texture.rs index 952a3e8..d15cc24 100644 --- a/src/texture.rs +++ b/src/texture.rs @@ -154,9 +154,7 @@ impl Clone for Map { } } -impl<'a, T: Texture, U: Clone, F: Fn(T::Texel) -> U, const N: usize> Texture - for Map -{ +impl, U: Clone, F: Fn(T::Texel) -> U, const N: usize> Texture for Map { type Index = T::Index; type Texel = U; #[inline(always)] @@ -260,7 +258,7 @@ pub trait Target: Texture<2, Index = usize> { } } -impl<'a, T: Target> Target for &'a mut T { +impl Target for &mut T { #[inline(always)] unsafe fn read_exclusive_unchecked(&self, x: usize, y: usize) -> Self::Texel { T::read_exclusive_unchecked(self, x, y) @@ -341,7 +339,7 @@ where #[inline(always)] fn read(&self, [x, y]: [Self::Index; 2]) -> Self::Texel { - self.get_pixel(x as u32, y as u32).clone() + *self.get_pixel(x as u32, y as u32) } }