Clippy.

Author: tychedelia

crates/processing_render/src/render/command.rs

@@ -19,11 +19,23 @@ pub enum DrawCommand {
     PushMatrix,
     PopMatrix,
     ResetMatrix,
-    Translate { x: f32, y: f32 },
-    Rotate { angle: f32 },
-    Scale { x: f32, y: f32 },
-    ShearX { angle: f32 },
-    ShearY { angle: f32 },
+    Translate {
+        x: f32,
+        y: f32,
+    },
+    Rotate {
+        angle: f32,
+    },
+    Scale {
+        x: f32,
+        y: f32,
+    },
+    ShearX {
+        angle: f32,
+    },
+    ShearY {
+        angle: f32,
+    },
 }
 
 #[derive(Debug, Default, Component)]

crates/processing_render/src/render/mod.rs

@@ -4,7 +4,9 @@ pub mod mesh_builder;
 pub mod primitive;
 pub mod transform;
 
-use bevy::{camera::visibility::RenderLayers, ecs::system::SystemParam, math::Affine3A, prelude::*};
+use bevy::{
+    camera::visibility::RenderLayers, ecs::system::SystemParam, math::Affine3A, prelude::*,
+};
 use command::{CommandBuffer, DrawCommand};
 use material::MaterialKey;
 use primitive::{TessellationMode, empty_mesh};
@@ -261,20 +263,18 @@ fn spawn_mesh(ctx: &mut RenderContext, mesh: Mesh, z_offset: f32) {
     ));
 }
 
-fn maybe_start_batch(ctx: &mut RenderContext, material_key: MaterialKey) -> bool {
+fn needs_batch(ctx: &RenderContext, material_key: &MaterialKey) -> bool {
     let current_transform = ctx.state.transform.current();
-    let material_changed = ctx.batch.material_key.as_ref() != Some(&material_key);
+    let material_changed = ctx.batch.material_key.as_ref() != Some(material_key);
     let transform_changed = ctx.batch.transform != current_transform;
+    material_changed || transform_changed
+}
 
-    if material_changed || transform_changed {
-        flush_batch(ctx);
-        ctx.batch.material_key = Some(material_key);
-        ctx.batch.transform = current_transform;
-        ctx.batch.current_mesh = Some(empty_mesh());
-        true
-    } else {
-        false
-    }
+fn start_batch(ctx: &mut RenderContext, material_key: MaterialKey) {
+    flush_batch(ctx);
+    ctx.batch.material_key = Some(material_key);
+    ctx.batch.transform = ctx.state.transform.current();
+    ctx.batch.current_mesh = Some(empty_mesh());
 }
 
 fn add_fill(ctx: &mut RenderContext, tessellate: impl FnOnce(&mut Mesh, Color)) {
@@ -286,9 +286,10 @@ fn add_fill(ctx: &mut RenderContext, tessellate: impl FnOnce(&mut Mesh, Color))
         background_image: None,
     };
 
-    maybe_start_batch(ctx, material_key);
+    if needs_batch(ctx, &material_key) {
+        start_batch(ctx, material_key);
+    }
 
-    // accumulate geometry into the current mega mesh
     if let Some(ref mut mesh) = ctx.batch.current_mesh {
         tessellate(mesh, color);
     }
@@ -304,9 +305,10 @@ fn add_stroke(ctx: &mut RenderContext, tessellate: impl FnOnce(&mut Mesh, Color,
         background_image: None,
     };
 
-    maybe_start_batch(ctx, material_key);
+    if needs_batch(ctx, &material_key) {
+        start_batch(ctx, material_key);
+    }
 
-    // accumulate geometry into the current mega mesh
     if let Some(ref mut mesh) = ctx.batch.current_mesh {
         tessellate(mesh, color, stroke_weight);
     }

crates/processing_render/src/render/transform.rs

@@ -51,7 +51,7 @@ impl TransformStack {
             Vec3::new(angle.tan(), 1.0, 0.0),
             Vec3::new(0.0, 0.0, 1.0),
         ));
-        self.current = self.current * shear;
+        self.current *= shear;
     }
 
     pub fn shear_y(&mut self, angle: f32) {
@@ -60,41 +60,41 @@ impl TransformStack {
             Vec3::new(0.0, 1.0, 0.0),
             Vec3::new(0.0, 0.0, 1.0),
         ));
-        self.current = self.current * shear;
+        self.current *= shear;
     }
 
     pub fn translate_3d(&mut self, x: f32, y: f32, z: f32) {
         let t = Affine3A::from_translation(Vec3::new(x, y, z));
-        self.current = self.current * t;
+        self.current *= t;
     }
 
     pub fn rotate_x(&mut self, angle: f32) {
         let r = Affine3A::from_quat(Quat::from_rotation_x(angle));
-        self.current = self.current * r;
+        self.current *= r;
     }
 
     pub fn rotate_y(&mut self, angle: f32) {
         let r = Affine3A::from_quat(Quat::from_rotation_y(angle));
-        self.current = self.current * r;
+        self.current *= r;
     }
 
     pub fn rotate_z(&mut self, angle: f32) {
         let r = Affine3A::from_quat(Quat::from_rotation_z(angle));
-        self.current = self.current * r;
+        self.current *= r;
     }
 
     pub fn rotate_axis(&mut self, angle: f32, axis: Vec3) {
         let r = Affine3A::from_quat(Quat::from_axis_angle(axis.normalize(), angle));
-        self.current = self.current * r;
+        self.current *= r;
     }
 
     pub fn scale_3d(&mut self, sx: f32, sy: f32, sz: f32) {
         let s = Affine3A::from_scale(Vec3::new(sx, sy, sz));
-        self.current = self.current * s;
+        self.current *= s;
     }
 
     pub fn apply(&mut self, transform: Affine3A) {
-        self.current = self.current * transform;
+        self.current *= transform;
     }
 
     pub fn to_bevy_transform(&self) -> bevy::prelude::Transform {
@@ -118,9 +118,10 @@ impl TransformStack {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use std::f32::consts::PI;
 
+    use super::*;
+
     static EPSILON: f32 = 1e-5;
 
     fn approx_eq(a: f32, b: f32) -> bool {

examples/transforms.rs

@@ -1,9 +1,10 @@
 mod glfw;
 
+use std::f32::consts::PI;
+
 use glfw::GlfwContext;
 use processing::prelude::*;
 use processing_render::render::command::DrawCommand;
-use std::f32::consts::PI;
 
 fn main() {
     sketch().unwrap();