core: Prevent per frame note-label buffer clone for each visible note

Author: PolyMeilex

neothesia-core/src/render/note_labels/mod.rs

@@ -97,28 +97,28 @@ impl NoteLabels {
         let labels = self.labels_cache.get(keyboard);
         let animation_speed = animation_speed / scale;
 
-        for note in self.notes.inner.iter() {
-            if !layout.range.contains(note.note) || note.channel == 9 {
-                continue;
-            }
-
-            let x = layout.keys[note.note as usize - range_start].x();
-            let label_buffer = &labels[(note.note % 12) as usize];
-
-            let y = self.pos.y - (note.start.as_secs_f32() - time) * animation_speed - label_width;
-
-            if y < 0.0 {
-                break;
-            }
-
-            if y > keyboard.pos().y {
-                continue;
-            }
-
-            self.text_renderer.queue(super::text::TextArea {
-                buffer: label_buffer.clone(),
-                left: x,
-                top: y,
+        let iter = self
+            .notes
+            .inner
+            .iter()
+            .filter(|note| layout.range.contains(note.note) && note.channel != 9)
+            .map(|note| {
+                let buffer = &labels[(note.note % 12) as usize];
+
+                let x = layout.keys[note.note as usize - range_start].x();
+                let y =
+                    self.pos.y - (note.start.as_secs_f32() - time) * animation_speed - label_width;
+
+                (buffer, x, y)
+            })
+            // Stop iteration once we reach top of the screen
+            .take_while(|(_buffer, _x, y)| *y > 0.0)
+            // TODO: Cache last note idx to skip this NoOp skip iteration
+            .skip_while(|(_buffer, _x, y)| *y > keyboard.pos().y)
+            .map(|(buffer, left, top)| glyphon::TextArea {
+                buffer,
+                left,
+                top,
                 scale: 1.0,
                 bounds: glyphon::TextBounds {
                     left: 0,
@@ -127,10 +127,11 @@ impl NoteLabels {
                     bottom: i32::MAX,
                 },
                 default_color: glyphon::Color::rgb(255, 255, 255),
+                custom_glyphs: &[],
             });
-        }
 
-        self.text_renderer.update(physical_size, scale);
+        self.text_renderer
+            .update_from_iter(physical_size, scale, iter);
     }
 
     pub fn render<'rpass>(&'rpass mut self, render_pass: &mut wgpu_jumpstart::RenderPass<'rpass>) {

neothesia-core/src/render/text/mod.rs

@@ -183,11 +183,61 @@ impl TextRenderer {
         self.text_areas.push(area);
     }
 
+    #[profiling::function]
     pub fn update(&mut self, physical_size: dpi::PhysicalSize<u32>, scale: f32) {
-        let shared = &mut *self.shared.borrow_mut();
-
-        let elements = self.text_areas.iter().map(|area| glyphon::TextArea {
+        let text_areas = self.text_areas.iter().map(|area| glyphon::TextArea {
             buffer: &area.buffer,
+            left: area.left,
+            top: area.top,
+            scale: area.scale,
+            bounds: area.bounds,
+            default_color: area.default_color,
+            custom_glyphs: &[],
+        });
+
+        Self::update_from_iter_inner(
+            &mut self.text_renderer,
+            &mut self.shared.borrow_mut(),
+            &self.device,
+            &self.queue,
+            physical_size,
+            scale,
+            text_areas,
+        );
+
+        self.text_areas.clear();
+    }
+
+    #[profiling::function]
+    pub fn update_from_iter<'a>(
+        &mut self,
+        physical_size: dpi::PhysicalSize<u32>,
+        scale: f32,
+        text_areas: impl Iterator<Item = glyphon::TextArea<'a>>,
+    ) {
+        Self::update_from_iter_inner(
+            &mut self.text_renderer,
+            &mut self.shared.borrow_mut(),
+            &self.device,
+            &self.queue,
+            physical_size,
+            scale,
+            text_areas,
+        );
+    }
+
+    #[profiling::function]
+    fn update_from_iter_inner<'a>(
+        text_renderer: &mut glyphon::TextRenderer,
+        shared: &mut TextShared,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        physical_size: dpi::PhysicalSize<u32>,
+        scale: f32,
+        text_areas: impl Iterator<Item = glyphon::TextArea<'a>>,
+    ) {
+        let elements = text_areas.map(|area| glyphon::TextArea {
+            buffer: area.buffer,
             left: area.left * scale,
             top: area.top * scale,
             scale: area.scale * scale,
@@ -198,30 +248,28 @@ impl TextRenderer {
                 bottom: (area.bounds.bottom as f32 * scale) as i32,
             },
             default_color: area.default_color,
-            custom_glyphs: &[],
+            custom_glyphs: area.custom_glyphs,
         });
 
         shared.viewport.update(
-            &self.queue,
+            queue,
             glyphon::Resolution {
                 width: physical_size.width,
                 height: physical_size.height,
             },
         );
 
-        self.text_renderer
+        text_renderer
             .prepare(
-                &self.device,
-                &self.queue,
+                device,
+                queue,
                 &mut crate::font_system::font_system().borrow_mut(),
                 &mut shared.atlas,
                 &shared.viewport,
                 elements,
                 &mut shared.swash_cache,
             )
             .unwrap();
-
-        self.text_areas.clear();
     }
 
     pub fn render<'rpass>(&'rpass self, render_pass: &mut wgpu_jumpstart::RenderPass<'rpass>) {