Auto merge of #2694 - glennw:screen-uv2, r=mrobinson

Allow texture cache entries to store non-rectangular UVs.

Most of the time, UVs are stored as a (top left, bottom right) pair
of coordinates in the texture cache. The exception to this is when
we have an off-screen render target that was transformed.

In this case, we need access to the four corners within the render
surface in order to generate correct UVs when we composite that
surface into the framebuffer.

Previously, we generated these in the brush shader by transforming
the vertex position, and using that to generate a screen space
texture coordinate.

This patch removes that code, and instead does the calculation of
the four corner UVs during render task generation on the CPU. The
corner coordinates are then stored in the texture cache entry, and
the shaders do a simple bilerp to find the correct UV at each vertex
when drawing these images.

This has a number of benefits:
 * We can draw a screen-space rendered surface at any location now
   with the same logic (we don't need hacks for applying local offsets
   etc when drawing drop-shadows).
 * Most importantly, when we store an off-screen surface in the texture
   cache for use on subsequent frames, the shader that draws that doesn't
   need to know anything about the transform of the surface when it was
   rendered. This means the screen-space UV generation doesn't rely
   on access to the clip-scroll node transform of the source surface.

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/webrender/2694)
<!-- Reviewable:end -->

Author: bors-servo

webrender/res/brush_image.glsl

@@ -40,24 +40,6 @@ ImageBrushData fetch_image_data(int address) {
     return data;
 }
 
-struct ImageBrushExtraData {
-    RectWithSize rendered_task_rect;
-    vec2 offset;
-};
-
-ImageBrushExtraData fetch_image_extra_data(int address) {
-    vec4[2] raw_data = fetch_from_resource_cache_2(address);
-    RectWithSize rendered_task_rect = RectWithSize(
-        raw_data[0].xy,
-        raw_data[0].zw
-    );
-    ImageBrushExtraData data = ImageBrushExtraData(
-        rendered_task_rect,
-        raw_data[1].xy
-    );
-    return data;
-}
-
 #ifdef WR_FEATURE_ALPHA_PASS
 vec2 transform_point_snapped(
     vec2 local_pos,
@@ -105,7 +87,7 @@ void brush_vs(
         max_uv - vec2(0.5)
     ) / texture_size.xyxy;
 
-    vec2 f;
+    vec2 f = (vi.local_pos - local_rect.p0) / local_rect.size;
 
 #ifdef WR_FEATURE_ALPHA_PASS
     int color_mode = user_data.y >> 16;
@@ -121,41 +103,18 @@ void brush_vs(
     // image.
     switch (raster_space) {
         case RASTER_SCREEN: {
-            ImageBrushExtraData extra_data = fetch_image_extra_data(user_data.z);
-
-            vec2 snapped_device_pos;
-
-            // For drop-shadows, we need to apply a local offset
-            // in order to generate the correct screen-space UV.
-            // For other effects, we can use the 1:1 mapping of
-            // the vertex device position for the UV generation.
-            switch (color_mode) {
-                case COLOR_MODE_ALPHA: {
-                    vec2 local_pos = vi.local_pos - extra_data.offset;
-                    snapped_device_pos = transform_point_snapped(
-                        local_pos,
-                        local_rect,
-                        transform
-                    );
-                    break;
-                }
-                default:
-                    snapped_device_pos = vi.snapped_device_pos;
-                    break;
-            }
-
-            f = (snapped_device_pos - extra_data.rendered_task_rect.p0) / extra_data.rendered_task_rect.size;
-
+            // Since the screen space UVs specify an arbitrary quad, do
+            // a bilinear interpolation to get the correct UV for this
+            // local position.
+            ImageResourceExtra extra_data = fetch_image_resource_extra(user_data.x);
+            vec2 x = mix(extra_data.st_tl, extra_data.st_tr, f.x);
+            vec2 y = mix(extra_data.st_bl, extra_data.st_br, f.x);
+            f = mix(x, y, f.y);
             break;
         }
-        case RASTER_LOCAL:
-        default: {
-            f = (vi.local_pos - local_rect.p0) / local_rect.size;
+        default:
             break;
-        }
     }
-#else
-    f = (vi.local_pos - local_rect.p0) / local_rect.size;
 #endif
 
     // Offset and scale vUv here to avoid doing it in the fragment shader.

webrender/res/resource_cache.glsl

@@ -4,6 +4,8 @@
 
 uniform HIGHP_SAMPLER_FLOAT sampler2D sResourceCache;
 
+#define VECS_PER_IMAGE_RESOURCE     2
+
 // TODO(gw): This is here temporarily while we have
 //           both GPU store and cache. When the GPU
 //           store code is removed, we can change the
@@ -113,4 +115,23 @@ ImageResource fetch_image_resource_direct(ivec2 address) {
     return ImageResource(uv_rect, data[1].x, data[1].yzw);
 }
 
+// Fetch optional extra data for a texture cache resource. This can contain
+// a polygon defining a UV rect within the texture cache resource.
+struct ImageResourceExtra {
+    vec2 st_tl;
+    vec2 st_tr;
+    vec2 st_bl;
+    vec2 st_br;
+};
+
+ImageResourceExtra fetch_image_resource_extra(int address) {
+    vec4 data[2] = fetch_from_resource_cache_2(address + VECS_PER_IMAGE_RESOURCE);
+    return ImageResourceExtra(
+        data[0].xy,
+        data[0].zw,
+        data[1].xy,
+        data[1].zw
+    );
+}
+
 #endif //WR_VERTEX_SHADER

webrender/src/batch.rs

@@ -18,7 +18,6 @@ use gpu_types::{PrimitiveInstance, RasterizationSpace, SimplePrimitiveInstance,
 use gpu_types::ZBufferIdGenerator;
 use internal_types::{FastHashMap, SavedTargetIndex, SourceTexture};
 use picture::{PictureCompositeMode, PicturePrimitive, PictureSurface};
-use picture::{IMAGE_BRUSH_BLOCKS, IMAGE_BRUSH_EXTRA_BLOCKS};
 use plane_split::{BspSplitter, Polygon, Splitter};
 use prim_store::{CachedGradient, ImageSource, PrimitiveIndex, PrimitiveKind, PrimitiveMetadata, PrimitiveStore};
 use prim_store::{BrushPrimitive, BrushKind, DeferredResolve, EdgeAaSegmentMask, PictureIndex, PrimitiveRun};
@@ -700,7 +699,7 @@ impl AlphaBatchBuilder {
                                                         uv_rect_address.as_int(),
                                                         (ShaderColorMode::ColorBitmap as i32) << 16 |
                                                         RasterizationSpace::Screen as i32,
-                                                        picture.extra_gpu_data_handle.as_int(gpu_cache),
+                                                        0,
                                                     ],
                                                 };
                                                 batch.push(PrimitiveInstance::from(instance));
@@ -750,11 +749,7 @@ impl AlphaBatchBuilder {
                                                 .as_int();
 
                                             // Get the GPU cache address of the extra data handle.
-                                            let extra_data_address = gpu_cache.get_address(&picture.extra_gpu_data_handle);
-                                            let shadow_prim_address = extra_data_address
-                                                .offset(IMAGE_BRUSH_EXTRA_BLOCKS);
-                                            let shadow_data_address = extra_data_address
-                                                .offset(IMAGE_BRUSH_EXTRA_BLOCKS + IMAGE_BRUSH_BLOCKS);
+                                            let shadow_prim_address = gpu_cache.get_address(&picture.extra_gpu_data_handle);
 
                                             let shadow_instance = BrushInstance {
                                                 picture_address: task_address,
@@ -770,7 +765,7 @@ impl AlphaBatchBuilder {
                                                     shadow_uv_rect_address,
                                                     (ShaderColorMode::Alpha as i32) << 16 |
                                                     RasterizationSpace::Screen as i32,
-                                                    shadow_data_address.as_int(),
+                                                    0,
                                                 ],
                                             };
 
@@ -780,7 +775,7 @@ impl AlphaBatchBuilder {
                                                     content_uv_rect_address,
                                                     (ShaderColorMode::ColorBitmap as i32) << 16 |
                                                     RasterizationSpace::Screen as i32,
-                                                    extra_data_address.as_int(),
+                                                    0,
                                                 ],
                                                 ..shadow_instance
                                             };
@@ -953,7 +948,7 @@ impl AlphaBatchBuilder {
                                         uv_rect_address,
                                         (ShaderColorMode::ColorBitmap as i32) << 16 |
                                         RasterizationSpace::Screen as i32,
-                                        picture.extra_gpu_data_handle.as_int(gpu_cache),
+                                        0,
                                     ],
                                 };
                                 batch.push(PrimitiveInstance::from(instance));

webrender/src/clip_scroll_node.rs

@@ -101,6 +101,9 @@ pub struct ClipScrollNode {
     /// World transform for content transformed by this node.
     pub world_content_transform: LayoutToWorldFastTransform,
 
+    /// The current transform kind of world_content_transform.
+    pub transform_kind: TransformedRectKind,
+
     /// Pipeline that this layer belongs to
     pub pipeline_id: PipelineId,
 
@@ -142,6 +145,7 @@ impl ClipScrollNode {
             local_viewport_rect: *rect,
             world_viewport_transform: LayoutToWorldFastTransform::identity(),
             world_content_transform: LayoutToWorldFastTransform::identity(),
+            transform_kind: TransformedRectKind::AxisAligned,
             parent: parent_index,
             children: Vec::new(),
             pipeline_id,
@@ -285,15 +289,10 @@ impl ClipScrollNode {
             }
         };
 
-        let transform_kind = if self.world_content_transform.preserves_2d_axis_alignment() {
-            TransformedRectKind::AxisAligned
-        } else {
-            TransformedRectKind::Complex
-        };
         let data = ClipScrollNodeData {
             transform: self.world_content_transform.into(),
             inv_transform,
-            transform_kind: transform_kind as u32 as f32,
+            transform_kind: self.transform_kind as u32 as f32,
             padding: [0.0; 3],
         };
 
@@ -321,6 +320,12 @@ impl ClipScrollNode {
 
         self.update_transform(state, next_coordinate_system_id, scene_properties);
 
+        self.transform_kind = if self.world_content_transform.preserves_2d_axis_alignment() {
+            TransformedRectKind::AxisAligned
+        } else {
+            TransformedRectKind::Complex
+        };
+
         // If this node is a reference frame, we check if it has a non-invertible matrix.
         // For non-reference-frames we assume that they will produce only additional
         // translations which should be invertible.

webrender/src/frame_builder.rs

@@ -10,7 +10,7 @@ use clip_scroll_node::{ClipScrollNode};
 use clip_scroll_tree::{ClipScrollNodeIndex, ClipScrollTree};
 use display_list_flattener::{DisplayListFlattener};
 use gpu_cache::GpuCache;
-use gpu_types::{ClipChainRectIndex, ClipScrollNodeData};
+use gpu_types::{ClipChainRectIndex, ClipScrollNodeData, UvRectKind};
 use hit_test::{HitTester, HitTestingRun};
 use internal_types::{FastHashMap};
 use picture::PictureSurface;
@@ -233,6 +233,7 @@ impl FrameBuilder {
             PrimitiveIndex(0),
             DeviceIntPoint::zero(),
             pic_state.tasks,
+            UvRectKind::Rect,
         );
 
         let render_task_id = frame_state.render_tasks.add(root_render_task);

webrender/src/glyph_rasterizer.rs

@@ -21,6 +21,7 @@ use device::TextureFilter;
 use euclid::{TypedPoint2D, TypedSize2D, TypedVector2D};
 use glyph_cache::{CachedGlyphInfo, GlyphCache, GlyphCacheEntry};
 use gpu_cache::GpuCache;
+use gpu_types::UvRectKind;
 use internal_types::ResourceCacheError;
 #[cfg(feature = "pathfinder")]
 use pathfinder_font_renderer;
@@ -800,6 +801,7 @@ impl GlyphRasterizer {
                             None,
                             gpu_cache,
                             Some(glyph_key_cache.eviction_notice()),
+                            UvRectKind::Rect,
                         );
                         GlyphCacheEntry::Cached(CachedGlyphInfo {
                             texture_cache_handle,

webrender/src/gpu_cache.rs

@@ -151,13 +151,6 @@ impl GpuCacheAddress {
             v: u16::MAX,
         }
     }
-
-    pub fn offset(&self, offset: usize) -> Self {
-        GpuCacheAddress {
-            u: self.u + offset as u16,
-            v: self.v
-        }
-    }
 }
 
 impl Add<usize> for GpuCacheAddress {

webrender/src/gpu_types.rs

@@ -277,15 +277,38 @@ impl ClipScrollNodeData {
 #[repr(C)]
 pub struct ClipChainRectIndex(pub usize);
 
+// Texture cache resources can be either a simple rect, or define
+// a polygon within a rect by specifying a UV coordinate for each
+// corner. This is useful for rendering screen-space rasterized
+// off-screen surfaces.
+#[derive(Debug, Copy, Clone)]
+#[cfg_attr(feature = "capture", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+pub enum UvRectKind {
+    // The 2d bounds of the texture cache entry define the
+    // valid UV space for this texture cache entry.
+    Rect,
+    // The four vertices below define a quad within
+    // the texture cache entry rect. The shader can
+    // use a bilerp() to correctly interpolate a
+    // UV coord in the vertex shader.
+    Quad {
+        top_left: DevicePoint,
+        top_right: DevicePoint,
+        bottom_left: DevicePoint,
+        bottom_right: DevicePoint,
+    },
+}
+
 #[derive(Debug, Copy, Clone)]
 #[cfg_attr(feature = "capture", derive(Serialize))]
 #[cfg_attr(feature = "replay", derive(Deserialize))]
-#[repr(C)]
 pub struct ImageSource {
     pub p0: DevicePoint,
     pub p1: DevicePoint,
     pub texture_layer: f32,
     pub user_data: [f32; 3],
+    pub uv_rect_kind: UvRectKind,
 }
 
 impl ImageSource {
@@ -302,5 +325,22 @@ impl ImageSource {
             self.user_data[1],
             self.user_data[2],
         ]);
+
+        // If this is a polygon uv kind, then upload the four vertices.
+        if let UvRectKind::Quad { top_left, top_right, bottom_left, bottom_right } = self.uv_rect_kind {
+            request.push([
+                top_left.x,
+                top_left.y,
+                top_right.x,
+                top_right.y,
+            ]);
+
+            request.push([
+                bottom_left.x,
+                bottom_left.y,
+                bottom_right.x,
+                bottom_right.y,
+            ]);
+        }
     }
 }