Rework extract_meshes

Cleanup redundant code
* `extract_meshes` had two for loops which are functionally identical,
  just copy-pasted code. This was because of the split query. We merge
  them and put them in a single loop.
* The tuple literal for the command buffers was difficult to read,
  because it spanned many levels of idententations and lines of codes.
  they now fit in a single line.

Author: nicopap

crates/bevy_pbr/src/render/mesh.rs

@@ -116,79 +116,43 @@ bitflags::bitflags! {
 
 pub fn extract_meshes(
     mut commands: Commands,
-    mut previous_caster_len: Local<usize>,
-    mut previous_not_caster_len: Local<usize>,
-    caster_query: Query<
-        (
-            Entity,
-            &ComputedVisibility,
-            &GlobalTransform,
-            &Handle<Mesh>,
-            Option<&NotShadowReceiver>,
-        ),
-        Without<NotShadowCaster>,
-    >,
-    not_caster_query: Query<
-        (
-            Entity,
-            &ComputedVisibility,
-            &GlobalTransform,
-            &Handle<Mesh>,
-            Option<&NotShadowReceiver>,
-        ),
-        With<NotShadowCaster>,
-    >,
+    mut prev_len_shadow_caster: Local<usize>,
+    mut prev_len_not_shadow_caster: Local<usize>,
+    meshes_query: Query<(
+        Entity,
+        &ComputedVisibility,
+        &GlobalTransform,
+        &Handle<Mesh>,
+        Option<Without<NotShadowReceiver>>,
+        Option<Without<NotShadowCaster>>,
+    )>,
 ) {
-    let mut caster_values = Vec::with_capacity(*previous_caster_len);
-    for (entity, computed_visibility, transform, handle, not_receiver) in caster_query.iter() {
-        if !computed_visibility.is_visible {
-            continue;
-        }
-        let transform = transform.compute_matrix();
-        caster_values.push((
-            entity,
-            (
-                handle.clone_weak(),
-                MeshUniform {
-                    flags: if not_receiver.is_some() {
-                        MeshFlags::empty().bits
-                    } else {
-                        MeshFlags::SHADOW_RECEIVER.bits
-                    },
-                    transform,
-                    inverse_transpose_model: transform.inverse().transpose(),
-                },
-            ),
-        ));
-    }
-    *previous_caster_len = caster_values.len();
-    commands.insert_or_spawn_batch(caster_values);
+    let mut caster_commands = Vec::with_capacity(*prev_len_shadow_caster);
+    let mut not_caster_commands = Vec::with_capacity(*prev_len_not_shadow_caster);
+    let visible_meshes = meshes_query.iter().filter(|(_, vis, ..)| vis.is_visible);
 
-    let mut not_caster_values = Vec::with_capacity(*previous_not_caster_len);
-    for (entity, computed_visibility, transform, mesh, not_receiver) in not_caster_query.iter() {
-        if !computed_visibility.is_visible {
-            continue;
-        }
+    for (entity, _, transform, handle, is_receiver, is_caster) in visible_meshes {
         let transform = transform.compute_matrix();
-        not_caster_values.push((
-            entity,
-            (
-                mesh.clone_weak(),
-                MeshUniform {
-                    flags: if not_receiver.is_some() {
-                        MeshFlags::empty().bits
-                    } else {
-                        MeshFlags::SHADOW_RECEIVER.bits
-                    },
-                    transform,
-                    inverse_transpose_model: transform.inverse().transpose(),
-                },
-                NotShadowCaster,
-            ),
-        ));
+        let shadow_receiver_flags = if is_receiver.is_some() {
+            MeshFlags::SHADOW_RECEIVER.bits
+        } else {
+            MeshFlags::empty().bits
+        };
+        let uniform = MeshUniform {
+            flags: shadow_receiver_flags,
+            transform,
+            inverse_transpose_model: transform.inverse().transpose(),
+        };
+        if is_caster.is_some() {
+            caster_commands.push((entity, (handle.clone_weak(), uniform)));
+        } else {
+            not_caster_commands.push((entity, (handle.clone_weak(), uniform, NotShadowCaster)));
+        }
     }
-    *previous_not_caster_len = not_caster_values.len();
-    commands.insert_or_spawn_batch(not_caster_values);
+    *prev_len_shadow_caster = caster_commands.len();
+    *prev_len_not_shadow_caster = not_caster_commands.len();
+    commands.insert_or_spawn_batch(caster_commands);
+    commands.insert_or_spawn_batch(not_caster_commands);
 }
 
 #[derive(Debug, Default)]