From 0548ea5d6d2fc927b632ea7197a19e76c82bce92 Mon Sep 17 00:00:00 2001 From: Glenn Watson Date: Tue, 14 Apr 2020 09:52:54 +0000 Subject: [PATCH 1/2] Bug 1629704 - Rotate vertex data textures per frame. r=Bert,kvark On some (primarily older, integrated) drivers, we see significant time in CPU stalls during updates to the vertex data textures. As a short term fix, this patch creates an array of vertex data textures, and rotates which set of them are in use each frame. There are better long-term options (such as porting the GPU cache scatter method, or perhaps using UBO/SSBOs here), but this is a simple workaround for now. Differential Revision: https://phabricator.services.mozilla.com/D70775 [ghsync] From https://hg.mozilla.org/mozilla-central/rev/b396f2b243fd9433e6038afdf03c905c1e0b3055 --- webrender/src/renderer.rs | 168 +++++++++++++++++++++++++------------- 1 file changed, 113 insertions(+), 55 deletions(-) diff --git a/webrender/src/renderer.rs b/webrender/src/renderer.rs index 281b71a2d1..4fdb8e51ff 100644 --- a/webrender/src/renderer.rs +++ b/webrender/src/renderer.rs @@ -126,6 +126,18 @@ cfg_if! { const DEFAULT_BATCH_LOOKBACK_COUNT: usize = 10; const VERTEX_TEXTURE_EXTRA_ROWS: i32 = 10; +/// The size of the array of each type of vertex data texture that +/// is round-robin-ed each frame during bind_frame_data. Doing this +/// helps avoid driver stalls while updating the texture in some +/// drivers. The size of these textures are typically very small +/// (e.g. < 16 kB) so it's not a huge waste of memory. Despite that, +/// this is a short-term solution - we want to find a better way +/// to provide this frame data, which will likely involve some +/// combination of UBO/SSBO usage. Although this only affects some +/// platforms, it's enabled on all platforms to reduce testing +/// differences between platforms. +const VERTEX_DATA_TEXTURE_COUNT: usize = 3; + /// Is only false if no WR instances have ever been created. static HAS_BEEN_INITIALIZED: AtomicBool = AtomicBool::new(false); @@ -1849,6 +1861,89 @@ impl DebugOverlayState { } } +pub struct VertexDataTextures { + prim_header_f_texture: VertexDataTexture, + prim_header_i_texture: VertexDataTexture, + transforms_texture: VertexDataTexture, + render_task_texture: VertexDataTexture, +} + +impl VertexDataTextures { + fn new( + device: &mut Device, + ) -> Self { + VertexDataTextures { + prim_header_f_texture: VertexDataTexture::new(device, ImageFormat::RGBAF32), + prim_header_i_texture: VertexDataTexture::new(device, ImageFormat::RGBAI32), + transforms_texture: VertexDataTexture::new(device, ImageFormat::RGBAF32), + render_task_texture: VertexDataTexture::new(device, ImageFormat::RGBAF32), + } + } + + fn update( + &mut self, + device: &mut Device, + frame: &mut Frame, + ) { + self.prim_header_f_texture.update( + device, + &mut frame.prim_headers.headers_float, + ); + device.bind_texture( + TextureSampler::PrimitiveHeadersF, + &self.prim_header_f_texture.texture(), + Swizzle::default(), + ); + + self.prim_header_i_texture.update( + device, + &mut frame.prim_headers.headers_int, + ); + device.bind_texture( + TextureSampler::PrimitiveHeadersI, + &self.prim_header_i_texture.texture(), + Swizzle::default(), + ); + + self.transforms_texture.update( + device, + &mut frame.transform_palette, + ); + device.bind_texture( + TextureSampler::TransformPalette, + &self.transforms_texture.texture(), + Swizzle::default(), + ); + + self.render_task_texture.update( + device, + &mut frame.render_tasks.task_data, + ); + device.bind_texture( + TextureSampler::RenderTasks, + &self.render_task_texture.texture(), + Swizzle::default(), + ); + } + + fn size_in_bytes(&self) -> usize { + self.prim_header_f_texture.size_in_bytes() + + self.prim_header_i_texture.size_in_bytes() + + self.transforms_texture.size_in_bytes() + + self.render_task_texture.size_in_bytes() + } + + fn deinit( + self, + device: &mut Device, + ) { + self.transforms_texture.deinit(device); + self.prim_header_f_texture.deinit(device); + self.prim_header_i_texture.deinit(device); + self.render_task_texture.deinit(device); + } +} + /// The renderer is responsible for submitting to the GPU the work prepared by the /// RenderBackend. /// @@ -1890,11 +1985,9 @@ pub struct Renderer { pub gpu_profile: GpuProfiler, vaos: RendererVAOs, - prim_header_f_texture: VertexDataTexture, - prim_header_i_texture: VertexDataTexture, - transforms_texture: VertexDataTexture, - render_task_texture: VertexDataTexture, gpu_cache_texture: GpuCacheTexture, + vertex_data_textures: Vec, + current_vertex_data_textures: usize, /// When the GPU cache debugger is enabled, we keep track of the live blocks /// in the GPU cache so that we can use them for the debug display. This @@ -2226,10 +2319,10 @@ impl Renderer { let texture_resolver = TextureResolver::new(&mut device); - let prim_header_f_texture = VertexDataTexture::new(&mut device, ImageFormat::RGBAF32); - let prim_header_i_texture = VertexDataTexture::new(&mut device, ImageFormat::RGBAI32); - let transforms_texture = VertexDataTexture::new(&mut device, ImageFormat::RGBAF32); - let render_task_texture = VertexDataTexture::new(&mut device, ImageFormat::RGBAF32); + let mut vertex_data_textures = Vec::new(); + for _ in 0 .. VERTEX_DATA_TEXTURE_COUNT { + vertex_data_textures.push(VertexDataTextures::new(&mut device)); + } // On some (mostly older, integrated) GPUs, the normal GPU texture cache update path // doesn't work well when running on ANGLE, causing CPU stalls inside D3D and/or the @@ -2496,10 +2589,8 @@ impl Renderer { svg_filter_vao, composite_vao, }, - transforms_texture, - prim_header_i_texture, - prim_header_f_texture, - render_task_texture, + vertex_data_textures, + current_vertex_data_textures: 0, pipeline_info: PipelineInfo::default(), dither_matrix_texture, external_image_handler: None, @@ -5491,43 +5582,12 @@ impl Renderer { fn bind_frame_data(&mut self, frame: &mut Frame) { let _timer = self.gpu_profile.start_timer(GPU_TAG_SETUP_DATA); - self.prim_header_f_texture.update( - &mut self.device, - &mut frame.prim_headers.headers_float, - ); - self.device.bind_texture( - TextureSampler::PrimitiveHeadersF, - &self.prim_header_f_texture.texture(), - Swizzle::default(), - ); - - self.prim_header_i_texture.update( + self.vertex_data_textures[self.current_vertex_data_textures].update( &mut self.device, - &mut frame.prim_headers.headers_int, - ); - self.device.bind_texture( - TextureSampler::PrimitiveHeadersI, - &self.prim_header_i_texture.texture(), - Swizzle::default(), - ); - - self.transforms_texture.update( - &mut self.device, - &mut frame.transform_palette, - ); - self.device.bind_texture( - TextureSampler::TransformPalette, - &self.transforms_texture.texture(), - Swizzle::default(), - ); - - self.render_task_texture - .update(&mut self.device, &mut frame.render_tasks.task_data); - self.device.bind_texture( - TextureSampler::RenderTasks, - &self.render_task_texture.texture(), - Swizzle::default(), + frame, ); + self.current_vertex_data_textures = + (self.current_vertex_data_textures + 1) % VERTEX_DATA_TEXTURE_COUNT; debug_assert!(self.texture_resolver.prev_pass_alpha.is_none()); debug_assert!(self.texture_resolver.prev_pass_color.is_none()); @@ -6389,10 +6449,9 @@ impl Renderer { if let Some(zoom_debug_texture) = self.zoom_debug_texture { self.device.delete_texture(zoom_debug_texture); } - self.transforms_texture.deinit(&mut self.device); - self.prim_header_f_texture.deinit(&mut self.device); - self.prim_header_i_texture.deinit(&mut self.device); - self.render_task_texture.deinit(&mut self.device); + for textures in self.vertex_data_textures.drain(..) { + textures.deinit(&mut self.device); + } self.device.delete_pbo(self.texture_cache_upload_pbo); self.texture_resolver.deinit(&mut self.device); self.device.delete_vao(self.vaos.prim_vao); @@ -6459,10 +6518,9 @@ impl Renderer { } // Vertex data GPU memory. - report.vertex_data_textures += self.prim_header_f_texture.size_in_bytes(); - report.vertex_data_textures += self.prim_header_i_texture.size_in_bytes(); - report.vertex_data_textures += self.transforms_texture.size_in_bytes(); - report.vertex_data_textures += self.render_task_texture.size_in_bytes(); + for textures in &self.vertex_data_textures { + report.vertex_data_textures += textures.size_in_bytes(); + } // Texture cache and render target GPU memory. report += self.texture_resolver.report_memory(); From 09522cddb6c8a5e46375e7baaff8b70217b94a99 Mon Sep 17 00:00:00 2001 From: Glenn Watson Date: Tue, 14 Apr 2020 09:53:04 +0000 Subject: [PATCH 2/2] Bug 1629672 - Move prim_origin from instance to template. r=Bert,kvark Previously, the prim origin needed to be stored in the prim instance, to avoid picture cache invalidations. With support for external scroll offset, this is no longer necessary. This simplifies some of the code paths, and reduces the size of primitive instances. Differential Revision: https://phabricator.services.mozilla.com/D70740 [ghsync] From https://hg.mozilla.org/mozilla-central/rev/1f65f78fb36707cd936882f4d363f7c5f8a3314d --- webrender/src/picture.rs | 25 +++--- webrender/src/prim_store/backdrop.rs | 17 +--- webrender/src/prim_store/borders.rs | 26 +++--- webrender/src/prim_store/gradient.rs | 70 +++++---------- webrender/src/prim_store/image.rs | 41 +++------ webrender/src/prim_store/line_dec.rs | 10 +-- webrender/src/prim_store/mod.rs | 126 ++++++++++----------------- webrender/src/prim_store/text_run.rs | 8 +- webrender/src/render_backend.rs | 5 +- webrender/src/scene_building.rs | 43 ++++----- 10 files changed, 131 insertions(+), 240 deletions(-) diff --git a/webrender/src/picture.rs b/webrender/src/picture.rs index 771453f5ce..ef01f98ea9 100644 --- a/webrender/src/picture.rs +++ b/webrender/src/picture.rs @@ -4155,12 +4155,8 @@ impl PrimitiveCluster { fn push( &mut self, prim_instance: PrimitiveInstance, - prim_size: LayoutSize, + prim_rect: LayoutRect, ) { - let prim_rect = LayoutRect::new( - prim_instance.prim_origin, - prim_size, - ); let culling_rect = prim_instance.local_clip_rect .intersection(&prim_rect) .unwrap_or_else(LayoutRect::zero); @@ -4195,7 +4191,7 @@ impl PrimitiveList { fn push( &mut self, prim_instance: PrimitiveInstance, - prim_size: LayoutSize, + prim_rect: LayoutRect, spatial_node_index: SpatialNodeIndex, prim_flags: PrimitiveFlags, insert_position: PrimitiveListPosition, @@ -4236,13 +4232,13 @@ impl PrimitiveList { spatial_node_index, flags, ); - cluster.push(prim_instance, prim_size); + cluster.push(prim_instance, prim_rect); self.clusters.insert(0, cluster); } PrimitiveListPosition::End => { if let Some(cluster) = self.clusters.last_mut() { if cluster.is_compatible(spatial_node_index, flags) { - cluster.push(prim_instance, prim_size); + cluster.push(prim_instance, prim_rect); return; } } @@ -4251,7 +4247,7 @@ impl PrimitiveList { spatial_node_index, flags, ); - cluster.push(prim_instance, prim_size); + cluster.push(prim_instance, prim_rect); self.clusters.push(cluster); } } @@ -4261,13 +4257,13 @@ impl PrimitiveList { pub fn add_prim_to_start( &mut self, prim_instance: PrimitiveInstance, - prim_size: LayoutSize, + prim_rect: LayoutRect, spatial_node_index: SpatialNodeIndex, flags: PrimitiveFlags, ) { self.push( prim_instance, - prim_size, + prim_rect, spatial_node_index, flags, PrimitiveListPosition::Begin, @@ -4278,13 +4274,13 @@ impl PrimitiveList { pub fn add_prim( &mut self, prim_instance: PrimitiveInstance, - prim_size: LayoutSize, + prim_rect: LayoutRect, spatial_node_index: SpatialNodeIndex, flags: PrimitiveFlags, ) { self.push( prim_instance, - prim_size, + prim_rect, spatial_node_index, flags, PrimitiveListPosition::End, @@ -5921,8 +5917,7 @@ impl PicturePrimitive { // TODO(aosmond): Is this safe? Updating the primitive size during // frame building is usually problematic since scene building will cache // the primitive information in the GPU already. - prim_instance.prim_origin = prim_rect.origin; - prim_data.common.prim_size = prim_rect.size; + prim_data.common.prim_rect = prim_rect; prim_instance.local_clip_rect = prim_rect; // Update the cluster bounding rect now that we have the backdrop rect. diff --git a/webrender/src/prim_store/backdrop.rs b/webrender/src/prim_store/backdrop.rs index b3f13f2af6..ea033574fb 100644 --- a/webrender/src/prim_store/backdrop.rs +++ b/webrender/src/prim_store/backdrop.rs @@ -2,13 +2,12 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -use api::PrimitiveFlags; use api::units::*; use crate::spatial_tree::SpatialNodeIndex; use crate::intern::{Internable, InternDebug, Handle as InternHandle}; use crate::internal_types::LayoutPrimitiveInfo; use crate::prim_store::{ - InternablePrimitive, PictureIndex, PrimitiveInstanceKind, PrimKey, PrimKeyCommonData, PrimTemplate, + InternablePrimitive, PictureIndex, PrimitiveInstanceKind, PrimKey, PrimTemplate, PrimTemplateCommonData, PrimitiveStore, RectangleKey, }; @@ -35,15 +34,11 @@ pub type BackdropKey = PrimKey; impl BackdropKey { pub fn new( - flags: PrimitiveFlags, - prim_size: LayoutSize, + info: &LayoutPrimitiveInfo, backdrop: Backdrop, ) -> Self { BackdropKey { - common: PrimKeyCommonData { - flags, - prim_size: prim_size.into(), - }, + common: info.into(), kind: backdrop, } } @@ -86,11 +81,7 @@ impl InternablePrimitive for Backdrop { self, info: &LayoutPrimitiveInfo, ) -> BackdropKey { - BackdropKey::new( - info.flags, - info.rect.size, - self - ) + BackdropKey::new(info, self) } fn make_instance_kind( diff --git a/webrender/src/prim_store/borders.rs b/webrender/src/prim_store/borders.rs index 6bb5ef19dd..084350c335 100644 --- a/webrender/src/prim_store/borders.rs +++ b/webrender/src/prim_store/borders.rs @@ -13,7 +13,7 @@ use crate::intern; use crate::internal_types::LayoutPrimitiveInfo; use crate::prim_store::{ BorderSegmentInfo, BrushSegment, NinePatchDescriptor, PrimKey, - PrimKeyCommonData, PrimTemplate, PrimTemplateCommonData, + PrimTemplate, PrimTemplateCommonData, PrimitiveInstanceKind, PrimitiveOpacity, PrimitiveStore, InternablePrimitive, }; @@ -36,9 +36,7 @@ impl NormalBorderKey { normal_border: NormalBorderPrim, ) -> Self { NormalBorderKey { - common: PrimKeyCommonData::with_info( - info, - ), + common: info.into(), kind: normal_border, } } @@ -67,7 +65,7 @@ impl NormalBorderData { frame_state: &mut FrameBuildingState, ) { if let Some(ref mut request) = frame_state.gpu_cache.request(&mut common.gpu_cache_handle) { - self.write_prim_gpu_blocks(request, common.prim_size); + self.write_prim_gpu_blocks(request, common.prim_rect.size); self.write_segment_gpu_blocks(request); } @@ -122,7 +120,7 @@ impl From for NormalBorderTemplate { let mut border_segments = Vec::new(); create_border_segments( - common.prim_size, + common.prim_rect.size, &border, &widths, &mut border_segments, @@ -208,9 +206,7 @@ impl ImageBorderKey { image_border: ImageBorder, ) -> Self { ImageBorderKey { - common: PrimKeyCommonData::with_info( - info, - ), + common: info.into(), kind: image_border, } } @@ -239,7 +235,7 @@ impl ImageBorderData { frame_state: &mut FrameBuildingState, ) { if let Some(ref mut request) = frame_state.gpu_cache.request(&mut common.gpu_cache_handle) { - self.write_prim_gpu_blocks(request, &common.prim_size); + self.write_prim_gpu_blocks(request, &common.prim_rect.size); self.write_segment_gpu_blocks(request); } @@ -305,7 +301,7 @@ impl From for ImageBorderTemplate { fn from(key: ImageBorderKey) -> Self { let common = PrimTemplateCommonData::with_key_common(key.common); - let brush_segments = key.kind.nine_patch.create_segments(common.prim_size); + let brush_segments = key.kind.nine_patch.create_segments(common.prim_rect.size); ImageBorderTemplate { common, kind: ImageBorderData { @@ -364,9 +360,9 @@ fn test_struct_sizes() { // (b) You made a structure larger. This is not necessarily a problem, but should only // be done with care, and after checking if talos performance regresses badly. assert_eq!(mem::size_of::(), 84, "NormalBorderPrim size changed"); - assert_eq!(mem::size_of::(), 208, "NormalBorderTemplate size changed"); - assert_eq!(mem::size_of::(), 96, "NormalBorderKey size changed"); + assert_eq!(mem::size_of::(), 216, "NormalBorderTemplate size changed"); + assert_eq!(mem::size_of::(), 104, "NormalBorderKey size changed"); assert_eq!(mem::size_of::(), 84, "ImageBorder size changed"); - assert_eq!(mem::size_of::(), 72, "ImageBorderTemplate size changed"); - assert_eq!(mem::size_of::(), 96, "ImageBorderKey size changed"); + assert_eq!(mem::size_of::(), 80, "ImageBorderTemplate size changed"); + assert_eq!(mem::size_of::(), 104, "ImageBorderKey size changed"); } diff --git a/webrender/src/prim_store/gradient.rs b/webrender/src/prim_store/gradient.rs index 336c44a29c..e2076a9a5d 100644 --- a/webrender/src/prim_store/gradient.rs +++ b/webrender/src/prim_store/gradient.rs @@ -4,7 +4,7 @@ use api::{ ColorF, ColorU, ExtendMode, GradientStop, - PremultipliedColorF, LineOrientation, PrimitiveFlags, + PremultipliedColorF, LineOrientation, }; use api::units::{LayoutPoint, LayoutSize, LayoutVector2D}; use crate::scene_building::IsVisible; @@ -78,15 +78,11 @@ pub struct LinearGradientKey { impl LinearGradientKey { pub fn new( - flags: PrimitiveFlags, - prim_size: LayoutSize, + info: &LayoutPrimitiveInfo, linear_grad: LinearGradient, ) -> Self { LinearGradientKey { - common: PrimKeyCommonData { - flags, - prim_size: prim_size.into(), - }, + common: info.into(), extend_mode: linear_grad.extend_mode, start_point: linear_grad.start_point, end_point: linear_grad.end_point, @@ -154,8 +150,8 @@ impl From for LinearGradientTemplate { // although this catches the vast majority of gradients on real pages. let mut supports_caching = // Gradient must cover entire primitive - item.tile_spacing.w + item.stretch_size.w >= common.prim_size.width && - item.tile_spacing.h + item.stretch_size.h >= common.prim_size.height && + item.tile_spacing.w + item.stretch_size.w >= common.prim_rect.size.width && + item.tile_spacing.h + item.stretch_size.h >= common.prim_rect.size.height && // Must be a vertical or horizontal gradient (item.start_point.x.approx_eq(&item.end_point.x) || item.start_point.y.approx_eq(&item.end_point.y)) && @@ -202,7 +198,7 @@ impl From for LinearGradientTemplate { let mut brush_segments = Vec::new(); if let Some(ref nine_patch) = item.nine_patch { - brush_segments = nine_patch.create_segments(common.prim_size); + brush_segments = nine_patch.create_segments(common.prim_rect.size); } // Save opacity of the stops for use in @@ -277,8 +273,8 @@ impl LinearGradientTemplate { // then we just assume the gradient is translucent for now. // (In the future we could consider segmenting in some cases). let stride = self.stretch_size + self.tile_spacing; - if stride.width >= self.common.prim_size.width && - stride.height >= self.common.prim_size.height { + if stride.width >= self.common.prim_rect.size.width && + stride.height >= self.common.prim_rect.size.height { self.stops_opacity } else { PrimitiveOpacity::translucent() @@ -314,11 +310,7 @@ impl InternablePrimitive for LinearGradient { self, info: &LayoutPrimitiveInfo, ) -> LinearGradientKey { - LinearGradientKey::new( - info.flags, - info.rect.size, - self - ) + LinearGradientKey::new(info, self) } fn make_instance_kind( @@ -391,15 +383,11 @@ pub struct RadialGradientKey { impl RadialGradientKey { pub fn new( - flags: PrimitiveFlags, - prim_size: LayoutSize, + info: &LayoutPrimitiveInfo, radial_grad: RadialGradient, ) -> Self { RadialGradientKey { - common: PrimKeyCommonData { - flags, - prim_size: prim_size.into(), - }, + common: info.into(), extend_mode: radial_grad.extend_mode, center: radial_grad.center, params: radial_grad.params, @@ -447,7 +435,7 @@ impl From for RadialGradientTemplate { let mut brush_segments = Vec::new(); if let Some(ref nine_patch) = item.nine_patch { - brush_segments = nine_patch.create_segments(common.prim_size); + brush_segments = nine_patch.create_segments(common.prim_rect.size); } let stops = item.stops.iter().map(|stop| { @@ -544,11 +532,7 @@ impl InternablePrimitive for RadialGradient { self, info: &LayoutPrimitiveInfo, ) -> RadialGradientKey { - RadialGradientKey::new( - info.flags, - info.rect.size, - self, - ) + RadialGradientKey::new(info, self) } fn make_instance_kind( @@ -611,15 +595,11 @@ pub struct ConicGradientKey { impl ConicGradientKey { pub fn new( - flags: PrimitiveFlags, - prim_size: LayoutSize, + info: &LayoutPrimitiveInfo, conic_grad: ConicGradient, ) -> Self { ConicGradientKey { - common: PrimKeyCommonData { - flags, - prim_size: prim_size.into(), - }, + common: info.into(), extend_mode: conic_grad.extend_mode, center: conic_grad.center, params: conic_grad.params, @@ -667,7 +647,7 @@ impl From for ConicGradientTemplate { let mut brush_segments = Vec::new(); if let Some(ref nine_patch) = item.nine_patch { - brush_segments = nine_patch.create_segments(common.prim_size); + brush_segments = nine_patch.create_segments(common.prim_rect.size); } let stops = item.stops.iter().map(|stop| { @@ -764,11 +744,7 @@ impl InternablePrimitive for ConicGradient { self, info: &LayoutPrimitiveInfo, ) -> ConicGradientKey { - ConicGradientKey::new( - info.flags, - info.rect.size, - self, - ) + ConicGradientKey::new(info, self) } fn make_instance_kind( @@ -1007,14 +983,14 @@ fn test_struct_sizes() { // (b) You made a structure larger. This is not necessarily a problem, but should only // be done with care, and after checking if talos performance regresses badly. assert_eq!(mem::size_of::(), 72, "LinearGradient size changed"); - assert_eq!(mem::size_of::(), 112, "LinearGradientTemplate size changed"); - assert_eq!(mem::size_of::(), 80, "LinearGradientKey size changed"); + assert_eq!(mem::size_of::(), 120, "LinearGradientTemplate size changed"); + assert_eq!(mem::size_of::(), 88, "LinearGradientKey size changed"); assert_eq!(mem::size_of::(), 72, "RadialGradient size changed"); - assert_eq!(mem::size_of::(), 120, "RadialGradientTemplate size changed"); - assert_eq!(mem::size_of::(), 88, "RadialGradientKey size changed"); + assert_eq!(mem::size_of::(), 128, "RadialGradientTemplate size changed"); + assert_eq!(mem::size_of::(), 96, "RadialGradientKey size changed"); assert_eq!(mem::size_of::(), 72, "ConicGradient size changed"); - assert_eq!(mem::size_of::(), 120, "ConicGradientTemplate size changed"); - assert_eq!(mem::size_of::(), 88, "ConicGradientKey size changed"); + assert_eq!(mem::size_of::(), 128, "ConicGradientTemplate size changed"); + assert_eq!(mem::size_of::(), 96, "ConicGradientKey size changed"); } diff --git a/webrender/src/prim_store/image.rs b/webrender/src/prim_store/image.rs index cf701207d1..dd726214bc 100644 --- a/webrender/src/prim_store/image.rs +++ b/webrender/src/prim_store/image.rs @@ -3,7 +3,7 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ use api::{ - AlphaType, ColorDepth, ColorF, ColorU, PrimitiveFlags, + AlphaType, ColorDepth, ColorF, ColorU, ImageKey as ApiImageKey, ImageRendering, PremultipliedColorF, Shadow, YuvColorSpace, ColorRange, YuvFormat, }; @@ -15,7 +15,7 @@ use crate::intern::{Internable, InternDebug, Handle as InternHandle}; use crate::internal_types::{LayoutPrimitiveInfo}; use crate::prim_store::{ EdgeAaSegmentMask, OpacityBindingIndex, PrimitiveInstanceKind, - PrimitiveOpacity, PrimKey, PrimKeyCommonData, + PrimitiveOpacity, PrimKey, PrimTemplate, PrimTemplateCommonData, PrimitiveStore, SegmentInstanceIndex, SizeKey, InternablePrimitive, }; @@ -85,15 +85,11 @@ pub type ImageKey = PrimKey; impl ImageKey { pub fn new( - flags: PrimitiveFlags, - prim_size: LayoutSize, + info: &LayoutPrimitiveInfo, image: Image, ) -> Self { ImageKey { - common: PrimKeyCommonData { - flags, - prim_size: prim_size.into(), - }, + common: info.into(), kind: image, } } @@ -315,11 +311,7 @@ impl InternablePrimitive for Image { self, info: &LayoutPrimitiveInfo, ) -> ImageKey { - ImageKey::new( - info.flags, - info.rect.size, - self - ) + ImageKey::new(info, self) } fn make_instance_kind( @@ -382,16 +374,11 @@ pub type YuvImageKey = PrimKey; impl YuvImageKey { pub fn new( - flags: PrimitiveFlags, - prim_size: LayoutSize, + info: &LayoutPrimitiveInfo, yuv_image: YuvImage, ) -> Self { - YuvImageKey { - common: PrimKeyCommonData { - flags, - prim_size: prim_size.into(), - }, + common: info.into(), kind: yuv_image, } } @@ -497,11 +484,7 @@ impl InternablePrimitive for YuvImage { self, info: &LayoutPrimitiveInfo, ) -> YuvImageKey { - YuvImageKey::new( - info.flags, - info.rect.size, - self, - ) + YuvImageKey::new(info, self) } fn make_instance_kind( @@ -535,9 +518,9 @@ fn test_struct_sizes() { // (b) You made a structure larger. This is not necessarily a problem, but should only // be done with care, and after checking if talos performance regresses badly. assert_eq!(mem::size_of::(), 52, "Image size changed"); - assert_eq!(mem::size_of::(), 104, "ImageTemplate size changed"); - assert_eq!(mem::size_of::(), 64, "ImageKey size changed"); + assert_eq!(mem::size_of::(), 112, "ImageTemplate size changed"); + assert_eq!(mem::size_of::(), 72, "ImageKey size changed"); assert_eq!(mem::size_of::(), 32, "YuvImage size changed"); - assert_eq!(mem::size_of::(), 52, "YuvImageTemplate size changed"); - assert_eq!(mem::size_of::(), 44, "YuvImageKey size changed"); + assert_eq!(mem::size_of::(), 60, "YuvImageTemplate size changed"); + assert_eq!(mem::size_of::(), 52, "YuvImageKey size changed"); } diff --git a/webrender/src/prim_store/line_dec.rs b/webrender/src/prim_store/line_dec.rs index 5166cb375e..8453745453 100644 --- a/webrender/src/prim_store/line_dec.rs +++ b/webrender/src/prim_store/line_dec.rs @@ -13,7 +13,7 @@ use crate::gpu_cache::GpuDataRequest; use crate::intern; use crate::internal_types::LayoutPrimitiveInfo; use crate::prim_store::{ - PrimKey, PrimKeyCommonData, PrimTemplate, PrimTemplateCommonData, + PrimKey, PrimTemplate, PrimTemplateCommonData, InternablePrimitive, PrimitiveStore, }; use crate::prim_store::PrimitiveInstanceKind; @@ -52,9 +52,7 @@ impl LineDecorationKey { line_dec: LineDecoration, ) -> Self { LineDecorationKey { - common: PrimKeyCommonData::with_info( - info, - ), + common: info.into(), kind: line_dec, } } @@ -180,6 +178,6 @@ fn test_struct_sizes() { // (b) You made a structure larger. This is not necessarily a problem, but should only // be done with care, and after checking if talos performance regresses badly. assert_eq!(mem::size_of::(), 20, "LineDecoration size changed"); - assert_eq!(mem::size_of::(), 52, "LineDecorationTemplate size changed"); - assert_eq!(mem::size_of::(), 32, "LineDecorationKey size changed"); + assert_eq!(mem::size_of::(), 60, "LineDecorationTemplate size changed"); + assert_eq!(mem::size_of::(), 40, "LineDecorationKey size changed"); } diff --git a/webrender/src/prim_store/mod.rs b/webrender/src/prim_store/mod.rs index 2fbfb948f9..4a1671ace7 100644 --- a/webrender/src/prim_store/mod.rs +++ b/webrender/src/prim_store/mod.rs @@ -668,16 +668,14 @@ impl From for PointKey { #[derive(Debug, Clone, Eq, MallocSizeOf, PartialEq, Hash)] pub struct PrimKeyCommonData { pub flags: PrimitiveFlags, - pub prim_size: SizeKey, + pub prim_rect: RectangleKey, } -impl PrimKeyCommonData { - pub fn with_info( - info: &LayoutPrimitiveInfo, - ) -> Self { +impl From<&LayoutPrimitiveInfo> for PrimKeyCommonData { + fn from(info: &LayoutPrimitiveInfo) -> Self { PrimKeyCommonData { flags: info.flags, - prim_size: info.rect.size.into(), + prim_rect: info.rect.into(), } } } @@ -700,15 +698,11 @@ pub struct PrimitiveKey { impl PrimitiveKey { pub fn new( - flags: PrimitiveFlags, - prim_size: LayoutSize, + info: &LayoutPrimitiveInfo, kind: PrimitiveKeyKind, ) -> Self { PrimitiveKey { - common: PrimKeyCommonData { - flags, - prim_size: prim_size.into(), - }, + common: info.into(), kind, } } @@ -752,7 +746,7 @@ impl From for PrimitiveTemplateKind { pub struct PrimTemplateCommonData { pub flags: PrimitiveFlags, pub may_need_repetition: bool, - pub prim_size: LayoutSize, + pub prim_rect: LayoutRect, pub opacity: PrimitiveOpacity, /// The GPU cache handle for a primitive template. Since this structure /// is retained across display lists by interning, this GPU cache handle @@ -766,7 +760,7 @@ impl PrimTemplateCommonData { PrimTemplateCommonData { flags: common.flags, may_need_repetition: true, - prim_size: common.prim_size.into(), + prim_rect: common.prim_rect.into(), gpu_cache_handle: GpuCacheHandle::new(), opacity: PrimitiveOpacity::translucent(), } @@ -868,11 +862,7 @@ impl InternablePrimitive for PrimitiveKeyKind { self, info: &LayoutPrimitiveInfo, ) -> PrimitiveKey { - PrimitiveKey::new( - info.flags, - info.rect.size, - self, - ) + PrimitiveKey::new(info, self) } fn make_instance_kind( @@ -1584,10 +1574,6 @@ pub struct PrimitiveInstance { /// can be found. pub kind: PrimitiveInstanceKind, - /// Local space origin of this primitive. The size - /// of the primitive is defined by the template. - pub prim_origin: LayoutPoint, - /// Local space clip rect for this instance pub local_clip_rect: LayoutRect, @@ -1609,13 +1595,11 @@ pub struct PrimitiveInstance { impl PrimitiveInstance { pub fn new( - prim_origin: LayoutPoint, local_clip_rect: LayoutRect, kind: PrimitiveInstanceKind, clip_chain_id: ClipChainId, ) -> Self { PrimitiveInstance { - prim_origin, local_clip_rect, kind, #[cfg(debug_assertions)] @@ -2061,17 +2045,7 @@ impl PrimitiveStore { frame_state.clip_chain_stack.pop_clip(); - // The local rect of pictures is calculated dynamically based on - // the content of children, which may move due to the spatial - // node they are attached to. Other parts of the code (such as - // segment generation) reads the origin from the prim instance, - // so ensure that is kept up to date here. - // TODO(gw): It's unfortunate that the prim origin is duplicated - // this way. In future, we could perhaps just store the - // size in the picture primitive, to that there isn't - // any duplicated data. let pic = &self.pictures[pic_index.0]; - prim_instance.prim_origin = pic.precise_local_rect.origin; if prim_instance.is_chased() && pic.estimated_local_rect != pic.precise_local_rect { println!("\testimate {:?} adjusted to {:?}", pic.estimated_local_rect, pic.precise_local_rect); @@ -2104,12 +2078,7 @@ impl PrimitiveStore { _ => { let prim_data = &frame_state.data_stores.as_common_data(&prim_instance); - let prim_rect = LayoutRect::new( - prim_instance.prim_origin, - prim_data.prim_size, - ); - - (false, prim_rect, prim_rect) + (false, prim_data.prim_rect, prim_data.prim_rect) } }; @@ -2493,13 +2462,9 @@ impl PrimitiveStore { // produce primitives that are partially covering the original image // rect and we want to clip these extra parts out. let prim_info = &frame_state.scratch.prim_info[prim_instance.visibility_info.0 as usize]; - let prim_rect = LayoutRect::new( - prim_instance.prim_origin, - common_data.prim_size, - ); let tight_clip_rect = prim_info .combined_local_clip_rect - .intersection(&prim_rect).unwrap(); + .intersection(&common_data.prim_rect).unwrap(); image_instance.tight_local_clip_rect = tight_clip_rect; let map_local_to_world = SpaceMapper::new_with_target( @@ -2524,7 +2489,7 @@ impl PrimitiveStore { common_data.may_need_repetition = false; let repetitions = crate::image::repetitions( - &prim_rect, + &common_data.prim_rect, &visible_rect, stride, ); @@ -2821,8 +2786,14 @@ impl PrimitiveStore { } }; + let prim_rect = data_stores.get_local_prim_rect( + prim_instance, + self, + ); + if !is_passthrough { prim_instance.update_clip_task( + &prim_rect.origin, prim_spatial_node_index, pic_context.raster_spatial_node_index, pic_context, @@ -2835,7 +2806,7 @@ impl PrimitiveStore { ); if prim_instance.is_chased() { - println!("\tconsidered visible and ready with local pos {:?}", prim_instance.prim_origin); + println!("\tconsidered visible and ready with local pos {:?}", prim_rect.origin); } } @@ -3010,7 +2981,7 @@ impl PrimitiveStore { pic_context.raster_spatial_node_index, ) .into_fast_transform(); - let prim_offset = prim_instance.prim_origin.to_vector() - run.reference_frame_relative_offset; + let prim_offset = prim_data.common.prim_rect.origin.to_vector() - run.reference_frame_relative_offset; let pic = &self.pictures[pic_context.pic_index.0]; let raster_space = pic.get_raster_space(frame_context.spatial_tree); @@ -3217,8 +3188,8 @@ impl PrimitiveStore { let common_data = &mut prim_data.common; let image_data = &mut prim_data.kind; - if image_data.stretch_size.width >= common_data.prim_size.width && - image_data.stretch_size.height >= common_data.prim_size.height { + if image_data.stretch_size.width >= common_data.prim_rect.size.width && + image_data.stretch_size.height >= common_data.prim_rect.size.height { common_data.may_need_repetition = false; } @@ -3253,8 +3224,8 @@ impl PrimitiveStore { // cache with any shared template data. prim_data.update(frame_state); - if prim_data.stretch_size.width >= prim_data.common.prim_size.width && - prim_data.stretch_size.height >= prim_data.common.prim_size.height { + if prim_data.stretch_size.width >= prim_data.common.prim_rect.size.width && + prim_data.stretch_size.height >= prim_data.common.prim_rect.size.height { prim_data.common.may_need_repetition = false; } @@ -3270,13 +3241,13 @@ impl PrimitiveStore { let (size, orientation, prim_start_offset, prim_end_offset) = if prim_data.start_point.x.approx_eq(&prim_data.end_point.x) { let prim_start_offset = -prim_data.start_point.y / gradient_size.height; - let prim_end_offset = (prim_data.common.prim_size.height - prim_data.start_point.y) + let prim_end_offset = (prim_data.common.prim_rect.size.height - prim_data.start_point.y) / gradient_size.height; let size = DeviceIntSize::new(16, TEXTURE_REGION_DIMENSIONS); (size, LineOrientation::Vertical, prim_start_offset, prim_end_offset) } else { let prim_start_offset = -prim_data.start_point.x / gradient_size.width; - let prim_end_offset = (prim_data.common.prim_size.width - prim_data.start_point.x) + let prim_end_offset = (prim_data.common.prim_rect.size.width - prim_data.start_point.x) / gradient_size.width; let size = DeviceIntSize::new(TEXTURE_REGION_DIMENSIONS, 16); (size, LineOrientation::Horizontal, prim_start_offset, prim_end_offset) @@ -3481,8 +3452,8 @@ impl PrimitiveStore { emit_segments(prim_start_offset, prim_end_offset, 0.0, prim_start_offset, prim_end_offset, - prim_instance.prim_origin, - prim_data.common.prim_size, + prim_data.common.prim_rect.origin, + prim_data.common.prim_rect.size, size, prim_data.stops_opacity.is_opaque, &stops, @@ -3508,8 +3479,8 @@ impl PrimitiveStore { emit_segments(repeat_start, repeat_end, gradient_offset_base, prim_start_offset, prim_end_offset, - prim_instance.prim_origin, - prim_data.common.prim_size, + prim_data.common.prim_rect.origin, + prim_data.common.prim_rect.size, size, prim_data.stops_opacity.is_opaque, &stops, @@ -3528,10 +3499,6 @@ impl PrimitiveStore { prim_data.common.may_need_repetition = false; let prim_info = &scratch.prim_info[prim_instance.visibility_info.0 as usize]; - let prim_rect = LayoutRect::new( - prim_instance.prim_origin, - prim_data.common.prim_size, - ); let map_local_to_world = SpaceMapper::new_with_target( ROOT_SPATIAL_NODE_INDEX, @@ -3542,7 +3509,7 @@ impl PrimitiveStore { gradient.visible_tiles_range = decompose_repeated_primitive( &prim_info.combined_local_clip_rect, - &prim_rect, + &prim_data.common.prim_rect, prim_info.clipped_world_rect, &prim_data.stretch_size, &prim_data.tile_spacing, @@ -3576,8 +3543,8 @@ impl PrimitiveStore { PrimitiveInstanceKind::RadialGradient { data_handle, ref mut visible_tiles_range, .. } => { let prim_data = &mut data_stores.radial_grad[*data_handle]; - if prim_data.stretch_size.width >= prim_data.common.prim_size.width && - prim_data.stretch_size.height >= prim_data.common.prim_size.height { + if prim_data.stretch_size.width >= prim_data.common.prim_rect.size.width && + prim_data.stretch_size.height >= prim_data.common.prim_rect.size.height { // We are performing the decomposition on the CPU here, no need to // have it in the shader. @@ -3590,10 +3557,6 @@ impl PrimitiveStore { if prim_data.tile_spacing != LayoutSize::zero() { let prim_info = &scratch.prim_info[prim_instance.visibility_info.0 as usize]; - let prim_rect = LayoutRect::new( - prim_instance.prim_origin, - prim_data.common.prim_size, - ); let map_local_to_world = SpaceMapper::new_with_target( ROOT_SPATIAL_NODE_INDEX, @@ -3606,7 +3569,7 @@ impl PrimitiveStore { *visible_tiles_range = decompose_repeated_primitive( &prim_info.combined_local_clip_rect, - &prim_rect, + &prim_data.common.prim_rect, prim_info.clipped_world_rect, &prim_data.stretch_size, &prim_data.tile_spacing, @@ -3640,8 +3603,8 @@ impl PrimitiveStore { PrimitiveInstanceKind::ConicGradient { data_handle, ref mut visible_tiles_range, .. } => { let prim_data = &mut data_stores.conic_grad[*data_handle]; - if prim_data.stretch_size.width >= prim_data.common.prim_size.width && - prim_data.stretch_size.height >= prim_data.common.prim_size.height { + if prim_data.stretch_size.width >= prim_data.common.prim_rect.size.width && + prim_data.stretch_size.height >= prim_data.common.prim_rect.size.height { // We are performing the decomposition on the CPU here, no need to // have it in the shader. @@ -3654,10 +3617,6 @@ impl PrimitiveStore { if prim_data.tile_spacing != LayoutSize::zero() { let prim_info = &scratch.prim_info[prim_instance.visibility_info.0 as usize]; - let prim_rect = LayoutRect::new( - prim_instance.prim_origin, - prim_data.common.prim_size, - ); let map_local_to_world = SpaceMapper::new_with_target( ROOT_SPATIAL_NODE_INDEX, @@ -3670,7 +3629,7 @@ impl PrimitiveStore { *visible_tiles_range = decompose_repeated_primitive( &prim_info.combined_local_clip_rect, - &prim_rect, + &prim_data.common.prim_rect, prim_info.clipped_world_rect, &prim_data.stretch_size, &prim_data.tile_spacing, @@ -4100,6 +4059,7 @@ impl PrimitiveInstance { fn update_clip_task_for_brush( &self, + prim_origin: &LayoutPoint, prim_info: &mut PrimitiveVisibility, prim_spatial_node_index: SpatialNodeIndex, root_spatial_node_index: SpatialNodeIndex, @@ -4256,7 +4216,7 @@ impl PrimitiveInstance { let segment_clip_chain = frame_state .clip_store .build_clip_chain_instance( - segment.local_rect.translate(self.prim_origin.to_vector()), + segment.local_rect.translate(prim_origin.to_vector()), &pic_state.map_local_to_pic, &pic_state.map_pic_to_world, &frame_context.spatial_tree, @@ -4290,6 +4250,7 @@ impl PrimitiveInstance { fn update_clip_task( &mut self, + prim_origin: &LayoutPoint, prim_spatial_node_index: SpatialNodeIndex, root_spatial_node_index: SpatialNodeIndex, pic_context: &PictureContext, @@ -4328,6 +4289,7 @@ impl PrimitiveInstance { // First try to render this primitive's mask using optimized brush rendering. if self.update_clip_task_for_brush( + prim_origin, prim_info, prim_spatial_node_index, root_spatial_node_index, @@ -4580,10 +4542,10 @@ fn test_struct_sizes() { // test expectations and move on. // (b) You made a structure larger. This is not necessarily a problem, but should only // be done with care, and after checking if talos performance regresses badly. - assert_eq!(mem::size_of::(), 88, "PrimitiveInstance size changed"); + assert_eq!(mem::size_of::(), 80, "PrimitiveInstance size changed"); assert_eq!(mem::size_of::(), 40, "PrimitiveInstanceKind size changed"); - assert_eq!(mem::size_of::(), 48, "PrimitiveTemplate size changed"); + assert_eq!(mem::size_of::(), 56, "PrimitiveTemplate size changed"); assert_eq!(mem::size_of::(), 28, "PrimitiveTemplateKind size changed"); - assert_eq!(mem::size_of::(), 28, "PrimitiveKey size changed"); + assert_eq!(mem::size_of::(), 36, "PrimitiveKey size changed"); assert_eq!(mem::size_of::(), 16, "PrimitiveKeyKind size changed"); } diff --git a/webrender/src/prim_store/text_run.rs b/webrender/src/prim_store/text_run.rs index b4d08fee16..f4d31d4b4b 100644 --- a/webrender/src/prim_store/text_run.rs +++ b/webrender/src/prim_store/text_run.rs @@ -41,9 +41,7 @@ impl TextRunKey { text_run: TextRun, ) -> Self { TextRunKey { - common: PrimKeyCommonData::with_info( - info, - ), + common: info.into(), font: text_run.font, glyphs: PrimaryArc(text_run.glyphs), shadow: text_run.shadow, @@ -421,7 +419,7 @@ fn test_struct_sizes() { // (b) You made a structure larger. This is not necessarily a problem, but should only // be done with care, and after checking if talos performance regresses badly. assert_eq!(mem::size_of::(), 56, "TextRun size changed"); - assert_eq!(mem::size_of::(), 72, "TextRunTemplate size changed"); - assert_eq!(mem::size_of::(), 64, "TextRunKey size changed"); + assert_eq!(mem::size_of::(), 80, "TextRunTemplate size changed"); + assert_eq!(mem::size_of::(), 72, "TextRunKey size changed"); assert_eq!(mem::size_of::(), 80, "TextRunPrimitive size changed"); } diff --git a/webrender/src/render_backend.rs b/webrender/src/render_backend.rs index 98d181d428..52377dec01 100644 --- a/webrender/src/render_backend.rs +++ b/webrender/src/render_backend.rs @@ -289,10 +289,7 @@ impl DataStores { unreachable!(); } _ => { - LayoutRect::new( - prim_instance.prim_origin, - self.as_common_data(prim_instance).prim_size, - ) + self.as_common_data(prim_instance).prim_rect } } } diff --git a/webrender/src/scene_building.rs b/webrender/src/scene_building.rs index 32120909cc..ffee876f6c 100644 --- a/webrender/src/scene_building.rs +++ b/webrender/src/scene_building.rs @@ -281,7 +281,7 @@ impl Slice { clip_chain_instance.clip_chain_id, PrimitiveInstanceKind::PushClipChain, ), - LayoutSize::zero(), + LayoutRect::zero(), clip_chain_instance.spatial_node_index, PrimitiveFlags::IS_BACKFACE_VISIBLE, ); @@ -299,7 +299,7 @@ impl Slice { clip_chain_instance.clip_chain_id, PrimitiveInstanceKind::PopClipChain, ), - LayoutSize::zero(), + LayoutRect::zero(), clip_chain_instance.spatial_node_index, PrimitiveFlags::IS_BACKFACE_VISIBLE, ); @@ -692,7 +692,7 @@ impl<'a> SceneBuilder<'a> { main_prim_list.add_prim( instance, - LayoutSize::zero(), + LayoutRect::zero(), scroll_root, PrimitiveFlags::IS_BACKFACE_VISIBLE, ); @@ -1599,7 +1599,6 @@ impl<'a> SceneBuilder<'a> { ); PrimitiveInstance::new( - info.rect.origin, info.clip_rect, instance_kind, clip_chain_id, @@ -1650,7 +1649,7 @@ impl<'a> SceneBuilder<'a> { pub fn add_primitive_to_draw_list( &mut self, prim_instance: PrimitiveInstance, - prim_size: LayoutSize, + prim_rect: LayoutRect, spatial_node_index: SpatialNodeIndex, flags: PrimitiveFlags, ) { @@ -1662,7 +1661,7 @@ impl<'a> SceneBuilder<'a> { let stacking_context = self.sc_stack.last_mut().unwrap(); stacking_context.prim_list.add_prim( prim_instance, - prim_size, + prim_rect, spatial_node_index, flags, ); @@ -1753,7 +1752,7 @@ impl<'a> SceneBuilder<'a> { self.add_primitive_to_hit_testing_list(info, clip_and_scroll); self.add_primitive_to_draw_list( prim_instance, - info.rect.size, + info.rect, clip_and_scroll.spatial_node_index, info.flags, ); @@ -1928,7 +1927,7 @@ impl<'a> SceneBuilder<'a> { ); stacking_context.prim_list.add_prim_to_start( prim, - LayoutSize::zero(), + LayoutRect::zero(), stacking_context.spatial_node_index, PrimitiveFlags::IS_BACKFACE_VISIBLE, ); @@ -1939,7 +1938,7 @@ impl<'a> SceneBuilder<'a> { ); stacking_context.prim_list.add_prim( prim, - LayoutSize::zero(), + LayoutRect::zero(), stacking_context.spatial_node_index, PrimitiveFlags::IS_BACKFACE_VISIBLE, ); @@ -2075,7 +2074,7 @@ impl<'a> SceneBuilder<'a> { for ext_prim in prims.drain(..) { prim_list.add_prim( ext_prim.instance, - LayoutSize::zero(), + LayoutRect::zero(), ext_prim.spatial_node_index, ext_prim.flags, ); @@ -2142,7 +2141,7 @@ impl<'a> SceneBuilder<'a> { let mut prim_list = PrimitiveList::empty(); prim_list.add_prim( cur_instance.clone(), - LayoutSize::zero(), + LayoutRect::zero(), stacking_context.spatial_node_index, stacking_context.prim_flags, ); @@ -2201,7 +2200,7 @@ impl<'a> SceneBuilder<'a> { } parent_sc.prim_list.add_prim( cur_instance, - LayoutSize::zero(), + LayoutRect::zero(), stacking_context.spatial_node_index, stacking_context.prim_flags, ); @@ -2596,7 +2595,6 @@ impl<'a> SceneBuilder<'a> { .intern(&shadow_pic_key, || ()); let shadow_prim_instance = PrimitiveInstance::new( - LayoutPoint::zero(), LayoutRect::max_rect(), PrimitiveInstanceKind::Picture { data_handle: shadow_prim_data_handle, @@ -2610,7 +2608,7 @@ impl<'a> SceneBuilder<'a> { // picture on to the shadow stack, to avoid infinite recursion! self.add_primitive_to_draw_list( shadow_prim_instance, - LayoutSize::zero(), + LayoutRect::zero(), pending_shadow.clip_and_scroll.spatial_node_index, PrimitiveFlags::IS_BACKFACE_VISIBLE, ); @@ -2688,7 +2686,7 @@ impl<'a> SceneBuilder<'a> { // Add the new primitive to the shadow picture. prim_list.add_prim( shadow_prim_instance, - info.rect.size, + info.rect, pending_primitive.clip_and_scroll.spatial_node_index, info.flags, ); @@ -3308,7 +3306,7 @@ impl<'a> SceneBuilder<'a> { let mut prim_list = PrimitiveList::empty(); prim_list.add_prim( instance, - LayoutSize::zero(), + LayoutRect::zero(), backdrop_spatial_node_index, prim_flags, ); @@ -3388,7 +3386,7 @@ impl<'a> SceneBuilder<'a> { .prim_list .add_prim( filtered_instance, - LayoutSize::zero(), + LayoutRect::zero(), backdrop_spatial_node_index, info.flags, ); @@ -3404,7 +3402,7 @@ impl<'a> SceneBuilder<'a> { if let Some((_, flattened_instance)) = flattened_items.take() { sc.prim_list.add_prim( flattened_instance, - LayoutSize::zero(), + LayoutRect::zero(), spatial_node_index, prim_flags, ); @@ -3429,7 +3427,7 @@ impl<'a> SceneBuilder<'a> { .prim_list .add_prim( instance, - LayoutSize::zero(), + LayoutRect::zero(), spatial_node_index, prim_flags, ); @@ -3493,7 +3491,7 @@ impl<'a> SceneBuilder<'a> { let mut prim_list = PrimitiveList::empty(); prim_list.add_prim( cur_instance.clone(), - LayoutSize::zero(), + LayoutRect::zero(), spatial_node_index, flags, ); @@ -3563,7 +3561,7 @@ impl<'a> SceneBuilder<'a> { let mut prim_list = PrimitiveList::empty(); prim_list.add_prim( cur_instance.clone(), - LayoutSize::zero(), + LayoutRect::zero(), spatial_node_index, flags, ); @@ -3984,7 +3982,6 @@ fn create_prim_instance( .intern(&pic_key, || ()); PrimitiveInstance::new( - LayoutPoint::zero(), LayoutRect::max_rect(), PrimitiveInstanceKind::Picture { data_handle, @@ -4000,7 +3997,6 @@ fn create_clip_prim_instance( kind: PrimitiveInstanceKind, ) -> PrimitiveInstance { PrimitiveInstance::new( - LayoutPoint::zero(), LayoutRect::max_rect(), kind, clip_chain_id, @@ -4152,7 +4148,6 @@ fn create_tile_cache( )); PrimitiveInstance::new( - LayoutPoint::zero(), LayoutRect::max_rect(), PrimitiveInstanceKind::Picture { data_handle: pic_data_handle,