feat: scene compute_bb

vello/src/scene.rs

@@ -126,6 +126,59 @@ impl Scene {
         self.encoding.encode_end_clip();
     }
 
+    /// Compute a rough bounding box of the control points in the scene.
+    /// This is not axis-aligned or precise.
+    pub fn compute_bb(&self) -> Rect {
+        if self.encoding.path_data.is_empty() {
+            return Rect::ZERO;
+        }
+
+        let mut min_x = f32::INFINITY;
+        let mut min_y = f32::INFINITY;
+        let mut max_x = f32::NEG_INFINITY;
+        let mut max_y = f32::NEG_INFINITY;
+
+        // Treat consecutive u32 pairs as potential x,y coordinates
+        for chunk in self
+            .encoding
+            .path_data
+            .chunks_exact(2)
+            .chain(self.encoding.draw_data.chunks_exact(2))
+        {
+            let &[x, y] = chunk else {
+                continue;
+            };
+            let x = f32::from_bits(x);
+            let y = f32::from_bits(y);
+
+            // Only consider finite values as valid coordinates
+            if x.is_finite() && y.is_finite() {
+                min_x = min_x.min(x);
+                min_y = min_y.min(y);
+                max_x = max_x.max(x);
+                max_y = max_y.max(y);
+            }
+        }
+
+        // Check glyph positions if any
+        for glyph in &self.encoding.resources.glyphs {
+            let x = glyph.x;
+            let y = glyph.y;
+            min_x = min_x.min(x);
+            min_y = min_y.min(y);
+            max_x = max_x.max(x);
+            max_y = max_y.max(y);
+        }
+
+        // If we found no valid coordinates, return zero.
+        if min_x.is_infinite() || min_y.is_infinite() || max_x.is_infinite() || max_y.is_infinite()
+        {
+            return Rect::ZERO;
+        }
+
+        Rect::new(min_x as f64, min_y as f64, max_x as f64, max_y as f64)
+    }
+
     /// Draw a rounded rectangle blurred with a gaussian filter.
     pub fn draw_blurred_rounded_rect(
         &mut self,

vello_tests/tests/scene.rs

@@ -0,0 +1,66 @@
+// Copyright 2024 the Vello Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+//! Simple testing of vello scenes.
+// The following lints are part of the Linebender standard set,
+// but resolving them has been deferred for now.
+// Feel free to send a PR that solves one or more of these.
+#![allow(
+    clippy::missing_assert_message,
+    clippy::allow_attributes_without_reason
+)]
+use vello::Scene;
+use vello::kurbo::{Affine, Ellipse, Rect};
+use vello::peniko::{Brush, color::palette};
+
+#[test]
+fn simple_square() {
+    let mut scene = Scene::new();
+    scene.fill(
+        vello::peniko::Fill::NonZero,
+        Affine::IDENTITY,
+        &Brush::Solid(palette::css::RED),
+        None,
+        &Rect::from_center_size((-25., 0.), (50., 50.)),
+    );
+    let actual = scene.compute_bb();
+    let expected = Rect::new(-50.0, -25.0, 0.0, 25.0);
+    assert_eq!(expected, actual);
+}
+
+#[test]
+fn simple_ellipse() {
+    let mut scene = Scene::new();
+    scene.fill(
+        vello::peniko::Fill::NonZero,
+        Affine::IDENTITY,
+        &Brush::Solid(palette::css::RED),
+        None,
+        &Ellipse::new((0.0, 0.0), (50.0, 20.0), 0.0),
+    );
+    let actual = scene.compute_bb();
+    let expected = Rect::new(-50.0, 50.0, -20.0, 20.0);
+    assert_eq!(expected, actual);
+}
+
+#[test]
+fn rotated_ellipse() {
+    let mut scene = Scene::new();
+    scene.fill(
+        vello::peniko::Fill::NonZero,
+        Affine::IDENTITY,
+        &Brush::Solid(palette::css::RED),
+        None,
+        &Ellipse::new((0.0, 0.0), (50.0, 20.0), 90.0),
+    );
+    let actual = scene.compute_bb();
+    let expected = Rect::new(-20.0, -50.0, 20.0, 50.0);
+    assert_eq!(expected, actual);
+}
+
+#[test]
+fn empty_scene() {
+    let scene = Scene::new();
+    let actual = scene.compute_bb();
+    let expected = Rect::ZERO;
+    assert_eq!(expected, actual);
+}