Major refactoring of how clips are processed down the pipeline, in preparation to multiple transformed clip support.

Removed MaskImageSource, introduced PrimitiveClipSource to the metadata.
Avoided cloning the auxiliary lists map.

Author: kvark

webrender/res/clip_shared.glsl

@@ -9,15 +9,15 @@ flat varying vec4 vClipMaskUvRect;
 flat varying vec4 vClipMaskLocalRect;
 
 #ifdef WR_VERTEX_SHADER
-void write_clip(ClipInfo clip) {
+void write_clip(ClipData clip) {
     vClipRect = vec4(clip.rect.rect.xy, clip.rect.rect.xy + clip.rect.rect.zw);
     vClipRadius = vec4(clip.top_left.outer_inner_radius.x,
                        clip.top_right.outer_inner_radius.x,
                        clip.bottom_right.outer_inner_radius.x,
                        clip.bottom_left.outer_inner_radius.x);
     //TODO: interpolate the final mask UV
-    vClipMaskUvRect = clip.mask_info.uv_rect;
-    vClipMaskLocalRect = clip.mask_info.local_rect; //TODO: transform
+    vClipMaskUvRect = clip.mask_data.uv_rect;
+    vClipMaskLocalRect = clip.mask_data.local_rect; //TODO: transform
 }
 #endif
 

webrender/res/prim_shared.glsl

@@ -347,13 +347,13 @@ ClipRect fetch_clip_rect(int index) {
     return rect;
 }
 
-struct ImageMaskInfo {
+struct ImageMaskData {
     vec4 uv_rect;
     vec4 local_rect;
 };
 
-ImageMaskInfo fetch_mask_info(int index) {
-    ImageMaskInfo info;
+ImageMaskData fetch_mask_data(int index) {
+    ImageMaskData info;
 
     ivec2 uv = get_fetch_uv_2(index);
 
@@ -379,24 +379,24 @@ ClipCorner fetch_clip_corner(int index) {
     return corner;
 }
 
-struct ClipInfo {
+struct ClipData {
     ClipRect rect;
     ClipCorner top_left;
     ClipCorner top_right;
     ClipCorner bottom_left;
     ClipCorner bottom_right;
-    ImageMaskInfo mask_info;
+    ImageMaskData mask_data;
 };
 
-ClipInfo fetch_clip(int index) {
-    ClipInfo clip;
+ClipData fetch_clip(int index) {
+    ClipData clip;
 
     clip.rect = fetch_clip_rect(index + 0);
     clip.top_left = fetch_clip_corner(index + 1);
     clip.top_right = fetch_clip_corner(index + 2);
     clip.bottom_left = fetch_clip_corner(index + 3);
     clip.bottom_right = fetch_clip_corner(index + 4);
-    clip.mask_info = fetch_mask_info(index + 5);
+    clip.mask_data = fetch_mask_data(index + 5);
 
     return clip;
 }

webrender/res/ps_gradient_clip.vs.glsl

@@ -66,6 +66,6 @@ void main(void) {
             break;
     }
 
-    ClipInfo clip = fetch_clip(prim.clip_index);
+    ClipData clip = fetch_clip(prim.clip_index);
     write_clip(clip);
 }

webrender/res/ps_image_clip.vs.glsl

@@ -23,7 +23,7 @@ void main(void) {
     vLocalPos = vi.local_clamped_pos;
 #endif
 
-    ClipInfo clip = fetch_clip(prim.clip_index);
+    ClipData clip = fetch_clip(prim.clip_index);
     write_clip(clip);
 
     // vUv will contain how many times this image has wrapped around the image size.

webrender/res/ps_rectangle_clip.vs.glsl

@@ -22,6 +22,6 @@ void main(void) {
     vPos = vi.local_clamped_pos;
 #endif
 
-    ClipInfo clip = fetch_clip(prim.clip_index);
+    ClipData clip = fetch_clip(prim.clip_index);
     write_clip(clip);
 }

webrender/src/frame.rs

@@ -11,16 +11,14 @@ use internal_types::{CompositionOp};
 use internal_types::{LowLevelFilterOp};
 use internal_types::{RendererFrame};
 use layer::{Layer, ScrollingState};
-use prim_store::ClipInfo;
 use resource_cache::{DummyResources, ResourceCache};
 use scene::{SceneStackingContext, ScenePipeline, Scene, SceneItem, SpecificSceneItem};
 use std::collections::{HashMap, HashSet};
 use std::hash::BuildHasherDefault;
-use tiling::{FrameBuilder, FrameBuilderConfig, InsideTest, Clip, MaskImageSource};
-use tiling::PrimitiveFlags;
+use tiling::{AuxiliaryListsMap, FrameBuilder, FrameBuilderConfig, PrimitiveFlags};
 use util::MatrixHelpers;
 use webrender_traits::{AuxiliaryLists, PipelineId, Epoch, ScrollPolicy, ScrollLayerId};
-use webrender_traits::{ColorF, StackingContext, FilterOp, MixBlendMode};
+use webrender_traits::{ClipRegion, ColorF, StackingContext, FilterOp, MixBlendMode};
 use webrender_traits::{ScrollEventPhase, ScrollLayerInfo, SpecificDisplayItem, ScrollLayerState};
 
 #[cfg(target_os = "macos")]
@@ -36,7 +34,6 @@ static DEFAULT_SCROLLBAR_COLOR: ColorF = ColorF { r: 0.3, g: 0.3, b: 0.3, a: 0.6
 
 struct FlattenContext<'a> {
     resource_cache: &'a mut ResourceCache,
-    dummy_resources: &'a DummyResources,
     scene: &'a Scene,
     pipeline_sizes: &'a mut HashMap<PipelineId, Size2D<f32>>,
     builder: &'a mut FrameBuilder,
@@ -411,13 +408,13 @@ impl Frame {
                 {
                     let mut frame_builder = FrameBuilder::new(root_pipeline.viewport_size,
                                                               device_pixel_ratio,
+                                                              dummy_resources.clone(),
                                                               self.debug,
                                                               self.frame_builder_config);
 
                     {
                         let mut context = FlattenContext {
                             resource_cache: resource_cache,
-                            dummy_resources: dummy_resources,
                             scene: scene,
                             pipeline_sizes: pipeline_sizes,
                             builder: &mut frame_builder,
@@ -538,76 +535,35 @@ impl Frame {
             //
             // If we do need this, does it make sense to keep Frame::clear_tiles?
             context.builder.add_solid_rectangle(&stacking_context.bounds,
-                                                &stacking_context.bounds,
-                                                None,
+                                                &ClipRegion::simple(&stacking_context.bounds),
                                                 &ColorF::new(1.0, 1.0, 1.0, 1.0),
                                                 PrimitiveFlags::None);
         }
 
-        let dummy_mask_source = {
-            let cache_id = context.dummy_resources.opaque_mask_image_id;
-            let cache_item = context.resource_cache.get_image_by_cache_id(cache_id);
-            MaskImageSource::Renderer(cache_item.texture_id)
-        };
-
         for item in scene_items {
             match item.specific {
                 SpecificSceneItem::DrawList(draw_list_id) => {
                     let draw_list = context.resource_cache.get_draw_list(draw_list_id);
                     let builder = &mut context.builder;
-                    let auxiliary_lists = self.pipeline_auxiliary_lists
-                                              .get(&parent_info.pipeline_id)
-                                              .expect("No auxiliary lists?!");
 
                     for item in &draw_list.items {
-                        let clips = auxiliary_lists.complex_clip_regions(&item.clip.complex);
-                        let mut clip = match clips.len() {
-                            0 if item.clip.image_mask.is_none() => None,
-                            0 => Some(Clip::new(ClipInfo::uniform(item.clip.main, 0.0), dummy_mask_source)),
-                            1 => Some(Clip::new(ClipInfo::from_clip_region(&clips[0]), dummy_mask_source)),
-                            _ => {
-                                let internal_clip = clips.last().unwrap();
-                                let region = if clips.iter().all(|current_clip| current_clip.might_contain(internal_clip)) {
-                                    internal_clip
-                                } else {
-                                    &clips[0]
-                                };
-                                Some(Clip::new(ClipInfo::from_clip_region(region), dummy_mask_source))
-                            },
-                        };
-
-                        if let Some(ref mask) = item.clip.image_mask {
-                            let old = match clip {
-                                Some(masked) => *masked.clip,
-                                None => ClipInfo::uniform(item.clip.main, 0.0),
-                            };
-                            //Note: can't call `tex_cache.aligned_uv_rect()` here since the image
-                            // is not yet marked as needed this frame.
-                            clip = Some(Clip::new(old.with_mask(Rect::zero(), mask.rect),
-                                                         MaskImageSource::User(mask.image)));
-                        }
-
-
                         match item.item {
                             SpecificDisplayItem::WebGL(ref info) => {
                                 builder.add_webgl_rectangle(item.rect,
-                                                            &item.clip.main,
-                                                            clip,
+                                                            &item.clip,
                                                             info.context_id);
                             }
                             SpecificDisplayItem::Image(ref info) => {
                                 builder.add_image(item.rect,
-                                                  &item.clip.main,
-                                                  clip,
+                                                  &item.clip,
                                                   &info.stretch_size,
                                                   &info.tile_spacing,
                                                   info.image_key,
                                                   info.image_rendering);
                             }
                             SpecificDisplayItem::Text(ref text_info) => {
                                 builder.add_text(item.rect,
-                                                 &item.clip.main,
-                                                 clip,
+                                                 &item.clip,
                                                  text_info.font_key,
                                                  text_info.size,
                                                  text_info.blur_radius,
@@ -616,23 +572,20 @@ impl Frame {
                             }
                             SpecificDisplayItem::Rectangle(ref info) => {
                                 builder.add_solid_rectangle(&item.rect,
-                                                            &item.clip.main,
-                                                            clip,
+                                                            &item.clip,
                                                             &info.color,
                                                             PrimitiveFlags::None);
                             }
                             SpecificDisplayItem::Gradient(ref info) => {
                                 builder.add_gradient(item.rect,
-                                                     &item.clip.main,
-                                                     clip,
+                                                     &item.clip,
                                                      info.start_point,
                                                      info.end_point,
                                                      info.stops);
                             }
                             SpecificDisplayItem::BoxShadow(ref box_shadow_info) => {
                                 builder.add_box_shadow(&box_shadow_info.box_bounds,
-                                                       &item.clip.main,
-                                                       clip,
+                                                       &item.clip,
                                                        &box_shadow_info.offset,
                                                        &box_shadow_info.color,
                                                        box_shadow_info.blur_radius,
@@ -642,8 +595,7 @@ impl Frame {
                             }
                             SpecificDisplayItem::Border(ref info) => {
                                 builder.add_border(item.rect,
-                                                   &item.clip.main,
-                                                   clip,
+                                                   &item.clip,
                                                    info);
                             }
                         }
@@ -762,8 +714,7 @@ impl Frame {
             let scrollbar_rect = Rect::new(Point2D::zero(),
                                            Size2D::new(10.0, 70.0));
             context.builder.add_solid_rectangle(&scrollbar_rect,
-                                                &scrollbar_rect,
-                                                None,
+                                                &ClipRegion::simple(&scrollbar_rect),
                                                 &DEFAULT_SCROLLBAR_COLOR,
                                                 PrimitiveFlags::Scrollbar(self.root_scroll_layer_id.unwrap(),
                                                                           4.0));
@@ -774,10 +725,11 @@ impl Frame {
 
     pub fn build(&mut self,
                  resource_cache: &mut ResourceCache,
+                 auxiliary_lists_map: &AuxiliaryListsMap,
                  device_pixel_ratio: f32)
                  -> RendererFrame {
         self.update_layer_transforms(device_pixel_ratio);
-        let frame = self.build_frame(resource_cache);
+        let frame = self.build_frame(resource_cache, auxiliary_lists_map);
         resource_cache.expire_old_resources(self.id);
         frame
     }
@@ -853,14 +805,12 @@ impl Frame {
     }
 
     fn build_frame(&mut self,
-                   resource_cache: &mut ResourceCache) -> RendererFrame {
+                   resource_cache: &mut ResourceCache,
+                   auxiliary_lists_map: &AuxiliaryListsMap) -> RendererFrame {
         let mut frame_builder = self.frame_builder.take();
-        let frame = frame_builder.as_mut().map(|builder| {
-            builder.build(resource_cache,
-                          self.id,
-                          &self.pipeline_auxiliary_lists,
-                          &self.layers)
-        });
+        let frame = frame_builder.as_mut().map(|builder|
+            builder.build(resource_cache, self.id, &self.layers, auxiliary_lists_map)
+        );
         self.frame_builder = frame_builder;
 
         let layers_bouncing_back = self.collect_layers_bouncing_back();