Adopt Taj's example

LaurenzV · LaurenzV · commit 60e3e34174de · 2025-09-16T14:02:18.000+02:00
diff --git a/sparse_strips/vello_hybrid/examples/scenes/src/clip.rs b/sparse_strips/vello_hybrid/examples/scenes/src/clip.rs
@@ -19,18 +19,50 @@ use vello_hybrid::Scene;
 
 /// Clip scene state
 #[derive(Debug)]
-pub struct ClipScene {}
+pub struct ClipScene {
+    use_clip_path: bool,
+    num_circles: usize,
+}
 
 impl ExampleScene for ClipScene {
     fn render(&mut self, ctx: &mut Scene, root_transform: Affine) {
-        render(ctx, root_transform);
+        render(ctx, root_transform, self.use_clip_path, self.num_circles);
+    }
+
+    fn handle_key(&mut self, key: &str) -> bool {
+        match key {
+            "c" | "C" => {
+                self.toggle_clip();
+                true
+            }
+            "m" | "M" => {
+                self.add_circle();
+                true
+            }
+            _ => false,
+        }
     }
 }
 
 impl ClipScene {
     /// Create a new `ClipScene`
     pub fn new() -> Self {
-        Self {}
+        Self {
+            use_clip_path: false,
+            num_circles: 1,
+        }
+    }
+
+    /// Toggle using clip path
+    pub fn toggle_clip(&mut self) {
+        self.use_clip_path = !self.use_clip_path;
+        println!("Use clip path: {}", self.use_clip_path);
+    }
+
+    /// Add another circle to the scene
+    pub fn add_circle(&mut self) {
+        self.num_circles += 1;
+        println!("Number of circles: {}", self.num_circles);
     }
 }
 
@@ -48,7 +80,7 @@ fn draw_clipping_outline(ctx: &mut Scene, path: &BezPath) {
 }
 
 /// Draws a deeply nested clip of circles.
-pub fn render(ctx: &mut Scene, root_transform: Affine) {
+pub fn render(ctx: &mut Scene, root_transform: Affine, use_clip_path: bool, num_circles: usize) {
     const INITIAL_RADIUS: f64 = 48.0;
     const RADIUS_DECREMENT: f64 = 2.5;
     const INNER_COUNT: usize = 10;
@@ -68,26 +100,57 @@ pub fn render(ctx: &mut Scene, root_transform: Affine) {
         DARK_GREEN,
     ];
 
-    const COVER_RECT: Rect = Rect::new(0.0, 0.0, 100.0, 100.0);
-    const CENTER: Point = Point::new(50.0, 50.0);
-    let mut radius = INITIAL_RADIUS;
+    const SPACING: f64 = 120.0;
+    const BASE_X: f64 = 50.0;
+    const BASE_Y: f64 = 50.0;
 
     ctx.set_transform(root_transform);
-    for _ in 0..outer_count {
-        for color in COLORS.iter() {
-            let clip_circle = Circle::new(CENTER, radius).to_path(0.1);
-            draw_clipping_outline(ctx, &clip_circle);
-            ctx.push_clip_layer(&clip_circle);
 
-            ctx.set_paint(*color);
-            ctx.fill_rect(&COVER_RECT);
+    // Draw multiple circles in a checkerboard pattern
+    for circle_idx in 0..num_circles {
+        // Calculate checkerboard position
+        // Create a grid pattern where circles are placed in a checkerboard layout
+        let row = circle_idx / 4;
+        let col = circle_idx % 4;
+
+        // Create checkerboard offset pattern
+        let offset_x = if (row + col) % 2 == 0 {
+            0.0
+        } else {
+            SPACING / 2.0
+        };
+        let x = BASE_X + col as f64 * SPACING + offset_x;
+        let y = BASE_Y + row as f64 * SPACING;
+
+        let center = Point::new(x, y);
+        let cover_rect = Rect::new(x - 50.0, y - 50.0, x + 50.0, y + 50.0);
+        let mut radius = INITIAL_RADIUS;
+
+        for _ in 0..outer_count {
+            for color in COLORS.iter() {
+                let clip_circle = Circle::new(center, radius).to_path(0.1);
+                draw_clipping_outline(ctx, &clip_circle);
+                if use_clip_path {
+                    ctx.push_clip_path(&clip_circle);
+                } else {
+                    ctx.push_clip_layer(&clip_circle);
+                }
 
-            radius -= RADIUS_DECREMENT;
+                ctx.set_paint(*color);
+                ctx.fill_rect(&cover_rect);
+
+                radius -= RADIUS_DECREMENT;
+            }
         }
-    }
-    for _ in 0..outer_count {
-        for _ in COLORS.iter() {
-            ctx.pop_layer();
+
+        for _ in 0..outer_count {
+            for _ in COLORS.iter() {
+                if !use_clip_path {
+                    ctx.pop_layer();
+                } else {
+                    ctx.pop_clip_path();
+                }
+            }
         }
     }
 }
diff --git a/sparse_strips/vello_hybrid/examples/winit/src/main.rs b/sparse_strips/vello_hybrid/examples/winit/src/main.rs
@@ -8,6 +8,7 @@ use render_context::{RenderContext, RenderSurface, create_vello_renderer, create
 #[cfg(not(target_arch = "wasm32"))]
 use std::env;
 use std::sync::Arc;
+use std::time::Instant;
 use vello_common::color::palette::css::WHITE;
 use vello_common::color::{AlphaColor, Srgb};
 use vello_common::kurbo::{Affine, Point};
@@ -45,6 +46,10 @@ struct App<'s> {
     transform: Affine,
     mouse_down: bool,
     last_cursor_position: Option<Point>,
+    last_frame_time: Option<Instant>,
+    frame_count: u32,
+    fps_update_time: Instant,
+    accumulated_frame_time: f64,
 }
 
 fn main() {
@@ -77,6 +82,7 @@ fn main() {
     #[cfg(target_arch = "wasm32")]
     let (scenes, start_scene_index) = (get_example_scenes(), 0);
 
+    let now = Instant::now();
     let mut app = App {
         context: RenderContext::new(),
         renderers: vec![],
@@ -87,6 +93,10 @@ fn main() {
         transform: Affine::IDENTITY,
         mouse_down: false,
         last_cursor_position: None,
+        last_frame_time: None,
+        frame_count: 0,
+        fps_update_time: now,
+        accumulated_frame_time: 0.0,
     };
 
     let event_loop = EventLoop::new().unwrap();
@@ -130,7 +140,7 @@ impl ApplicationHandler for App<'_> {
             window.clone(),
             size.width,
             size.height,
-            wgpu::PresentMode::AutoVsync,
+            wgpu::PresentMode::Immediate, // Unlimited FPS mode
             wgpu::TextureFormat::Bgra8Unorm,
         ));
 
@@ -203,10 +213,10 @@ impl ApplicationHandler for App<'_> {
                     event_loop.exit();
                 }
                 Key::Character(ch) => {
-                    if let Some(scene) = self.scenes.get_mut(self.current_scene)
-                        && scene.handle_key(ch.as_str())
-                    {
-                        window.request_redraw();
+                    if let Some(scene) = self.scenes.get_mut(self.current_scene) {
+                        if scene.handle_key(ch.as_str()) {
+                            window.request_redraw();
+                        }
                     }
                 }
                 _ => {}
@@ -268,6 +278,31 @@ impl ApplicationHandler for App<'_> {
                 window.request_redraw();
             }
             WindowEvent::RedrawRequested => {
+                // Measure frame time
+                let now = Instant::now();
+                if let Some(last_time) = self.last_frame_time {
+                    let frame_time = now.duration_since(last_time).as_secs_f64() * 1000.0; // Convert to milliseconds
+                    self.accumulated_frame_time += frame_time;
+                    self.frame_count += 1;
+
+                    // Update window title every second with average FPS
+                    if now.duration_since(self.fps_update_time).as_secs_f64() >= 1.0 {
+                        let avg_frame_time = self.accumulated_frame_time / self.frame_count as f64;
+                        let avg_fps = 1000.0 / avg_frame_time;
+                        println!("Average FPS: {:.1}", avg_fps);
+                        window.set_title(&format!(
+                            "Vello Hybrid - Scene {} - {:.1} FPS ({:.2}ms avg)",
+                            self.current_scene, avg_fps, avg_frame_time
+                        ));
+
+                        // Reset counters
+                        self.frame_count = 0;
+                        self.accumulated_frame_time = 0.0;
+                        self.fps_update_time = now;
+                    }
+                }
+                self.last_frame_time = Some(now);
+
                 self.scene.reset();
 
                 self.scene.set_transform(self.transform);
@@ -311,6 +346,9 @@ impl ApplicationHandler for App<'_> {
                 surface_texture.present();
 
                 device_handle.device.poll(wgpu::PollType::Poll).unwrap();
+
+                // Request continuous redraw for FPS measurement
+                window.request_redraw();
             }
             _ => {}
         }
