Nuon layers and scroll (#278)

* Layers

* Nuon Scroll

Author: PolyMeilex

neothesia/src/scene/mod.rs

@@ -2,6 +2,7 @@ pub mod menu_scene;
 pub mod playing_scene;
 
 use crate::context::Context;
+use iced_core::image::Renderer as _;
 use midi_file::midly::MidiMessage;
 use neothesia_core::render::{QuadRenderer, TextRenderer};
 use std::time::Duration;
@@ -14,67 +15,104 @@ pub trait Scene {
     fn midi_event(&mut self, _ctx: &mut Context, _channel: u8, _message: &MidiMessage) {}
 }
 
-fn render_nuon(
-    ui: &mut nuon::Ui,
-    quad_pipeline: &mut QuadRenderer,
-    text_renderer: &mut TextRenderer,
-    renderer: &mut impl iced_core::image::Renderer<Handle = iced_core::image::Handle>,
-) {
-    for quad in ui.quads.iter() {
-        quad_pipeline.push(neothesia_core::render::QuadInstance {
-            position: quad.rect.origin.into(),
-            size: quad.rect.size.into(),
-            color: wgpu_jumpstart::Color::new(
-                quad.color.r,
-                quad.color.g,
-                quad.color.b,
-                quad.color.a,
-            )
-            .into_linear_rgba(),
-            border_radius: quad.border_radius,
+struct NuonLayer {
+    quad_renderer: QuadRenderer,
+    text_renderer: TextRenderer,
+}
+
+#[derive(Default)]
+pub struct NuonRenderer {
+    layers: Vec<NuonLayer>,
+}
+
+impl NuonRenderer {
+    fn ensure_layers(&mut self, ctx: &mut Context, len: usize) {
+        self.layers.resize_with(len, || NuonLayer {
+            quad_renderer: ctx.quad_renderer_facotry.new_renderer(),
+            text_renderer: ctx.text_renderer_factory.new_renderer(),
         });
     }
 
-    for img in ui.images.iter() {
-        renderer.draw_image(
-            iced_core::Image {
-                handle: img.image.clone(),
-                filter_method: iced_core::image::FilterMethod::default(),
-                rotation: iced_core::Radians(0.0),
-                opacity: 1.0,
-                snap: false,
-            },
-            iced_core::Rectangle {
-                x: img.rect.origin.x,
-                y: img.rect.origin.y,
-                width: img.rect.size.width,
-                height: img.rect.size.height,
-            },
-        );
+    pub fn render<'rpass>(&'rpass self, rpass: &mut wgpu_jumpstart::RenderPass<'rpass>) {
+        for layer in self.layers.iter() {
+            layer.quad_renderer.render(rpass);
+            layer.text_renderer.render(rpass);
+        }
     }
+}
 
-    for icon in ui.icons.iter() {
-        text_renderer.queue_icon(icon.origin.x, icon.origin.y, icon.size, &icon.icon);
-    }
+fn render_nuon(ui: &mut nuon::Ui, nuon_renderer: &mut NuonRenderer, ctx: &mut Context) {
+    nuon_renderer.ensure_layers(ctx, ui.layers.len());
 
-    for text in ui.text.iter() {
-        let buffer = if text.bold {
-            TextRenderer::gen_buffer_bold(text.size, &text.text)
-        } else {
-            TextRenderer::gen_buffer(text.size, &text.text)
-        };
+    let renderer = &mut ctx.iced_manager.renderer;
 
-        match text.text_justify {
-            nuon::TextJustify::Left => {
-                text_renderer.queue_buffer_left(text.rect, buffer);
-            }
-            nuon::TextJustify::Right => {
-                text_renderer.queue_buffer_right(text.rect, buffer);
-            }
-            nuon::TextJustify::Center => {
-                text_renderer.queue_buffer_centered(text.rect, buffer);
+    for (layer, out) in ui.layers.iter().zip(nuon_renderer.layers.iter_mut()) {
+        out.quad_renderer.clear();
+        out.quad_renderer.set_scissor_rect(layer.scissor_rect);
+        out.text_renderer.set_scissor_rect(layer.scissor_rect);
+
+        for quad in layer.quads.iter() {
+            out.quad_renderer
+                .push(neothesia_core::render::QuadInstance {
+                    position: quad.rect.origin.into(),
+                    size: quad.rect.size.into(),
+                    color: wgpu_jumpstart::Color::new(
+                        quad.color.r,
+                        quad.color.g,
+                        quad.color.b,
+                        quad.color.a,
+                    )
+                    .into_linear_rgba(),
+                    border_radius: quad.border_radius,
+                });
+        }
+
+        for img in layer.images.iter() {
+            renderer.draw_image(
+                iced_core::Image {
+                    handle: img.image.clone(),
+                    filter_method: iced_core::image::FilterMethod::default(),
+                    rotation: iced_core::Radians(0.0),
+                    opacity: 1.0,
+                    snap: false,
+                },
+                iced_core::Rectangle {
+                    x: img.rect.origin.x,
+                    y: img.rect.origin.y,
+                    width: img.rect.size.width,
+                    height: img.rect.size.height,
+                },
+            );
+        }
+
+        for icon in layer.icons.iter() {
+            out.text_renderer
+                .queue_icon(icon.origin.x, icon.origin.y, icon.size, &icon.icon);
+        }
+
+        for text in layer.text.iter() {
+            let buffer = if text.bold {
+                TextRenderer::gen_buffer_bold(text.size, &text.text)
+            } else {
+                TextRenderer::gen_buffer(text.size, &text.text)
+            };
+
+            match text.text_justify {
+                nuon::TextJustify::Left => {
+                    out.text_renderer.queue_buffer_left(text.rect, buffer);
+                }
+                nuon::TextJustify::Right => {
+                    out.text_renderer.queue_buffer_right(text.rect, buffer);
+                }
+                nuon::TextJustify::Center => {
+                    out.text_renderer.queue_buffer_centered(text.rect, buffer);
+                }
             }
         }
+
+        out.quad_renderer.prepare();
+        out.text_renderer
+            .update(ctx.window_state.logical_size.into());
     }
 
     ui.done();

neothesia/src/scene/playing_scene/mod.rs

@@ -10,7 +10,7 @@ use winit::{
 
 use self::top_bar::TopBar;
 
-use super::Scene;
+use super::{NuonRenderer, Scene};
 use crate::{context::Context, render::WaterfallRenderer, song::Song, NeothesiaEvent};
 
 mod keyboard;
@@ -42,6 +42,7 @@ pub struct PlayingScene {
     waterfall: WaterfallRenderer,
     guidelines: GuidelineRenderer,
     text_renderer: TextRenderer,
+    nuon_renderer: NuonRenderer,
 
     note_labels: Option<NoteLabels>,
 
@@ -119,6 +120,7 @@ impl PlayingScene {
             guidelines,
             note_labels,
             text_renderer,
+            nuon_renderer: NuonRenderer::default(),
 
             waterfall,
             player,
@@ -232,12 +234,7 @@ impl Scene for PlayingScene {
 
         TopBar::update(self, ctx);
 
-        super::render_nuon(
-            &mut self.nuon,
-            &mut self.quad_renderer_fg,
-            &mut self.text_renderer,
-            &mut ctx.iced_manager.renderer,
-        );
+        super::render_nuon(&mut self.nuon, &mut self.nuon_renderer, ctx);
 
         self.quad_renderer_bg.prepare();
         self.quad_renderer_fg.prepare();
@@ -275,6 +272,8 @@ impl Scene for PlayingScene {
             glow.pipeline.render(rpass);
         }
         self.text_renderer.render(rpass);
+
+        self.nuon_renderer.render(rpass);
     }
 
     fn window_event(&mut self, ctx: &mut Context, event: &WindowEvent) {