Update WR - includes a number of optimizations, bsd build fixes, tidy ups.

components/servo/Cargo.lock

@@ -2661,7 +2661,7 @@ dependencies = [
 [[package]]
 name = "webrender"
 version = "0.7.0"
-source = "git+https://github.com/servo/webrender#a3adb113f95b682ae3176c4000bdcaad1e7cb940"
+source = "git+https://github.com/servo/webrender#860da4ff8b7dcb079ae85d4369d2412300e61599"
 dependencies = [
  "app_units 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "bincode 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -2686,7 +2686,7 @@ dependencies = [
 [[package]]
 name = "webrender_traits"
 version = "0.7.0"
-source = "git+https://github.com/servo/webrender#a3adb113f95b682ae3176c4000bdcaad1e7cb940"
+source = "git+https://github.com/servo/webrender#860da4ff8b7dcb079ae85d4369d2412300e61599"
 dependencies = [
  "app_units 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "byteorder 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)",

ports/cef/Cargo.lock

@@ -2519,7 +2519,7 @@ dependencies = [
 [[package]]
 name = "webrender"
 version = "0.7.0"
-source = "git+https://github.com/servo/webrender#a3adb113f95b682ae3176c4000bdcaad1e7cb940"
+source = "git+https://github.com/servo/webrender#860da4ff8b7dcb079ae85d4369d2412300e61599"
 dependencies = [
  "app_units 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "bincode 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -2544,7 +2544,7 @@ dependencies = [
 [[package]]
 name = "webrender_traits"
 version = "0.7.0"
-source = "git+https://github.com/servo/webrender#a3adb113f95b682ae3176c4000bdcaad1e7cb940"
+source = "git+https://github.com/servo/webrender#860da4ff8b7dcb079ae85d4369d2412300e61599"
 dependencies = [
  "app_units 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "byteorder 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)",

resources/shaders/prim_shared.glsl

@@ -120,8 +120,8 @@ Layer fetch_layer(int index) {
 }
 
 struct Tile {
-    vec4 actual_rect;
+    vec4 screen_origin_task_origin;
-    vec4 target_rect;
+    vec4 size;
 };
 
 Tile fetch_tile(int index) {
@@ -129,8 +129,8 @@ Tile fetch_tile(int index) {
 
     ivec2 uv = get_fetch_uv(index, VECS_PER_TILE);
 
-    tile.actual_rect = texelFetchOffset(sRenderTasks, uv, 0, ivec2(0, 0));
+    tile.screen_origin_task_origin = texelFetchOffset(sRenderTasks, uv, 0, ivec2(0, 0));
-    tile.target_rect = texelFetchOffset(sRenderTasks, uv, 0, ivec2(1, 0));
+    tile.size = texelFetchOffset(sRenderTasks, uv, 0, ivec2(1, 0));
 
     return tile;
 }
@@ -406,13 +406,13 @@ VertexInfo write_vertex(vec4 instance_rect,
     vec2 device_pos = world_pos.xy * uDevicePixelRatio;
 
     vec2 clamped_pos = clamp(device_pos,
-                             vec2(tile.actual_rect.xy),
+                             vec2(tile.screen_origin_task_origin.xy),
-                             vec2(tile.actual_rect.xy + tile.actual_rect.zw));
+                             vec2(tile.screen_origin_task_origin.xy + tile.size.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 + vec2(tile.target_rect.xy) - vec2(tile.actual_rect.xy);
+    vec2 final_pos = clamped_pos + vec2(tile.screen_origin_task_origin.zw) - vec2(tile.screen_origin_task_origin.xy);
 
     gl_Position = uTransform * vec4(final_pos, 0, 1);
 
@@ -460,12 +460,12 @@ TransformVertexInfo write_transform_vertex(vec4 instance_rect,
     vec2 max_pos = max(tp0.xy, max(tp1.xy, max(tp2.xy, tp3.xy)));
 
     vec2 min_pos_clamped = clamp(min_pos * uDevicePixelRatio,
-                                 vec2(tile.actual_rect.xy),
+                                 vec2(tile.screen_origin_task_origin.xy),
-                                 vec2(tile.actual_rect.xy + tile.actual_rect.zw));
+                                 vec2(tile.screen_origin_task_origin.xy + tile.size.xy));
 
     vec2 max_pos_clamped = clamp(max_pos * uDevicePixelRatio,
-                                 vec2(tile.actual_rect.xy),
+                                 vec2(tile.screen_origin_task_origin.xy),
-                                 vec2(tile.actual_rect.xy + tile.actual_rect.zw));
+                                 vec2(tile.screen_origin_task_origin.xy + tile.size.xy));
 
     vec2 clamped_pos = mix(min_pos_clamped,
                            max_pos_clamped,
@@ -473,7 +473,7 @@ TransformVertexInfo write_transform_vertex(vec4 instance_rect,
 
     vec3 layer_pos = get_layer_pos(clamped_pos / uDevicePixelRatio, layer);
 
-    vec2 final_pos = clamped_pos + vec2(tile.target_rect.xy) - vec2(tile.actual_rect.xy);
+    vec2 final_pos = clamped_pos + vec2(tile.screen_origin_task_origin.zw) - vec2(tile.screen_origin_task_origin.xy);
 
     gl_Position = uTransform * vec4(final_pos, 0, 1);
 
@@ -550,30 +550,28 @@ BoxShadow fetch_boxshadow(int index) {
 }
 
 struct Blend {
-    ivec4 src_id_target_id_opacity;
+    ivec4 src_id_target_id_op_amount;
 };
 
 Blend fetch_blend(int index) {
     Blend blend;
 
     int offset = index * 1;
-    blend.src_id_target_id_opacity = int_data[offset + 0];
+    blend.src_id_target_id_op_amount = int_data[offset + 0];
 
     return blend;
 }
 
 struct Composite {
-    ivec4 src0_src1_target_id;
+    ivec4 src0_src1_target_id_op;
-    ivec4 info_amount;
 };
 
 Composite fetch_composite(int index) {
     Composite composite;
 
-    int offset = index * 2;
+    int offset = index * 1;
 
-    composite.src0_src1_target_id = int_data[offset + 0];
+    composite.src0_src1_target_id_op = int_data[offset + 0];
-    composite.info_amount = int_data[offset + 1];
 
     return composite;
 }

resources/shaders/ps_blend.fs.glsl

@@ -4,7 +4,137 @@
 
 uniform sampler2D sCache;
 
-void main(void) {
+vec3 rgbToHsv(vec3 c) {
-    vec4 color = texture(sCache, vUv);
+    float value = max(max(c.r, c.g), c.b);
-    oFragColor = vec4(color.rgb * vBrightnessOpacity.x, color.a * vBrightnessOpacity.y);
+
+    float chroma = value - min(min(c.r, c.g), c.b);
+    if (chroma == 0.0) {
+        return vec3(0.0);
+    }
+    float saturation = chroma / value;
+
+    float hue;
+    if (c.r == value)
+        hue = (c.g - c.b) / chroma;
+    else if (c.g == value)
+        hue = 2.0 + (c.b - c.r) / chroma;
+    else // if (c.b == value)
+        hue = 4.0 + (c.r - c.g) / chroma;
+
+    hue *= 1.0/6.0;
+    if (hue < 0.0)
+        hue += 1.0;
+    return vec3(hue, saturation, value);
+}
+
+vec3 hsvToRgb(vec3 c) {
+    if (c.s == 0.0) {
+        return vec3(c.z);
+    }
+
+    float hue = c.x * 6.0;
+    int sector = int(hue);
+    float residualHue = hue - float(sector);
+
+    vec3 pqt = c.z * vec3(1.0 - c.y, 1.0 - c.y * residualHue, 1.0 - c.y * (1.0 - residualHue));
+    switch (sector) {
+        case 0:
+            return vec3(c.z, pqt.z, pqt.x);
+        case 1:
+            return vec3(pqt.y, c.z, pqt.x);
+        case 2:
+            return vec3(pqt.x, c.z, pqt.z);
+        case 3:
+            return vec3(pqt.x, pqt.y, c.z);
+        case 4:
+            return vec3(pqt.z, pqt.x, c.z);
+        default:
+            return vec3(c.z, pqt.x, pqt.y);
+    }
+}
+
+vec4 Blur(float radius, vec2 direction) {
+    // TODO(gw): Support blur in WR2!
+    return vec4(1.0);
+}
+
+vec4 Contrast(vec4 Cs, float amount) {
+    return vec4(Cs.rgb * amount - 0.5 * amount + 0.5, 1.0);
+}
+
+vec4 Grayscale(vec4 Cs, float amount) {
+    float ia = 1.0 - amount;
+    return mat4(vec4(0.2126 + 0.7874 * ia, 0.2126 - 0.2126 * ia, 0.2126 - 0.2126 * ia, 0.0),
+                vec4(0.7152 - 0.7152 * ia, 0.7152 + 0.2848 * ia, 0.7152 - 0.7152 * ia, 0.0),
+                vec4(0.0722 - 0.0722 * ia, 0.0722 - 0.0722 * ia, 0.0722 + 0.9278 * ia, 0.0),
+                vec4(0.0, 0.0, 0.0, 1.0)) * Cs;
+}
+
+vec4 HueRotate(vec4 Cs, float amount) {
+    vec3 CsHsv = rgbToHsv(Cs.rgb);
+    CsHsv.x = mod(CsHsv.x + amount / 6.283185307179586, 1.0);
+    return vec4(hsvToRgb(CsHsv), Cs.a);
+}
+
+vec4 Invert(vec4 Cs, float amount) {
+    return mix(Cs, vec4(1.0, 1.0, 1.0, Cs.a) - vec4(Cs.rgb, 0.0), amount);
+}
+
+vec4 Saturate(vec4 Cs, float amount) {
+    return vec4(hsvToRgb(min(vec3(1.0, amount, 1.0) * rgbToHsv(Cs.rgb), vec3(1.0))), Cs.a);
+}
+
+vec4 Sepia(vec4 Cs, float amount) {
+    float ia = 1.0 - amount;
+    return mat4(vec4(0.393 + 0.607 * ia, 0.349 - 0.349 * ia, 0.272 - 0.272 * ia, 0.0),
+                vec4(0.769 - 0.769 * ia, 0.686 + 0.314 * ia, 0.534 - 0.534 * ia, 0.0),
+                vec4(0.189 - 0.189 * ia, 0.168 - 0.168 * ia, 0.131 + 0.869 * ia, 0.0),
+                vec4(0.0, 0.0, 0.0, 1.0)) * Cs;
+}
+
+vec4 Brightness(vec4 Cs, float amount) {
+    return vec4(Cs.rgb * amount, Cs.a);
+}
+
+vec4 Opacity(vec4 Cs, float amount) {
+    return vec4(Cs.rgb, Cs.a * amount);
+}
+
+void main(void) {
+    vec4 Cs = texture(sCache, vUv);
+
+    if (Cs.a == 0.0) {
+        discard;
+    }
+
+    switch (vOp) {
+        case 0:
+            // Gaussian blur is specially handled:
+            oFragColor = Cs;// Blur(vAmount, vec2(0,0));
+            break;
+        case 1:
+            oFragColor = Contrast(Cs, vAmount);
+            break;
+        case 2:
+            oFragColor = Grayscale(Cs, vAmount);
+            break;
+        case 3:
+            oFragColor = HueRotate(Cs, vAmount);
+            break;
+        case 4:
+            oFragColor = Invert(Cs, vAmount);
+            break;
+        case 5:
+            oFragColor = Saturate(Cs, vAmount);
+            break;
+        case 6:
+            oFragColor = Sepia(Cs, vAmount);
+            break;
+        case 7:
+            oFragColor = Brightness(Cs, vAmount);
+            break;
+        case 8:
+            oFragColor = Opacity(Cs, vAmount);
+            break;
+    }
 }

resources/shaders/ps_blend.glsl

@@ -3,4 +3,5 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 varying vec2 vUv;
-varying vec2 vBrightnessOpacity;
+flat varying float vAmount;
+flat varying int vOp;

resources/shaders/ps_blend.vs.glsl

@@ -5,17 +5,23 @@
 
 void main(void) {
     Blend blend = fetch_blend(gl_InstanceID);
-    Tile src = fetch_tile(blend.src_id_target_id_opacity.x);
+    Tile src = fetch_tile(blend.src_id_target_id_op_amount.x);
-    Tile dest = fetch_tile(blend.src_id_target_id_opacity.y);
+    Tile dest = fetch_tile(blend.src_id_target_id_op_amount.y);
 
-    vec2 local_pos = mix(vec2(dest.target_rect.xy),
+    vec2 dest_origin = dest.screen_origin_task_origin.zw -
-                         vec2(dest.target_rect.xy + dest.target_rect.zw),
+                       dest.screen_origin_task_origin.xy +
+                       src.screen_origin_task_origin.xy;
+
+    vec2 local_pos = mix(dest_origin,
+                         dest_origin + src.size.xy,
                          aPosition.xy);
 
-    vec2 st0 = vec2(src.target_rect.xy) / 2048.0;
+    vec2 st0 = vec2(src.screen_origin_task_origin.zw) / 2048.0;
-    vec2 st1 = vec2(src.target_rect.xy + src.target_rect.zw) / 2048.0;
+    vec2 st1 = vec2(src.screen_origin_task_origin.zw + src.size.xy) / 2048.0;
     vUv = mix(st0, st1, aPosition.xy);
-    vBrightnessOpacity = blend.src_id_target_id_opacity.zw / 65535.0;
+
+    vOp = blend.src_id_target_id_op_amount.z;
+    vAmount = blend.src_id_target_id_op_amount.w / 65535.0;
 
     gl_Position = uTransform * vec4(local_pos, 0, 1);
 }

resources/shaders/ps_composite.fs.glsl

@@ -4,102 +4,14 @@
  * 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/. */
 
-#define COMPOSITE_KIND_MIX_BLEND_MODE   0
-#define COMPOSITE_KIND_FILTER           1
-
 uniform sampler2D sCache;
 
-vec3 rgbToHsv(vec3 c) {
-    float value = max(max(c.r, c.g), c.b);
-
-    float chroma = value - min(min(c.r, c.g), c.b);
-    if (chroma == 0.0) {
-        return vec3(0.0);
-    }
-    float saturation = chroma / value;
-
-    float hue;
-    if (c.r == value)
-        hue = (c.g - c.b) / chroma;
-    else if (c.g == value)
-        hue = 2.0 + (c.b - c.r) / chroma;
-    else // if (c.b == value)
-        hue = 4.0 + (c.r - c.g) / chroma;
-
-    hue *= 1.0/6.0;
-    if (hue < 0.0)
-        hue += 1.0;
-    return vec3(hue, saturation, value);
-}
-
-vec3 hsvToRgb(vec3 c) {
-    if (c.s == 0.0) {
-        return vec3(c.z);
-    }
-
-    float hue = c.x * 6.0;
-    int sector = int(hue);
-    float residualHue = hue - float(sector);
-
-    vec3 pqt = c.z * vec3(1.0 - c.y, 1.0 - c.y * residualHue, 1.0 - c.y * (1.0 - residualHue));
-    if (sector == 0)
-        return vec3(c.z, pqt.z, pqt.x);
-    if (sector == 1)
-        return vec3(pqt.y, c.z, pqt.x);
-    if (sector == 2)
-        return vec3(pqt.x, c.z, pqt.z);
-    if (sector == 3)
-        return vec3(pqt.x, pqt.y, c.z);
-    if (sector == 4)
-        return vec3(pqt.z, pqt.x, c.z);
-    return vec3(c.z, pqt.x, pqt.y);
-}
-
 float gauss(float x, float sigma) {
     if (sigma == 0.0)
         return 1.0;
     return (1.0 / sqrt(6.283185307179586 * sigma * sigma)) * exp(-(x * x) / (2.0 * sigma * sigma));
 }
 
-vec4 Blur(float radius, vec2 direction) {
-    // TODO(gw): Support blur in WR2!
-    return vec4(1, 1, 1, 1);
-}
-
-vec4 Contrast(vec4 Cs, float amount) {
-    return vec4(Cs.rgb * amount - 0.5 * amount + 0.5, 1.0);
-}
-
-vec4 Grayscale(vec4 Cs, float amount) {
-    float ia = 1.0 - amount;
-    return mat4(vec4(0.2126 + 0.7874 * ia, 0.2126 - 0.2126 * ia, 0.2126 - 0.2126 * ia, 0.0),
-                vec4(0.7152 - 0.7152 * ia, 0.7152 + 0.2848 * ia, 0.7152 - 0.7152 * ia, 0.0),
-                vec4(0.0722 - 0.0722 * ia, 0.0722 - 0.0722 * ia, 0.0722 + 0.9278 * ia, 0.0),
-                vec4(0.0, 0.0, 0.0, 1.0)) * Cs;
-}
-
-vec4 HueRotate(vec4 Cs, float amount) {
-    vec3 CsHsv = rgbToHsv(Cs.rgb);
-    CsHsv.x = mod(CsHsv.x + amount / 6.283185307179586, 1.0);
-    return vec4(hsvToRgb(CsHsv), Cs.a);
-}
-
-vec4 Invert(vec4 Cs, float amount) {
-    return mix(Cs, vec4(1.0, 1.0, 1.0, Cs.a) - vec4(Cs.rgb, 0.0), amount);
-}
-
-vec4 Saturate(vec4 Cs, float amount) {
-    return vec4(hsvToRgb(min(vec3(1.0, amount, 1.0) * rgbToHsv(Cs.rgb), vec3(1.0))), Cs.a);
-}
-
-vec4 Sepia(vec4 Cs, float amount) {
-    float ia = 1.0 - amount;
-    return mat4(vec4(0.393 + 0.607 * ia, 0.349 - 0.349 * ia, 0.272 - 0.272 * ia, 0.0),
-                vec4(0.769 - 0.769 * ia, 0.686 + 0.314 * ia, 0.534 - 0.534 * ia, 0.0),
-                vec4(0.189 - 0.189 * ia, 0.168 - 0.168 * ia, 0.131 + 0.869 * ia, 0.0),
-                vec4(0.0, 0.0, 0.0, 1.0)) * Cs;
-}
-
 vec3 Multiply(vec3 Cb, vec3 Cs) {
     return Cb * Cs;
 }
@@ -242,77 +154,63 @@ vec3 Luminosity(vec3 Cb, vec3 Cs) {
 }
 
 void main(void) {
-    vec4 Cs = texture(sCache, vUv1);
     vec4 Cb = texture(sCache, vUv0);
 
-    // TODO(gw): This is a hack that's (probably) wrong.
+    if (vUv1.x < vUv1Rect.x ||
-    //           Instead of drawing the tile rect, draw the
+        vUv1.x > vUv1Rect.z ||
-    //           stacking context bounds instead?
+        vUv1.y < vUv1Rect.y ||
-    if (Cs.a == 0.0) {
+        vUv1.y > vUv1Rect.w) {
         oFragColor = Cb;
         return;
     }
 
-    int kind = vInfo.x;
+    vec4 Cs = texture(sCache, vUv1);
-    int op = vInfo.y;
-    float amount = vAmount;
 
     // Return yellow if none of the branches match (shouldn't happen).
     vec4 result = vec4(1.0, 1.0, 0.0, 1.0);
 
-    switch (kind) {
+    switch (vOp) {
-        case COMPOSITE_KIND_MIX_BLEND_MODE:
+        case 2:
-            if (op == 2) {
             result.rgb = Screen(Cb.rgb, Cs.rgb);
-            } else if (op == 3) {
+            break;
+        case 3:
             result.rgb = HardLight(Cs.rgb, Cb.rgb);        // Overlay is inverse of Hardlight
-            } else if (op == 6) {
+            break;
+        case 6:
             result.r = ColorDodge(Cb.r, Cs.r);
             result.g = ColorDodge(Cb.g, Cs.g);
             result.b = ColorDodge(Cb.b, Cs.b);
-            } else if (op == 7) {
+            break;
+        case 7:
             result.r = ColorBurn(Cb.r, Cs.r);
             result.g = ColorBurn(Cb.g, Cs.g);
             result.b = ColorBurn(Cb.b, Cs.b);
-            } else if (op == 8) {
+            break;
+        case 8:
             result.rgb = HardLight(Cb.rgb, Cs.rgb);
-            } else if (op == 9) {
+            break;
+        case 9:
             result.r = SoftLight(Cb.r, Cs.r);
             result.g = SoftLight(Cb.g, Cs.g);
             result.b = SoftLight(Cb.b, Cs.b);
-            } else if (op == 10) {
-                result.rgb = Difference(Cb.rgb, Cs.rgb);
-            } else if (op == 11) {
-                result.rgb = Exclusion(Cb.rgb, Cs.rgb);
-            } else if (op == 12) {
-                result.rgb = Hue(Cb.rgb, Cs.rgb);
-            } else if (op == 13) {
-                result.rgb = Saturation(Cb.rgb, Cs.rgb);
-            } else if (op == 14) {
-                result.rgb = Color(Cb.rgb, Cs.rgb);
-            } else if (op == 15) {
-                result.rgb = Luminosity(Cb.rgb, Cs.rgb);
-            }
             break;
-        case COMPOSITE_KIND_FILTER:
+        case 10:
-            if (op == 0) {
+            result.rgb = Difference(Cb.rgb, Cs.rgb);
-                // Gaussian blur is specially handled:
+            break;
-                result = Cs;// Blur(amount, vec2(0,0));
+        case 11:
-            } else {
+            result.rgb = Exclusion(Cb.rgb, Cs.rgb);
-                if (op == 1) {
+            break;
-                    result = Contrast(Cs, amount);
+        case 12:
-                } else if (op == 2) {
+            result.rgb = Hue(Cb.rgb, Cs.rgb);
-                    result = Grayscale(Cs, amount);
+            break;
-                } else if (op == 3) {
+        case 13:
-                    result = HueRotate(Cs, amount);
+            result.rgb = Saturation(Cb.rgb, Cs.rgb);
-                } else if (op == 4) {
+            break;
-                    result = Invert(Cs, amount);
+        case 14:
-                } else if (op == 5) {
+            result.rgb = Color(Cb.rgb, Cs.rgb);
-                    result = Saturate(Cs, amount);
+            break;
-                } else if (op == 6) {
+        case 15:
-                    result = Sepia(Cs, amount);
+            result.rgb = Luminosity(Cb.rgb, Cs.rgb);
-                }
-            }
             break;
     }
 

resources/shaders/ps_composite.glsl

@@ -4,5 +4,5 @@
 
 varying vec2 vUv0;
 varying vec2 vUv1;
-flat varying ivec2 vInfo;
+flat varying vec4 vUv1Rect;
-flat varying float vAmount;
+flat varying int vOp;

resources/shaders/ps_composite.vs.glsl

@@ -5,24 +5,28 @@
 
 void main(void) {
     Composite composite = fetch_composite(gl_InstanceID);
-    Tile src0 = fetch_tile(composite.src0_src1_target_id.x);
+    Tile src0 = fetch_tile(composite.src0_src1_target_id_op.x);
-    Tile src1 = fetch_tile(composite.src0_src1_target_id.y);
+    Tile src1 = fetch_tile(composite.src0_src1_target_id_op.y);
-    Tile dest = fetch_tile(composite.src0_src1_target_id.z);
+    Tile dest = fetch_tile(composite.src0_src1_target_id_op.z);
 
-    vec2 local_pos = mix(vec2(dest.target_rect.xy),
+    vec2 local_pos = mix(dest.screen_origin_task_origin.zw,
-                         vec2(dest.target_rect.xy + dest.target_rect.zw),
+                         dest.screen_origin_task_origin.zw + dest.size.xy,
                          aPosition.xy);
 
-    vec2 st0 = vec2(src0.target_rect.xy) / 2048.0;
+    vec2 st0 = vec2(src0.screen_origin_task_origin.zw) / 2048.0;
-    vec2 st1 = vec2(src0.target_rect.xy + src0.target_rect.zw) / 2048.0;
+    vec2 st1 = vec2(src0.screen_origin_task_origin.zw + src0.size.xy) / 2048.0;
     vUv0 = mix(st0, st1, aPosition.xy);
 
-    st0 = vec2(src1.target_rect.xy) / 2048.0;
+    st0 = vec2(src1.screen_origin_task_origin.zw) / 2048.0;
-    st1 = vec2(src1.target_rect.xy + src1.target_rect.zw) / 2048.0;
+    st1 = vec2(src1.screen_origin_task_origin.zw + src1.size.xy) / 2048.0;
-    vUv1 = mix(st0, st1, aPosition.xy);
+    vec2 local_virtual_pos = mix(dest.screen_origin_task_origin.xy,
+                                 dest.screen_origin_task_origin.xy + dest.size.xy,
+                                 aPosition.xy);
+    vec2 f = (local_virtual_pos - src1.screen_origin_task_origin.xy) / src1.size.xy;
+    vUv1 = mix(st0, st1, f);
+    vUv1Rect = vec4(st0, st1);
 
-    vInfo = composite.info_amount.xy;
+    vOp = composite.src0_src1_target_id_op.w;
-    vAmount = composite.info_amount.z / 65535.0;
 
     gl_Position = uTransform * vec4(local_pos, 0, 1);
 }