use crate::geometry::{Point, Rect, Transform, Vec2};
use crate::scene::{
BlendMode, Element, FillStrokeStyle, Layer, NodeKind, Scene, SceneNode, Stroke,
};
use kurbo::Shape;
pub use svg::{SvgRenderer, SvgSizing};
pub use vello_pixmap::VelloPixmapRenderer;
mod svg;
mod vello_pixmap;
pub(crate) fn arc_path_y_down(
center: Point,
radii: Vec2,
start_angle: f64,
sweep_angle: f64,
) -> kurbo::BezPath {
let arc = kurbo::Arc::new(
(center.x, -center.y),
(radii.x, radii.y),
-start_angle,
-sweep_angle,
0.0,
)
.to_path(0.1);
let mut path = arc;
path.apply_affine(kurbo::Affine::new([1.0, 0.0, 0.0, -1.0, 0.0, 0.0]));
path
}
pub trait Renderer {
fn draw_rect(&mut self, rect: Rect, style: &FillStrokeStyle);
fn draw_circle(&mut self, center: Point, radius: f64, style: &FillStrokeStyle);
fn draw_ellipse(&mut self, center: Point, radii: Vec2, rotation: f64, style: &FillStrokeStyle) {
let path =
kurbo::Ellipse::new((center.x, center.y), (radii.x, radii.y), rotation).to_path(0.1);
self.draw_path(&path, style, true);
}
fn draw_rounded_rect(&mut self, rect: Rect, radius: f64, style: &FillStrokeStyle) {
self.draw_rounded_rect_radii(rect, crate::scene::CornerRadii::uniform(radius), style);
}
fn draw_rounded_rect_radii(
&mut self,
rect: Rect,
radii: crate::scene::CornerRadii,
style: &FillStrokeStyle,
) {
let path = kurbo::RoundedRect::from_rect(rect, radii.to_kurbo()).to_path(0.1);
self.draw_path(&path, style, true);
}
fn draw_line(&mut self, start: Point, end: Point, style: &Stroke);
fn draw_polyline(&mut self, points: &[Point], style: &Stroke);
fn draw_polygon(&mut self, points: &[Point], style: &FillStrokeStyle) {
let mut path = kurbo::BezPath::new();
if let Some(p0) = points.first() {
path.move_to((p0.x, p0.y));
for p in &points[1..] {
path.line_to((p.x, p.y));
}
path.close_path();
}
self.draw_path(&path, style, false);
}
fn draw_arc(
&mut self,
center: Point,
radii: Vec2,
start_angle: f64,
sweep_angle: f64,
style: &Stroke,
) {
let path = crate::render::arc_path_y_down(center, radii, start_angle, sweep_angle);
let style = FillStrokeStyle {
fill: None,
stroke: Some(style.clone()),
};
self.draw_path(&path, &style, false);
}
fn draw_pie(
&mut self,
center: Point,
radius: f64,
start_angle: f64,
sweep_angle: f64,
style: &FillStrokeStyle,
) {
let mut path = kurbo::BezPath::new();
path.move_to((center.x, center.y));
let arc = crate::render::arc_path_y_down(
center,
Vec2::new(radius, radius),
start_angle,
sweep_angle,
);
let mut els = arc.elements().iter();
if let Some(kurbo::PathEl::MoveTo(p0)) = els.next() {
path.line_to(*p0);
for el in els {
path.push(*el);
}
} else {
path.extend(arc);
}
path.close_path();
self.draw_path(&path, style, false);
}
fn draw_path(&mut self, path: &kurbo::BezPath, style: &FillStrokeStyle, closed: bool);
fn draw_gradient_path(
&mut self,
path: &kurbo::BezPath,
gradient: &crate::scene::LinearGradient,
stroke: Option<&crate::scene::Stroke>,
);
fn draw_text(
&mut self,
spans: &[crate::text::RichSpan],
position: Point,
style: &crate::text::TextStyle,
layout: Option<&crate::text::TextLayout>,
);
fn draw_image(&mut self, image: &crate::SceneImage, frame: Rect, opacity: f64) {
let _ = (image, frame, opacity);
}
fn push_transform(&mut self, _t: Transform) {}
fn pop_transform(&mut self) {}
fn push_opacity(&mut self, _opacity: f64) {}
fn pop_opacity(&mut self) {}
fn push_blend(&mut self, _mode: BlendMode) {}
fn pop_blend(&mut self) {}
fn push_mask(&mut self, _mask: &crate::scene::Mask) {}
fn pop_mask(&mut self) {}
fn push_filter(&mut self, _filter: &crate::scene::Filter) {}
fn pop_filter(&mut self) {}
fn push_name(&mut self, _name: Option<&str>) {}
fn pop_name(&mut self) {}
fn push_clip(&mut self, _clip: &crate::scene::Clip) {}
fn pop_clip(&mut self) {}
fn push_color_matrix(&mut self, _matrix: crate::scene::ColorMatrix) {}
fn pop_color_matrix(&mut self) {}
fn push_antialias(&mut self, _enabled: bool) {}
fn pop_antialias(&mut self) {}
fn push_scope(&mut self, scope: &crate::scene::NodeScope) {
if let Some(t) = scope.transform {
self.push_transform(t);
}
if let Some(clip) = scope.clip {
self.push_clip(clip);
}
if let Some(enabled) = scope.antialias {
self.push_antialias(enabled);
}
if let Some(matrix) = scope.color_matrix {
self.push_color_matrix(matrix);
}
if let Some(filter) = scope.filter {
self.push_filter(filter);
}
if scope.opacity != 1.0 {
self.push_opacity(scope.opacity);
}
if !scope.blend_mode.is_normal() {
self.push_blend(scope.blend_mode);
}
if let Some(mask) = scope.mask {
self.push_mask(mask);
}
if let Some(name) = scope.name {
self.push_name(Some(name));
}
}
fn pop_scope(&mut self, scope: &crate::scene::NodeScope) {
if scope.name.is_some() {
self.pop_name();
}
if scope.mask.is_some() {
self.pop_mask();
}
if !scope.blend_mode.is_normal() {
self.pop_blend();
}
if scope.opacity != 1.0 {
self.pop_opacity();
}
if scope.filter.is_some() {
self.pop_filter();
}
if scope.color_matrix.is_some() {
self.pop_color_matrix();
}
if scope.antialias.is_some() {
self.pop_antialias();
}
if scope.clip.is_some() {
self.pop_clip();
}
if scope.transform.is_some() {
self.pop_transform();
}
}
fn push_node_scope(&mut self, node: &SceneNode) {
self.push_scope(&node.scope());
}
fn pop_node_scope(&mut self, node: &SceneNode) {
self.pop_scope(&node.scope());
}
fn render_scene(&mut self, scene: &Scene) {
self.render_scene_ordered(scene);
}
fn render_children(&mut self, nodes: &[SceneNode]) {
for node in SceneNode::ordered(nodes) {
self.render_node(node);
}
}
fn render_scene_ordered(&mut self, scene: &Scene) {
self.render_children(&scene.nodes);
for layer in &scene.layers {
self.render_layer(layer);
}
}
fn render_layer(&mut self, layer: &Layer) {
if !layer.visible {
return;
}
let scope = layer.scope();
self.push_scope(&scope);
self.render_children(&layer.nodes);
self.pop_scope(&scope);
}
fn render_node(&mut self, node: &SceneNode) {
if !node.visible {
return;
}
self.push_node_scope(node);
match &node.kind {
NodeKind::Group(children) => self.render_children(children),
NodeKind::Draw(element) => self.draw_element(element),
}
self.pop_node_scope(node);
}
fn draw_element(&mut self, element: &Element) {
match element {
Element::Rect { rect, style } => self.draw_rect(*rect, style),
Element::Circle {
center,
radius,
style,
} => self.draw_circle(*center, *radius, style),
Element::Ellipse {
center,
radii,
rotation,
style,
} => self.draw_ellipse(*center, *radii, *rotation, style),
Element::RoundedRect { rect, radii, style } => {
if radii.is_uniform() {
self.draw_rounded_rect(*rect, radii.uniform_value(), style);
} else {
self.draw_rounded_rect_radii(*rect, *radii, style);
}
}
Element::Line { start, end, style } => self.draw_line(*start, *end, style),
Element::Polyline { points, style } => self.draw_polyline(points, style),
Element::Polygon { points, style } => self.draw_polygon(points, style),
Element::Arc {
center,
radii,
start_angle,
sweep_angle,
style,
} => self.draw_arc(*center, *radii, *start_angle, *sweep_angle, style),
Element::Pie {
center,
radius,
start_angle,
sweep_angle,
style,
} => self.draw_pie(*center, *radius, *start_angle, *sweep_angle, style),
Element::Path {
path,
style,
closed,
} => self.draw_path(path, style, *closed),
Element::Image {
image,
frame,
opacity,
} => self.draw_image(image, *frame, *opacity),
Element::GradientPath {
path,
gradient,
stroke,
} => self.draw_gradient_path(path, gradient, stroke.as_ref()),
Element::Text {
spans,
position,
style,
layout,
} => self.draw_text(spans, *position, style, layout.as_deref()),
}
}
}
#[cfg(test)]
mod tests {
use crate::geometry::{Point, Vec2};
fn expected_screen_points(
center: Point,
radii: Vec2,
start_angle: f64,
sweep_angle: f64,
) -> (Point, Point) {
let start = Point::new(
center.x + radii.x * start_angle.cos(),
center.y + radii.y * start_angle.sin(),
);
let end_angle = start_angle + sweep_angle;
let end = Point::new(
center.x + radii.x * end_angle.cos(),
center.y + radii.y * end_angle.sin(),
);
(start, end)
}
#[test]
fn arc_y_down_matches_svg_geometry() {
let cases = [
(
Point::new(300.0, 320.0),
Vec2::new(70.0, 70.0),
0.0f64,
std::f64::consts::FRAC_PI_2,
),
(
Point::new(300.0, 320.0),
Vec2::new(70.0, 70.0),
std::f64::consts::FRAC_PI_2,
std::f64::consts::FRAC_PI_2,
),
(
Point::new(300.0, 320.0),
Vec2::new(70.0, 70.0),
std::f64::consts::PI,
-std::f64::consts::FRAC_PI_2,
),
(Point::new(100.0, 100.0), Vec2::new(40.0, 20.0), 0.4, 2.7),
];
for (center, radii, a, s) in cases {
let path = crate::render::arc_path_y_down(center, radii, a, s);
let pts: Vec<Point> = path
.elements()
.iter()
.filter_map(|el| match el {
kurbo::PathEl::MoveTo(p)
| kurbo::PathEl::LineTo(p)
| kurbo::PathEl::QuadTo(_, p)
| kurbo::PathEl::CurveTo(_, _, p) => Some(Point::new(p.x, p.y)),
kurbo::PathEl::ClosePath => None,
})
.collect();
let n = pts.len();
assert!(n >= 2, "arc path should have at least 2 points");
let got_start = pts[0];
let got_end = pts[n - 1];
let (exp_start, exp_end) = expected_screen_points(center, radii, a, s);
let eps = 1e-6;
assert!(
(got_start.x - exp_start.x).abs() < eps && (got_start.y - exp_start.y).abs() < eps,
"start mismatch: got {:?} expected {:?} (center={:?} radii={:?} a={} s={})",
got_start,
exp_start,
center,
radii,
a,
s
);
assert!(
(got_end.x - exp_end.x).abs() < eps && (got_end.y - exp_end.y).abs() < eps,
"end mismatch: got {:?} expected {:?} (center={:?} radii={:?} a={} s={})",
got_end,
exp_end,
center,
radii,
a,
s
);
}
}
}