Make all render task data structs contain a common base field.

Some render tasks can have a source task of different kinds. The
most common example is that the source task to a blur task can
be any of (a) a picture (b) an alpha task (c) a downscaling task.

To ensure this works correctly, we separate render task data into
a common base, followed by a small amount of task-specific data.

The blur tasks now only fetch the common task data, which is all
that they require.

This fixes a bug (that I don't think is actually occurring in any
tests), and is also prep work for the next step. Now that everything
is using Picture internally, we can remove the AlphaBatchTask
completely. This will allow us to start converting more primitives
over to use a smaller subset of brush shaders, which will alow us
to start doing the primitive segmentation and also get better
batching results.

webrender/res/brush.glsl

@@ -62,7 +62,8 @@ void main(void) {
 
         // Right now - pictures only support local positions. In the future, this
         // will be expanded to support transform picture types (the common kind).
-        device_pos = pic_task.target_rect.p0 + uDevicePixelRatio * (local_pos - pic_task.content_origin);
+        device_pos = pic_task.common_data.task_rect.p0 +
+                     uDevicePixelRatio * (local_pos - pic_task.content_origin);
 
         // Write the final position transformed by the orthographic device-pixel projection.
         gl_Position = uTransform * vec4(device_pos, 0.0, 1.0);

webrender/res/brush_image.glsl

@@ -31,20 +31,20 @@ void brush_vs(
     //           we can expand this to support items from
     //           the normal texture cache and unify this
     //           with the normal image shader.
-    BlurTask task = fetch_blur_task(user_data.x);
-    vUv.z = task.render_target_layer_index;
+    BlurTask blur_task = fetch_blur_task(user_data.x);
+    vUv.z = blur_task.common_data.render_target_layer_index;
     vImageKind = user_data.y;
 
 #if defined WR_FEATURE_COLOR_TARGET
     vec2 texture_size = vec2(textureSize(sColor0, 0).xy);
 #else
     vec2 texture_size = vec2(textureSize(sColor1, 0).xy);
-    vColor = task.color;
+    vColor = blur_task.color;
 #endif
 
-    vec2 uv0 = task.target_rect.p0;
-    vec2 src_size = task.target_rect.size * task.scale_factor;
-    vec2 uv1 = uv0 + task.target_rect.size;
+    vec2 uv0 = blur_task.common_data.task_rect.p0;
+    vec2 src_size = blur_task.common_data.task_rect.size * blur_task.scale_factor;
+    vec2 uv1 = uv0 + blur_task.common_data.task_rect.size;
 
     // TODO(gw): In the future we'll probably draw these as segments
     //           with the brush shader. When that occurs, we can

webrender/res/clip_shared.glsl

@@ -52,8 +52,8 @@ ClipVertexInfo write_clip_tile_vertex(RectWithSize local_clip_rect,
                                       Layer layer,
                                       ClipArea area,
                                       int segment) {
-    vec2 outer_p0 = area.screen_origin_target_index.xy;
-    vec2 outer_p1 = outer_p0 + area.task_bounds.zw - area.task_bounds.xy;
+    vec2 outer_p0 = area.screen_origin;
+    vec2 outer_p1 = outer_p0 + area.common_data.task_rect.size;
     vec2 inner_p0 = area.inner_rect.xy;
     vec2 inner_p1 = area.inner_rect.zw;
 
@@ -86,7 +86,9 @@ ClipVertexInfo write_clip_tile_vertex(RectWithSize local_clip_rect,
     vec4 layer_pos = get_layer_pos(actual_pos / uDevicePixelRatio, layer);
 
     // compute the point position in side the layer, in CSS space
-    vec2 vertex_pos = actual_pos + area.task_bounds.xy - area.screen_origin_target_index.xy;
+    vec2 vertex_pos = actual_pos +
+                      area.common_data.task_rect.p0 -
+                      area.screen_origin;
 
     gl_Position = uTransform * vec4(vertex_pos, 0.0, 1);
 

webrender/res/cs_blur.glsl

@@ -23,20 +23,20 @@ in int aBlurDirection;
 in vec4 aBlurRegion;
 
 void main(void) {
-    RenderTaskData task = fetch_render_task(aBlurRenderTaskAddress);
-    RenderTaskData src_task = fetch_render_task(aBlurSourceTaskAddress);
+    BlurTask blur_task = fetch_blur_task(aBlurRenderTaskAddress);
+    RenderTaskCommonData src_task = fetch_render_task_common_data(aBlurSourceTaskAddress);
 
-    vec4 src_rect = src_task.data0;
-    vec4 target_rect = task.data0;
+    RectWithSize src_rect = src_task.task_rect;
+    RectWithSize target_rect = blur_task.common_data.task_rect;
 
 #if defined WR_FEATURE_COLOR_TARGET
     vec2 texture_size = vec2(textureSize(sCacheRGBA8, 0).xy);
 #else
     vec2 texture_size = vec2(textureSize(sCacheA8, 0).xy);
 #endif
-    vUv.z = src_task.data1.x;
-    vBlurRadius = int(3.0 * task.data1.y);
-    vSigma = task.data1.y;
+    vUv.z = src_task.render_target_layer_index;
+    vBlurRadius = int(3.0 * blur_task.blur_radius);
+    vSigma = blur_task.blur_radius;
 
     switch (aBlurDirection) {
         case DIR_HORIZONTAL:
@@ -47,20 +47,21 @@ void main(void) {
             break;
     }
 
-    vUvRect = vec4(src_rect.xy + vec2(0.5),
-                   src_rect.xy + src_rect.zw - vec2(0.5));
+    vUvRect = vec4(src_rect.p0 + vec2(0.5),
+                   src_rect.p0 + src_rect.size - vec2(0.5));
     vUvRect /= texture_size.xyxy;
 
     if (aBlurRegion.z > 0.0) {
         vec4 blur_region = aBlurRegion * uDevicePixelRatio;
-        src_rect = vec4(src_rect.xy + blur_region.xy, blur_region.zw);
-        target_rect = vec4(target_rect.xy + blur_region.xy, blur_region.zw);
+        src_rect = RectWithSize(src_rect.p0 + blur_region.xy, blur_region.zw);
+        target_rect.p0 = target_rect.p0 + blur_region.xy;
+        target_rect.size = blur_region.zw;
     }
 
-    vec2 pos = target_rect.xy + target_rect.zw * aPosition.xy;
+    vec2 pos = target_rect.p0 + target_rect.size * aPosition.xy;
 
-    vec2 uv0 = src_rect.xy / texture_size;
-    vec2 uv1 = (src_rect.xy + src_rect.zw) / texture_size;
+    vec2 uv0 = src_rect.p0 / texture_size;
+    vec2 uv1 = (src_rect.p0 + src_rect.size) / texture_size;
     vUv.xy = mix(uv0, uv1, aPosition.xy);
 
     gl_Position = uTransform * vec4(pos, 0.0, 1.0);

webrender/res/cs_clip_border.glsl

@@ -128,8 +128,8 @@ void main(void) {
 
     // Position vertex within the render task area.
     vec2 final_pos = device_pos -
-                     area.screen_origin_target_index.xy +
-                     area.task_bounds.xy;
+                     area.screen_origin +
+                     area.common_data.task_rect.p0;
 
     // Calculate the local space position for this vertex.
     vec4 layer_pos = get_layer_pos(world_pos.xy, layer);

webrender/res/cs_text_run.glsl

@@ -32,7 +32,7 @@ void main(void) {
     // the glyph offset, relative to its primitive bounding rect.
     vec2 size = (res.uv_rect.zw - res.uv_rect.xy) * res.scale;
     vec2 local_pos = glyph.offset + vec2(res.offset.x, -res.offset.y) / uDevicePixelRatio;
-    vec2 origin = prim.task.target_rect.p0 +
+    vec2 origin = prim.task.common_data.task_rect.p0 +
                   uDevicePixelRatio * (local_pos - prim.task.content_origin);
     vec4 local_rect = vec4(origin, size);
 

webrender/res/prim_shared.glsl

@@ -206,22 +206,35 @@ Layer fetch_layer(int clip_node_id, int scroll_node_id) {
     return layer;
 }
 
-struct RenderTaskData {
-    vec4 data0;
-    vec4 data1;
-    vec4 data2;
+struct RenderTaskCommonData {
+    RectWithSize task_rect;
+    float render_target_layer_index;
 };
 
-RenderTaskData fetch_render_task(int index) {
-    RenderTaskData task;
+RenderTaskCommonData fetch_render_task_data(
+    int index,
+    out vec3 data1,
+    out vec4 data2
+) {
+    ivec2 uv = get_fetch_uv(index, VECS_PER_RENDER_TASK);
+
+    vec4 texel0 = TEXEL_FETCH(sRenderTasks, uv, 0, ivec2(0, 0));
+    vec4 texel1 = TEXEL_FETCH(sRenderTasks, uv, 0, ivec2(1, 0));
+    vec4 texel2 = TEXEL_FETCH(sRenderTasks, uv, 0, ivec2(2, 0));
+
+    data1 = texel1.yzw;
+    data2 = texel2;
 
+    return RenderTaskCommonData(RectWithSize(texel0.xy, texel0.zw), texel1.x);
+}
+
+RenderTaskCommonData fetch_render_task_common_data(int index) {
     ivec2 uv = get_fetch_uv(index, VECS_PER_RENDER_TASK);
 
-    task.data0 = TEXEL_FETCH(sRenderTasks, uv, 0, ivec2(0, 0));
-    task.data1 = TEXEL_FETCH(sRenderTasks, uv, 0, ivec2(1, 0));
-    task.data2 = TEXEL_FETCH(sRenderTasks, uv, 0, ivec2(2, 0));
+    vec4 texel0 = TEXEL_FETCH(sRenderTasks, uv, 0, ivec2(0, 0));
+    vec4 texel1 = TEXEL_FETCH(sRenderTasks, uv, 0, ivec2(1, 0));
 
-    return task;
+    return RenderTaskCommonData(RectWithSize(texel0.xy, texel0.zw), texel1.x);
 }
 
 /*
@@ -230,87 +243,90 @@ RenderTaskData fetch_render_task(int index) {
  the transform mode of primitives on this picture, among other things.
  */
 struct PictureTask {
-    RectWithSize target_rect;
-    float render_target_layer_index;
+    RenderTaskCommonData common_data;
     vec2 content_origin;
     vec4 color;
 };
 
 PictureTask fetch_picture_task(int address) {
-    RenderTaskData task_data = fetch_render_task(address);
-
-    RectWithSize target_rect = RectWithSize(
-        task_data.data0.xy,
-        task_data.data0.zw
-    );
+    vec3 data1;
+    vec4 data2;
+    RenderTaskCommonData common_data = fetch_render_task_data(address, data1, data2);
 
     PictureTask task = PictureTask(
-        target_rect,
-        task_data.data1.x,
-        task_data.data1.yz,
-        task_data.data2
+        common_data,
+        data1.xy,
+        data2
     );
 
     return task;
 }
 
 struct BlurTask {
-    RectWithSize target_rect;
-    float render_target_layer_index;
+    RenderTaskCommonData common_data;
     float blur_radius;
     float scale_factor;
     vec4 color;
 };
 
 BlurTask fetch_blur_task(int address) {
-    RenderTaskData task_data = fetch_render_task(address);
+    vec3 data1;
+    vec4 data2;
+
+    RenderTaskCommonData common_data = fetch_render_task_data(
+        address,
+        data1,
+        data2
+    );
 
     return BlurTask(
-        RectWithSize(task_data.data0.xy, task_data.data0.zw),
-        task_data.data1.x,
-        task_data.data1.y,
-        task_data.data1.z,
-        task_data.data2
+        common_data,
+        data1.x,
+        data1.y,
+        data2
     );
 }
 
 struct AlphaBatchTask {
+    RenderTaskCommonData common_data;
     vec2 screen_space_origin;
-    vec2 render_target_origin;
-    vec2 size;
-    float render_target_layer_index;
 };
 
 AlphaBatchTask fetch_alpha_batch_task(int index) {
-    RenderTaskData data = fetch_render_task(index);
+    vec3 data1;
+    vec4 data2;
+    RenderTaskCommonData common_data = fetch_render_task_data(index, data1, data2);
 
-    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;
+    AlphaBatchTask task = AlphaBatchTask(
+        common_data,
+        data1.xy
+    );
 
     return task;
 }
 
 struct ClipArea {
-    vec4 task_bounds;
-    vec4 screen_origin_target_index;
+    RenderTaskCommonData common_data;
+    vec2 screen_origin;
     vec4 inner_rect;
 };
 
 ClipArea fetch_clip_area(int index) {
     ClipArea area;
 
     if (index == 0x7FFFFFFF) { //special sentinel task index
-        area.task_bounds = vec4(0.0, 0.0, 0.0, 0.0);
-        area.screen_origin_target_index = vec4(0.0, 0.0, 0.0, 0.0);
+        area.common_data = RenderTaskCommonData(
+            RectWithSize(vec2(0.0), vec2(0.0)),
+            0.0
+        );
+        area.screen_origin = vec2(0.0);
         area.inner_rect = vec4(0.0);
     } else {
-        RenderTaskData task = fetch_render_task(index);
-        area.task_bounds = task.data0;
-        area.screen_origin_target_index = task.data1;
-        area.inner_rect = task.data2;
+        vec3 data1;
+        vec4 data2;
+        area.common_data = fetch_render_task_data(index, data1, data2);
+        area.screen_origin = data1.xy;
+        area.inner_rect = data2;
     }
 
     return area;
@@ -598,7 +614,7 @@ VertexInfo write_vertex(RectWithSize instance_rect,
     // Apply offsets for the render task to get correct screen location.
     vec2 final_pos = device_pos + snap_offset -
                      task.screen_space_origin +
-                     task.render_target_origin;
+                     task.common_data.task_rect.p0;
 
     gl_Position = uTransform * vec4(final_pos, z, 1.0);
 
@@ -708,7 +724,7 @@ TransformVertexInfo write_transform_vertex(RectWithSize instance_rect,
     // Apply offsets for the render task to get correct screen location.
     vec2 final_pos = device_pos - //Note: `snap_rect` is not used
                      task.screen_space_origin +
-                     task.render_target_origin;
+                     task.common_data.task_rect.p0;
 
 
     gl_Position = uTransform * vec4(final_pos, z, 1.0);
@@ -797,9 +813,14 @@ Image fetch_image(int address) {
 }
 
 void write_clip(vec2 global_pos, ClipArea area) {
-    vec2 uv = global_pos + area.task_bounds.xy - area.screen_origin_target_index.xy;
-    vClipMaskUvBounds = area.task_bounds;
-    vClipMaskUv = vec3(uv, area.screen_origin_target_index.z);
+    vec2 uv = global_pos +
+              area.common_data.task_rect.p0 -
+              area.screen_origin;
+    vClipMaskUvBounds = vec4(
+        area.common_data.task_rect.p0,
+        area.common_data.task_rect.p0 + area.common_data.task_rect.size
+    );
+    vClipMaskUv = vec3(uv, area.common_data.render_target_layer_index);
 }
 #endif //WR_VERTEX_SHADER
 

webrender/res/ps_blend.glsl

@@ -16,20 +16,20 @@ void main(void) {
     AlphaBatchTask dest_task = fetch_alpha_batch_task(ci.render_task_index);
     AlphaBatchTask src_task = fetch_alpha_batch_task(ci.src_task_index);
 
-    vec2 dest_origin = dest_task.render_target_origin -
+    vec2 dest_origin = dest_task.common_data.task_rect.p0 -
                        dest_task.screen_space_origin +
                        src_task.screen_space_origin;
 
     vec2 local_pos = mix(dest_origin,
-                         dest_origin + src_task.size,
+                         dest_origin + src_task.common_data.task_rect.size,
                          aPosition.xy);
 
     vec2 texture_size = vec2(textureSize(sCacheRGBA8, 0));
-    vec2 st0 = src_task.render_target_origin;
-    vec2 st1 = src_task.render_target_origin + src_task.size;
+    vec2 st0 = src_task.common_data.task_rect.p0;
+    vec2 st1 = src_task.common_data.task_rect.p0 + src_task.common_data.task_rect.size;
 
-    vec2 uv = src_task.render_target_origin + aPosition.xy * src_task.size;
-    vUv = vec3(uv / texture_size, src_task.render_target_layer_index);
+    vec2 uv = src_task.common_data.task_rect.p0 + aPosition.xy * src_task.common_data.task_rect.size;
+    vUv = vec3(uv / texture_size, src_task.common_data.render_target_layer_index);
     vUvBounds = vec4(st0 + 0.5, st1 - 0.5) / texture_size.xyxy;
 
     vOp = ci.user_data0;