Bug 1759647 - Fix segments on snapped picture surface with clips + scale transform r=gfx-reviewers,nical

Differential Revision: https://phabricator.services.mozilla.com/D141182

[ghsync] From https://hg.mozilla.org/mozilla-central/rev/3bfcf747cccfdebd6da85c316b2448dfb17a0323

Author: Glenn Watson

webrender/src/batch.rs

@@ -31,7 +31,7 @@ use crate::space::SpaceMapper;
 use crate::visibility::{PrimitiveVisibilityFlags, VisibilityState};
 use smallvec::SmallVec;
 use std::{f32, i32, usize, mem};
-use crate::util::{project_rect, MaxRect, MatrixHelpers, TransformedRectKind};
+use crate::util::{project_rect, MaxRect, MatrixHelpers, TransformedRectKind, ScaleOffset};
 use crate::segment::EdgeAaSegmentMask;
 
 // Special sentinel value recognized by the shader. It is considered to be
@@ -1353,43 +1353,39 @@ impl BatchBuilder {
 
                         let surface = &ctx.surfaces[raster_config.surface_index.0];
 
-                        // If we are drawing with snapping enabled, the local rect of the prim must be in the raster
-                        // space, to avoid situations where there is a 180deg rotation in between the root and primitive
-                        // space not being correctly applied.
-                        let prim_header = if surface.surface_spatial_node_index == surface.raster_spatial_node_index {
-                            PrimitiveHeader {
-                                local_rect: prim_rect,
-                                local_clip_rect: prim_info.combined_local_clip_rect,
-                                specific_prim_address: prim_cache_address,
-                                transform_id,
-                            }
+                        // If we are drawing with snapping enabled, form a simple transform that just applies
+                        // the scale / translation from the raster transform. Otherwise, in edge cases where the
+                        // intermediate surface has a non-identity but axis-aligned transform (e.g. a 180 degree
+                        // rotation) it can be applied twice.
+                        let transform_id = if surface.surface_spatial_node_index == surface.raster_spatial_node_index {
+                            transform_id
                         } else {
                             let map_local_to_raster = SpaceMapper::new_with_target(
-                                surface.raster_spatial_node_index,
+                                root_spatial_node_index,
                                 surface.surface_spatial_node_index,
                                 LayoutRect::max_rect(),
                                 ctx.spatial_tree,
                             );
 
-                            let prim_rect = map_local_to_raster
+                            let raster_rect = map_local_to_raster
                                 .map(&prim_rect)
                                 .unwrap();
-                            let local_clip_rect = map_local_to_raster
-                                .map(&prim_info.combined_local_clip_rect)
-                                .unwrap();
-                            let transform_id = transforms
-                                .get_id(
-                                    surface.raster_spatial_node_index,
-                                    root_spatial_node_index,
-                                    ctx.spatial_tree,
-                                );
 
-                            PrimitiveHeader {
-                                local_rect: prim_rect,
-                                local_clip_rect,
-                                specific_prim_address: prim_cache_address,
-                                transform_id,
-                            }
+                            let sx = (raster_rect.max.x - raster_rect.min.x) / (prim_rect.max.x - prim_rect.min.x);
+                            let sy = (raster_rect.max.y - raster_rect.min.y) / (prim_rect.max.y - prim_rect.min.y);
+
+                            let tx = raster_rect.min.x - sx * prim_rect.min.x;
+                            let ty = raster_rect.min.y - sy * prim_rect.min.y;
+
+                            let transform = ScaleOffset::new(sx, sy, tx, ty);
+                            transforms.get_custom(transform.to_transform())
+                        };
+
+                        let prim_header = PrimitiveHeader {
+                            local_rect: prim_rect,
+                            local_clip_rect: prim_info.combined_local_clip_rect,
+                            specific_prim_address: prim_cache_address,
+                            transform_id,
                         };
 
                         let mut is_opaque = prim_info.clip_task_index == ClipTaskIndex::INVALID

webrender/src/gpu_types.rs

@@ -788,6 +788,23 @@ impl TransformPalette {
             (transform_kind << 24)
         )
     }
+
+    pub fn get_custom(
+        &mut self,
+        transform: LayoutToPictureTransform,
+    ) -> TransformPaletteId {
+        let index = register_transform(
+            &mut self.metadata,
+            &mut self.transforms,
+            transform,
+        );
+
+        let transform_kind = self.metadata[index].transform_kind as u32;
+        TransformPaletteId(
+            (index as u32) |
+            (transform_kind << 24)
+        )
+    }
 }
 
 // Texture cache resources can be either a simple rect, or define

webrender/src/picture.rs

@@ -5948,7 +5948,6 @@ impl PicturePrimitive {
 
     pub fn prepare_for_render(
         &mut self,
-        frame_context: &FrameBuildingContext,
         frame_state: &mut FrameBuildingState,
         data_stores: &mut DataStores,
     ) -> bool {
@@ -5984,27 +5983,11 @@ impl PicturePrimitive {
                             shadow.blur_radius,
                         );
 
-                        let mut shadow_rect = prim_rect.inflate(
+                        let shadow_rect = prim_rect.inflate(
                             blur_inflation_x * BLUR_SAMPLE_SCALE,
                             blur_inflation_y * BLUR_SAMPLE_SCALE,
                         ).translate(shadow.offset);
 
-                        // If we are drawing with snapping enabled, the local rect of the prim must be in the raster
-                        // space, to avoid situations where there is a 180deg rotation in between the root and primitive
-                        // space not being correctly applied.
-                        if surface.surface_spatial_node_index != surface.raster_spatial_node_index {
-                            let map_local_to_raster = SpaceMapper::new_with_target(
-                                surface.raster_spatial_node_index,
-                                surface.surface_spatial_node_index,
-                                LayoutRect::max_rect(),
-                                frame_context.spatial_tree,
-                            );
-
-                            shadow_rect = map_local_to_raster
-                                .map(&shadow_rect)
-                                .unwrap();
-                        }
-
                         // ImageBrush colors
                         request.push(shadow.color.premultiplied());
                         request.push(PremultipliedColorF::WHITE);

webrender/src/prepare.rs

@@ -763,7 +763,6 @@ fn prepare_interned_prim_for_render(
             let pic = &mut store.pictures[pic_index.0];
 
             if pic.prepare_for_render(
-                frame_context,
                 frame_state,
                 data_stores,
             ) {

webrender/src/util.rs

@@ -135,6 +135,13 @@ pub struct ScaleOffset {
 }
 
 impl ScaleOffset {
+    pub fn new(sx: f32, sy: f32, tx: f32, ty: f32) -> Self {
+        ScaleOffset {
+            scale: Vector2D::new(sx, sy),
+            offset: Vector2D::new(tx, ty),
+        }
+    }
+
     pub fn identity() -> Self {
         ScaleOffset {
             scale: Vector2D::new(1.0, 1.0),