From 6216c513d5e5853bf1d43342094e91a74981f4f2 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Mon, 1 Apr 2024 11:30:01 +0200 Subject: Use generic `Content` in `Text` to avoid reallocation in `fill_text` --- renderer/src/fallback.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'renderer/src') diff --git a/renderer/src/fallback.rs b/renderer/src/fallback.rs index ef9cc9a9..b9ceb4b2 100644 --- a/renderer/src/fallback.rs +++ b/renderer/src/fallback.rs @@ -115,7 +115,7 @@ where fn fill_text( &mut self, - text: core::Text<'_, Self::Font>, + text: core::Text, position: Point, color: Color, clip_bounds: Rectangle, -- cgit From b05e61f5c8ae61c9f3c7cc08cded53901ebbccfd Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 3 Apr 2024 21:07:54 +0200 Subject: Redesign `iced_wgpu` layering architecture --- renderer/src/fallback.rs | 32 ++++++++++++++++++++++++-------- 1 file changed, 24 insertions(+), 8 deletions(-) (limited to 'renderer/src') diff --git a/renderer/src/fallback.rs b/renderer/src/fallback.rs index b9ceb4b2..b6459243 100644 --- a/renderer/src/fallback.rs +++ b/renderer/src/fallback.rs @@ -39,16 +39,20 @@ where delegate!(self, renderer, renderer.clear()); } - fn start_layer(&mut self) { - delegate!(self, renderer, renderer.start_layer()); + fn start_layer(&mut self, bounds: Rectangle) { + delegate!(self, renderer, renderer.start_layer(bounds)); } fn end_layer(&mut self, bounds: Rectangle) { delegate!(self, renderer, renderer.end_layer(bounds)); } - fn start_transformation(&mut self) { - delegate!(self, renderer, renderer.start_transformation()); + fn start_transformation(&mut self, transformation: Transformation) { + delegate!( + self, + renderer, + renderer.start_transformation(transformation) + ); } fn end_transformation(&mut self, transformation: Transformation) { @@ -433,6 +437,7 @@ mod geometry { } } + #[derive(Clone)] pub enum Geometry { Left(L), Right(R), @@ -452,10 +457,21 @@ mod geometry { } } - fn cache(self) -> Self::Cache { - match self { - Self::Left(geometry) => Geometry::Left(geometry.cache()), - Self::Right(geometry) => Geometry::Right(geometry.cache()), + fn cache(self, previous: Option) -> Self::Cache { + match (self, previous) { + (Self::Left(geometry), Some(Geometry::Left(previous))) => { + Geometry::Left(geometry.cache(Some(previous))) + } + (Self::Left(geometry), None) => { + Geometry::Left(geometry.cache(None)) + } + (Self::Right(geometry), Some(Geometry::Right(previous))) => { + Geometry::Right(geometry.cache(Some(previous))) + } + (Self::Right(geometry), None) => { + Geometry::Right(geometry.cache(None)) + } + _ => unreachable!(), } } } -- cgit From 6d3e1d835e1688fbc58622a03a784ed25ed3f0e1 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Fri, 5 Apr 2024 23:59:21 +0200 Subject: Decouple caching from layering and simplify everything --- renderer/src/fallback.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'renderer/src') diff --git a/renderer/src/fallback.rs b/renderer/src/fallback.rs index b6459243..60b57604 100644 --- a/renderer/src/fallback.rs +++ b/renderer/src/fallback.rs @@ -405,7 +405,7 @@ where #[cfg(feature = "geometry")] mod geometry { use super::Renderer; - use crate::core::{Point, Radians, Size, Vector}; + use crate::core::{Point, Radians, Rectangle, Size, Vector}; use crate::graphics::geometry::{self, Fill, Path, Stroke, Text}; use crate::graphics::Cached; @@ -533,10 +533,10 @@ mod geometry { delegate!(self, frame, frame.pop_transform()); } - fn draft(&mut self, size: Size) -> Self { + fn draft(&mut self, bounds: Rectangle) -> Self { match self { - Self::Left(frame) => Self::Left(frame.draft(size)), - Self::Right(frame) => Self::Right(frame.draft(size)), + Self::Left(frame) => Self::Left(frame.draft(bounds)), + Self::Right(frame) => Self::Right(frame.draft(bounds)), } } -- cgit From 5cd98f069dea8720bca7748d6c12fa410cbe79b5 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Sun, 7 Apr 2024 12:42:12 +0200 Subject: Use built-in `[lints]` table in `Cargo.toml` --- renderer/src/fallback.rs | 258 ++++++++++++++++++++++++++--------------------- renderer/src/lib.rs | 3 +- 2 files changed, 146 insertions(+), 115 deletions(-) (limited to 'renderer/src') diff --git a/renderer/src/fallback.rs b/renderer/src/fallback.rs index b9ceb4b2..85ac3d93 100644 --- a/renderer/src/fallback.rs +++ b/renderer/src/fallback.rs @@ -1,3 +1,4 @@ +//! Compose existing renderers and create type-safe fallback strategies. use crate::core::image; use crate::core::renderer; use crate::core::svg; @@ -8,24 +9,31 @@ use crate::graphics; use crate::graphics::compositor; use crate::graphics::mesh; -pub enum Renderer { - Left(L), - Right(R), +/// A renderer `A` with a fallback strategy `B`. +/// +/// This type can be used to easily compose existing renderers and +/// create custom, type-safe fallback strategies. +#[derive(Debug)] +pub enum Renderer { + /// The primary rendering option. + Primary(A), + /// The secondary (or fallback) rendering option. + Secondary(B), } macro_rules! delegate { ($renderer:expr, $name:ident, $body:expr) => { match $renderer { - Self::Left($name) => $body, - Self::Right($name) => $body, + Self::Primary($name) => $body, + Self::Secondary($name) => $body, } }; } -impl core::Renderer for Renderer +impl core::Renderer for Renderer where - L: core::Renderer, - R: core::Renderer, + A: core::Renderer, + B: core::Renderer, { fn fill_quad( &mut self, @@ -56,22 +64,22 @@ where } } -impl core::text::Renderer for Renderer +impl core::text::Renderer for Renderer where - L: core::text::Renderer, - R: core::text::Renderer< - Font = L::Font, - Paragraph = L::Paragraph, - Editor = L::Editor, + A: core::text::Renderer, + B: core::text::Renderer< + Font = A::Font, + Paragraph = A::Paragraph, + Editor = A::Editor, >, { - type Font = L::Font; - type Paragraph = L::Paragraph; - type Editor = L::Editor; + type Font = A::Font; + type Paragraph = A::Paragraph; + type Editor = A::Editor; - const ICON_FONT: Self::Font = L::ICON_FONT; - const CHECKMARK_ICON: char = L::CHECKMARK_ICON; - const ARROW_DOWN_ICON: char = L::ARROW_DOWN_ICON; + const ICON_FONT: Self::Font = A::ICON_FONT; + const CHECKMARK_ICON: char = A::CHECKMARK_ICON; + const ARROW_DOWN_ICON: char = A::ARROW_DOWN_ICON; fn default_font(&self) -> Self::Font { delegate!(self, renderer, renderer.default_font()) @@ -128,12 +136,12 @@ where } } -impl image::Renderer for Renderer +impl image::Renderer for Renderer where - L: image::Renderer, - R: image::Renderer, + A: image::Renderer, + B: image::Renderer, { - type Handle = L::Handle; + type Handle = A::Handle; fn measure_image(&self, handle: &Self::Handle) -> Size { delegate!(self, renderer, renderer.measure_image(handle)) @@ -153,10 +161,10 @@ where } } -impl svg::Renderer for Renderer +impl svg::Renderer for Renderer where - L: svg::Renderer, - R: svg::Renderer, + A: svg::Renderer, + B: svg::Renderer, { fn measure_svg(&self, handle: &svg::Handle) -> Size { delegate!(self, renderer, renderer.measure_svg(handle)) @@ -172,37 +180,49 @@ where } } -impl mesh::Renderer for Renderer +impl mesh::Renderer for Renderer where - L: mesh::Renderer, - R: mesh::Renderer, + A: mesh::Renderer, + B: mesh::Renderer, { fn draw_mesh(&mut self, mesh: graphics::Mesh) { delegate!(self, renderer, renderer.draw_mesh(mesh)); } } -pub enum Compositor +/// A compositor `A` with a fallback strategy `B`. +/// +/// It works analogously to [`Renderer`]. +#[derive(Debug)] +pub enum Compositor where - L: graphics::Compositor, - R: graphics::Compositor, + A: graphics::Compositor, + B: graphics::Compositor, { - Left(L), - Right(R), + /// The primary compositing option. + Primary(A), + /// The secondary (or fallback) compositing option. + Secondary(B), } -pub enum Surface { - Left(L), - Right(R), +/// A surface `A` with a fallback strategy `B`. +/// +/// It works analogously to [`Renderer`]. +#[derive(Debug)] +pub enum Surface { + /// The primary surface option. + Primary(A), + /// The secondary (or fallback) surface option. + Secondary(B), } -impl graphics::Compositor for Compositor +impl graphics::Compositor for Compositor where - L: graphics::Compositor, - R: graphics::Compositor, + A: graphics::Compositor, + B: graphics::Compositor, { - type Renderer = Renderer; - type Surface = Surface; + type Renderer = Renderer; + type Surface = Surface; async fn with_backend( settings: graphics::Settings, @@ -233,19 +253,19 @@ where let mut errors = vec![]; for backend in candidates.iter().map(Option::as_deref) { - match L::with_backend(settings, compatible_window.clone(), backend) + match A::with_backend(settings, compatible_window.clone(), backend) .await { - Ok(compositor) => return Ok(Self::Left(compositor)), + Ok(compositor) => return Ok(Self::Primary(compositor)), Err(error) => { errors.push(error); } } - match R::with_backend(settings, compatible_window.clone(), backend) + match B::with_backend(settings, compatible_window.clone(), backend) .await { - Ok(compositor) => return Ok(Self::Right(compositor)), + Ok(compositor) => return Ok(Self::Secondary(compositor)), Err(error) => { errors.push(error); } @@ -257,11 +277,11 @@ where fn create_renderer(&self) -> Self::Renderer { match self { - Self::Left(compositor) => { - Renderer::Left(compositor.create_renderer()) + Self::Primary(compositor) => { + Renderer::Primary(compositor.create_renderer()) } - Self::Right(compositor) => { - Renderer::Right(compositor.create_renderer()) + Self::Secondary(compositor) => { + Renderer::Secondary(compositor.create_renderer()) } } } @@ -273,12 +293,12 @@ where height: u32, ) -> Self::Surface { match self { - Self::Left(compositor) => { - Surface::Left(compositor.create_surface(window, width, height)) - } - Self::Right(compositor) => { - Surface::Right(compositor.create_surface(window, width, height)) - } + Self::Primary(compositor) => Surface::Primary( + compositor.create_surface(window, width, height), + ), + Self::Secondary(compositor) => Surface::Secondary( + compositor.create_surface(window, width, height), + ), } } @@ -289,10 +309,10 @@ where height: u32, ) { match (self, surface) { - (Self::Left(compositor), Surface::Left(surface)) => { + (Self::Primary(compositor), Surface::Primary(surface)) => { compositor.configure_surface(surface, width, height); } - (Self::Right(compositor), Surface::Right(surface)) => { + (Self::Secondary(compositor), Surface::Secondary(surface)) => { compositor.configure_surface(surface, width, height); } _ => unreachable!(), @@ -313,9 +333,9 @@ where ) -> Result<(), compositor::SurfaceError> { match (self, renderer, surface) { ( - Self::Left(compositor), - Renderer::Left(renderer), - Surface::Left(surface), + Self::Primary(compositor), + Renderer::Primary(renderer), + Surface::Primary(surface), ) => compositor.present( renderer, surface, @@ -324,9 +344,9 @@ where overlay, ), ( - Self::Right(compositor), - Renderer::Right(renderer), - Surface::Right(surface), + Self::Secondary(compositor), + Renderer::Secondary(renderer), + Surface::Secondary(surface), ) => compositor.present( renderer, surface, @@ -348,9 +368,9 @@ where ) -> Vec { match (self, renderer, surface) { ( - Self::Left(compositor), - Renderer::Left(renderer), - Surface::Left(surface), + Self::Primary(compositor), + Renderer::Primary(renderer), + Surface::Primary(surface), ) => compositor.screenshot( renderer, surface, @@ -359,9 +379,9 @@ where overlay, ), ( - Self::Right(compositor), - Renderer::Right(renderer), - Surface::Right(surface), + Self::Secondary(compositor), + Renderer::Secondary(renderer), + Surface::Secondary(surface), ) => compositor.screenshot( renderer, surface, @@ -375,10 +395,10 @@ where } #[cfg(feature = "wgpu")] -impl iced_wgpu::primitive::pipeline::Renderer for Renderer +impl iced_wgpu::primitive::pipeline::Renderer for Renderer where - L: iced_wgpu::primitive::pipeline::Renderer, - R: core::Renderer, + A: iced_wgpu::primitive::pipeline::Renderer, + B: core::Renderer, { fn draw_pipeline_primitive( &mut self, @@ -386,10 +406,10 @@ where primitive: impl iced_wgpu::primitive::pipeline::Primitive, ) { match self { - Self::Left(renderer) => { + Self::Primary(renderer) => { renderer.draw_pipeline_primitive(bounds, primitive); } - Self::Right(_) => { + Self::Secondary(_) => { log::warn!( "Custom shader primitive is not supported with this renderer." ); @@ -405,27 +425,31 @@ mod geometry { use crate::graphics::geometry::{self, Fill, Path, Stroke, Text}; use crate::graphics::Cached; - impl geometry::Renderer for Renderer + impl geometry::Renderer for Renderer where - L: geometry::Renderer, - R: geometry::Renderer, + A: geometry::Renderer, + B: geometry::Renderer, { - type Geometry = Geometry; - type Frame = Frame; + type Geometry = Geometry; + type Frame = Frame; fn new_frame(&self, size: iced_graphics::core::Size) -> Self::Frame { match self { - Self::Left(renderer) => Frame::Left(renderer.new_frame(size)), - Self::Right(renderer) => Frame::Right(renderer.new_frame(size)), + Self::Primary(renderer) => { + Frame::Primary(renderer.new_frame(size)) + } + Self::Secondary(renderer) => { + Frame::Secondary(renderer.new_frame(size)) + } } } fn draw_geometry(&mut self, geometry: Self::Geometry) { match (self, geometry) { - (Self::Left(renderer), Geometry::Left(geometry)) => { + (Self::Primary(renderer), Geometry::Primary(geometry)) => { renderer.draw_geometry(geometry); } - (Self::Right(renderer), Geometry::Right(geometry)) => { + (Self::Secondary(renderer), Geometry::Secondary(geometry)) => { renderer.draw_geometry(geometry); } _ => unreachable!(), @@ -433,44 +457,48 @@ mod geometry { } } - pub enum Geometry { - Left(L), - Right(R), + #[derive(Debug)] + pub enum Geometry { + Primary(A), + Secondary(B), } - impl Cached for Geometry + impl Cached for Geometry where - L: Cached, - R: Cached, + A: Cached, + B: Cached, { - type Cache = Geometry; + type Cache = Geometry; fn load(cache: &Self::Cache) -> Self { match cache { - Geometry::Left(cache) => Self::Left(L::load(cache)), - Geometry::Right(cache) => Self::Right(R::load(cache)), + Geometry::Primary(cache) => Self::Primary(A::load(cache)), + Geometry::Secondary(cache) => Self::Secondary(B::load(cache)), } } fn cache(self) -> Self::Cache { match self { - Self::Left(geometry) => Geometry::Left(geometry.cache()), - Self::Right(geometry) => Geometry::Right(geometry.cache()), + Self::Primary(geometry) => Geometry::Primary(geometry.cache()), + Self::Secondary(geometry) => { + Geometry::Secondary(geometry.cache()) + } } } } - pub enum Frame { - Left(L), - Right(R), + #[derive(Debug)] + pub enum Frame { + Primary(A), + Secondary(B), } - impl geometry::frame::Backend for Frame + impl geometry::frame::Backend for Frame where - L: geometry::frame::Backend, - R: geometry::frame::Backend, + A: geometry::frame::Backend, + B: geometry::frame::Backend, { - type Geometry = Geometry; + type Geometry = Geometry; fn width(&self) -> f32 { delegate!(self, frame, frame.width()) @@ -519,17 +547,17 @@ mod geometry { fn draft(&mut self, size: Size) -> Self { match self { - Self::Left(frame) => Self::Left(frame.draft(size)), - Self::Right(frame) => Self::Right(frame.draft(size)), + Self::Primary(frame) => Self::Primary(frame.draft(size)), + Self::Secondary(frame) => Self::Secondary(frame.draft(size)), } } fn paste(&mut self, frame: Self, at: Point) { match (self, frame) { - (Self::Left(target), Self::Left(source)) => { + (Self::Primary(target), Self::Primary(source)) => { target.paste(source, at); } - (Self::Right(target), Self::Right(source)) => { + (Self::Secondary(target), Self::Secondary(source)) => { target.paste(source, at); } _ => unreachable!(), @@ -554,17 +582,21 @@ mod geometry { fn into_geometry(self) -> Self::Geometry { match self { - Frame::Left(frame) => Geometry::Left(frame.into_geometry()), - Frame::Right(frame) => Geometry::Right(frame.into_geometry()), + Frame::Primary(frame) => { + Geometry::Primary(frame.into_geometry()) + } + Frame::Secondary(frame) => { + Geometry::Secondary(frame.into_geometry()) + } } } } } -impl compositor::Default for Renderer +impl compositor::Default for Renderer where - L: compositor::Default, - R: compositor::Default, + A: compositor::Default, + B: compositor::Default, { - type Compositor = Compositor; + type Compositor = Compositor; } diff --git a/renderer/src/lib.rs b/renderer/src/lib.rs index 7c48995d..056da5ed 100644 --- a/renderer/src/lib.rs +++ b/renderer/src/lib.rs @@ -1,5 +1,4 @@ -#![forbid(rust_2018_idioms)] -#![deny(unsafe_code, unused_results, rustdoc::broken_intra_doc_links)] +//! The official renderer for iced. #![cfg_attr(docsrs, feature(doc_auto_cfg))] #[cfg(feature = "wgpu")] pub use iced_wgpu as wgpu; -- cgit From d922b478156488a7bc03c6e791e05c040d702634 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Mon, 8 Apr 2024 15:04:35 +0200 Subject: Reintroduce support for custom primitives in `iced_wgpu` --- renderer/src/fallback.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'renderer/src') diff --git a/renderer/src/fallback.rs b/renderer/src/fallback.rs index 2676ba87..975f4866 100644 --- a/renderer/src/fallback.rs +++ b/renderer/src/fallback.rs @@ -399,19 +399,19 @@ where } #[cfg(feature = "wgpu")] -impl iced_wgpu::primitive::pipeline::Renderer for Renderer +impl iced_wgpu::primitive::Renderer for Renderer where - A: iced_wgpu::primitive::pipeline::Renderer, + A: iced_wgpu::primitive::Renderer, B: core::Renderer, { - fn draw_pipeline_primitive( + fn draw_primitive( &mut self, bounds: Rectangle, - primitive: impl iced_wgpu::primitive::pipeline::Primitive, + primitive: impl iced_wgpu::Primitive, ) { match self { Self::Primary(renderer) => { - renderer.draw_pipeline_primitive(bounds, primitive); + renderer.draw_primitive(bounds, primitive); } Self::Secondary(_) => { log::warn!( -- cgit From 6ad5bb3597f640ac329801adf735d633bf0a512f Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Tue, 9 Apr 2024 22:25:16 +0200 Subject: Port `iced_tiny_skia` to new layering architecture --- renderer/src/fallback.rs | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) (limited to 'renderer/src') diff --git a/renderer/src/fallback.rs b/renderer/src/fallback.rs index 975f4866..c932de00 100644 --- a/renderer/src/fallback.rs +++ b/renderer/src/fallback.rs @@ -9,6 +9,8 @@ use crate::graphics; use crate::graphics::compositor; use crate::graphics::mesh; +use std::borrow::Cow; + /// A renderer `A` with a fallback strategy `B`. /// /// This type can be used to easily compose existing renderers and @@ -51,8 +53,8 @@ where delegate!(self, renderer, renderer.start_layer(bounds)); } - fn end_layer(&mut self, bounds: Rectangle) { - delegate!(self, renderer, renderer.end_layer(bounds)); + fn end_layer(&mut self) { + delegate!(self, renderer, renderer.end_layer()); } fn start_transformation(&mut self, transformation: Transformation) { @@ -63,8 +65,8 @@ where ); } - fn end_transformation(&mut self, transformation: Transformation) { - delegate!(self, renderer, renderer.end_transformation(transformation)); + fn end_transformation(&mut self) { + delegate!(self, renderer, renderer.end_transformation()); } } @@ -93,10 +95,6 @@ where delegate!(self, renderer, renderer.default_size()) } - fn load_font(&mut self, font: std::borrow::Cow<'static, [u8]>) { - delegate!(self, renderer, renderer.load_font(font)); - } - fn fill_paragraph( &mut self, text: &Self::Paragraph, @@ -323,6 +321,10 @@ where } } + fn load_font(&mut self, font: Cow<'static, [u8]>) { + delegate!(self, compositor, compositor.load_font(font)); + } + fn fetch_information(&self) -> compositor::Information { delegate!(self, compositor, compositor.fetch_information()) } -- cgit