Merge branch 'blender2.7'
[blender.git] / source / blender / editors / sculpt_paint / paint_vertex_color_utils.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * ***** END GPL LICENSE BLOCK *****
19  */
20
21 /** \file blender/editors/sculpt_paint/paint_vertex_color_utils.c
22  *  \ingroup edsculpt
23  *
24  * Intended for use by `paint_vertex.c` & `paint_vertex_color_ops.c`.
25  */
26
27 #include "MEM_guardedalloc.h"
28
29 #include "DNA_brush_types.h"
30 #include "DNA_mesh_types.h"
31 #include "DNA_meshdata_types.h"
32 #include "DNA_object_types.h"
33 #include "DNA_scene_types.h"
34
35 #include "BLI_math_base.h"
36 #include "BLI_math_color.h"
37
38 #include "IMB_colormanagement.h"
39 #include "IMB_imbuf.h"
40
41 #include "BKE_context.h"
42 #include "BKE_mesh.h"
43
44 #include "DEG_depsgraph.h"
45
46 #include "ED_mesh.h"
47
48 #include "paint_intern.h"  /* own include */
49
50 #define EPS_SATURATION 0.0005f
51
52 /**
53  * Apply callback to each vertex of the active vertex color layer.
54  */
55 bool ED_vpaint_color_transform(
56         struct Object *ob,
57         VPaintTransform_Callback vpaint_tx_fn,
58         const void *user_data)
59 {
60         Mesh *me;
61         const MPoly *mp;
62
63         if (((me = BKE_mesh_from_object(ob)) == NULL) ||
64             (ED_mesh_color_ensure(me, NULL) == false))
65         {
66                 return false;
67         }
68
69         const bool use_face_sel = (me->editflag & ME_EDIT_PAINT_FACE_SEL) != 0;
70         mp = me->mpoly;
71
72         for (int i = 0; i < me->totpoly; i++, mp++) {
73                 MLoopCol *lcol = &me->mloopcol[mp->loopstart];
74
75                 if (use_face_sel && !(mp->flag & ME_FACE_SEL)) {
76                         continue;
77                 }
78
79                 for (int j = 0; j < mp->totloop; j++, lcol++) {
80                         float col_mix[3];
81                         rgb_uchar_to_float(col_mix, &lcol->r);
82
83                         vpaint_tx_fn(col_mix, user_data, col_mix);
84
85                         rgb_float_to_uchar(&lcol->r, col_mix);
86                 }
87         }
88
89         /* remove stale me->mcol, will be added later */
90         BKE_mesh_tessface_clear(me);
91
92         DEG_id_tag_update(&me->id, 0);
93
94         return true;
95 }
96
97 /* -------------------------------------------------------------------- */
98 /** \name Color Blending Modes
99  * \{ */
100
101 BLI_INLINE uint mcol_blend(uint col_src, uint col_dst, int fac)
102 {
103         uchar *cp_src, *cp_dst, *cp_mix;
104         int mfac;
105         uint col_mix = 0;
106
107         if (fac == 0) {
108                 return col_src;
109         }
110
111         if (fac >= 255) {
112                 return col_dst;
113         }
114
115         mfac = 255 - fac;
116
117         cp_src = (uchar *)&col_src;
118         cp_dst = (uchar *)&col_dst;
119         cp_mix = (uchar *)&col_mix;
120
121         /* Updated to use the rgb squared color model which blends nicer. */
122         int r1 = cp_src[0] * cp_src[0];
123         int g1 = cp_src[1] * cp_src[1];
124         int b1 = cp_src[2] * cp_src[2];
125         int a1 = cp_src[3] * cp_src[3];
126
127         int r2 = cp_dst[0] * cp_dst[0];
128         int g2 = cp_dst[1] * cp_dst[1];
129         int b2 = cp_dst[2] * cp_dst[2];
130         int a2 = cp_dst[3] * cp_dst[3];
131
132         cp_mix[0] = round_fl_to_uchar(sqrtf(divide_round_i((mfac * r1 + fac * r2), 255)));
133         cp_mix[1] = round_fl_to_uchar(sqrtf(divide_round_i((mfac * g1 + fac * g2), 255)));
134         cp_mix[2] = round_fl_to_uchar(sqrtf(divide_round_i((mfac * b1 + fac * b2), 255)));
135         cp_mix[3] = round_fl_to_uchar(sqrtf(divide_round_i((mfac * a1 + fac * a2), 255)));
136
137         return col_mix;
138 }
139
140 BLI_INLINE uint mcol_add(uint col_src, uint col_dst, int fac)
141 {
142         uchar *cp_src, *cp_dst, *cp_mix;
143         int temp;
144         uint col_mix = 0;
145
146         if (fac == 0) {
147                 return col_src;
148         }
149
150         cp_src = (uchar *)&col_src;
151         cp_dst = (uchar *)&col_dst;
152         cp_mix = (uchar *)&col_mix;
153
154         temp = cp_src[0] + divide_round_i((fac * cp_dst[0]), 255);
155         cp_mix[0] = (temp > 254) ? 255 : temp;
156         temp = cp_src[1] + divide_round_i((fac * cp_dst[1]), 255);
157         cp_mix[1] = (temp > 254) ? 255 : temp;
158         temp = cp_src[2] + divide_round_i((fac * cp_dst[2]), 255);
159         cp_mix[2] = (temp > 254) ? 255 : temp;
160         temp = cp_src[3] + divide_round_i((fac * cp_dst[3]), 255);
161         cp_mix[3] = (temp > 254) ? 255 : temp;
162
163         return col_mix;
164 }
165
166 BLI_INLINE uint mcol_sub(uint col_src, uint col_dst, int fac)
167 {
168         uchar *cp_src, *cp_dst, *cp_mix;
169         int temp;
170         uint col_mix = 0;
171
172         if (fac == 0) {
173                 return col_src;
174         }
175
176         cp_src = (uchar *)&col_src;
177         cp_dst = (uchar *)&col_dst;
178         cp_mix = (uchar *)&col_mix;
179
180         temp = cp_src[0] - divide_round_i((fac * cp_dst[0]), 255);
181         cp_mix[0] = (temp < 0) ? 0 : temp;
182         temp = cp_src[1] - divide_round_i((fac * cp_dst[1]), 255);
183         cp_mix[1] = (temp < 0) ? 0 : temp;
184         temp = cp_src[2] - divide_round_i((fac * cp_dst[2]), 255);
185         cp_mix[2] = (temp < 0) ? 0 : temp;
186         temp = cp_src[3] - divide_round_i((fac * cp_dst[3]), 255);
187         cp_mix[3] = (temp < 0) ? 0 : temp;
188
189         return col_mix;
190 }
191
192 BLI_INLINE uint mcol_mul(uint col_src, uint col_dst, int fac)
193 {
194         uchar *cp_src, *cp_dst, *cp_mix;
195         int mfac;
196         uint col_mix = 0;
197
198         if (fac == 0) {
199                 return col_src;
200         }
201
202         mfac = 255 - fac;
203
204         cp_src = (uchar *)&col_src;
205         cp_dst = (uchar *)&col_dst;
206         cp_mix = (uchar *)&col_mix;
207
208         /* first mul, then blend the fac */
209         cp_mix[0] = divide_round_i(mfac * cp_src[0] * 255 + fac * cp_dst[0] * cp_src[0], 255 * 255);
210         cp_mix[1] = divide_round_i(mfac * cp_src[1] * 255 + fac * cp_dst[1] * cp_src[1], 255 * 255);
211         cp_mix[2] = divide_round_i(mfac * cp_src[2] * 255 + fac * cp_dst[2] * cp_src[2], 255 * 255);
212         cp_mix[3] = divide_round_i(mfac * cp_src[3] * 255 + fac * cp_dst[3] * cp_src[3], 255 * 255);
213
214         return col_mix;
215 }
216
217 BLI_INLINE uint mcol_lighten(uint col_src, uint col_dst, int fac)
218 {
219         uchar *cp_src, *cp_dst, *cp_mix;
220         int mfac;
221         uint col_mix = 0;
222
223         if (fac == 0) {
224                 return col_src;
225         }
226         else if (fac >= 255) {
227                 return col_dst;
228         }
229
230         mfac = 255 - fac;
231
232         cp_src = (uchar *)&col_src;
233         cp_dst = (uchar *)&col_dst;
234         cp_mix = (uchar *)&col_mix;
235
236         /* See if are lighter, if so mix, else don't do anything.
237          * if the paint color is darker then the original, then ignore */
238         if (IMB_colormanagement_get_luminance_byte(cp_src) > IMB_colormanagement_get_luminance_byte(cp_dst)) {
239                 return col_src;
240         }
241
242         cp_mix[0] = divide_round_i(mfac * cp_src[0] + fac * cp_dst[0], 255);
243         cp_mix[1] = divide_round_i(mfac * cp_src[1] + fac * cp_dst[1], 255);
244         cp_mix[2] = divide_round_i(mfac * cp_src[2] + fac * cp_dst[2], 255);
245         cp_mix[3] = divide_round_i(mfac * cp_src[3] + fac * cp_dst[3], 255);
246
247         return col_mix;
248 }
249
250 BLI_INLINE uint mcol_darken(uint col_src, uint col_dst, int fac)
251 {
252         uchar *cp_src, *cp_dst, *cp_mix;
253         int mfac;
254         uint col_mix = 0;
255
256         if (fac == 0) {
257                 return col_src;
258         }
259         else if (fac >= 255) {
260                 return col_dst;
261         }
262
263         mfac = 255 - fac;
264
265         cp_src = (uchar *)&col_src;
266         cp_dst = (uchar *)&col_dst;
267         cp_mix = (uchar *)&col_mix;
268
269         /* See if were darker, if so mix, else don't do anything.
270          * if the paint color is brighter then the original, then ignore */
271         if (IMB_colormanagement_get_luminance_byte(cp_src) < IMB_colormanagement_get_luminance_byte(cp_dst)) {
272                 return col_src;
273         }
274
275         cp_mix[0] = divide_round_i((mfac * cp_src[0] + fac * cp_dst[0]), 255);
276         cp_mix[1] = divide_round_i((mfac * cp_src[1] + fac * cp_dst[1]), 255);
277         cp_mix[2] = divide_round_i((mfac * cp_src[2] + fac * cp_dst[2]), 255);
278         cp_mix[3] = divide_round_i((mfac * cp_src[3] + fac * cp_dst[3]), 255);
279         return col_mix;
280 }
281
282 BLI_INLINE uint mcol_colordodge(uint col_src, uint col_dst, int fac)
283 {
284         uchar *cp_src, *cp_dst, *cp_mix;
285         int mfac, temp;
286         uint col_mix = 0;
287
288         if (fac == 0) {
289                 return col_src;
290         }
291
292         mfac = 255 - fac;
293
294         cp_src = (uchar *)&col_src;
295         cp_dst = (uchar *)&col_dst;
296         cp_mix = (uchar *)&col_mix;
297
298         temp = (cp_dst[0] == 255) ? 255 : min_ii((cp_src[0] * 225) / (255 - cp_dst[0]), 255);
299         cp_mix[0] = (mfac * cp_src[0] + temp * fac) / 255;
300         temp = (cp_dst[1] == 255) ? 255 : min_ii((cp_src[1] * 225) / (255 - cp_dst[1]), 255);
301         cp_mix[1] = (mfac * cp_src[1] + temp * fac) / 255;
302         temp = (cp_dst[2] == 255) ? 255 : min_ii((cp_src[2] * 225) / (255 - cp_dst[2]), 255);
303         cp_mix[2] = (mfac * cp_src[2] + temp * fac) / 255;
304         temp = (cp_dst[3] == 255) ? 255 : min_ii((cp_src[3] * 225) / (255 - cp_dst[3]), 255);
305         cp_mix[3] = (mfac * cp_src[3] + temp * fac) / 255;
306         return col_mix;
307 }
308
309 BLI_INLINE uint mcol_difference(uint col_src, uint col_dst, int fac)
310 {
311         uchar *cp_src, *cp_dst, *cp_mix;
312         int mfac, temp;
313         uint col_mix = 0;
314
315         if (fac == 0) {
316                 return col_src;
317         }
318
319         mfac = 255 - fac;
320
321         cp_src = (uchar *)&col_src;
322         cp_dst = (uchar *)&col_dst;
323         cp_mix = (uchar *)&col_mix;
324
325         temp = abs(cp_src[0] - cp_dst[0]);
326         cp_mix[0] = (mfac * cp_src[0] + temp * fac) / 255;
327         temp = abs(cp_src[1] - cp_dst[1]);
328         cp_mix[1] = (mfac * cp_src[1] + temp * fac) / 255;
329         temp = abs(cp_src[2] - cp_dst[2]);
330         cp_mix[2] = (mfac * cp_src[2] + temp * fac) / 255;
331         temp = abs(cp_src[3] - cp_dst[3]);
332         cp_mix[3] = (mfac * cp_src[3] + temp * fac) / 255;
333         return col_mix;
334 }
335
336 BLI_INLINE uint mcol_screen(uint col_src, uint col_dst, int fac)
337 {
338         uchar *cp_src, *cp_dst, *cp_mix;
339         int mfac, temp;
340         uint col_mix = 0;
341
342         if (fac == 0) {
343                 return col_src;
344         }
345
346         mfac = 255 - fac;
347
348         cp_src = (uchar *)&col_src;
349         cp_dst = (uchar *)&col_dst;
350         cp_mix = (uchar *)&col_mix;
351
352         temp = max_ii(255 - (((255 - cp_src[0]) * (255 - cp_dst[0])) / 255), 0);
353         cp_mix[0] = (mfac * cp_src[0] + temp * fac) / 255;
354         temp = max_ii(255 - (((255 - cp_src[1]) * (255 - cp_dst[1])) / 255), 0);
355         cp_mix[1] = (mfac * cp_src[1] + temp * fac) / 255;
356         temp = max_ii(255 - (((255 - cp_src[2]) * (255 - cp_dst[2])) / 255), 0);
357         cp_mix[2] = (mfac * cp_src[2] + temp * fac) / 255;
358         temp = max_ii(255 - (((255 - cp_src[3]) * (255 - cp_dst[3])) / 255), 0);
359         cp_mix[3] = (mfac * cp_src[3] + temp * fac) / 255;
360         return col_mix;
361 }
362
363 BLI_INLINE uint mcol_hardlight(uint col_src, uint col_dst, int fac)
364 {
365         uchar *cp_src, *cp_dst, *cp_mix;
366         int mfac, temp;
367         uint col_mix = 0;
368
369         if (fac == 0) {
370                 return col_src;
371         }
372
373         mfac = 255 - fac;
374
375         cp_src = (uchar *)&col_src;
376         cp_dst = (uchar *)&col_dst;
377         cp_mix = (uchar *)&col_mix;
378
379         int i = 0;
380
381         for (i = 0; i < 4; i++) {
382                 if (cp_dst[i] > 127) {
383                         temp = 255 - ((255 - 2 * (cp_dst[i] - 127)) * (255 - cp_src[i]) / 255);
384                 }
385                 else {
386                         temp = (2 * cp_dst[i] * cp_src[i]) >> 8;
387                 }
388                 cp_mix[i] = min_ii((mfac * cp_src[i] + temp * fac) / 255, 255);
389         }
390         return col_mix;
391 }
392
393 BLI_INLINE uint mcol_overlay(uint col_src, uint col_dst, int fac)
394 {
395         uchar *cp_src, *cp_dst, *cp_mix;
396         int mfac, temp;
397         uint col_mix = 0;
398
399         if (fac == 0) {
400                 return col_src;
401         }
402
403         mfac = 255 - fac;
404
405         cp_src = (uchar *)&col_src;
406         cp_dst = (uchar *)&col_dst;
407         cp_mix = (uchar *)&col_mix;
408
409         int i = 0;
410
411         for (i = 0; i < 4; i++) {
412                 if (cp_src[i] > 127) {
413                         temp = 255 - ((255 - 2 * (cp_src[i] - 127)) * (255 - cp_dst[i]) / 255);
414                 }
415                 else {
416                         temp = (2 * cp_dst[i] * cp_src[i]) >> 8;
417                 }
418                 cp_mix[i] = min_ii((mfac * cp_src[i] + temp * fac) / 255, 255);
419         }
420         return col_mix;
421 }
422
423 BLI_INLINE uint mcol_softlight(uint col_src, uint col_dst, int fac)
424 {
425         uchar *cp_src, *cp_dst, *cp_mix;
426         int mfac, temp;
427         uint col_mix = 0;
428
429         if (fac == 0) {
430                 return col_src;
431         }
432
433         mfac = 255 - fac;
434
435         cp_src = (uchar *)&col_src;
436         cp_dst = (uchar *)&col_dst;
437         cp_mix = (uchar *)&col_mix;
438
439         int i = 0;
440
441         for (i = 0; i < 4; i++) {
442                 if (cp_src[i] < 127) {
443                         temp = ((2 * ((cp_dst[i] / 2) + 64)) * cp_src[i]) / 255;
444                 }
445                 else {
446                         temp = 255 - (2 * (255 - ((cp_dst[i] / 2) + 64)) * (255 - cp_src[i]) / 255);
447                 }
448                 cp_mix[i] = (temp * fac + cp_src[i] * mfac) / 255;
449         }
450         return col_mix;
451 }
452
453 BLI_INLINE uint mcol_exclusion(uint col_src, uint col_dst, int fac)
454 {
455         uchar *cp_src, *cp_dst, *cp_mix;
456         int mfac, temp;
457         uint col_mix = 0;
458
459         if (fac == 0) {
460                 return col_src;
461         }
462
463         mfac = 255 - fac;
464
465         cp_src = (uchar *)&col_src;
466         cp_dst = (uchar *)&col_dst;
467         cp_mix = (uchar *)&col_mix;
468
469         int i = 0;
470
471         for (i = 0; i < 4; i++) {
472                 temp = 127 - ((2 * (cp_src[i] - 127) * (cp_dst[i] - 127)) / 255);
473                 cp_mix[i] = (temp * fac + cp_src[i] * mfac) / 255;
474         }
475         return col_mix;
476 }
477
478 BLI_INLINE uint mcol_luminosity(uint col_src, uint col_dst, int fac)
479 {
480         uchar *cp_src, *cp_dst, *cp_mix;
481         int mfac;
482         uint col_mix = 0;
483
484         if (fac == 0) {
485                 return col_src;
486         }
487
488         mfac = 255 - fac;
489
490         cp_src = (uchar *)&col_src;
491         cp_dst = (uchar *)&col_dst;
492         cp_mix = (uchar *)&col_mix;
493
494         float h1, s1, v1;
495         float h2, s2, v2;
496         float r, g, b;
497         rgb_to_hsv(cp_src[0] / 255.0f, cp_src[1] / 255.0f, cp_src[2] / 255.0f, &h1, &s1, &v1);
498         rgb_to_hsv(cp_dst[0] / 255.0f, cp_dst[1] / 255.0f, cp_dst[2] / 255.0f, &h2, &s2, &v2);
499
500         v1 = v2;
501
502         hsv_to_rgb(h1, s1, v1, &r, &g, &b);
503
504         cp_mix[0] = ((int)(r * 255.0f) * fac + mfac * cp_src[0]) / 255;
505         cp_mix[1] = ((int)(g * 255.0f) * fac + mfac * cp_src[1]) / 255;
506         cp_mix[2] = ((int)(b * 255.0f) * fac + mfac * cp_src[2]) / 255;
507         cp_mix[3] = ((int)(cp_dst[3])  * fac + mfac * cp_src[3]) / 255;
508         return col_mix;
509 }
510
511 BLI_INLINE uint mcol_saturation(uint col_src, uint col_dst, int fac)
512 {
513         uchar *cp_src, *cp_dst, *cp_mix;
514         int mfac;
515         uint col_mix = 0;
516
517         if (fac == 0) {
518                 return col_src;
519         }
520
521         mfac = 255 - fac;
522
523         cp_src = (uchar *)&col_src;
524         cp_dst = (uchar *)&col_dst;
525         cp_mix = (uchar *)&col_mix;
526
527         float h1, s1, v1;
528         float h2, s2, v2;
529         float r, g, b;
530         rgb_to_hsv(cp_src[0] / 255.0f, cp_src[1] / 255.0f, cp_src[2] / 255.0f, &h1, &s1, &v1);
531         rgb_to_hsv(cp_dst[0] / 255.0f, cp_dst[1] / 255.0f, cp_dst[2] / 255.0f, &h2, &s2, &v2);
532
533         if (s1 > EPS_SATURATION) {
534                 s1 = s2;
535         }
536
537         hsv_to_rgb(h1, s1, v1, &r, &g, &b);
538
539         cp_mix[0] = ((int)(r * 255.0f) * fac + mfac * cp_src[0]) / 255;
540         cp_mix[1] = ((int)(g * 255.0f) * fac + mfac * cp_src[1]) / 255;
541         cp_mix[2] = ((int)(b * 255.0f) * fac + mfac * cp_src[2]) / 255;
542         return col_mix;
543 }
544
545 BLI_INLINE uint mcol_hue(uint col_src, uint col_dst, int fac)
546 {
547         uchar *cp_src, *cp_dst, *cp_mix;
548         int mfac;
549         uint col_mix = 0;
550
551         if (fac == 0) {
552                 return col_src;
553         }
554
555         mfac = 255 - fac;
556
557         cp_src = (uchar *)&col_src;
558         cp_dst = (uchar *)&col_dst;
559         cp_mix = (uchar *)&col_mix;
560
561         float h1, s1, v1;
562         float h2, s2, v2;
563         float r, g, b;
564         rgb_to_hsv(cp_src[0] / 255.0f, cp_src[1] / 255.0f, cp_src[2] / 255.0f, &h1, &s1, &v1);
565         rgb_to_hsv(cp_dst[0] / 255.0f, cp_dst[1] / 255.0f, cp_dst[2] / 255.0f, &h2, &s2, &v2);
566
567         h1 = h2;
568
569         hsv_to_rgb(h1, s1, v1, &r, &g, &b);
570
571         cp_mix[0] = ((int)(r * 255.0f) * fac + mfac * cp_src[0]) / 255;
572         cp_mix[1] = ((int)(g * 255.0f) * fac + mfac * cp_src[1]) / 255;
573         cp_mix[2] = ((int)(b * 255.0f) * fac + mfac * cp_src[2]) / 255;
574         cp_mix[3] = ((int)(cp_dst[3])  * fac + mfac * cp_src[3]) / 255;
575         return col_mix;
576 }
577
578 BLI_INLINE uint mcol_alpha_add(uint col_src, int fac)
579 {
580         uchar *cp_src, *cp_mix;
581         int temp;
582         uint col_mix = col_src;
583
584         if (fac == 0) {
585                 return col_src;
586         }
587
588         cp_src = (uchar *)&col_src;
589         cp_mix = (uchar *)&col_mix;
590
591         temp = cp_src[3] + fac;
592         cp_mix[3] = (temp > 254) ? 255 : temp;
593
594         return col_mix;
595 }
596
597 BLI_INLINE uint mcol_alpha_sub(uint col_src, int fac)
598 {
599         uchar *cp_src, *cp_mix;
600         int temp;
601         uint col_mix = col_src;
602
603         if (fac == 0) {
604                 return col_src;
605         }
606
607         cp_src = (uchar *)&col_src;
608         cp_mix = (uchar *)&col_mix;
609
610         temp = cp_src[3] - fac;
611         cp_mix[3] = temp < 0 ? 0 : temp;
612
613         return col_mix;
614 }
615
616 /* wpaint has 'ED_wpaint_blend_tool' */
617 uint ED_vpaint_blend_tool(
618         const int tool, const uint col,
619         const uint paintcol, const int alpha_i)
620 {
621         switch ((IMB_BlendMode)tool) {
622                 case IMB_BLEND_MIX:        return mcol_blend(col, paintcol, alpha_i);
623                 case IMB_BLEND_ADD:        return mcol_add(col, paintcol, alpha_i);
624                 case IMB_BLEND_SUB:        return mcol_sub(col, paintcol, alpha_i);
625                 case IMB_BLEND_MUL:        return mcol_mul(col, paintcol, alpha_i);
626                 case IMB_BLEND_LIGHTEN:    return mcol_lighten(col, paintcol, alpha_i);
627                 case IMB_BLEND_DARKEN:     return mcol_darken(col, paintcol, alpha_i);
628                 case IMB_BLEND_COLORDODGE: return mcol_colordodge(col, paintcol, alpha_i);
629                 case IMB_BLEND_DIFFERENCE: return mcol_difference(col, paintcol, alpha_i);
630                 case IMB_BLEND_SCREEN:     return mcol_screen(col, paintcol, alpha_i);
631                 case IMB_BLEND_HARDLIGHT:  return mcol_hardlight(col, paintcol, alpha_i);
632                 case IMB_BLEND_OVERLAY:    return mcol_overlay(col, paintcol, alpha_i);
633                 case IMB_BLEND_SOFTLIGHT:  return mcol_softlight(col, paintcol, alpha_i);
634                 case IMB_BLEND_EXCLUSION:  return mcol_exclusion(col, paintcol, alpha_i);
635                 case IMB_BLEND_LUMINOSITY: return mcol_luminosity(col, paintcol, alpha_i);
636                 case IMB_BLEND_SATURATION: return mcol_saturation(col, paintcol, alpha_i);
637                 case IMB_BLEND_HUE:        return mcol_hue(col, paintcol, alpha_i);
638                 /* non-color */
639                 case IMB_BLEND_ERASE_ALPHA: return mcol_alpha_sub(col, alpha_i);
640                 case IMB_BLEND_ADD_ALPHA:   return mcol_alpha_add(col, alpha_i);
641                 default:
642                         BLI_assert(0);
643                         return 0;
644         }
645 }
646
647 /** \} */