Auto merge of #502 - kvark:prim_transform, r=glennw

Local rectangle clipping for transformed primitives

Finishes #427 implementation, now the text is cut evenly and not aligned to tile borders.
Also refactored `build_bounding_rect()` as well as a bit of `assign_prims_to_screen_tiles()`.

![textrun-comparison3](https://cloud.githubusercontent.com/assets/107301/19860234/5ce0c85a-9f5e-11e6-82f2-d72f19e4641a.png)

<!-- 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/502)
<!-- Reviewable:end -->

Author: bors-servo

webrender/res/prim_shared.glsl

@@ -439,6 +439,10 @@ vec4 get_layer_pos(vec2 pos, Layer layer) {
     return untransform(pos, n, a, layer.inv_transform);
 }
 
+vec2 clamp_rect(vec2 point, vec4 rect) {
+    return clamp(point, rect.xy, rect.xy + rect.zw);
+}
+
 struct Rect {
     vec2 p0;
     vec2 p1;
@@ -463,9 +467,7 @@ VertexInfo write_vertex(vec4 instance_rect,
     vec2 cp1 = floor(0.5 + (local_clip_rect.xy + local_clip_rect.zw) * uDevicePixelRatio) / uDevicePixelRatio;
     local_pos = clamp(local_pos, cp0, cp1);
 
-    local_pos = clamp(local_pos,
-                      layer.local_clip_rect.xy,
-                      layer.local_clip_rect.xy + layer.local_clip_rect.zw);
+    local_pos = clamp_rect(local_pos, layer.local_clip_rect);
 
     vec4 world_pos = layer.transform * vec4(local_pos, 0, 1);
     world_pos.xyz /= world_pos.w;
@@ -495,15 +497,16 @@ struct TransformVertexInfo {
 };
 
 TransformVertexInfo write_transform_vertex(vec4 instance_rect,
-                                           vec4 local_clip_rect, //unused
+                                           vec4 local_clip_rect,
                                            Layer layer,
                                            Tile tile) {
-    vec2 lp0 = clamp(instance_rect.xy,
-                     layer.local_clip_rect.xy,
-                     layer.local_clip_rect.xy + layer.local_clip_rect.zw);
-    vec2 lp1 = clamp(instance_rect.xy + instance_rect.zw,
-                     layer.local_clip_rect.xy,
-                     layer.local_clip_rect.xy + layer.local_clip_rect.zw);
+    vec2 lp0_base = instance_rect.xy;
+    vec2 lp1_base = instance_rect.xy + instance_rect.zw;
+
+    vec2 lp0 = clamp_rect(clamp_rect(lp0_base, local_clip_rect),
+                          layer.local_clip_rect);
+    vec2 lp1 = clamp_rect(clamp_rect(lp1_base, local_clip_rect),
+                          layer.local_clip_rect);
 
     vec4 clipped_local_rect = vec4(lp0, lp1 - lp0);
 

webrender/src/prim_store.rs

@@ -656,28 +656,20 @@ impl PrimitiveStore {
                                layer_transform: &Matrix4D<f32>,
                                layer_combined_local_clip_rect: &Rect<f32>,
                                device_pixel_ratio: f32) -> bool {
-        let mut bounding_rect = None;
-        let mut visible = false;
         let geom = &self.gpu_geometry.get(GpuStoreAddress(prim_index.0 as i32));
 
-        match geom.local_rect
-                  .intersection(&geom.local_clip_rect)
-                  .and_then(|rect| rect.intersection(layer_combined_local_clip_rect)) {
-            Some(local_rect) => {
-                let xf_rect = TransformedRect::new(&local_rect,
-                                                   layer_transform,
-                                                   device_pixel_ratio);
-                if xf_rect.bounding_rect
-                          .intersects(screen_rect) {
-                    bounding_rect = Some(xf_rect.bounding_rect);
-                    visible = true;
-                }
-            }
-            None => {}
-        };
+        let bounding_rect = geom.local_rect
+                                .intersection(&geom.local_clip_rect)
+                                .and_then(|rect| rect.intersection(layer_combined_local_clip_rect))
+                                .and_then(|ref local_rect| {
+            let xf_rect = TransformedRect::new(local_rect,
+                                               layer_transform,
+                                               device_pixel_ratio);
+            xf_rect.bounding_rect.intersection(screen_rect)
+        });
 
         self.cpu_bounding_rects[prim_index.0] = bounding_rect;
-        visible
+        bounding_rect.is_some()
     }
 
     pub fn prepare_prim_for_render(&mut self,

webrender/src/tiling.rs

@@ -1991,26 +1991,16 @@ impl FrameBuilder {
                             let p_tile_x1 = (p_rect.origin.x + p_rect.size.width + SCREEN_TILE_SIZE - 1) / SCREEN_TILE_SIZE;
                             let p_tile_y1 = (p_rect.origin.y + p_rect.size.height + SCREEN_TILE_SIZE - 1) / SCREEN_TILE_SIZE;
 
-                            let p_tile_x0 = cmp::min(p_tile_x0, tile_range.x1);
-                            let p_tile_x0 = cmp::max(p_tile_x0, tile_range.x0);
-                            let p_tile_x1 = cmp::min(p_tile_x1, tile_range.x1);
-                            let p_tile_x1 = cmp::max(p_tile_x1, tile_range.x0);
-
-                            let p_tile_y0 = cmp::min(p_tile_y0, tile_range.y1);
-                            let p_tile_y0 = cmp::max(p_tile_y0, tile_range.y0);
-                            let p_tile_y1 = cmp::min(p_tile_y1, tile_range.y1);
-                            let p_tile_y1 = cmp::max(p_tile_y1, tile_range.y0);
-
-                            for py in p_tile_y0..p_tile_y1 {
-                                for px in p_tile_x0..p_tile_x1 {
+                            for py in cmp::max(p_tile_y0, tile_range.y0) .. cmp::min(p_tile_y1, tile_range.y1) {
+                                for px in cmp::max(p_tile_x0, tile_range.x0) .. cmp::min(p_tile_x1, tile_range.x1) {
                                     let tile = &mut screen_tiles[(py * x_tile_count + px) as usize];
 
                                     // TODO(gw): Support narrow phase for 3d transform elements!
                                     if xf_rect.kind == TransformedRectKind::Complex ||
-                                       self.prim_store.prim_affects_tile(prim_index,
-                                                                         &tile.rect,
-                                                                         &packed_layer.transform,
-                                                                         self.device_pixel_ratio) {
+                                            self.prim_store.prim_affects_tile(prim_index,
+                                                                              &tile.rect,
+                                                                              &packed_layer.transform,
+                                                                              self.device_pixel_ratio) {
                                         tile.push_primitive(prim_index);
                                     }
                                 }