Remove the tiling code.

webrender/res/prim_shared.glsl

@@ -146,19 +146,23 @@ RenderTaskData fetch_render_task(int index) {
     return task;
 }
 
-struct Tile {
-    vec4 screen_origin_task_origin;
-    vec4 size_target_index;
+struct AlphaBatchTask {
+    vec2 screen_space_origin;
+    vec2 render_target_origin;
+    vec2 size;
+    float render_target_layer_index;
 };
 
-Tile fetch_tile(int index) {
-    RenderTaskData task = fetch_render_task(index);
+AlphaBatchTask fetch_alpha_batch_task(int index) {
+    RenderTaskData data = fetch_render_task(index);
 
-    Tile tile;
-    tile.screen_origin_task_origin = task.data0;
-    tile.size_target_index = task.data1;
+    AlphaBatchTask task;
+    task.render_target_origin = data.data0.xy;
+    task.size = data.data0.zw;
+    task.screen_space_origin = data.data1.xy;
+    task.render_target_layer_index = data.data1.z;
 
-    return tile;
+    return task;
 }
 
 struct ClipArea {
@@ -320,8 +324,8 @@ CachePrimitiveInstance fetch_cache_instance() {
 
 struct Primitive {
     Layer layer;
-    Tile tile;
     ClipArea clip_area;
+    AlphaBatchTask task;
     vec4 local_rect;
     vec4 local_clip_rect;
     int prim_index;
@@ -336,8 +340,8 @@ Primitive load_primitive_custom(PrimitiveInstance pi) {
     Primitive prim;
 
     prim.layer = fetch_layer(pi.layer_index);
-    prim.tile = fetch_tile(pi.render_task_index);
     prim.clip_area = fetch_clip_area(pi.clip_task_index);
+    prim.task = fetch_alpha_batch_task(pi.render_task_index);
 
     PrimitiveGeometry pg = fetch_prim_geometry(pi.global_prim_index);
     prim.local_rect = pg.local_rect;
@@ -413,15 +417,15 @@ struct Rect {
 
 struct VertexInfo {
     Rect local_rect;
-    vec2 local_clamped_pos;
-    vec2 global_clamped_pos;
+    vec2 local_pos;
+    vec2 screen_pos;
 };
 
 VertexInfo write_vertex(vec4 instance_rect,
                         vec4 local_clip_rect,
                         float z,
                         Layer layer,
-                        Tile tile) {
+                        AlphaBatchTask task) {
     vec2 p0 = floor(0.5 + instance_rect.xy * uDevicePixelRatio) / uDevicePixelRatio;
     vec2 p1 = floor(0.5 + (instance_rect.xy + instance_rect.zw) * uDevicePixelRatio) / uDevicePixelRatio;
 
@@ -438,34 +442,27 @@ VertexInfo write_vertex(vec4 instance_rect,
 
     vec2 device_pos = world_pos.xy * uDevicePixelRatio;
 
-    vec2 clamped_pos = clamp(device_pos,
-                             tile.screen_origin_task_origin.xy,
-                             tile.screen_origin_task_origin.xy + tile.size_target_index.xy);
-
-    vec4 local_clamped_pos = layer.inv_transform * vec4(clamped_pos / uDevicePixelRatio, world_pos.z, 1);
-    local_clamped_pos.xyz /= local_clamped_pos.w;
-
-    vec2 final_pos = clamped_pos + tile.screen_origin_task_origin.zw - tile.screen_origin_task_origin.xy;
+    vec2 final_pos = device_pos - task.screen_space_origin + task.render_target_origin;
 
     gl_Position = uTransform * vec4(final_pos, z, 1.0);
 
-    VertexInfo vi = VertexInfo(Rect(p0, p1), local_clamped_pos.xy, clamped_pos.xy);
+    VertexInfo vi = VertexInfo(Rect(p0, p1), local_pos.xy, device_pos.xy);
     return vi;
 }
 
 #ifdef WR_FEATURE_TRANSFORM
 
 struct TransformVertexInfo {
     vec3 local_pos;
-    vec2 global_clamped_pos;
+    vec2 screen_pos;
     vec4 clipped_local_rect;
 };
 
 TransformVertexInfo write_transform_vertex(vec4 instance_rect,
                                            vec4 local_clip_rect,
                                            float z,
                                            Layer layer,
-                                           Tile tile) {
+                                           AlphaBatchTask task) {
     vec2 lp0_base = instance_rect.xy;
     vec2 lp1_base = instance_rect.xy + instance_rect.zw;
 
@@ -492,32 +489,21 @@ TransformVertexInfo write_transform_vertex(vec4 instance_rect,
     vec2 tp3 = t3.xy / t3.w;
 
     // compute a CSS space aligned bounding box
-    vec2 min_pos = min(min(tp0.xy, tp1.xy), min(tp2.xy, tp3.xy));
-    vec2 max_pos = max(max(tp0.xy, tp1.xy), max(tp2.xy, tp3.xy));
-
-    // clamp to the tile boundaries, in device space
-    vec2 min_pos_clamped = clamp(min_pos * uDevicePixelRatio,
-                                 tile.screen_origin_task_origin.xy,
-                                 tile.screen_origin_task_origin.xy + tile.size_target_index.xy);
-
-    vec2 max_pos_clamped = clamp(max_pos * uDevicePixelRatio,
-                                 tile.screen_origin_task_origin.xy,
-                                 tile.screen_origin_task_origin.xy + tile.size_target_index.xy);
+    vec2 min_pos = uDevicePixelRatio * min(min(tp0.xy, tp1.xy), min(tp2.xy, tp3.xy));
+    vec2 max_pos = uDevicePixelRatio * max(max(tp0.xy, tp1.xy), max(tp2.xy, tp3.xy));
 
     // compute the device space position of this vertex
-    vec2 clamped_pos = mix(min_pos_clamped,
-                           max_pos_clamped,
-                           aPosition.xy);
+    vec2 device_pos = mix(min_pos, max_pos, aPosition.xy);
 
     // compute the point position in side the layer, in CSS space
-    vec4 layer_pos = get_layer_pos(clamped_pos / uDevicePixelRatio, layer);
+    vec4 layer_pos = get_layer_pos(device_pos / uDevicePixelRatio, layer);
 
     // apply the task offset
-    vec2 final_pos = clamped_pos + tile.screen_origin_task_origin.zw - tile.screen_origin_task_origin.xy;
+    vec2 final_pos = device_pos - task.screen_space_origin + task.render_target_origin;
 
     gl_Position = uTransform * vec4(final_pos, z, 1.0);
 
-    return TransformVertexInfo(layer_pos.xyw, clamped_pos, clipped_local_rect);
+    return TransformVertexInfo(layer_pos.xyw, device_pos, clipped_local_rect);
 }
 
 #endif //WR_FEATURE_TRANSFORM

webrender/res/ps_angle_gradient.vs.glsl

@@ -11,10 +11,10 @@ void main(void) {
                                  prim.local_clip_rect,
                                  prim.z,
                                  prim.layer,
-                                 prim.tile);
+                                 prim.task);
 
     vStopCount = int(prim.user_data.x);
-    vPos = vi.local_clamped_pos;
+    vPos = vi.local_pos;
 
     // Snap the start/end points to device pixel units.
     // I'm not sure this is entirely correct, but the

webrender/res/ps_blend.vs.glsl

@@ -3,44 +3,26 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-struct Blend {
-    ivec4 src_id_target_id_op_amount;
-    int z;
-};
-
-Blend fetch_blend() {
-    PrimitiveInstance pi = fetch_prim_instance();
-
-    Blend blend;
-    blend.src_id_target_id_op_amount = ivec4(pi.user_data.x,
-                                             pi.render_task_index,
-                                             pi.sub_index,
-                                             pi.user_data.y);
-    blend.z = pi.z;
-
-    return blend;
-}
-
 void main(void) {
-    Blend blend = fetch_blend();
-    Tile src = fetch_tile(blend.src_id_target_id_op_amount.x);
-    Tile dest = fetch_tile(blend.src_id_target_id_op_amount.y);
+    PrimitiveInstance pi = fetch_prim_instance();
+    AlphaBatchTask dest_task = fetch_alpha_batch_task(pi.render_task_index);
+    AlphaBatchTask src_task = fetch_alpha_batch_task(pi.user_data.x);
 
-    vec2 dest_origin = dest.screen_origin_task_origin.zw -
-                       dest.screen_origin_task_origin.xy +
-                       src.screen_origin_task_origin.xy;
+    vec2 dest_origin = dest_task.render_target_origin -
+                       dest_task.screen_space_origin +
+                       src_task.screen_space_origin;
 
     vec2 local_pos = mix(dest_origin,
-                         dest_origin + src.size_target_index.xy,
+                         dest_origin + src_task.size,
                          aPosition.xy);
 
     vec2 texture_size = vec2(textureSize(sCache, 0));
-    vec2 st0 = src.screen_origin_task_origin.zw / texture_size;
-    vec2 st1 = (src.screen_origin_task_origin.zw + src.size_target_index.xy) / texture_size;
-    vUv = vec3(mix(st0, st1, aPosition.xy), src.size_target_index.z);
+    vec2 st0 = src_task.render_target_origin / texture_size;
+    vec2 st1 = (src_task.render_target_origin + src_task.size) / texture_size;
+    vUv = vec3(mix(st0, st1, aPosition.xy), src_task.render_target_layer_index);
 
-    vOp = blend.src_id_target_id_op_amount.z;
-    vAmount = float(blend.src_id_target_id_op_amount.w) / 65535.0;
+    vOp = pi.sub_index;
+    vAmount = float(pi.user_data.y) / 65535.0;
 
-    gl_Position = uTransform * vec4(local_pos, blend.z, 1.0);
+    gl_Position = uTransform * vec4(local_pos, pi.z, 1.0);
 }

webrender/res/ps_border.vs.glsl

@@ -138,7 +138,7 @@ void main(void) {
                                                     prim.local_clip_rect,
                                                     prim.z,
                                                     prim.layer,
-                                                    prim.tile);
+                                                    prim.task);
     vLocalPos = vi.local_pos;
 
     // Local space
@@ -148,8 +148,8 @@ void main(void) {
                                  prim.local_clip_rect,
                                  prim.z,
                                  prim.layer,
-                                 prim.tile);
-    vLocalPos = vi.local_clamped_pos.xy;
+                                 prim.task);
+    vLocalPos = vi.local_pos.xy;
 
     // Local space
     vLocalRect = prim.local_rect;
@@ -217,10 +217,10 @@ void main(void) {
 #ifdef WR_FEATURE_TRANSFORM
     vPieceRectHypotenuseLength = sqrt(pow(width, 2.0) + pow(height, 2.0));
 #else
-    vDistanceFromMixLine = (vi.local_clamped_pos.x - x0) * height -
-                           (vi.local_clamped_pos.y - y0) * width;
-    vDistanceFromMiddle = (vi.local_clamped_pos.x - vLocalRect.x) +
-                          (vi.local_clamped_pos.y - vLocalRect.y) -
+    vDistanceFromMixLine = (vi.local_pos.x - x0) * height -
+                           (vi.local_pos.y - y0) * width;
+    vDistanceFromMiddle = (vi.local_pos.x - vLocalRect.x) +
+                          (vi.local_pos.y - vLocalRect.y) -
                           0.5 * (vLocalRect.z + vLocalRect.w);
 #endif
 }

webrender/res/ps_box_shadow.vs.glsl

@@ -12,7 +12,7 @@ void main(void) {
                                  prim.local_clip_rect,
                                  prim.z,
                                  prim.layer,
-                                 prim.tile);
+                                 prim.task);
 
     RenderTaskData child_task = fetch_render_task(prim.user_data.x);
     vUv.z = child_task.data1.x;
@@ -22,7 +22,7 @@ void main(void) {
     vec2 patch_size_device_pixels = child_task.data0.zw - vec2(2.0);
     vec2 patch_size = patch_size_device_pixels / uDevicePixelRatio;
 
-    vUv.xy = (vi.local_clamped_pos - prim.local_rect.xy) / patch_size;
+    vUv.xy = (vi.local_pos - prim.local_rect.xy) / patch_size;
     vMirrorPoint = 0.5 * prim.local_rect.zw / patch_size;
 
     vec2 texture_size = vec2(textureSize(sCache, 0));

webrender/res/ps_cache_image.vs.glsl

@@ -13,7 +13,7 @@ void main(void) {
                                  prim.local_clip_rect,
                                  prim.z,
                                  prim.layer,
-                                 prim.tile);
+                                 prim.task);
 
     RenderTaskData child_task = fetch_render_task(prim.user_data.x);
     vUv.z = child_task.data1.x;
@@ -22,7 +22,7 @@ void main(void) {
     vec2 uv0 = child_task.data0.xy / texture_size;
     vec2 uv1 = (child_task.data0.xy + child_task.data0.zw) / texture_size;
 
-    vec2 f = (vi.local_clamped_pos - prim.local_rect.xy) / prim.local_rect.zw;
+    vec2 f = (vi.local_pos - prim.local_rect.xy) / prim.local_rect.zw;
 
     vUv.xy = mix(uv0, uv1, f);
 }

webrender/res/ps_composite.fs.glsl

@@ -153,15 +153,6 @@ vec3 Luminosity(vec3 Cb, vec3 Cs) {
 
 void main(void) {
     vec4 Cb = texture(sCache, vUv0);
-
-    if (vUv1.x < vUv1Rect.x ||
-        vUv1.x > vUv1Rect.z ||
-        vUv1.y < vUv1Rect.y ||
-        vUv1.y > vUv1Rect.w) {
-        oFragColor = Cb;
-        return;
-    }
-
     vec4 Cs = texture(sCache, vUv1);
 
     // Return yellow if none of the branches match (shouldn't happen).

webrender/res/ps_composite.glsl

@@ -4,5 +4,4 @@
 
 varying vec3 vUv0;
 varying vec3 vUv1;
-flat varying vec4 vUv1Rect;
 flat varying int vOp;

webrender/res/ps_composite.vs.glsl

@@ -3,48 +3,32 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-struct Composite {
-    ivec4 src0_src1_target_id_op;
-    int z;
-};
-
-Composite fetch_composite() {
+void main(void) {
     PrimitiveInstance pi = fetch_prim_instance();
+    AlphaBatchTask dest_task = fetch_alpha_batch_task(pi.render_task_index);
+    AlphaBatchTask backdrop_task = fetch_alpha_batch_task(pi.user_data.x);
+    AlphaBatchTask src_task = fetch_alpha_batch_task(pi.user_data.y);
 
-    Composite composite;
-    composite.src0_src1_target_id_op = ivec4(pi.user_data.xy,
-                                             pi.render_task_index,
-                                             pi.sub_index);
-    composite.z = pi.z;
-
-    return composite;
-}
-
-void main(void) {
-    Composite composite = fetch_composite();
-    Tile src0 = fetch_tile(composite.src0_src1_target_id_op.x);
-    Tile src1 = fetch_tile(composite.src0_src1_target_id_op.y);
-    Tile dest = fetch_tile(composite.src0_src1_target_id_op.z);
+    vec2 dest_origin = dest_task.render_target_origin -
+                       dest_task.screen_space_origin +
+                       src_task.screen_space_origin;
 
-    vec2 local_pos = mix(dest.screen_origin_task_origin.zw,
-                         dest.screen_origin_task_origin.zw + dest.size_target_index.xy,
+    vec2 local_pos = mix(dest_origin,
+                         dest_origin + src_task.size,
                          aPosition.xy);
 
     vec2 texture_size = vec2(textureSize(sCache, 0));
-    vec2 st0 = src0.screen_origin_task_origin.zw / texture_size;
-    vec2 st1 = (src0.screen_origin_task_origin.zw + src0.size_target_index.xy) / texture_size;
-    vUv0 = vec3(mix(st0, st1, aPosition.xy), src0.size_target_index.z);
-
-    st0 = vec2(src1.screen_origin_task_origin.zw) / texture_size;
-    st1 = vec2(src1.screen_origin_task_origin.zw + src1.size_target_index.xy) / texture_size;
-    vec2 local_virtual_pos = mix(dest.screen_origin_task_origin.xy,
-                                 dest.screen_origin_task_origin.xy + dest.size_target_index.xy,
-                                 aPosition.xy);
-    vec2 f = (local_virtual_pos - src1.screen_origin_task_origin.xy) / src1.size_target_index.xy;
-    vUv1 = vec3(mix(st0, st1, f), src1.size_target_index.z);
-    vUv1Rect = vec4(st0, st1);
-
-    vOp = composite.src0_src1_target_id_op.w;
-
-    gl_Position = uTransform * vec4(local_pos, composite.z, 1.0);
+
+    vec2 st0 = (backdrop_task.render_target_origin + vec2(0.0, backdrop_task.size.y)) / texture_size;
+    vec2 st1 = (backdrop_task.render_target_origin + vec2(backdrop_task.size.x, 0.0)) / texture_size;
+    vUv0 = vec3(mix(st0, st1, aPosition.xy), backdrop_task.render_target_layer_index);
+
+    st0 = src_task.render_target_origin / texture_size;
+    st1 = (src_task.render_target_origin + src_task.size) / texture_size;
+    vUv1 = vec3(mix(st0, st1, aPosition.xy), src_task.render_target_layer_index);
+
+    vOp = pi.sub_index;
+
+    gl_Position = uTransform * vec4(local_pos, pi.z, 1.0);
+
 }