From f531d953e368bdcc93d4e828b442a38d1f87f09f Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Wed, 21 Feb 2024 22:03:43 -0700 Subject: [PATCH] WIP --- crates/gpui/src/scene.rs | 328 ++++++++------------------- crates/gpui/src/view.rs | 10 +- crates/gpui/src/window/element_cx.rs | 163 ++++++------- 3 files changed, 161 insertions(+), 340 deletions(-) diff --git a/crates/gpui/src/scene.rs b/crates/gpui/src/scene.rs index 67ec181149..b585b5d62c 100644 --- a/crates/gpui/src/scene.rs +++ b/crates/gpui/src/scene.rs @@ -1,16 +1,12 @@ use crate::{ point, AtlasTextureId, AtlasTile, Bounds, ContentMask, Corners, Edges, EntityId, Hsla, Pixels, - Point, ScaledPixels, StackingOrder, + Point, ScaledPixels, }; -use collections::{BTreeMap, FxHashSet}; use std::{fmt::Debug, iter::Peekable, slice}; #[allow(non_camel_case_types, unused)] pub(crate) type PathVertex_ScaledPixels = PathVertex; -pub(crate) type LayerId = u32; -pub(crate) type DrawOrder = u32; - #[derive(Default, Copy, Clone, Debug, Eq, PartialEq, Hash)] #[repr(C)] pub(crate) struct ViewId { @@ -37,21 +33,18 @@ impl From for EntityId { #[derive(Default)] /// An index into all the geometry in a `Scene` at a point in time. -pub(crate) struct SceneIndex { - pub(crate) shadow: usize, - pub(crate) quad: usize, - pub(crate) path: usize, - pub(crate) underline: usize, - pub(crate) monochrome_sprite: usize, - pub(crate) polychrome_sprite: usize, - pub(crate) surface: usize, +pub(crate) struct PrimitiveCounts { + pub(crate) shadows: usize, + pub(crate) quads: usize, + pub(crate) paths: usize, + pub(crate) underlines: usize, + pub(crate) monochrome_sprites: usize, + pub(crate) polychrome_sprites: usize, + pub(crate) surfaces: usize, } #[derive(Default)] pub(crate) struct Scene { - last_layer: Option<(StackingOrder, LayerId)>, - layers_by_order: BTreeMap, - orders_by_layer: BTreeMap, pub(crate) shadows: Vec, pub(crate) quads: Vec, pub(crate) paths: Vec>, @@ -59,13 +52,11 @@ pub(crate) struct Scene { pub(crate) monochrome_sprites: Vec, pub(crate) polychrome_sprites: Vec, pub(crate) surfaces: Vec, + pub(crate) primitive_count: u32, } impl Scene { pub fn clear(&mut self) { - self.last_layer = None; - self.layers_by_order.clear(); - self.orders_by_layer.clear(); self.shadows.clear(); self.quads.clear(); self.paths.clear(); @@ -73,17 +64,18 @@ impl Scene { self.monochrome_sprites.clear(); self.polychrome_sprites.clear(); self.surfaces.clear(); + self.primitive_count = 0; } - pub fn len(&self) -> SceneIndex { - SceneIndex { - shadow: self.shadows.len(), - quad: self.quads.len(), - path: self.paths.len(), - underline: self.underlines.len(), - monochrome_sprite: self.monochrome_sprites.len(), - polychrome_sprite: self.polychrome_sprites.len(), - surface: self.surfaces.len(), + pub fn primitive_counts(&self) -> PrimitiveCounts { + PrimitiveCounts { + shadows: self.shadows.len(), + quads: self.quads.len(), + paths: self.paths.len(), + underlines: self.underlines.len(), + monochrome_sprites: self.monochrome_sprites.len(), + polychrome_sprites: self.polychrome_sprites.len(), + surfaces: self.surfaces.len(), } } @@ -117,8 +109,12 @@ impl Scene { } } - pub(crate) fn insert(&mut self, order: &StackingOrder, primitive: impl Into) { - let primitive = primitive.into(); + pub(crate) fn push_primitive>( + &mut self, + build_primitive: impl FnOnce(u32) -> T, + ) { + let primitive = build_primitive(self.primitive_count).into(); + let clipped_bounds = primitive .bounds() .intersect(&primitive.content_mask().bounds); @@ -128,150 +124,62 @@ impl Scene { return; } - let layer_id = self.layer_id_for_order(order); match primitive { Primitive::Shadow(mut shadow) => { - shadow.layer_id = layer_id; self.shadows.push(shadow); } Primitive::Quad(mut quad) => { - quad.layer_id = layer_id; self.quads.push(quad); } Primitive::Path(mut path) => { - path.layer_id = layer_id; - path.id = PathId(self.paths.len()); self.paths.push(path); } Primitive::Underline(mut underline) => { - underline.layer_id = layer_id; self.underlines.push(underline); } Primitive::MonochromeSprite(mut sprite) => { - sprite.layer_id = layer_id; self.monochrome_sprites.push(sprite); } Primitive::PolychromeSprite(mut sprite) => { - sprite.layer_id = layer_id; self.polychrome_sprites.push(sprite); } Primitive::Surface(mut surface) => { - surface.layer_id = layer_id; self.surfaces.push(surface); } } + + self.primitive_count += 1; } - fn layer_id_for_order(&mut self, order: &StackingOrder) -> LayerId { - if let Some((last_order, last_layer_id)) = self.last_layer.as_ref() { - if order == last_order { - return *last_layer_id; - } - } - - let layer_id = if let Some(layer_id) = self.layers_by_order.get(order) { - *layer_id - } else { - let next_id = self.layers_by_order.len() as LayerId; - self.layers_by_order.insert(order.clone(), next_id); - self.orders_by_layer.insert(next_id, order.clone()); - next_id - }; - self.last_layer = Some((order.clone(), layer_id)); - layer_id - } - - pub fn reuse_views(&mut self, views: &FxHashSet, prev_scene: &mut Self) { - for shadow in prev_scene.shadows.drain(..) { - if views.contains(&shadow.view_id.into()) { - let order = &prev_scene.orders_by_layer[&shadow.layer_id]; - self.insert(order, shadow); - } - } - - for quad in prev_scene.quads.drain(..) { - if views.contains(&quad.view_id.into()) { - let order = &prev_scene.orders_by_layer[&quad.layer_id]; - self.insert(order, quad); - } - } - - for path in prev_scene.paths.drain(..) { - if views.contains(&path.view_id.into()) { - let order = &prev_scene.orders_by_layer[&path.layer_id]; - self.insert(order, path); - } - } - - for underline in prev_scene.underlines.drain(..) { - if views.contains(&underline.view_id.into()) { - let order = &prev_scene.orders_by_layer[&underline.layer_id]; - self.insert(order, underline); - } - } - - for sprite in prev_scene.monochrome_sprites.drain(..) { - if views.contains(&sprite.view_id.into()) { - let order = &prev_scene.orders_by_layer[&sprite.layer_id]; - self.insert(order, sprite); - } - } - - for sprite in prev_scene.polychrome_sprites.drain(..) { - if views.contains(&sprite.view_id.into()) { - let order = &prev_scene.orders_by_layer[&sprite.layer_id]; - self.insert(order, sprite); - } - } - - for surface in prev_scene.surfaces.drain(..) { - if views.contains(&surface.view_id.into()) { - let order = &prev_scene.orders_by_layer[&surface.layer_id]; - self.insert(order, surface); - } - } - } - - pub fn finish(&mut self) { - let mut orders = vec![0; self.layers_by_order.len()]; - for (ix, layer_id) in self.layers_by_order.values().enumerate() { - orders[*layer_id as usize] = ix as u32; - } - - for shadow in &mut self.shadows { - shadow.order = orders[shadow.layer_id as usize]; - } - self.shadows.sort_by_key(|shadow| shadow.order); - - for quad in &mut self.quads { - quad.order = orders[quad.layer_id as usize]; - } - self.quads.sort_by_key(|quad| quad.order); - - for path in &mut self.paths { - path.order = orders[path.layer_id as usize]; - } - self.paths.sort_by_key(|path| path.order); - - for underline in &mut self.underlines { - underline.order = orders[underline.layer_id as usize]; - } - self.underlines.sort_by_key(|underline| underline.order); - - for monochrome_sprite in &mut self.monochrome_sprites { - monochrome_sprite.order = orders[monochrome_sprite.layer_id as usize]; - } - self.monochrome_sprites.sort_by_key(|sprite| sprite.order); - - for polychrome_sprite in &mut self.polychrome_sprites { - polychrome_sprite.order = orders[polychrome_sprite.layer_id as usize]; - } - self.polychrome_sprites.sort_by_key(|sprite| sprite.order); - - for surface in &mut self.surfaces { - surface.order = orders[surface.layer_id as usize]; - } - self.surfaces.sort_by_key(|surface| surface.order); + pub fn reuse_subscene( + &mut self, + prev_scene: &mut Self, + start: PrimitiveCounts, + end: PrimitiveCounts, + ) { + self.shadows + .extend(prev_scene.shadows.drain(start.shadows..end.shadows)); + self.quads + .extend(prev_scene.quads.drain(start.quads..end.quads)); + self.paths + .extend(prev_scene.paths.drain(start.paths..end.paths)); + self.underlines.extend( + prev_scene + .underlines + .drain(start.underlines..end.underlines), + ); + self.monochrome_sprites.extend( + prev_scene + .monochrome_sprites + .drain(start.monochrome_sprites..end.monochrome_sprites), + ); + self.polychrome_sprites.extend( + prev_scene + .polychrome_sprites + .drain(start.polychrome_sprites..end.polychrome_sprites), + ); + self.surfaces + .extend(prev_scene.surfaces.drain(start.surfaces..end.surfaces)); } } @@ -305,25 +213,31 @@ impl<'a> Iterator for BatchIterator<'a> { fn next(&mut self) -> Option { let mut orders_and_kinds = [ ( - self.shadows_iter.peek().map(|s| s.order), + self.shadows_iter.peek().map(|s| s.draw_order), PrimitiveKind::Shadow, ), - (self.quads_iter.peek().map(|q| q.order), PrimitiveKind::Quad), - (self.paths_iter.peek().map(|q| q.order), PrimitiveKind::Path), ( - self.underlines_iter.peek().map(|u| u.order), + self.quads_iter.peek().map(|q| q.draw_order), + PrimitiveKind::Quad, + ), + ( + self.paths_iter.peek().map(|q| q.draw_order), + PrimitiveKind::Path, + ), + ( + self.underlines_iter.peek().map(|u| u.draw_order), PrimitiveKind::Underline, ), ( - self.monochrome_sprites_iter.peek().map(|s| s.order), + self.monochrome_sprites_iter.peek().map(|s| s.draw_order), PrimitiveKind::MonochromeSprite, ), ( - self.polychrome_sprites_iter.peek().map(|s| s.order), + self.polychrome_sprites_iter.peek().map(|s| s.draw_order), PrimitiveKind::PolychromeSprite, ), ( - self.surfaces_iter.peek().map(|s| s.order), + self.surfaces_iter.peek().map(|s| s.draw_order), PrimitiveKind::Surface, ), ]; @@ -344,7 +258,7 @@ impl<'a> Iterator for BatchIterator<'a> { self.shadows_iter.next(); while self .shadows_iter - .next_if(|shadow| (shadow.order, batch_kind) < max_order_and_kind) + .next_if(|shadow| (shadow.draw_order, batch_kind) < max_order_and_kind) .is_some() { shadows_end += 1; @@ -360,7 +274,7 @@ impl<'a> Iterator for BatchIterator<'a> { self.quads_iter.next(); while self .quads_iter - .next_if(|quad| (quad.order, batch_kind) < max_order_and_kind) + .next_if(|quad| (quad.draw_order, batch_kind) < max_order_and_kind) .is_some() { quads_end += 1; @@ -374,7 +288,7 @@ impl<'a> Iterator for BatchIterator<'a> { self.paths_iter.next(); while self .paths_iter - .next_if(|path| (path.order, batch_kind) < max_order_and_kind) + .next_if(|path| (path.draw_order, batch_kind) < max_order_and_kind) .is_some() { paths_end += 1; @@ -388,7 +302,7 @@ impl<'a> Iterator for BatchIterator<'a> { self.underlines_iter.next(); while self .underlines_iter - .next_if(|underline| (underline.order, batch_kind) < max_order_and_kind) + .next_if(|underline| (underline.draw_order, batch_kind) < max_order_and_kind) .is_some() { underlines_end += 1; @@ -406,7 +320,7 @@ impl<'a> Iterator for BatchIterator<'a> { while self .monochrome_sprites_iter .next_if(|sprite| { - (sprite.order, batch_kind) < max_order_and_kind + (sprite.draw_order, batch_kind) < max_order_and_kind && sprite.tile.texture_id == texture_id }) .is_some() @@ -427,7 +341,7 @@ impl<'a> Iterator for BatchIterator<'a> { while self .polychrome_sprites_iter .next_if(|sprite| { - (sprite.order, batch_kind) < max_order_and_kind + (sprite.draw_order, batch_kind) < max_order_and_kind && sprite.tile.texture_id == texture_id }) .is_some() @@ -446,7 +360,7 @@ impl<'a> Iterator for BatchIterator<'a> { self.surfaces_iter.next(); while self .surfaces_iter - .next_if(|surface| (surface.order, batch_kind) < max_order_and_kind) + .next_if(|surface| (surface.draw_order, batch_kind) < max_order_and_kind) .is_some() { surfaces_end += 1; @@ -528,9 +442,7 @@ pub(crate) enum PrimitiveBatch<'a> { #[derive(Default, Debug, Clone, Eq, PartialEq)] #[repr(C)] pub(crate) struct Quad { - pub view_id: ViewId, - pub layer_id: LayerId, - pub order: DrawOrder, + pub draw_order: u32, pub bounds: Bounds, pub content_mask: ContentMask, pub background: Hsla, @@ -541,7 +453,7 @@ pub(crate) struct Quad { impl Ord for Quad { fn cmp(&self, other: &Self) -> std::cmp::Ordering { - self.order.cmp(&other.order) + self.draw_order.cmp(&other.draw_order) } } @@ -560,9 +472,7 @@ impl From for Primitive { #[derive(Debug, Clone, Eq, PartialEq)] #[repr(C)] pub(crate) struct Underline { - pub view_id: ViewId, - pub layer_id: LayerId, - pub order: DrawOrder, + pub draw_order: u32, pub bounds: Bounds, pub content_mask: ContentMask, pub color: Hsla, @@ -572,7 +482,7 @@ pub(crate) struct Underline { impl Ord for Underline { fn cmp(&self, other: &Self) -> std::cmp::Ordering { - self.order.cmp(&other.order) + self.draw_order.cmp(&other.draw_order) } } @@ -591,9 +501,7 @@ impl From for Primitive { #[derive(Debug, Clone, Eq, PartialEq)] #[repr(C)] pub(crate) struct Shadow { - pub view_id: ViewId, - pub layer_id: LayerId, - pub order: DrawOrder, + pub draw_order: u32, pub bounds: Bounds, pub corner_radii: Corners, pub content_mask: ContentMask, @@ -604,7 +512,7 @@ pub(crate) struct Shadow { impl Ord for Shadow { fn cmp(&self, other: &Self) -> std::cmp::Ordering { - self.order.cmp(&other.order) + self.draw_order.cmp(&other.draw_order) } } @@ -623,30 +531,13 @@ impl From for Primitive { #[derive(Clone, Debug, Eq, PartialEq)] #[repr(C)] pub(crate) struct MonochromeSprite { - pub view_id: ViewId, - pub layer_id: LayerId, - pub order: DrawOrder, + pub draw_order: u32, pub bounds: Bounds, pub content_mask: ContentMask, pub color: Hsla, pub tile: AtlasTile, } -impl Ord for MonochromeSprite { - fn cmp(&self, other: &Self) -> std::cmp::Ordering { - match self.order.cmp(&other.order) { - std::cmp::Ordering::Equal => self.tile.tile_id.cmp(&other.tile.tile_id), - order => order, - } - } -} - -impl PartialOrd for MonochromeSprite { - fn partial_cmp(&self, other: &Self) -> Option { - Some(self.cmp(other)) - } -} - impl From for Primitive { fn from(sprite: MonochromeSprite) -> Self { Primitive::MonochromeSprite(sprite) @@ -656,9 +547,7 @@ impl From for Primitive { #[derive(Clone, Debug, Eq, PartialEq)] #[repr(C)] pub(crate) struct PolychromeSprite { - pub view_id: ViewId, - pub layer_id: LayerId, - pub order: DrawOrder, + pub draw_order: u32, pub bounds: Bounds, pub content_mask: ContentMask, pub corner_radii: Corners, @@ -667,21 +556,6 @@ pub(crate) struct PolychromeSprite { pub pad: u32, // align to 8 bytes } -impl Ord for PolychromeSprite { - fn cmp(&self, other: &Self) -> std::cmp::Ordering { - match self.order.cmp(&other.order) { - std::cmp::Ordering::Equal => self.tile.tile_id.cmp(&other.tile.tile_id), - order => order, - } - } -} - -impl PartialOrd for PolychromeSprite { - fn partial_cmp(&self, other: &Self) -> Option { - Some(self.cmp(other)) - } -} - impl From for Primitive { fn from(sprite: PolychromeSprite) -> Self { Primitive::PolychromeSprite(sprite) @@ -690,27 +564,13 @@ impl From for Primitive { #[derive(Clone, Debug, Eq, PartialEq)] pub(crate) struct Surface { - pub view_id: ViewId, - pub layer_id: LayerId, - pub order: DrawOrder, + pub draw_order: u32, pub bounds: Bounds, pub content_mask: ContentMask, #[cfg(target_os = "macos")] pub image_buffer: media::core_video::CVImageBuffer, } -impl Ord for Surface { - fn cmp(&self, other: &Self) -> std::cmp::Ordering { - self.order.cmp(&other.order) - } -} - -impl PartialOrd for Surface { - fn partial_cmp(&self, other: &Self) -> Option { - Some(self.cmp(other)) - } -} - impl From for Primitive { fn from(surface: Surface) -> Self { Primitive::Surface(surface) @@ -723,10 +583,8 @@ pub(crate) struct PathId(pub(crate) usize); /// A line made up of a series of vertices and control points. #[derive(Debug)] pub struct Path { + pub(crate) draw_order: u32, pub(crate) id: PathId, - pub(crate) view_id: ViewId, - layer_id: LayerId, - order: DrawOrder, pub(crate) bounds: Bounds

, pub(crate) content_mask: ContentMask

, pub(crate) vertices: Vec>, @@ -740,10 +598,8 @@ impl Path { /// Create a new path with the given starting point. pub fn new(start: Point) -> Self { Self { + draw_order: 0, id: PathId(0), - view_id: ViewId::default(), - layer_id: LayerId::default(), - order: DrawOrder::default(), vertices: Vec::new(), start, current: start, @@ -760,10 +616,8 @@ impl Path { /// Scale this path by the given factor. pub fn scale(&self, factor: f32) -> Path { Path { + draw_order: self.draw_order, id: self.id, - view_id: self.view_id, - layer_id: self.layer_id, - order: self.order, bounds: self.bounds.scale(factor), content_mask: self.content_mask.scale(factor), vertices: self @@ -849,13 +703,13 @@ impl Eq for Path {} impl PartialEq for Path { fn eq(&self, other: &Self) -> bool { - self.order == other.order + self.draw_order == other.draw_order } } impl Ord for Path { fn cmp(&self, other: &Self) -> std::cmp::Ordering { - self.order.cmp(&other.order) + self.draw_order.cmp(&other.draw_order) } } diff --git a/crates/gpui/src/view.rs b/crates/gpui/src/view.rs index cfc2016bff..b5754425fc 100644 --- a/crates/gpui/src/view.rs +++ b/crates/gpui/src/view.rs @@ -1,7 +1,7 @@ use crate::{ seal::Sealed, AnyElement, AnyModel, AnyWeakModel, AppContext, AvailableSpace, Bounds, ContentMask, Element, ElementContext, ElementId, Entity, EntityId, Flatten, FocusHandle, - FocusableView, IntoElement, LayoutId, Model, Pixels, Point, Render, SceneIndex, Size, + FocusableView, IntoElement, LayoutId, Model, Pixels, Point, PrimitiveCounts, Render, Size, StackingOrder, Style, TextStyle, ViewContext, VisualContext, WeakModel, }; use anyhow::{Context, Result}; @@ -33,8 +33,8 @@ struct ViewCacheData { stacking_order: StackingOrder, content_mask: ContentMask, text_style: TextStyle, - scene_start: SceneIndex, - scene_end: SceneIndex, + scene_start: PrimitiveCounts, + scene_end: PrimitiveCounts, } impl Entity for View { @@ -324,14 +324,14 @@ impl Element for AnyView { } } - let scene_start = cx.window.next_frame.scene.len(); + let scene_start = cx.window.next_frame.scene.primitive_counts(); if let Some(mut element) = state.element.take() { element.paint(cx); } else { let mut element = (self.request_layout)(self, cx).1; element.draw(bounds.origin, bounds.size.into(), cx); } - let scene_end = cx.window.next_frame.scene.len(); + let scene_end = cx.window.next_frame.scene.primitive_counts(); state.next_stacking_order_id = cx .window diff --git a/crates/gpui/src/window/element_cx.rs b/crates/gpui/src/window/element_cx.rs index 22ab59a84c..e6c622adb9 100644 --- a/crates/gpui/src/window/element_cx.rs +++ b/crates/gpui/src/window/element_cx.rs @@ -21,7 +21,7 @@ use std::{ }; use anyhow::Result; -use collections::{FxHashMap, FxHashSet}; +use collections::FxHashMap; use derive_more::{Deref, DerefMut}; #[cfg(target_os = "macos")] use media::core_video::CVImageBuffer; @@ -69,7 +69,6 @@ pub(crate) struct Frame { pub(crate) cursor_styles: FxHashMap, pub(crate) requested_cursor_style: Option, pub(crate) view_stack: Vec, - pub(crate) reused_views: FxHashSet, #[cfg(any(test, feature = "test-support"))] pub(crate) debug_bounds: FxHashMap>, @@ -95,7 +94,6 @@ impl Frame { cursor_styles: FxHashMap::default(), requested_cursor_style: None, view_stack: Vec::new(), - reused_views: FxHashSet::default(), #[cfg(any(test, feature = "test-support"))] debug_bounds: FxHashMap::default(), @@ -109,7 +107,6 @@ impl Frame { self.depth_map.clear(); self.next_stacking_order_ids = vec![0]; self.next_root_z_index = 0; - self.reused_views.clear(); self.scene.clear(); self.requested_input_handler.take(); self.tooltip_request.take(); @@ -153,11 +150,6 @@ impl Frame { self.element_states.entry(element_id).or_insert(state); } } - - // Reuse geometry that didn't change since the last frame. - self.scene - .reuse_views(&self.reused_views, &mut prev_frame.scene); - self.scene.finish(); } } @@ -666,20 +658,15 @@ impl<'a> ElementContext<'a> { let mut shadow_bounds = bounds; shadow_bounds.origin += shadow.offset; shadow_bounds.dilate(shadow.spread_radius); - window.next_frame.scene.insert( - &window.next_frame.z_index_stack, - Shadow { - view_id: view_id.into(), - layer_id: 0, - order: 0, - bounds: shadow_bounds.scale(scale_factor), - content_mask: content_mask.scale(scale_factor), - corner_radii: corner_radii.scale(scale_factor), - color: shadow.color, - blur_radius: shadow.blur_radius.scale(scale_factor), - pad: 0, - }, - ); + window.next_frame.scene.push_primitive(|draw_order| Shadow { + draw_order, + bounds: shadow_bounds.scale(scale_factor), + content_mask: content_mask.scale(scale_factor), + corner_radii: corner_radii.scale(scale_factor), + color: shadow.color, + blur_radius: shadow.blur_radius.scale(scale_factor), + pad: 0, + }); } } @@ -692,20 +679,15 @@ impl<'a> ElementContext<'a> { let view_id = self.parent_view_id(); let window = &mut *self.window; - window.next_frame.scene.insert( - &window.next_frame.z_index_stack, - Quad { - view_id: view_id.into(), - layer_id: 0, - order: 0, - bounds: quad.bounds.scale(scale_factor), - content_mask: content_mask.scale(scale_factor), - background: quad.background, - border_color: quad.border_color, - corner_radii: quad.corner_radii.scale(scale_factor), - border_widths: quad.border_widths.scale(scale_factor), - }, - ); + window.next_frame.scene.push_primitive(|draw_order| Quad { + draw_order, + bounds: quad.bounds.scale(scale_factor), + content_mask: content_mask.scale(scale_factor), + background: quad.background, + border_color: quad.border_color, + corner_radii: quad.corner_radii.scale(scale_factor), + border_widths: quad.border_widths.scale(scale_factor), + }); } /// Paint the given `Path` into the scene for the next frame at the current z-index. @@ -716,12 +698,11 @@ impl<'a> ElementContext<'a> { path.content_mask = content_mask; path.color = color.into(); - path.view_id = view_id.into(); let window = &mut *self.window; - window - .next_frame - .scene - .insert(&window.next_frame.z_index_stack, path.scale(scale_factor)); + window.next_frame.scene.push_primitive(|draw_order| { + path.draw_order = draw_order; + path.scale(scale_factor) + }); } /// Paint an underline into the scene for the next frame at the current z-index. @@ -745,19 +726,17 @@ impl<'a> ElementContext<'a> { let view_id = self.parent_view_id(); let window = &mut *self.window; - window.next_frame.scene.insert( - &window.next_frame.z_index_stack, - Underline { - view_id: view_id.into(), - layer_id: 0, - order: 0, + window + .next_frame + .scene + .push_primitive(|draw_order| Underline { + draw_order, bounds: bounds.scale(scale_factor), content_mask: content_mask.scale(scale_factor), color: style.color.unwrap_or_default(), thickness: style.thickness.scale(scale_factor), wavy: style.wavy, - }, - ); + }); } /// Paint a strikethrough into the scene for the next frame at the current z-index. @@ -777,19 +756,17 @@ impl<'a> ElementContext<'a> { let view_id = self.parent_view_id(); let window = &mut *self.window; - window.next_frame.scene.insert( - &window.next_frame.z_index_stack, - Underline { - view_id: view_id.into(), - layer_id: 0, - order: 0, + window + .next_frame + .scene + .push_primitive(|draw_order| Underline { + draw_order, bounds: bounds.scale(scale_factor), content_mask: content_mask.scale(scale_factor), thickness: style.thickness.scale(scale_factor), color: style.color.unwrap_or_default(), wavy: false, - }, - ); + }); } /// Paints a monochrome (non-emoji) glyph into the scene for the next frame at the current z-index. @@ -837,18 +814,16 @@ impl<'a> ElementContext<'a> { let content_mask = self.content_mask().scale(scale_factor); let view_id = self.parent_view_id(); let window = &mut *self.window; - window.next_frame.scene.insert( - &window.next_frame.z_index_stack, - MonochromeSprite { - view_id: view_id.into(), - layer_id: 0, - order: 0, + window + .next_frame + .scene + .push_primitive(|draw_order| MonochromeSprite { + draw_order, bounds, content_mask, color, tile, - }, - ); + }); } Ok(()) } @@ -895,20 +870,18 @@ impl<'a> ElementContext<'a> { let view_id = self.parent_view_id(); let window = &mut *self.window; - window.next_frame.scene.insert( - &window.next_frame.z_index_stack, - PolychromeSprite { - view_id: view_id.into(), - layer_id: 0, - order: 0, + window + .next_frame + .scene + .push_primitive(|draw_order| PolychromeSprite { + draw_order, bounds, corner_radii: Default::default(), content_mask, tile, grayscale: false, pad: 0, - }, - ); + }); } Ok(()) } @@ -941,18 +914,16 @@ impl<'a> ElementContext<'a> { let view_id = self.parent_view_id(); let window = &mut *self.window; - window.next_frame.scene.insert( - &window.next_frame.z_index_stack, - MonochromeSprite { - view_id: view_id.into(), - layer_id: 0, - order: 0, + window + .next_frame + .scene + .push_primitive(|draw_order| MonochromeSprite { + draw_order, bounds, content_mask, color, tile, - }, - ); + }); Ok(()) } @@ -980,20 +951,18 @@ impl<'a> ElementContext<'a> { let view_id = self.parent_view_id(); let window = &mut *self.window; - window.next_frame.scene.insert( - &window.next_frame.z_index_stack, - PolychromeSprite { - view_id: view_id.into(), - layer_id: 0, - order: 0, + window + .next_frame + .scene + .push_primitive(|draw_order| PolychromeSprite { + draw_order, bounds, content_mask, corner_radii, tile, grayscale, pad: 0, - }, - ); + }); Ok(()) } @@ -1005,17 +974,15 @@ impl<'a> ElementContext<'a> { let content_mask = self.content_mask().scale(scale_factor); let view_id = self.parent_view_id(); let window = &mut *self.window; - window.next_frame.scene.insert( - &window.next_frame.z_index_stack, - crate::Surface { - view_id: view_id.into(), - layer_id: 0, - order: 0, + window + .next_frame + .scene + .push_primitive(|draw_order| crate::Surface { + draw_order, bounds, content_mask, image_buffer, - }, - ); + }); } #[must_use]