From fce5d7cca390fa4fd79d0c964cae1051ebae27c5 Mon Sep 17 00:00:00 2001 From: Martin Robinson Date: Wed, 1 Feb 2017 15:50:34 +0100 Subject: [PATCH] Clarify the difference between packed layers and stacking contexts Eventually scroll layers will create packed layers as well, so this will help to keep things clear. This shouldn't change behavior, because currently packed layer ids will always be equal to the stacking context ids of their owners. --- webrender/src/frame.rs | 42 +++--- webrender/src/tiling.rs | 319 ++++++++++++++++++++++------------------ 2 files changed, 197 insertions(+), 164 deletions(-) diff --git a/webrender/src/frame.rs b/webrender/src/frame.rs index 7eb2251003..baee0450fa 100644 --- a/webrender/src/frame.rs +++ b/webrender/src/frame.rs @@ -321,12 +321,12 @@ impl Frame { let layer_rect = LayerRect::new(LayerPoint::zero(), LayerSize::new(content_size.width + clip.origin.x, content_size.height + clip.origin.y)); - context.builder.push_layer(layer_rect, - &ClipRegion::simple(&layer_rect), - LayerToScrollTransform::identity(), - pipeline_id, - current_scroll_layer_id, - CompositeOps::empty()); + context.builder.push_stacking_context(layer_rect, + &ClipRegion::simple(&layer_rect), + LayerToScrollTransform::identity(), + pipeline_id, + current_scroll_layer_id, + CompositeOps::empty()); self.flatten_items(traversal, pipeline_id, @@ -336,7 +336,7 @@ impl Frame { LayerToScrollTransform::identity(), level); - context.builder.pop_layer(); + context.builder.pop_stacking_context(); } fn flatten_stacking_context<'a>(&mut self, @@ -400,12 +400,12 @@ impl Frame { // Adding a dummy layer for this rectangle in order to disable clipping. let no_clip = ClipRegion::simple(&clip_region.main); - context.builder.push_layer(clip_region.main, - &no_clip, - transform, - pipeline_id, - scroll_layer_id, - CompositeOps::empty()); + context.builder.push_stacking_context(clip_region.main, + &no_clip, + transform, + pipeline_id, + scroll_layer_id, + CompositeOps::empty()); //Note: we don't use the original clip region here, // it's already processed by the layer we just pushed. @@ -414,18 +414,18 @@ impl Frame { &bg_color, PrimitiveFlags::None); - context.builder.pop_layer(); + context.builder.pop_stacking_context(); } } } // TODO(gw): Int with overflow etc - context.builder.push_layer(clip_region.main, - &clip_region, - transform, - pipeline_id, - scroll_layer_id, - composition_operations); + context.builder.push_stacking_context(clip_region.main, + &clip_region, + transform, + pipeline_id, + scroll_layer_id, + composition_operations); self.flatten_items(traversal, pipeline_id, @@ -444,7 +444,7 @@ impl Frame { PrimitiveFlags::Scrollbar(self.scroll_tree.topmost_scroll_layer_id, 4.0)); } - context.builder.pop_layer(); + context.builder.pop_stacking_context(); } fn flatten_iframe<'a>(&mut self, diff --git a/webrender/src/tiling.rs b/webrender/src/tiling.rs index 93411a2783..c3414ee5b7 100644 --- a/webrender/src/tiling.rs +++ b/webrender/src/tiling.rs @@ -60,13 +60,13 @@ trait AlphaBatchHelpers { fn add_prim_to_batch(&self, prim_index: PrimitiveIndex, batch: &mut PrimitiveBatch, - layer_index: StackingContextIndex, + packed_layer_index: PackedLayerIndex, task_index: RenderTaskIndex, render_tasks: &RenderTaskCollection, pass_index: RenderPassIndex, z_sort_index: i32); fn add_blend_to_batch(&self, - layer_index: StackingContextIndex, + stacking_context_index: StackingContextIndex, batch: &mut PrimitiveBatch, task_index: RenderTaskIndex, src_task_index: RenderTaskIndex, @@ -150,7 +150,7 @@ impl AlphaBatchHelpers for PrimitiveStore { } fn add_blend_to_batch(&self, - layer_index: StackingContextIndex, + stacking_context_index: StackingContextIndex, batch: &mut PrimitiveBatch, task_index: RenderTaskIndex, src_task_index: RenderTaskIndex, @@ -170,7 +170,7 @@ impl AlphaBatchHelpers for PrimitiveStore { let amount = (amount * 65535.0).round() as i32; - batch.items.push(PrimitiveBatchItem::StackingContext(layer_index)); + batch.items.push(PrimitiveBatchItem::StackingContext(stacking_context_index)); match batch.data { PrimitiveBatchData::Instances(ref mut data) => { @@ -192,13 +192,13 @@ impl AlphaBatchHelpers for PrimitiveStore { fn add_prim_to_batch(&self, prim_index: PrimitiveIndex, batch: &mut PrimitiveBatch, - layer_index: StackingContextIndex, + packed_layer_index: PackedLayerIndex, task_index: RenderTaskIndex, render_tasks: &RenderTaskCollection, child_pass_index: RenderPassIndex, z_sort_index: i32) { let metadata = self.get_metadata(prim_index); - let layer_index = layer_index.0 as i32; + let packed_layer_index = packed_layer_index.0 as i32; let global_prim_id = prim_index.0 as i32; let prim_address = metadata.gpu_prim_index; let clip_task_index = match metadata.clip_task { @@ -223,7 +223,7 @@ impl AlphaBatchHelpers for PrimitiveStore { data.push(PrimitiveInstance { task_index: task_index, clip_task_index: clip_task_index, - layer_index: layer_index, + layer_index: packed_layer_index, global_prim_id: global_prim_id, prim_address: prim_address, sub_index: 0, @@ -238,7 +238,7 @@ impl AlphaBatchHelpers for PrimitiveStore { data.push(PrimitiveInstance { task_index: task_index, clip_task_index: clip_task_index, - layer_index: layer_index, + layer_index: packed_layer_index, global_prim_id: global_prim_id, prim_address: prim_address, sub_index: metadata.gpu_data_address.0 + glyph_index, @@ -253,7 +253,7 @@ impl AlphaBatchHelpers for PrimitiveStore { data.push(PrimitiveInstance { task_index: task_index, clip_task_index: clip_task_index, - layer_index: layer_index, + layer_index: packed_layer_index, global_prim_id: global_prim_id, prim_address: prim_address, sub_index: 0, @@ -265,7 +265,7 @@ impl AlphaBatchHelpers for PrimitiveStore { data.push(PrimitiveInstance { task_index: task_index, clip_task_index: clip_task_index, - layer_index: layer_index, + layer_index: packed_layer_index, global_prim_id: global_prim_id, prim_address: prim_address, sub_index: 0, @@ -278,7 +278,7 @@ impl AlphaBatchHelpers for PrimitiveStore { data.push(PrimitiveInstance { task_index: task_index, clip_task_index: clip_task_index, - layer_index: layer_index, + layer_index: packed_layer_index, global_prim_id: global_prim_id, prim_address: prim_address, sub_index: border_segment, @@ -292,7 +292,7 @@ impl AlphaBatchHelpers for PrimitiveStore { data.push(PrimitiveInstance { task_index: task_index, clip_task_index: clip_task_index, - layer_index: layer_index, + layer_index: packed_layer_index, global_prim_id: global_prim_id, prim_address: prim_address, sub_index: metadata.gpu_data_address.0 + part_index, @@ -305,7 +305,7 @@ impl AlphaBatchHelpers for PrimitiveStore { data.push(PrimitiveInstance { task_index: task_index, clip_task_index: clip_task_index, - layer_index: layer_index, + layer_index: packed_layer_index, global_prim_id: global_prim_id, prim_address: prim_address, sub_index: metadata.gpu_data_address.0, @@ -317,7 +317,7 @@ impl AlphaBatchHelpers for PrimitiveStore { data.push(PrimitiveInstance { task_index: task_index, clip_task_index: clip_task_index, - layer_index: layer_index, + layer_index: packed_layer_index, global_prim_id: global_prim_id, prim_address: prim_address, sub_index: metadata.gpu_data_address.0, @@ -334,7 +334,7 @@ impl AlphaBatchHelpers for PrimitiveStore { data.push(PrimitiveInstance { task_index: task_index, clip_task_index: clip_task_index, - layer_index: layer_index, + layer_index: packed_layer_index, global_prim_id: global_prim_id, prim_address: prim_address, sub_index: metadata.gpu_data_address.0 + rect_index, @@ -355,7 +355,7 @@ impl AlphaBatchHelpers for PrimitiveStore { data.push(PrimitiveInstance { task_index: task_index, clip_task_index: clip_task_index, - layer_index: layer_index, + layer_index: packed_layer_index, global_prim_id: global_prim_id, prim_address: prim_address, sub_index: 0, @@ -564,20 +564,24 @@ impl AlphaBatcher { for item in &task.alpha_items { let (batch_key, item_bounding_rect) = match item { - &AlphaRenderItem::Blend(sc_index, ..) => { - let layer = &ctx.layer_store[sc_index.0]; + &AlphaRenderItem::Blend(stacking_context_index, ..) => { + let stacking_context = &ctx.stacking_context_store[stacking_context_index.0]; (AlphaBatchKey::new(AlphaBatchKind::Blend, AlphaBatchKeyFlags::empty(), BlendMode::Alpha, BatchTextures::no_texture()), - &layer.xf_rect.as_ref().unwrap().bounding_rect) + &stacking_context.xf_rect.as_ref().unwrap().bounding_rect) } - &AlphaRenderItem::Composite(sc_index, backdrop_id, src_id, info, z) => { + &AlphaRenderItem::Composite(stacking_context_index, + backdrop_id, + src_id, + info, + z) => { // Composites always get added to their own batch. // This is because the result of a composite can affect // the input to the next composite. Perhaps we can // optimize this in the future. - let batch = PrimitiveBatch::new_composite(sc_index, + let batch = PrimitiveBatch::new_composite(stacking_context_index, task_index, render_tasks.get_task_index(&backdrop_id, child_pass_index), render_tasks.get_static_task_index(&src_id), @@ -586,10 +590,11 @@ impl AlphaBatcher { alpha_batches.push(batch); continue; } - &AlphaRenderItem::Primitive(sc_index, prim_index, _) => { - let layer = &ctx.layer_store[sc_index.0]; + &AlphaRenderItem::Primitive(stacking_context_index, prim_index, _) => { + let stacking_context = + &ctx.stacking_context_store[stacking_context_index.0]; let prim_metadata = ctx.prim_store.get_metadata(prim_index); - let transform_kind = layer.xf_rect.as_ref().unwrap().kind; + let transform_kind = stacking_context.xf_rect.as_ref().unwrap().kind; let needs_clipping = prim_metadata.clip_task.is_some(); let needs_blending = transform_kind == TransformedRectKind::Complex || !prim_metadata.is_opaque || @@ -631,9 +636,14 @@ impl AlphaBatcher { // check for intersections for item in &batch.items { let intersects = match *item { - PrimitiveBatchItem::StackingContext(sc_index) => { - let layer = &ctx.layer_store[sc_index.0]; - layer.xf_rect.as_ref().unwrap().bounding_rect.intersects(item_bounding_rect) + PrimitiveBatchItem::StackingContext(stacking_context_index) => { + let stacking_context = + &ctx.stacking_context_store[stacking_context_index.0]; + stacking_context.xf_rect + .as_ref() + .unwrap() + .bounding_rect + .intersects(item_bounding_rect) } PrimitiveBatchItem::Primitive(prim_index) => { let bounding_rect = &ctx.prim_store.cpu_bounding_rects[prim_index.0]; @@ -666,18 +676,20 @@ impl AlphaBatcher { let batch = &mut alpha_batches[alpha_batch_index.unwrap()]; match item { &AlphaRenderItem::Composite(..) => unreachable!(), - &AlphaRenderItem::Blend(sc_index, src_id, info, z) => { - ctx.prim_store.add_blend_to_batch(sc_index, + &AlphaRenderItem::Blend(stacking_context_index, src_id, info, z) => { + ctx.prim_store.add_blend_to_batch(stacking_context_index, batch, task_index, render_tasks.get_static_task_index(&src_id), info, z); } - &AlphaRenderItem::Primitive(sc_index, prim_index, z) => { + &AlphaRenderItem::Primitive(stacking_context_index, prim_index, z) => { + let stacking_context = + &ctx.stacking_context_store[stacking_context_index.0]; ctx.prim_store.add_prim_to_batch(prim_index, batch, - sc_index, + stacking_context.packed_layer_index, task_index, render_tasks, child_pass_index, @@ -690,10 +702,10 @@ impl AlphaBatcher { let batch_key = match item { &AlphaRenderItem::Composite(..) => unreachable!(), &AlphaRenderItem::Blend(..) => unreachable!(), - &AlphaRenderItem::Primitive(sc_index, prim_index, _) => { - let layer = &ctx.layer_store[sc_index.0]; + &AlphaRenderItem::Primitive(stacking_context_index, prim_index, _) => { + let stacking_context = &ctx.stacking_context_store[stacking_context_index.0]; let prim_metadata = ctx.prim_store.get_metadata(prim_index); - let transform_kind = layer.xf_rect.as_ref().unwrap().kind; + let transform_kind = stacking_context.xf_rect.as_ref().unwrap().kind; let needs_clipping = prim_metadata.clip_task.is_some(); let needs_blending = transform_kind == TransformedRectKind::Complex || !prim_metadata.is_opaque || @@ -743,10 +755,12 @@ impl AlphaBatcher { match item { &AlphaRenderItem::Composite(..) => unreachable!(), &AlphaRenderItem::Blend(..) => unreachable!(), - &AlphaRenderItem::Primitive(sc_index, prim_index, z) => { + &AlphaRenderItem::Primitive(stacking_context_index, prim_index, z) => { + let stacking_context = + &ctx.stacking_context_store[stacking_context_index.0]; ctx.prim_store.add_prim_to_batch(prim_index, batch, - sc_index, + stacking_context.packed_layer_index, task_index, render_tasks, child_pass_index, @@ -778,16 +792,18 @@ impl ClipBatcher { } } - fn add(&mut self, - task_index: RenderTaskIndex, - clips: &[(StackingContextIndex, MaskCacheInfo)], - resource_cache: &ResourceCache, - geometry_kind: MaskGeometryKind) { + fn add<'a>(&mut self, + task_index: RenderTaskIndex, + clips: &[(StackingContextIndex, MaskCacheInfo)], + resource_cache: &ResourceCache, + stacking_context_store: &'a [StackingContext], + geometry_kind: MaskGeometryKind) { - for &(layer_id, ref info) in clips.iter() { + for &(stacking_context_index, ref info) in clips.iter() { + let stacking_context = &stacking_context_store[stacking_context_index.0]; let instance = CacheClipInstance { task_id: task_index.0 as i32, - layer_index: layer_id.0 as i32, + layer_index: stacking_context.packed_layer_index.0 as i32, address: GpuStoreAddress(0), segment: 0, }; @@ -843,7 +859,7 @@ impl ClipBatcher { } struct RenderTargetContext<'a> { - layer_store: &'a [StackingContext], + stacking_context_store: &'a [StackingContext], prim_store: &'a PrimitiveStore, resource_cache: &'a ResourceCache, } @@ -992,6 +1008,7 @@ impl RenderTarget { self.clip_batcher.add(task_index, &task_info.clips, &ctx.resource_cache, + &ctx.stacking_context_store, task_info.geometry_kind); } RenderTaskKind::Readback(device_rect) => { @@ -1218,7 +1235,7 @@ impl RenderTask { fn new_mask(actual_rect: DeviceIntRect, mask_key: MaskCacheKey, clips: &[(StackingContextIndex, MaskCacheInfo)], - layers: &[StackingContext]) + stacking_context_store: &[StackingContext]) -> MaskResult { if clips.is_empty() { return MaskResult::Outside; @@ -1250,11 +1267,11 @@ impl RenderTask { let mut geometry_kind = MaskGeometryKind::Default; if inner_rect.is_some() && clips.len() == 1 { - let (sc_index, ref clip_info) = clips[0]; + let (stacking_context_index, ref clip_info) = clips[0]; + let stacking_context = &stacking_context_store[stacking_context_index.0]; - if clip_info.image.is_none() && - clip_info.effective_clip_count == 1 && - layers[sc_index.0].xf_rect.as_ref().unwrap().kind == TransformedRectKind::AxisAligned { + if clip_info.image.is_none() && clip_info.effective_clip_count == 1 && + stacking_context.xf_rect.as_ref().unwrap().kind == TransformedRectKind::AxisAligned { geometry_kind = MaskGeometryKind::CornersOnly; } } @@ -1640,7 +1657,7 @@ impl PrimitiveBatch { } } - fn new_composite(layer_index: StackingContextIndex, + fn new_composite(stacking_context_index: StackingContextIndex, task_index: RenderTaskIndex, backdrop_task: RenderTaskIndex, src_task_index: RenderTaskIndex, @@ -1665,11 +1682,14 @@ impl PrimitiveBatch { PrimitiveBatch { key: key, data: data, - items: vec![PrimitiveBatchItem::StackingContext(layer_index)], + items: vec![PrimitiveBatchItem::StackingContext(stacking_context_index)], } } } +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)] +pub struct PackedLayerIndex(pub usize); + #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)] pub struct StackingContextIndex(pub usize); @@ -1682,20 +1702,21 @@ pub struct StackingContext { composite_ops: CompositeOps, clip_source: ClipSource, clip_cache_info: Option, + packed_layer_index: PackedLayerIndex, } #[derive(Debug, Clone)] #[repr(C)] -pub struct PackedStackingContext { +pub struct PackedLayer { transform: LayerToWorldTransform, inv_transform: WorldToLayerTransform, local_clip_rect: LayerRect, screen_vertices: [WorldPoint4D; 4], } -impl Default for PackedStackingContext { - fn default() -> PackedStackingContext { - PackedStackingContext { +impl Default for PackedLayer { + fn default() -> PackedLayer { + PackedLayer { transform: LayerToWorldTransform::identity(), inv_transform: WorldToLayerTransform::identity(), local_clip_rect: LayerRect::zero(), @@ -1776,8 +1797,8 @@ pub struct FrameBuilder { _debug: bool, // Unused for now, but handy to keep around config: FrameBuilderConfig, - layer_store: Vec, - packed_layers: Vec, + stacking_context_store: Vec, + packed_layers: Vec, scrollbar_prims: Vec, } @@ -1792,7 +1813,7 @@ pub struct Frame { pub passes: Vec, pub profile_counters: FrameProfileCounters, - pub layer_texture_data: Vec, + pub layer_texture_data: Vec, pub render_task_data: Vec, pub gpu_data16: Vec, pub gpu_data32: Vec, @@ -1817,7 +1838,7 @@ impl FrameBuilder { FrameBuilder { screen_rect: LayerRect::new(LayerPoint::zero(), viewport_size), background_color: background_color, - layer_store: Vec::new(), + stacking_context_store: Vec::new(), prim_store: PrimitiveStore::new(), cmds: Vec::new(), _debug: debug, @@ -1865,21 +1886,22 @@ impl FrameBuilder { prim_index } - pub fn push_layer(&mut self, - rect: LayerRect, - clip_region: &ClipRegion, - transform: LayerToScrollTransform, - pipeline_id: PipelineId, - scroll_layer_id: ScrollLayerId, - composite_ops: CompositeOps) { - let sc_index = StackingContextIndex(self.layer_store.len()); + pub fn push_stacking_context(&mut self, + rect: LayerRect, + clip_region: &ClipRegion, + transform: LayerToScrollTransform, + pipeline_id: PipelineId, + scroll_layer_id: ScrollLayerId, + composite_ops: CompositeOps) { + let stacking_context_index = StackingContextIndex(self.stacking_context_store.len()); + let packed_layer_index = PackedLayerIndex(self.packed_layers.len()); let clip_source = ClipSource::Region(clip_region.clone()); let clip_info = MaskCacheInfo::new(&clip_source, true, // needs an extra clip for the clip rectangle &mut self.prim_store.gpu_data32); - let sc = StackingContext { + self.stacking_context_store.push(StackingContext { local_rect: rect, local_transform: transform, scroll_layer_id: scroll_layer_id, @@ -1888,20 +1910,14 @@ impl FrameBuilder { composite_ops: composite_ops, clip_source: clip_source, clip_cache_info: clip_info, - }; - self.layer_store.push(sc); - - self.packed_layers.push(PackedStackingContext { - transform: LayerToWorldTransform::identity(), - inv_transform: WorldToLayerTransform::identity(), - screen_vertices: [WorldPoint4D::zero(); 4], - local_clip_rect: LayerRect::zero(), + packed_layer_index: packed_layer_index, }); - self.cmds.push(PrimitiveRunCmd::PushStackingContext(sc_index)); + self.packed_layers.push(Default::default()); + self.cmds.push(PrimitiveRunCmd::PushStackingContext(stacking_context_index)); } - pub fn pop_layer(&mut self) { + pub fn pop_stacking_context(&mut self) { self.cmds.push(PrimitiveRunCmd::PopStackingContext); } @@ -2369,36 +2385,40 @@ impl FrameBuilder { // TODO(gw): This can be done earlier once update_layer_transforms() is fixed. // TODO(gw): Remove this stack once the layers refactor is done! - let mut layer_stack: Vec = Vec::new(); + let mut stacking_context_stack: Vec = Vec::new(); let mut clip_info_stack = Vec::new(); for cmd in &self.cmds { match cmd { - &PrimitiveRunCmd::PushStackingContext(sc_index) => { - layer_stack.push(sc_index); - let layer = &mut self.layer_store[sc_index.0]; - let packed_layer = &mut self.packed_layers[sc_index.0]; + &PrimitiveRunCmd::PushStackingContext(stacking_context_index) => { + stacking_context_stack.push(stacking_context_index); + let stacking_context = + &mut self.stacking_context_store[stacking_context_index.0]; + let packed_layer = + &mut self.packed_layers[stacking_context.packed_layer_index.0]; - layer.xf_rect = None; + stacking_context.xf_rect = None; - let scroll_layer = &scroll_tree.layers[&layer.scroll_layer_id]; + let scroll_layer = &scroll_tree.layers[&stacking_context.scroll_layer_id]; packed_layer.transform = scroll_layer.world_content_transform .with_source::() // the scroll layer is considered a parent of layer - .pre_mul(&layer.local_transform); + .pre_mul(&stacking_context.local_transform); packed_layer.inv_transform = packed_layer.transform.inverse().unwrap(); - if !layer.can_contribute_to_scene() { + if !stacking_context.can_contribute_to_scene() { continue; } - let inv_layer_transform = layer.local_transform.inverse().unwrap(); + let inv_layer_transform = stacking_context.local_transform.inverse().unwrap(); let local_viewport_rect = as_scroll_parent_rect(&scroll_layer.combined_local_viewport_rect); let viewport_rect = inv_layer_transform.transform_rect(&local_viewport_rect); - let local_clip_rect = layer.clip_source.to_rect().unwrap_or(layer.local_rect); - let layer_local_rect = layer.local_rect - .intersection(&viewport_rect) - .and_then(|rect| rect.intersection(&local_clip_rect)); + let local_clip_rect = + stacking_context.clip_source.to_rect().unwrap_or(stacking_context.local_rect); + let layer_local_rect = + stacking_context.local_rect + .intersection(&viewport_rect) + .and_then(|rect| rect.intersection(&local_clip_rect)); if let Some(layer_local_rect) = layer_local_rect { let layer_xf_rect = TransformedRect::new(&layer_local_rect, @@ -2408,38 +2428,38 @@ impl FrameBuilder { if layer_xf_rect.bounding_rect.intersects(&screen_rect) { packed_layer.screen_vertices = layer_xf_rect.vertices.clone(); packed_layer.local_clip_rect = layer_local_rect; - layer.xf_rect = Some(layer_xf_rect); + stacking_context.xf_rect = Some(layer_xf_rect); } } - if let Some(ref mut clip_info) = layer.clip_cache_info { - let auxiliary_lists = auxiliary_lists_map.get(&layer.pipeline_id) + if let Some(ref mut clip_info) = stacking_context.clip_cache_info { + let auxiliary_lists = auxiliary_lists_map.get(&stacking_context.pipeline_id) .expect("No auxiliary lists?"); - clip_info.update(&layer.clip_source, + clip_info.update(&stacking_context.clip_source, &packed_layer.transform, &mut self.prim_store.gpu_data32, device_pixel_ratio, auxiliary_lists); - if let ClipSource::Region(ClipRegion{ image_mask: Some(ref mask), .. }) = layer.clip_source { + if let ClipSource::Region(ClipRegion{ image_mask: Some(ref mask), .. }) = stacking_context.clip_source { resource_cache.request_image(mask.image, ImageRendering::Auto); - //Note: no need to add the layer for resolve, all layers get resolved + //Note: no need to add the stacking context for resolve, all layers get resolved } - // Create a task for the layer mask, if needed, - // i.e. if there are rounded corners or image masks for the layer. - clip_info_stack.push((sc_index, clip_info.clone())); + // Create a task for the stacking context mask, if needed, i.e. if there + // are rounded corners or image masks for the stacking context. + clip_info_stack.push((stacking_context_index, clip_info.clone())); } } &PrimitiveRunCmd::PrimitiveRun(prim_index, prim_count) => { - let sc_index = layer_stack.last().unwrap(); - let layer = &self.layer_store[sc_index.0]; - if !layer.is_visible() { + let stacking_context_index = stacking_context_stack.last().unwrap(); + let stacking_context = &self.stacking_context_store[stacking_context_index.0]; + if !stacking_context.is_visible() { continue; } - let packed_layer = &self.packed_layers[sc_index.0]; - let auxiliary_lists = auxiliary_lists_map.get(&layer.pipeline_id) + let packed_layer = &self.packed_layers[stacking_context.packed_layer_index.0]; + let auxiliary_lists = auxiliary_lists_map.get(&stacking_context.pipeline_id) .expect("No auxiliary lists?"); for i in 0..prim_count { @@ -2470,7 +2490,7 @@ impl FrameBuilder { let mut visible = true; if let Some(info) = prim_clip_info { - clip_info_stack.push((*sc_index, info.clone())); + clip_info_stack.push((*stacking_context_index, info.clone())); } // Try to create a mask if we may need to. @@ -2485,14 +2505,15 @@ impl FrameBuilder { (MaskCacheKey::Primitive(prim_index), prim_bounding_rect) } None => { - let layer_rect = layer.xf_rect.as_ref().unwrap().bounding_rect; - (MaskCacheKey::StackingContext(*sc_index), layer_rect) + (MaskCacheKey::StackingContext(*stacking_context_index), + stacking_context.xf_rect.as_ref().unwrap().bounding_rect) } }; - let mask_opt = RenderTask::new_mask(mask_rect, - mask_key, - &clip_info_stack, - &self.layer_store); + let mask_opt = + RenderTask::new_mask(mask_rect, + mask_key, + &clip_info_stack, + &self.stacking_context_store); match mask_opt { MaskResult::Outside => { // Primitive is completely clipped out. @@ -2519,15 +2540,15 @@ impl FrameBuilder { } } &PrimitiveRunCmd::PopStackingContext => { - let sc_index = *layer_stack.last().unwrap(); - let layer = &mut self.layer_store[sc_index.0]; - if layer.can_contribute_to_scene() { - if layer.clip_cache_info.is_some() { + let stacking_context_index = *stacking_context_stack.last().unwrap(); + let stacking_context = &self.stacking_context_store[stacking_context_index.0]; + if stacking_context.can_contribute_to_scene() { + if stacking_context.clip_cache_info.is_some() { clip_info_stack.pop().unwrap(); } } - layer_stack.pop().unwrap(); + stacking_context_stack.pop().unwrap(); } } } @@ -2591,20 +2612,21 @@ impl FrameBuilder { for cmd in &self.cmds { match *cmd { - PrimitiveRunCmd::PushStackingContext(sc_index) => { - let layer = &self.layer_store[sc_index.0]; - sc_stack.push(sc_index); + PrimitiveRunCmd::PushStackingContext(stacking_context_index) => { + let stacking_context = &self.stacking_context_store[stacking_context_index.0]; + sc_stack.push(stacking_context_index); - if !layer.is_visible() { + if !stacking_context.is_visible() { continue; } - let composite_count = layer.composite_ops.count(); + let composite_count = stacking_context.composite_ops.count(); for _ in 0..composite_count { - let layer_rect = layer.xf_rect.as_ref().unwrap().bounding_rect; - let location = RenderTaskLocation::Dynamic(None, layer_rect.size); + let stacking_context_rect = + stacking_context.xf_rect.as_ref().unwrap().bounding_rect; + let location = RenderTaskLocation::Dynamic(None, stacking_context_rect.size); let new_task = RenderTask::new_alpha_batch(next_task_index, - layer_rect.origin, + stacking_context_rect.origin, location); next_task_index.0 += 1; let prev_task = mem::replace(&mut current_task, new_task); @@ -2612,27 +2634,36 @@ impl FrameBuilder { } } PrimitiveRunCmd::PopStackingContext => { - let sc_index = sc_stack.pop().unwrap(); - let layer = &self.layer_store[sc_index.0]; + let stacking_context_index = sc_stack.pop().unwrap(); + let stacking_context = &self.stacking_context_store[stacking_context_index.0]; - if !layer.is_visible() { + if !stacking_context.is_visible() { continue; } - for filter in &layer.composite_ops.filters { + for filter in &stacking_context.composite_ops.filters { let mut prev_task = alpha_task_stack.pop().unwrap(); - let item = AlphaRenderItem::Blend(sc_index, current_task.id, *filter, next_z); + let item = AlphaRenderItem::Blend(stacking_context_index, + current_task.id, + *filter, + next_z); next_z += 1; prev_task.as_alpha_batch().alpha_items.push(item); prev_task.children.push(current_task); current_task = prev_task; } - if let Some(mix_blend_mode) = layer.composite_ops.mix_blend_mode { - let layer_rect = layer.xf_rect.as_ref().unwrap().bounding_rect; - let readback_task = RenderTask::new_readback(sc_index, layer_rect); + if let Some(mix_blend_mode) = stacking_context.composite_ops.mix_blend_mode { + let stacking_context_rect = + stacking_context.xf_rect.as_ref().unwrap().bounding_rect; + let readback_task = + RenderTask::new_readback(stacking_context_index, stacking_context_rect); let mut prev_task = alpha_task_stack.pop().unwrap(); - let item = AlphaRenderItem::Composite(sc_index, readback_task.id, current_task.id, mix_blend_mode, next_z); + let item = AlphaRenderItem::Composite(stacking_context_index, + readback_task.id, + current_task.id, + mix_blend_mode, + next_z); next_z += 1; prev_task.as_alpha_batch().alpha_items.push(item); prev_task.children.push(current_task); @@ -2641,10 +2672,10 @@ impl FrameBuilder { } } PrimitiveRunCmd::PrimitiveRun(first_prim_index, prim_count) => { - let sc_index = *sc_stack.last().unwrap(); - let layer = &self.layer_store[sc_index.0]; + let stacking_context_index = *sc_stack.last().unwrap(); + let stacking_context = &self.stacking_context_store[stacking_context_index.0]; - if !layer.is_visible() { + if !stacking_context.is_visible() { continue; } @@ -2662,7 +2693,7 @@ impl FrameBuilder { current_task.children.push(clip_task.clone()); } - let transform_kind = layer.xf_rect.as_ref().unwrap().kind; + let transform_kind = stacking_context.xf_rect.as_ref().unwrap().kind; let needs_clipping = prim_metadata.clip_task.is_some(); let needs_blending = transform_kind == TransformedRectKind::Complex || !prim_metadata.is_opaque || @@ -2673,7 +2704,9 @@ impl FrameBuilder { } else { &mut current_task.as_alpha_batch().opaque_items }; - items.push(AlphaRenderItem::Primitive(sc_index, prim_index, next_z)); + items.push(AlphaRenderItem::Primitive(stacking_context_index, + prim_index, + next_z)); next_z += 1; } } @@ -2727,8 +2760,8 @@ impl FrameBuilder { resource_cache.block_until_all_resources_added(); - for layer in self.layer_store.iter() { - if let Some(ref clip_info) = layer.clip_cache_info { + for stacking_context in self.stacking_context_store.iter() { + if let Some(ref clip_info) = stacking_context.clip_cache_info { self.prim_store.resolve_clip_cache(clip_info, resource_cache); } } @@ -2750,7 +2783,7 @@ impl FrameBuilder { for pass in &mut passes { let ctx = RenderTargetContext { - layer_store: &self.layer_store, + stacking_context_store: &self.stacking_context_store, prim_store: &self.prim_store, resource_cache: resource_cache, };