gfx/wr/webrender/res/brush_mix_blend.glsl

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #define VECS_PER_SPECIFIC_BRUSH 3
   6 #define WR_FEATURE_TEXTURE_2D
   7
   8 #include shared,prim_shared,brush
   9
  10 // UV and bounds for the source image
  11 varying highp vec2 v_src_uv;
  12 flat varying highp vec4 v_src_uv_sample_bounds;
  13
  14 // UV and bounds for the backdrop image
  15 varying highp vec2 v_backdrop_uv;
  16 flat varying highp vec4 v_backdrop_uv_sample_bounds;
  17
  18 // Flag to allow perspective interpolation of UV.
  19 // Packed in to vector to work around bug 1630356.
  20 flat varying mediump vec2 v_perspective;
  21 // mix-blend op. Packed in to vector to work around bug 1630356.
  22 flat varying mediump ivec2 v_op;
  23
  24 #ifdef WR_VERTEX_SHADER
  25
  26 void get_uv(
  27     int res_address,
  28     vec2 f,
  29     ivec2 texture_size,
  30     float perspective_f,
  31     out vec2 out_uv,
  32     out vec4 out_uv_sample_bounds
  33 ) {
  34     ImageSource res = fetch_image_source(res_address);
  35     vec2 uv0 = res.uv_rect.p0;
  36     vec2 uv1 = res.uv_rect.p1;
  37
  38     vec2 inv_texture_size = vec2(1.0) / vec2(texture_size);
  39     f = get_image_quad_uv(res_address, f);
  40     vec2 uv = mix(uv0, uv1, f);
  41
  42     out_uv = uv * inv_texture_size * perspective_f;
  43     out_uv_sample_bounds = vec4(uv0 + vec2(0.5), uv1 - vec2(0.5)) * inv_texture_size.xyxy;
  44 }
  45
  46 void brush_vs(
  47     VertexInfo vi,
  48     int prim_address,
  49     RectWithEndpoint local_rect,
  50     RectWithEndpoint segment_rect,
  51     ivec4 prim_user_data,
  52     int specific_resource_address,
  53     mat4 transform,
  54     PictureTask pic_task,
  55     int brush_flags,
  56     vec4 unused
  57 ) {
  58     vec2 f = (vi.local_pos - local_rect.p0) / rect_size(local_rect);
  59     float perspective_interpolate = (brush_flags & BRUSH_FLAG_PERSPECTIVE_INTERPOLATION) != 0 ? 1.0 : 0.0;
  60     float perspective_f = mix(vi.world_pos.w, 1.0, perspective_interpolate);
  61     v_perspective.x = perspective_interpolate;
  62     v_op.x = prim_user_data.x;
  63
  64     get_uv(
  65         prim_user_data.y,
  66         f,
  67         TEX_SIZE(sColor0).xy,
  68         1.0,
  69         v_backdrop_uv,
  70         v_backdrop_uv_sample_bounds
  71     );
  72
  73     get_uv(
  74         prim_user_data.z,
  75         f,
  76         TEX_SIZE(sColor1).xy,
  77         perspective_f,
  78         v_src_uv,
  79         v_src_uv_sample_bounds
  80     );
  81 }
  82 #endif
  83
  84 #ifdef WR_FRAGMENT_SHADER
  85 vec3 Multiply(vec3 Cb, vec3 Cs) {
  86     return Cb * Cs;
  87 }
  88
  89 vec3 Screen(vec3 Cb, vec3 Cs) {
  90     return Cb + Cs - (Cb * Cs);
  91 }
  92
  93 vec3 HardLight(vec3 Cb, vec3 Cs) {
  94     vec3 m = Multiply(Cb, 2.0 * Cs);
  95     vec3 s = Screen(Cb, 2.0 * Cs - 1.0);
  96     vec3 edge = vec3(0.5, 0.5, 0.5);
  97     return mix(m, s, step(edge, Cs));
  98 }
  99
 100 // TODO: Worth doing with mix/step? Check GLSL output.
 101 float ColorDodge(float Cb, float Cs) {
 102     if (Cb == 0.0)
 103         return 0.0;
 104     else if (Cs == 1.0)
 105         return 1.0;
 106     else
 107         return min(1.0, Cb / (1.0 - Cs));
 108 }
 109
 110 // TODO: Worth doing with mix/step? Check GLSL output.
 111 float ColorBurn(float Cb, float Cs) {
 112     if (Cb == 1.0)
 113         return 1.0;
 114     else if (Cs == 0.0)
 115         return 0.0;
 116     else
 117         return 1.0 - min(1.0, (1.0 - Cb) / Cs);
 118 }
 119
 120 float SoftLight(float Cb, float Cs) {
 121     if (Cs <= 0.5) {
 122         return Cb - (1.0 - 2.0 * Cs) * Cb * (1.0 - Cb);
 123     } else {
 124         float D;
 125
 126         if (Cb <= 0.25)
 127             D = ((16.0 * Cb - 12.0) * Cb + 4.0) * Cb;
 128         else
 129             D = sqrt(Cb);
 130
 131         return Cb + (2.0 * Cs - 1.0) * (D - Cb);
 132     }
 133 }
 134
 135 vec3 Difference(vec3 Cb, vec3 Cs) {
 136     return abs(Cb - Cs);
 137 }
 138
 139 // These functions below are taken from the spec.
 140 // There's probably a much quicker way to implement
 141 // them in GLSL...
 142 float Sat(vec3 c) {
 143     return max(c.r, max(c.g, c.b)) - min(c.r, min(c.g, c.b));
 144 }
 145
 146 float Lum(vec3 c) {
 147     vec3 f = vec3(0.3, 0.59, 0.11);
 148     return dot(c, f);
 149 }
 150
 151 vec3 ClipColor(vec3 C) {
 152     float L = Lum(C);
 153     float n = min(C.r, min(C.g, C.b));
 154     float x = max(C.r, max(C.g, C.b));
 155
 156     if (n < 0.0)
 157         C = L + (((C - L) * L) / (L - n));
 158
 159     if (x > 1.0)
 160         C = L + (((C - L) * (1.0 - L)) / (x - L));
 161
 162     return C;
 163 }
 164
 165 vec3 SetLum(vec3 C, float l) {
 166     float d = l - Lum(C);
 167     return ClipColor(C + d);
 168 }
 169
 170 void SetSatInner(inout float Cmin, inout float Cmid, inout float Cmax, float s) {
 171     if (Cmax > Cmin) {
 172         Cmid = (((Cmid - Cmin) * s) / (Cmax - Cmin));
 173         Cmax = s;
 174     } else {
 175         Cmid = 0.0;
 176         Cmax = 0.0;
 177     }
 178     Cmin = 0.0;
 179 }
 180
 181 vec3 SetSat(vec3 C, float s) {
 182     if (C.r <= C.g) {
 183         if (C.g <= C.b) {
 184             SetSatInner(C.r, C.g, C.b, s);
 185         } else {
 186             if (C.r <= C.b) {
 187                 SetSatInner(C.r, C.b, C.g, s);
 188             } else {
 189                 SetSatInner(C.b, C.r, C.g, s);
 190             }
 191         }
 192     } else {
 193         if (C.r <= C.b) {
 194             SetSatInner(C.g, C.r, C.b, s);
 195         } else {
 196             if (C.g <= C.b) {
 197                 SetSatInner(C.g, C.b, C.r, s);
 198             } else {
 199                 SetSatInner(C.b, C.g, C.r, s);
 200             }
 201         }
 202     }
 203     return C;
 204 }
 205
 206 vec3 Hue(vec3 Cb, vec3 Cs) {
 207     return SetLum(SetSat(Cs, Sat(Cb)), Lum(Cb));
 208 }
 209
 210 vec3 Saturation(vec3 Cb, vec3 Cs) {
 211     return SetLum(SetSat(Cb, Sat(Cs)), Lum(Cb));
 212 }
 213
 214 vec3 Color(vec3 Cb, vec3 Cs) {
 215     return SetLum(Cs, Lum(Cb));
 216 }
 217
 218 vec3 Luminosity(vec3 Cb, vec3 Cs) {
 219     return SetLum(Cb, Lum(Cs));
 220 }
 221
 222 const int MixBlendMode_Multiply    = 1;
 223 const int MixBlendMode_Screen      = 2;
 224 const int MixBlendMode_Overlay     = 3;
 225 const int MixBlendMode_Darken      = 4;
 226 const int MixBlendMode_Lighten     = 5;
 227 const int MixBlendMode_ColorDodge  = 6;
 228 const int MixBlendMode_ColorBurn   = 7;
 229 const int MixBlendMode_HardLight   = 8;
 230 const int MixBlendMode_SoftLight   = 9;
 231 const int MixBlendMode_Difference  = 10;
 232 const int MixBlendMode_Exclusion   = 11;
 233 const int MixBlendMode_Hue         = 12;
 234 const int MixBlendMode_Saturation  = 13;
 235 const int MixBlendMode_Color       = 14;
 236 const int MixBlendMode_Luminosity  = 15;
 237 const int MixBlendMode_PlusLighter = 16;
 238
 239 Fragment brush_fs() {
 240     float perspective_divisor = mix(gl_FragCoord.w, 1.0, v_perspective.x);
 241
 242     vec2 src_uv = v_src_uv * perspective_divisor;
 243     src_uv = clamp(src_uv, v_src_uv_sample_bounds.xy, v_src_uv_sample_bounds.zw);
 244
 245     vec2 backdrop_uv = clamp(v_backdrop_uv, v_backdrop_uv_sample_bounds.xy, v_backdrop_uv_sample_bounds.zw);
 246
 247     vec4 Cb = texture(sColor0, backdrop_uv);
 248     vec4 Cs = texture(sColor1, src_uv);
 249
 250     // The mix-blend-mode functions assume no premultiplied alpha
 251     if (Cb.a != 0.0) {
 252         Cb.rgb /= Cb.a;
 253     }
 254
 255     if (Cs.a != 0.0) {
 256         Cs.rgb /= Cs.a;
 257     }
 258
 259     // Return yellow if none of the branches match (shouldn't happen).
 260     vec4 result = vec4(1.0, 1.0, 0.0, 1.0);
 261
 262     // On Android v_op has been packed in to a vector to avoid a driver bug
 263     // on Adreno 3xx. However, this runs in to another Adreno 3xx driver bug
 264     // where the switch doesn't match any cases. Unpacking the value from the
 265     // vec in to a local variable prior to the switch works around this, but
 266     // gets optimized away by glslopt. Adding a bitwise AND prevents that.
 267     // See bug 1726755.
 268     // default: default: to appease angle_shader_validation
 269     switch (v_op.x & 0xFF) {
 270         case MixBlendMode_Multiply:
 271             result.rgb = Multiply(Cb.rgb, Cs.rgb);
 272             break;
 273         case MixBlendMode_Overlay:
 274             // Overlay is inverse of Hardlight
 275             result.rgb = HardLight(Cs.rgb, Cb.rgb);
 276             break;
 277         case MixBlendMode_Darken:
 278             result.rgb = min(Cs.rgb, Cb.rgb);
 279             break;
 280         case MixBlendMode_Lighten:
 281             result.rgb = max(Cs.rgb, Cb.rgb);
 282             break;
 283         case MixBlendMode_ColorDodge:
 284             result.r = ColorDodge(Cb.r, Cs.r);
 285             result.g = ColorDodge(Cb.g, Cs.g);
 286             result.b = ColorDodge(Cb.b, Cs.b);
 287             break;
 288         case MixBlendMode_ColorBurn:
 289             result.r = ColorBurn(Cb.r, Cs.r);
 290             result.g = ColorBurn(Cb.g, Cs.g);
 291             result.b = ColorBurn(Cb.b, Cs.b);
 292             break;
 293         case MixBlendMode_HardLight:
 294             result.rgb = HardLight(Cb.rgb, Cs.rgb);
 295             break;
 296         case MixBlendMode_SoftLight:
 297             result.r = SoftLight(Cb.r, Cs.r);
 298             result.g = SoftLight(Cb.g, Cs.g);
 299             result.b = SoftLight(Cb.b, Cs.b);
 300             break;
 301         case MixBlendMode_Difference:
 302             result.rgb = Difference(Cb.rgb, Cs.rgb);
 303             break;
 304         case MixBlendMode_Hue:
 305             result.rgb = Hue(Cb.rgb, Cs.rgb);
 306             break;
 307         case MixBlendMode_Saturation:
 308             result.rgb = Saturation(Cb.rgb, Cs.rgb);
 309             break;
 310         case MixBlendMode_Color:
 311             result.rgb = Color(Cb.rgb, Cs.rgb);
 312             break;
 313         case MixBlendMode_Luminosity:
 314             result.rgb = Luminosity(Cb.rgb, Cs.rgb);
 315             break;
 316         case MixBlendMode_Screen:
 317         case MixBlendMode_Exclusion:
 318         case MixBlendMode_PlusLighter:
 319             // This should be unreachable, since we implement
 320             // MixBlendMode::Screen, MixBlendMode::Exclusion and
 321             // MixBlendMode::PlusLighter using glBlendFuncSeparate.
 322             break;
 323         default: break;
 324     }
 325
 326     result.rgb = (1.0 - Cb.a) * Cs.rgb + Cb.a * result.rgb;
 327     result.a = Cs.a;
 328     result.rgb *= result.a;
 329
 330     return Fragment(result);
 331 }
 332 #endif