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/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(); 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,