Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(133)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: src/core/SkXfermode.cpp

Issue 1684623002: implement more xfermodeproc4f and add GM (Closed) Base URL: https://skia.googlesource.com/skia.git@master
Patch Set: remove unnecessary pins, and add assert Created 4 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « gm/xfermodes.cpp ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/core/SkXfermode.cpp
diff --git a/src/core/SkXfermode.cpp b/src/core/SkXfermode.cpp
index 2f29f1a63d78c892af4b79a5f4746d1d8f359967..254c4d694f80c7217285085de4acb37714cbcde4 100644
--- a/src/core/SkXfermode.cpp
+++ b/src/core/SkXfermode.cpp
@@ -53,6 +53,21 @@ static Sk4f alpha(const Sk4f& color) { return Sk4f(color.kth<3>()); }
static Sk4f inv_alpha(const Sk4f& color) { return Sk4f(1 - color.kth<3>()); }
static Sk4f pin_1(const Sk4f& value) { return Sk4f::Min(value, Sk4f(1)); }
+static Sk4f color_alpha(const Sk4f& color, float newAlpha) {
+ return Sk4f(color.kth<0>(), color.kth<1>(), color.kth<2>(), newAlpha);
+}
+static Sk4f color_alpha(const Sk4f& color, const Sk4f& newAlpha) {
+ return color_alpha(color, newAlpha.kth<3>());
+}
+
+static Sk4f set_argb(float a, float r, float g, float b) {
+ if (0 == SkPM4f::R) {
+ return Sk4f(r, g, b, a);
+ } else {
+ return Sk4f(b, g, r, a);
+ }
+}
+
static Sk4f clear_4f(const Sk4f& s, const Sk4f& d) { return Sk4f(0); }
static Sk4f src_4f(const Sk4f& s, const Sk4f& d) { return s; }
static Sk4f dst_4f(const Sk4f& s, const Sk4f& d) { return d; }
@@ -73,29 +88,279 @@ static Sk4f multiply_4f(const Sk4f& s, const Sk4f& d) {
return s * inv_alpha(d) + d * inv_alpha(s) + s * d;
}
-///////////////////////////////////////////////////////////////////////////////
+static Sk4f overlay_4f(const Sk4f& s, const Sk4f& d) {
+ Sk4f da = alpha(d);
+ Sk4f sa = alpha(s);
+ Sk4f two = Sk4f(2);
+ Sk4f rc = (two * d <= da).thenElse(two * s * d,
+ sa * da - two * (da - d) * (sa - s));
+ return color_alpha(s - s * da + d - d * sa + rc, sa + da - sa * da);
mtklein 2016/02/09 17:25:51 I find things a little easier to read if you bind
reed1 2016/02/09 18:36:19 I like the shared-expression refactor: done. Not s
+}
-static SkPM4f as_pm4f(const Sk4f& x) {
- SkPM4f pm4;
- x.store(pm4.fVec);
- return pm4;
+static Sk4f darken_4f(const Sk4f& s, const Sk4f& d) {
+ Sk4f sa = alpha(s);
+ Sk4f da = alpha(d);
+ return color_alpha(s + d - Sk4f::Max(s * da, d * sa), sa + da - sa * da);
mtklein 2016/02/09 17:25:51 Aren't color and alpha actually the same math?
reed1 2016/02/09 18:36:19 Done.
}
-static Sk4f as_4f(const SkPM4f& pm4) {
- return Sk4f::Load(pm4.fVec);
+static Sk4f lighten_4f(const Sk4f& s, const Sk4f& d) {
+ Sk4f sa = alpha(s);
+ Sk4f da = alpha(d);
+ return color_alpha(s + d - Sk4f::Min(s * da, d * sa), sa + da - sa * da);
mtklein 2016/02/09 17:25:51 Same deal? return s + d - Sk4f::Min(s*alpha(d)
reed1 2016/02/09 18:36:19 Done.
}
-template <Sk4f (blend)(const Sk4f&, const Sk4f&)>
-SkPM4f proc_4f(const SkPM4f& src, const SkPM4f& dst) {
- return as_pm4f(blend(as_4f(src), as_4f(dst)));
+static inline float colordodge_f(float sc, float dc, float sa, float da) {
mtklein 2016/02/09 17:25:51 Let's steal my Sk4f version of this from SkXfermod
reed1 2016/02/09 19:10:25 Done.
+ if (0 == dc) {
+ return sc * (1 - da);
+ }
+ float exor = sc * (1 - da) + dc * (1 - sa);
+ float diff = sa - sc;
+ if (0 == diff) {
+ return sa * da + exor;
+ } else {
+ return sa * SkTMin(da, dc * sa / diff) + exor;
+ }
+}
+static Sk4f colordodge_4f(const Sk4f& s, const Sk4f& d) {
+ float sa = s.kth<3>();
+ float da = d.kth<3>();
+ return Sk4f(colordodge_f(s.kth<0>(), d.kth<0>(), sa, da),
+ colordodge_f(s.kth<1>(), d.kth<1>(), sa, da),
+ colordodge_f(s.kth<2>(), d.kth<2>(), sa, da),
+ sa + da - sa * da);
}
-///////////////////////////////////////////////////////////////////////////////
+static inline float colorburn_f(float sc, float dc, float sa, float da) {
+ if (0 == sc) {
+ return dc * (1 - sa);
+ }
+ float exor = sc * (1 - da) + dc * (1 - sa);
+ float diff = da - dc;
+ if (0 == diff) {
+ return sa * da + exor;
+ } else {
+ return sa * (da - SkTMin(da, diff * sa / sc)) + exor;
+ }
+}
+static Sk4f colorburn_4f(const Sk4f& s, const Sk4f& d) {
mtklein 2016/02/09 17:25:52 Ditto... also got an Sk4f version in SkXfermode_op
reed1 2016/02/09 19:10:25 Done.
+ float sa = s.kth<3>();
+ float da = d.kth<3>();
+ return Sk4f(colorburn_f(s.kth<0>(), d.kth<0>(), sa, da),
+ colorburn_f(s.kth<1>(), d.kth<1>(), sa, da),
+ colorburn_f(s.kth<2>(), d.kth<2>(), sa, da),
+ sa + da - sa * da);
+}
+
+static Sk4f hardlight_4f(const Sk4f& s, const Sk4f& d) {
mtklein 2016/02/09 17:25:51 Let's put overlay and hardlight closer together?
reed1 2016/02/09 18:36:19 Done.
+ Sk4f sa = alpha(s);
+ Sk4f da = alpha(d);
+ Sk4f one = Sk4f(1);
+ Sk4f two = Sk4f(2);
+ Sk4f rc = (two * s <= sa).thenElse(two * s * d,
+ sa * da - two * (da - d) * (sa - s));
+ return color_alpha(rc + s * (one - da) + d * (one - sa),
+ sa + da - sa * da);
+}
+
+static inline float softlight_f(float sc, float dc, float sa, float da) {
mtklein 2016/02/09 17:25:52 Also have a 4f version in SkXfermode_opts.h
reed1 2016/02/09 19:10:25 Done.
+ float m = da ? dc / da : 0;
+ float rc;
+ if (2 * sc <= sa) {
+ rc = dc * (sa + (2 * sc - sa) * (1 - m));
+ } else if (4 * dc <= da) {
+ float tmp = (4 * m * (4 * m + 1) * (m - 1)) + 7 * m;
+ rc = dc * sa + da * (2 * sc - sa) * tmp;
+ } else {
+ float tmp = sqrtf(m) - m;
+ rc = dc * sa + da * (2 * sc - sa) * tmp;
+ }
+ return rc + sc * (1 - da) + dc * (1 - sa);
+}
+static Sk4f softlight_4f(const Sk4f& s, const Sk4f& d) {
+ float sa = s.kth<3>();
+ float da = d.kth<3>();
+ return Sk4f(softlight_f(s.kth<0>(), d.kth<0>(), sa, da),
+ softlight_f(s.kth<1>(), d.kth<1>(), sa, da),
+ softlight_f(s.kth<2>(), d.kth<2>(), sa, da),
+ sa + da - sa * da);
+}
+
+static Sk4f difference_4f(const Sk4f& s, const Sk4f& d) {
+ Sk4f sa = alpha(s);
+ Sk4f da = alpha(d);
+ return color_alpha(s + d - Sk4f(2) * Sk4f::Min(s * da, d * sa),
mtklein 2016/02/09 17:25:51 I think this is clearer, and maybe cheaper, to pul
reed1 2016/02/09 19:10:25 Clever. done.
+ sa + da - sa * da);
+}
+
+static Sk4f exclusion_4f(const Sk4f& s, const Sk4f& d) {
+ Sk4f tmp = s + d - s * d;
+ return color_alpha(tmp - s * d, tmp);
mtklein 2016/02/09 17:25:51 Same sort of thing? Sk4f screen = s + d - s*d; re
reed1 2016/02/09 19:10:25 Done.
+}
-static SkPM4f not_implemented_yet_proc4f(const SkPM4f& src, const SkPM4f& dst) {
- return {{ 0.5f, 1.0f, 0.25f, 0.5f }};
+////////////////////////////////////////////////////
mtklein 2016/02/09 17:25:51 FYI, didn't pay much attention below here...
+
+// The CSS compositing spec introduces the following formulas:
+// (See https://dvcs.w3.org/hg/FXTF/rawfile/tip/compositing/index.html#blendingnonseparable)
+// SkComputeLuminance is similar to this formula but it uses the new definition from Rec. 709
+// while PDF and CG uses the one from Rec. Rec. 601
+// See http://www.glennchan.info/articles/technical/hd-versus-sd-color-space/hd-versus-sd-color-space.htm
+static inline float Lum(float r, float g, float b) {
+ return r * 0.2126f + g * 0.7152f + b * 0.0722f;
}
+static inline float max(float a, float b, float c) {
+ return SkTMax(a, SkTMax(b, c));
+}
+
+static inline float min(float a, float b, float c) {
+ return SkTMin(a, SkTMin(b, c));
+}
+
+static inline float Sat(float r, float g, float b) {
+ return max(r, g, b) - min(r, g, b);
+}
+
+static inline void setSaturationComponents(float* Cmin, float* Cmid, float* Cmax, float s) {
+ if(*Cmax > *Cmin) {
+ *Cmid = (*Cmid - *Cmin) * s / (*Cmax - *Cmin);
+ *Cmax = s;
+ } else {
+ *Cmax = 0;
+ *Cmid = 0;
+ }
+ *Cmin = 0;
+}
+
+static inline void SetSat(float* r, float* g, float* b, float s) {
+ if(*r <= *g) {
+ if(*g <= *b) {
+ setSaturationComponents(r, g, b, s);
+ } else if(*r <= *b) {
+ setSaturationComponents(r, b, g, s);
+ } else {
+ setSaturationComponents(b, r, g, s);
+ }
+ } else if(*r <= *b) {
+ setSaturationComponents(g, r, b, s);
+ } else if(*g <= *b) {
+ setSaturationComponents(g, b, r, s);
+ } else {
+ setSaturationComponents(b, g, r, s);
+ }
+}
+
+static inline void clipColor(float* r, float* g, float* b, float a) {
+ float L = Lum(*r, *g, *b);
+ float n = min(*r, *g, *b);
+ float x = max(*r, *g, *b);
+ float denom;
+ if ((n < 0) && (denom = L - n)) { // Compute denom and make sure it's non zero
+ float scale = L / denom;
+ *r = L + (*r - L) * scale;
+ *g = L + (*g - L) * scale;
+ *b = L + (*b - L) * scale;
+ }
+
+ if ((x > a) && (denom = x - L)) { // Compute denom and make sure it's non zero
+ float scale = (a - L) / denom;
+ *r = L + (*r - L) * scale;
+ *g = L + (*g - L) * scale;
+ *b = L + (*b - L) * scale;
+ }
+}
+
+static inline void SetLum(float* r, float* g, float* b, float a, float l) {
+ float d = l - Lum(*r, *g, *b);
+ *r += d;
+ *g += d;
+ *b += d;
+ clipColor(r, g, b, a);
+}
+
+static Sk4f hue_4f(const Sk4f& s, const Sk4f& d) {
+ float sa = s.kth<SkPM4f::A>();
+ float sr = s.kth<SkPM4f::R>();
+ float sg = s.kth<SkPM4f::G>();
+ float sb = s.kth<SkPM4f::B>();
+
+ float da = d.kth<SkPM4f::A>();
+ float dr = d.kth<SkPM4f::R>();
+ float dg = d.kth<SkPM4f::G>();
+ float db = d.kth<SkPM4f::B>();
+
+ float Sr = sr;
+ float Sg = sg;
+ float Sb = sb;
+ SetSat(&Sr, &Sg, &Sb, Sat(dr, dg, db) * sa);
+ SetLum(&Sr, &Sg, &Sb, sa * da, Lum(dr, dg, db) * sa);
+
+ return color_alpha(s * inv_alpha(d) + d * inv_alpha(s) + set_argb(0, Sr, Sg, Sb),
+ sa + da - sa * da);
+}
+
+static Sk4f saturation_4f(const Sk4f& s, const Sk4f& d) {
+ float sa = s.kth<SkPM4f::A>();
+ float sr = s.kth<SkPM4f::R>();
+ float sg = s.kth<SkPM4f::G>();
+ float sb = s.kth<SkPM4f::B>();
+
+ float da = d.kth<SkPM4f::A>();
+ float dr = d.kth<SkPM4f::R>();
+ float dg = d.kth<SkPM4f::G>();
+ float db = d.kth<SkPM4f::B>();
+
+ float Dr = dr;
+ float Dg = dg;
+ float Db = db;
+ SetSat(&Dr, &Dg, &Db, Sat(sr, sg, sb) * da);
+ SetLum(&Dr, &Dg, &Db, sa * da, Lum(dr, dg, db) * sa);
+
+ return color_alpha(s * inv_alpha(d) + d * inv_alpha(s) + set_argb(0, Dr, Dg, Db),
+ sa + da - sa * da);
+}
+
+static Sk4f color_4f(const Sk4f& s, const Sk4f& d) {
+ float sa = s.kth<SkPM4f::A>();
+ float sr = s.kth<SkPM4f::R>();
+ float sg = s.kth<SkPM4f::G>();
+ float sb = s.kth<SkPM4f::B>();
+
+ float da = d.kth<SkPM4f::A>();
+ float dr = d.kth<SkPM4f::R>();
+ float dg = d.kth<SkPM4f::G>();
+ float db = d.kth<SkPM4f::B>();
+
+ float Sr = sr;
+ float Sg = sg;
+ float Sb = sb;
+ SetLum(&Sr, &Sg, &Sb, sa * da, Lum(dr, dg, db) * sa);
+
+ return color_alpha(s * inv_alpha(d) + d * inv_alpha(s) + set_argb(0, Sr, Sg, Sb),
+ sa + da - sa * da);
+}
+
+static Sk4f luminosity_4f(const Sk4f& s, const Sk4f& d) {
+ float sa = s.kth<SkPM4f::A>();
+ float sr = s.kth<SkPM4f::R>();
+ float sg = s.kth<SkPM4f::G>();
+ float sb = s.kth<SkPM4f::B>();
+
+ float da = d.kth<SkPM4f::A>();
+ float dr = d.kth<SkPM4f::R>();
+ float dg = d.kth<SkPM4f::G>();
+ float db = d.kth<SkPM4f::B>();
+
+ float Dr = dr;
+ float Dg = dg;
+ float Db = db;
+ SetLum(&Dr, &Dg, &Db, sa * da, Lum(sr, sg, sb) * da);
+
+ return color_alpha(s * inv_alpha(d) + d * inv_alpha(s) + set_argb(0, Dr, Dg, Db),
+ sa + da - sa * da);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
// kClear_Mode, //!< [0, 0]
static SkPMColor clear_modeproc(SkPMColor src, SkPMColor dst) {
return 0;
@@ -267,9 +532,6 @@ static SkPMColor overlay_modeproc(SkPMColor src, SkPMColor dst) {
int b = overlay_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
return SkPackARGB32(a, r, g, b);
}
-static SkPM4f overlay_proc4f(const SkPM4f& src, const SkPM4f& dst) {
- return not_implemented_yet_proc4f(src, dst);
-}
// kDarken_Mode
static inline int darken_byte(int sc, int dc, int sa, int da) {
@@ -292,9 +554,6 @@ static SkPMColor darken_modeproc(SkPMColor src, SkPMColor dst) {
int b = darken_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
return SkPackARGB32(a, r, g, b);
}
-static SkPM4f darken_proc4f(const SkPM4f& src, const SkPM4f& dst) {
- return not_implemented_yet_proc4f(src, dst);
-}
// kLighten_Mode
static inline int lighten_byte(int sc, int dc, int sa, int da) {
@@ -317,9 +576,6 @@ static SkPMColor lighten_modeproc(SkPMColor src, SkPMColor dst) {
int b = lighten_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
return SkPackARGB32(a, r, g, b);
}
-static SkPM4f lighten_proc4f(const SkPM4f& src, const SkPM4f& dst) {
- return not_implemented_yet_proc4f(src, dst);
-}
// kColorDodge_Mode
static inline int colordodge_byte(int sc, int dc, int sa, int da) {
@@ -344,9 +600,6 @@ static SkPMColor colordodge_modeproc(SkPMColor src, SkPMColor dst) {
int b = colordodge_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
return SkPackARGB32(a, r, g, b);
}
-static SkPM4f colordodge_proc4f(const SkPM4f& src, const SkPM4f& dst) {
- return not_implemented_yet_proc4f(src, dst);
-}
// kColorBurn_Mode
static inline int colorburn_byte(int sc, int dc, int sa, int da) {
@@ -371,9 +624,6 @@ static SkPMColor colorburn_modeproc(SkPMColor src, SkPMColor dst) {
int b = colorburn_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
return SkPackARGB32(a, r, g, b);
}
-static SkPM4f colorburn_proc4f(const SkPM4f& src, const SkPM4f& dst) {
- return not_implemented_yet_proc4f(src, dst);
-}
// kHardLight_Mode
static inline int hardlight_byte(int sc, int dc, int sa, int da) {
@@ -394,9 +644,6 @@ static SkPMColor hardlight_modeproc(SkPMColor src, SkPMColor dst) {
int b = hardlight_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
return SkPackARGB32(a, r, g, b);
}
-static SkPM4f hardlight_proc4f(const SkPM4f& src, const SkPM4f& dst) {
- return not_implemented_yet_proc4f(src, dst);
-}
// returns 255 * sqrt(n/255)
static U8CPU sqrt_unit_byte(U8CPU n) {
@@ -427,9 +674,6 @@ static SkPMColor softlight_modeproc(SkPMColor src, SkPMColor dst) {
int b = softlight_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
return SkPackARGB32(a, r, g, b);
}
-static SkPM4f softlight_proc4f(const SkPM4f& src, const SkPM4f& dst) {
- return not_implemented_yet_proc4f(src, dst);
-}
// kDifference_Mode
static inline int difference_byte(int sc, int dc, int sa, int da) {
@@ -445,9 +689,6 @@ static SkPMColor difference_modeproc(SkPMColor src, SkPMColor dst) {
int b = difference_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
return SkPackARGB32(a, r, g, b);
}
-static SkPM4f difference_proc4f(const SkPM4f& src, const SkPM4f& dst) {
- return not_implemented_yet_proc4f(src, dst);
-}
// kExclusion_Mode
static inline int exclusion_byte(int sc, int dc, int, int) {
@@ -467,9 +708,6 @@ static SkPMColor exclusion_modeproc(SkPMColor src, SkPMColor dst) {
int b = exclusion_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
return SkPackARGB32(a, r, g, b);
}
-static SkPM4f exclusion_proc4f(const SkPM4f& src, const SkPM4f& dst) {
- return not_implemented_yet_proc4f(src, dst);
-}
// The CSS compositing spec introduces the following formulas:
// (See https://dvcs.w3.org/hg/FXTF/rawfile/tip/compositing/index.html#blendingnonseparable)
@@ -585,9 +823,6 @@ static SkPMColor hue_modeproc(SkPMColor src, SkPMColor dst) {
int b = blendfunc_nonsep_byte(sb, db, sa, da, Sb);
return SkPackARGB32(a, r, g, b);
}
-static SkPM4f hue_proc4f(const SkPM4f& src, const SkPM4f& dst) {
- return not_implemented_yet_proc4f(src, dst);
-}
// kSaturation_Mode
// B(Cb, Cs) = SetLum(SetSat(Cb, Sat(Cs)), Lum(Cb))
@@ -622,9 +857,6 @@ static SkPMColor saturation_modeproc(SkPMColor src, SkPMColor dst) {
int b = blendfunc_nonsep_byte(sb, db, sa, da, Db);
return SkPackARGB32(a, r, g, b);
}
-static SkPM4f saturation_proc4f(const SkPM4f& src, const SkPM4f& dst) {
- return not_implemented_yet_proc4f(src, dst);
-}
// kColor_Mode
// B(Cb, Cs) = SetLum(Cs, Lum(Cb))
@@ -658,9 +890,6 @@ static SkPMColor color_modeproc(SkPMColor src, SkPMColor dst) {
int b = blendfunc_nonsep_byte(sb, db, sa, da, Sb);
return SkPackARGB32(a, r, g, b);
}
-static SkPM4f color_proc4f(const SkPM4f& src, const SkPM4f& dst) {
- return not_implemented_yet_proc4f(src, dst);
-}
// kLuminosity_Mode
// B(Cb, Cs) = SetLum(Cb, Lum(Cs))
@@ -694,8 +923,29 @@ static SkPMColor luminosity_modeproc(SkPMColor src, SkPMColor dst) {
int b = blendfunc_nonsep_byte(sb, db, sa, da, Db);
return SkPackARGB32(a, r, g, b);
}
-static SkPM4f luminosity_proc4f(const SkPM4f& src, const SkPM4f& dst) {
- return not_implemented_yet_proc4f(src, dst);
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+static SkPM4f as_pm4f(const Sk4f& x) {
+ SkPM4f pm4;
+ x.store(pm4.fVec);
+ return pm4;
+}
+
+static Sk4f as_4f(const SkPM4f& pm4) {
+ return Sk4f::Load(pm4.fVec);
+}
+
+template <Sk4f (blend)(const Sk4f&, const Sk4f&)> SkPM4f proc_4f(const SkPM4f& s, const SkPM4f& d) {
+ SkPM4f r = as_pm4f(blend(as_4f(s), as_4f(d)));
+#ifdef SK_DEBUG
+ const float min = 0;
+ const float max = 1;
+ for (int i = 0; i < 4; ++i) {
+ SkASSERT(r.fVec[i] >= min && r.fVec[i] <= max);
+ }
+#endif
+ return r;
}
const ProcCoeff gProcCoeffs[] = {
@@ -715,20 +965,20 @@ const ProcCoeff gProcCoeffs[] = {
{ plus_modeproc, proc_4f<plus_4f>, SkXfermode::kOne_Coeff, SkXfermode::kOne_Coeff },
{ modulate_modeproc, proc_4f<modulate_4f>, SkXfermode::kZero_Coeff, SkXfermode::kSC_Coeff },
{ screen_modeproc, proc_4f<screen_4f>, SkXfermode::kOne_Coeff, SkXfermode::kISC_Coeff },
- { overlay_modeproc, overlay_proc4f, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
- { darken_modeproc, darken_proc4f, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
- { lighten_modeproc, lighten_proc4f, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
- { colordodge_modeproc, colordodge_proc4f, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
- { colorburn_modeproc, colorburn_proc4f, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
- { hardlight_modeproc, hardlight_proc4f, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
- { softlight_modeproc, softlight_proc4f, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
- { difference_modeproc, difference_proc4f, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
- { exclusion_modeproc, exclusion_proc4f, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
+ { overlay_modeproc, proc_4f<overlay_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
+ { darken_modeproc, proc_4f<darken_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
+ { lighten_modeproc, proc_4f<lighten_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
+ { colordodge_modeproc, proc_4f<colordodge_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
+ { colorburn_modeproc, proc_4f<colorburn_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
+ { hardlight_modeproc, proc_4f<hardlight_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
+ { softlight_modeproc, proc_4f<softlight_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
+ { difference_modeproc, proc_4f<difference_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
+ { exclusion_modeproc, proc_4f<exclusion_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
{ multiply_modeproc, proc_4f<multiply_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
- { hue_modeproc, hue_proc4f, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
- { saturation_modeproc, saturation_proc4f, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
- { color_modeproc, color_proc4f, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
- { luminosity_modeproc, luminosity_proc4f, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
+ { hue_modeproc, proc_4f<hue_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
+ { saturation_modeproc, proc_4f<saturation_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
+ { color_modeproc, proc_4f<color_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
+ { luminosity_modeproc, proc_4f<luminosity_4f>, CANNOT_USE_COEFF, CANNOT_USE_COEFF },
};
///////////////////////////////////////////////////////////////////////////////
« no previous file with comments | « gm/xfermodes.cpp ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698