Fix T66768: Grid fill span not working
[blender.git] / source / blender / editors / sculpt_paint / paint_image_2d.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23 //#include <math.h>
24 #include <string.h>
25
26 #include "MEM_guardedalloc.h"
27
28 #include "DNA_brush_types.h"
29 #include "DNA_scene_types.h"
30 #include "DNA_space_types.h"
31 #include "DNA_object_types.h"
32
33 #include "BLI_math_color_blend.h"
34 #include "BLI_stack.h"
35 #include "BLI_bitmap.h"
36 #include "BLI_task.h"
37
38 #include "BKE_colorband.h"
39 #include "BKE_context.h"
40 #include "BKE_brush.h"
41 #include "BKE_image.h"
42 #include "BKE_paint.h"
43 #include "BKE_report.h"
44
45 #include "DEG_depsgraph.h"
46
47 #include "ED_paint.h"
48 #include "ED_screen.h"
49
50 #include "IMB_imbuf.h"
51 #include "IMB_imbuf_types.h"
52 #include "IMB_colormanagement.h"
53
54 #include "WM_api.h"
55 #include "WM_types.h"
56
57 #include "UI_view2d.h"
58
59 #include "GPU_draw.h"
60
61 #include "paint_intern.h"
62
63 /* Brush Painting for 2D image editor */
64
65 /* Defines and Structs */
66
67 typedef struct BrushPainterCache {
68   bool use_float;            /* need float imbuf? */
69   bool use_color_correction; /* use color correction for float */
70   bool invert;
71
72   bool is_texbrush;
73   bool is_maskbrush;
74
75   int lastdiameter;
76   float last_tex_rotation;
77   float last_mask_rotation;
78   float last_pressure;
79
80   ImBuf *ibuf;
81   ImBuf *texibuf;
82   unsigned short *curve_mask;
83   unsigned short *tex_mask;
84   unsigned short *tex_mask_old;
85   unsigned int tex_mask_old_w;
86   unsigned int tex_mask_old_h;
87 } BrushPainterCache;
88
89 typedef struct BrushPainter {
90   Scene *scene;
91   Brush *brush;
92
93   float lastpaintpos[2];  /* position of last paint op */
94   float startpaintpos[2]; /* position of first paint */
95
96   short firsttouch; /* first paint op */
97
98   struct ImagePool *pool; /* image pool */
99   rctf tex_mapping;       /* texture coordinate mapping */
100   rctf mask_mapping;      /* mask texture coordinate mapping */
101
102   BrushPainterCache cache;
103 } BrushPainter;
104
105 typedef struct ImagePaintRegion {
106   int destx, desty;
107   int srcx, srcy;
108   int width, height;
109 } ImagePaintRegion;
110
111 typedef struct ImagePaintState {
112   BrushPainter *painter;
113   SpaceImage *sima;
114   View2D *v2d;
115   Scene *scene;
116   bScreen *screen;
117   struct ImagePool *image_pool;
118
119   Brush *brush;
120   short tool, blend;
121   Image *image;
122   ImBuf *canvas;
123   ImBuf *clonecanvas;
124   const char *warnpackedfile;
125   const char *warnmultifile;
126
127   bool do_masking;
128
129   /* viewport texture paint only, but _not_ project paint */
130   Object *ob;
131   int faceindex;
132   float uv[2];
133   int do_facesel;
134   int symmetry;
135
136   bool need_redraw;
137
138   BlurKernel *blurkernel;
139 } ImagePaintState;
140
141 static BrushPainter *brush_painter_2d_new(Scene *scene, Brush *brush, bool invert)
142 {
143   BrushPainter *painter = MEM_callocN(sizeof(BrushPainter), "BrushPainter");
144
145   painter->brush = brush;
146   painter->scene = scene;
147   painter->firsttouch = 1;
148   painter->cache.lastdiameter = -1; /* force ibuf create in refresh */
149   painter->cache.invert = invert;
150
151   return painter;
152 }
153
154 static void brush_painter_2d_require_imbuf(BrushPainter *painter,
155                                            bool use_float,
156                                            bool use_color_correction)
157 {
158   Brush *brush = painter->brush;
159
160   if ((painter->cache.use_float != use_float)) {
161     if (painter->cache.ibuf) {
162       IMB_freeImBuf(painter->cache.ibuf);
163     }
164     if (painter->cache.curve_mask) {
165       MEM_freeN(painter->cache.curve_mask);
166     }
167     if (painter->cache.tex_mask) {
168       MEM_freeN(painter->cache.tex_mask);
169     }
170     if (painter->cache.tex_mask_old) {
171       MEM_freeN(painter->cache.tex_mask_old);
172     }
173     painter->cache.ibuf = NULL;
174     painter->cache.curve_mask = NULL;
175     painter->cache.tex_mask = NULL;
176     painter->cache.lastdiameter = -1; /* force ibuf create in refresh */
177   }
178
179   painter->cache.use_float = use_float;
180   painter->cache.use_color_correction = use_float && use_color_correction;
181   painter->cache.is_texbrush = (brush->mtex.tex && brush->imagepaint_tool == PAINT_TOOL_DRAW) ?
182                                    true :
183                                    false;
184   painter->cache.is_maskbrush = (brush->mask_mtex.tex) ? true : false;
185 }
186
187 static void brush_painter_2d_free(BrushPainter *painter)
188 {
189   if (painter->cache.ibuf) {
190     IMB_freeImBuf(painter->cache.ibuf);
191   }
192   if (painter->cache.texibuf) {
193     IMB_freeImBuf(painter->cache.texibuf);
194   }
195   if (painter->cache.curve_mask) {
196     MEM_freeN(painter->cache.curve_mask);
197   }
198   if (painter->cache.tex_mask) {
199     MEM_freeN(painter->cache.tex_mask);
200   }
201   if (painter->cache.tex_mask_old) {
202     MEM_freeN(painter->cache.tex_mask_old);
203   }
204   MEM_freeN(painter);
205 }
206
207 static void brush_imbuf_tex_co(rctf *mapping, int x, int y, float texco[3])
208 {
209   texco[0] = mapping->xmin + x * mapping->xmax;
210   texco[1] = mapping->ymin + y * mapping->ymax;
211   texco[2] = 0.0f;
212 }
213
214 /* create a mask with the mask texture */
215 static unsigned short *brush_painter_mask_ibuf_new(BrushPainter *painter, int size)
216 {
217   Scene *scene = painter->scene;
218   Brush *brush = painter->brush;
219   rctf mask_mapping = painter->mask_mapping;
220   struct ImagePool *pool = painter->pool;
221
222   float texco[3];
223   unsigned short *mask, *m;
224   int x, y, thread = 0;
225
226   mask = MEM_mallocN(sizeof(unsigned short) * size * size, "brush_painter_mask");
227   m = mask;
228
229   for (y = 0; y < size; y++) {
230     for (x = 0; x < size; x++, m++) {
231       float res;
232       brush_imbuf_tex_co(&mask_mapping, x, y, texco);
233       res = BKE_brush_sample_masktex(scene, brush, texco, thread, pool);
234       *m = (unsigned short)(65535.0f * res);
235     }
236   }
237
238   return mask;
239 }
240
241 /* update rectangular section of the brush image */
242 static void brush_painter_mask_imbuf_update(BrushPainter *painter,
243                                             unsigned short *tex_mask_old,
244                                             int origx,
245                                             int origy,
246                                             int w,
247                                             int h,
248                                             int xt,
249                                             int yt,
250                                             int diameter)
251 {
252   Scene *scene = painter->scene;
253   Brush *brush = painter->brush;
254   rctf tex_mapping = painter->mask_mapping;
255   struct ImagePool *pool = painter->pool;
256   unsigned short res;
257
258   bool use_texture_old = (tex_mask_old != NULL);
259
260   int x, y, thread = 0;
261
262   unsigned short *tex_mask = painter->cache.tex_mask;
263   unsigned short *tex_mask_cur = painter->cache.tex_mask_old;
264
265   /* fill pixels */
266   for (y = origy; y < h; y++) {
267     for (x = origx; x < w; x++) {
268       /* sample texture */
269       float texco[3];
270
271       /* handle byte pixel */
272       unsigned short *b = tex_mask + (y * diameter + x);
273       unsigned short *t = tex_mask_cur + (y * diameter + x);
274
275       if (!use_texture_old) {
276         brush_imbuf_tex_co(&tex_mapping, x, y, texco);
277         res = (unsigned short)(65535.0f *
278                                BKE_brush_sample_masktex(scene, brush, texco, thread, pool));
279       }
280
281       /* read from old texture buffer */
282       if (use_texture_old) {
283         res = *(tex_mask_old +
284                 ((y - origy + yt) * painter->cache.tex_mask_old_w + (x - origx + xt)));
285       }
286
287       /* write to new texture mask */
288       *t = res;
289       /* write to mask image buffer */
290       *b = res;
291     }
292   }
293 }
294
295 /**
296  * Update the brush mask image by trying to reuse the cached texture result.
297  * This can be considerably faster for brushes that change size due to pressure or
298  * textures that stick to the surface where only part of the pixels are new
299  */
300 static void brush_painter_mask_imbuf_partial_update(BrushPainter *painter,
301                                                     const float pos[2],
302                                                     int diameter)
303 {
304   BrushPainterCache *cache = &painter->cache;
305   unsigned short *tex_mask_old;
306   int destx, desty, srcx, srcy, w, h, x1, y1, x2, y2;
307
308   /* create brush image buffer if it didn't exist yet */
309   if (!cache->tex_mask) {
310     cache->tex_mask = MEM_mallocN(sizeof(unsigned short) * diameter * diameter,
311                                   "brush_painter_mask");
312   }
313
314   /* create new texture image buffer with coordinates relative to old */
315   tex_mask_old = cache->tex_mask_old;
316   cache->tex_mask_old = MEM_mallocN(sizeof(unsigned short) * diameter * diameter,
317                                     "brush_painter_mask");
318
319   if (tex_mask_old) {
320     ImBuf maskibuf;
321     ImBuf maskibuf_old;
322     maskibuf.x = maskibuf.y = diameter;
323     maskibuf_old.x = cache->tex_mask_old_w;
324     maskibuf_old.y = cache->tex_mask_old_h;
325
326     srcx = srcy = 0;
327     w = cache->tex_mask_old_w;
328     h = cache->tex_mask_old_h;
329     destx = (int)floorf(painter->lastpaintpos[0]) - (int)floorf(pos[0]) + (diameter / 2 - w / 2);
330     desty = (int)floorf(painter->lastpaintpos[1]) - (int)floorf(pos[1]) + (diameter / 2 - h / 2);
331
332     /* hack, use temporary rects so that clipping works */
333     IMB_rectclip(&maskibuf, &maskibuf_old, &destx, &desty, &srcx, &srcy, &w, &h);
334   }
335   else {
336     srcx = srcy = 0;
337     destx = desty = 0;
338     w = h = 0;
339   }
340
341   x1 = min_ii(destx, diameter);
342   y1 = min_ii(desty, diameter);
343   x2 = min_ii(destx + w, diameter);
344   y2 = min_ii(desty + h, diameter);
345
346   /* blend existing texture in new position */
347   if ((x1 < x2) && (y1 < y2)) {
348     brush_painter_mask_imbuf_update(painter, tex_mask_old, x1, y1, x2, y2, srcx, srcy, diameter);
349   }
350
351   if (tex_mask_old) {
352     MEM_freeN(tex_mask_old);
353   }
354
355   /* sample texture in new areas */
356   if ((0 < x1) && (0 < diameter)) {
357     brush_painter_mask_imbuf_update(painter, NULL, 0, 0, x1, diameter, 0, 0, diameter);
358   }
359   if ((x2 < diameter) && (0 < diameter)) {
360     brush_painter_mask_imbuf_update(painter, NULL, x2, 0, diameter, diameter, 0, 0, diameter);
361   }
362   if ((x1 < x2) && (0 < y1)) {
363     brush_painter_mask_imbuf_update(painter, NULL, x1, 0, x2, y1, 0, 0, diameter);
364   }
365   if ((x1 < x2) && (y2 < diameter)) {
366     brush_painter_mask_imbuf_update(painter, NULL, x1, y2, x2, diameter, 0, 0, diameter);
367   }
368
369   /* through with sampling, now update sizes */
370   cache->tex_mask_old_w = diameter;
371   cache->tex_mask_old_h = diameter;
372 }
373
374 /* create a mask with the falloff strength */
375 static unsigned short *brush_painter_curve_mask_new(BrushPainter *painter,
376                                                     int diameter,
377                                                     float radius)
378 {
379   Brush *brush = painter->brush;
380
381   int xoff = -radius;
382   int yoff = -radius;
383
384   unsigned short *mask, *m;
385   int x, y;
386
387   mask = MEM_mallocN(sizeof(unsigned short) * diameter * diameter, "brush_painter_mask");
388   m = mask;
389
390   for (y = 0; y < diameter; y++) {
391     for (x = 0; x < diameter; x++, m++) {
392       float xy[2] = {x + xoff, y + yoff};
393       float len = len_v2(xy);
394
395       *m = (unsigned short)(65535.0f * BKE_brush_curve_strength_clamped(brush, len, radius));
396     }
397   }
398
399   return mask;
400 }
401
402 /* create imbuf with brush color */
403 static ImBuf *brush_painter_imbuf_new(BrushPainter *painter,
404                                       int size,
405                                       float pressure,
406                                       float distance)
407 {
408   Scene *scene = painter->scene;
409   Brush *brush = painter->brush;
410
411   const char *display_device = scene->display_settings.display_device;
412   struct ColorManagedDisplay *display = IMB_colormanagement_display_get_named(display_device);
413
414   rctf tex_mapping = painter->tex_mapping;
415   struct ImagePool *pool = painter->pool;
416
417   bool use_color_correction = painter->cache.use_color_correction;
418   bool use_float = painter->cache.use_float;
419   bool is_texbrush = painter->cache.is_texbrush;
420
421   int x, y, thread = 0;
422   float brush_rgb[3];
423
424   /* allocate image buffer */
425   ImBuf *ibuf = IMB_allocImBuf(size, size, 32, (use_float) ? IB_rectfloat : IB_rect);
426
427   /* get brush color */
428   if (brush->imagepaint_tool == PAINT_TOOL_DRAW) {
429     paint_brush_color_get(scene,
430                           brush,
431                           use_color_correction,
432                           painter->cache.invert,
433                           distance,
434                           pressure,
435                           brush_rgb,
436                           display);
437   }
438   else {
439     brush_rgb[0] = 1.0f;
440     brush_rgb[1] = 1.0f;
441     brush_rgb[2] = 1.0f;
442   }
443
444   /* fill image buffer */
445   for (y = 0; y < size; y++) {
446     for (x = 0; x < size; x++) {
447       /* sample texture and multiply with brush color */
448       float texco[3], rgba[4];
449
450       if (is_texbrush) {
451         brush_imbuf_tex_co(&tex_mapping, x, y, texco);
452         BKE_brush_sample_tex_3d(scene, brush, texco, rgba, thread, pool);
453         /* TODO(sergey): Support texture paint color space. */
454         if (!use_float) {
455           IMB_colormanagement_scene_linear_to_display_v3(rgba, display);
456         }
457         mul_v3_v3(rgba, brush_rgb);
458       }
459       else {
460         copy_v3_v3(rgba, brush_rgb);
461         rgba[3] = 1.0f;
462       }
463
464       if (use_float) {
465         /* write to float pixel */
466         float *dstf = ibuf->rect_float + (y * size + x) * 4;
467         mul_v3_v3fl(dstf, rgba, rgba[3]); /* premultiply */
468         dstf[3] = rgba[3];
469       }
470       else {
471         /* write to byte pixel */
472         unsigned char *dst = (unsigned char *)ibuf->rect + (y * size + x) * 4;
473
474         rgb_float_to_uchar(dst, rgba);
475         dst[3] = unit_float_to_uchar_clamp(rgba[3]);
476       }
477     }
478   }
479
480   return ibuf;
481 }
482
483 /* update rectangular section of the brush image */
484 static void brush_painter_imbuf_update(
485     BrushPainter *painter, ImBuf *oldtexibuf, int origx, int origy, int w, int h, int xt, int yt)
486 {
487   Scene *scene = painter->scene;
488   Brush *brush = painter->brush;
489
490   const char *display_device = scene->display_settings.display_device;
491   struct ColorManagedDisplay *display = IMB_colormanagement_display_get_named(display_device);
492
493   rctf tex_mapping = painter->tex_mapping;
494   struct ImagePool *pool = painter->pool;
495
496   bool use_color_correction = painter->cache.use_color_correction;
497   bool use_float = painter->cache.use_float;
498   bool is_texbrush = painter->cache.is_texbrush;
499   bool use_texture_old = (oldtexibuf != NULL);
500
501   int x, y, thread = 0;
502   float brush_rgb[3];
503
504   ImBuf *ibuf = painter->cache.ibuf;
505   ImBuf *texibuf = painter->cache.texibuf;
506
507   /* get brush color */
508   if (brush->imagepaint_tool == PAINT_TOOL_DRAW) {
509     paint_brush_color_get(
510         scene, brush, use_color_correction, painter->cache.invert, 0.0, 1.0, brush_rgb, display);
511   }
512   else {
513     brush_rgb[0] = 1.0f;
514     brush_rgb[1] = 1.0f;
515     brush_rgb[2] = 1.0f;
516   }
517
518   /* fill pixels */
519   for (y = origy; y < h; y++) {
520     for (x = origx; x < w; x++) {
521       /* sample texture and multiply with brush color */
522       float texco[3], rgba[4];
523
524       if (!use_texture_old) {
525         if (is_texbrush) {
526           brush_imbuf_tex_co(&tex_mapping, x, y, texco);
527           BKE_brush_sample_tex_3d(scene, brush, texco, rgba, thread, pool);
528           /* TODO(sergey): Support texture paint color space. */
529           if (!use_float) {
530             IMB_colormanagement_scene_linear_to_display_v3(rgba, display);
531           }
532           mul_v3_v3(rgba, brush_rgb);
533         }
534         else {
535           copy_v3_v3(rgba, brush_rgb);
536           rgba[3] = 1.0f;
537         }
538       }
539
540       if (use_float) {
541         /* handle float pixel */
542         float *bf = ibuf->rect_float + (y * ibuf->x + x) * 4;
543         float *tf = texibuf->rect_float + (y * texibuf->x + x) * 4;
544
545         /* read from old texture buffer */
546         if (use_texture_old) {
547           const float *otf = oldtexibuf->rect_float +
548                              ((y - origy + yt) * oldtexibuf->x + (x - origx + xt)) * 4;
549           copy_v4_v4(rgba, otf);
550         }
551
552         /* write to new texture buffer */
553         copy_v4_v4(tf, rgba);
554
555         /* output premultiplied float image, mf was already premultiplied */
556         mul_v3_v3fl(bf, rgba, rgba[3]);
557         bf[3] = rgba[3];
558       }
559       else {
560         unsigned char crgba[4];
561
562         /* handle byte pixel */
563         unsigned char *b = (unsigned char *)ibuf->rect + (y * ibuf->x + x) * 4;
564         unsigned char *t = (unsigned char *)texibuf->rect + (y * texibuf->x + x) * 4;
565
566         /* read from old texture buffer */
567         if (use_texture_old) {
568           unsigned char *ot = (unsigned char *)oldtexibuf->rect +
569                               ((y - origy + yt) * oldtexibuf->x + (x - origx + xt)) * 4;
570           crgba[0] = ot[0];
571           crgba[1] = ot[1];
572           crgba[2] = ot[2];
573           crgba[3] = ot[3];
574         }
575         else {
576           rgba_float_to_uchar(crgba, rgba);
577         }
578
579         /* write to new texture buffer */
580         t[0] = crgba[0];
581         t[1] = crgba[1];
582         t[2] = crgba[2];
583         t[3] = crgba[3];
584
585         /* write to brush image buffer */
586         b[0] = crgba[0];
587         b[1] = crgba[1];
588         b[2] = crgba[2];
589         b[3] = crgba[3];
590       }
591     }
592   }
593 }
594
595 /* update the brush image by trying to reuse the cached texture result. this
596  * can be considerably faster for brushes that change size due to pressure or
597  * textures that stick to the surface where only part of the pixels are new */
598 static void brush_painter_imbuf_partial_update(BrushPainter *painter,
599                                                const float pos[2],
600                                                int diameter)
601 {
602   BrushPainterCache *cache = &painter->cache;
603   ImBuf *oldtexibuf, *ibuf;
604   int imbflag, destx, desty, srcx, srcy, w, h, x1, y1, x2, y2;
605
606   /* create brush image buffer if it didn't exist yet */
607   imbflag = (cache->use_float) ? IB_rectfloat : IB_rect;
608   if (!cache->ibuf) {
609     cache->ibuf = IMB_allocImBuf(diameter, diameter, 32, imbflag);
610   }
611   ibuf = cache->ibuf;
612
613   /* create new texture image buffer with coordinates relative to old */
614   oldtexibuf = cache->texibuf;
615   cache->texibuf = IMB_allocImBuf(diameter, diameter, 32, imbflag);
616
617   if (oldtexibuf) {
618     srcx = srcy = 0;
619     w = oldtexibuf->x;
620     h = oldtexibuf->y;
621     destx = (int)floorf(painter->lastpaintpos[0]) - (int)floorf(pos[0]) + (diameter / 2 - w / 2);
622     desty = (int)floorf(painter->lastpaintpos[1]) - (int)floorf(pos[1]) + (diameter / 2 - h / 2);
623
624     IMB_rectclip(cache->texibuf, oldtexibuf, &destx, &desty, &srcx, &srcy, &w, &h);
625   }
626   else {
627     srcx = srcy = 0;
628     destx = desty = 0;
629     w = h = 0;
630   }
631
632   x1 = min_ii(destx, ibuf->x);
633   y1 = min_ii(desty, ibuf->y);
634   x2 = min_ii(destx + w, ibuf->x);
635   y2 = min_ii(desty + h, ibuf->y);
636
637   /* blend existing texture in new position */
638   if ((x1 < x2) && (y1 < y2)) {
639     brush_painter_imbuf_update(painter, oldtexibuf, x1, y1, x2, y2, srcx, srcy);
640   }
641
642   if (oldtexibuf) {
643     IMB_freeImBuf(oldtexibuf);
644   }
645
646   /* sample texture in new areas */
647   if ((0 < x1) && (0 < ibuf->y)) {
648     brush_painter_imbuf_update(painter, NULL, 0, 0, x1, ibuf->y, 0, 0);
649   }
650   if ((x2 < ibuf->x) && (0 < ibuf->y)) {
651     brush_painter_imbuf_update(painter, NULL, x2, 0, ibuf->x, ibuf->y, 0, 0);
652   }
653   if ((x1 < x2) && (0 < y1)) {
654     brush_painter_imbuf_update(painter, NULL, x1, 0, x2, y1, 0, 0);
655   }
656   if ((x1 < x2) && (y2 < ibuf->y)) {
657     brush_painter_imbuf_update(painter, NULL, x1, y2, x2, ibuf->y, 0, 0);
658   }
659 }
660
661 static void brush_painter_2d_tex_mapping(ImagePaintState *s,
662                                          int diameter,
663                                          const float startpos[2],
664                                          const float pos[2],
665                                          const float mouse[2],
666                                          int mapmode,
667                                          rctf *mapping)
668 {
669   float invw = 1.0f / (float)s->canvas->x;
670   float invh = 1.0f / (float)s->canvas->y;
671   int xmin, ymin, xmax, ymax;
672   int ipos[2];
673
674   /* find start coordinate of brush in canvas */
675   ipos[0] = (int)floorf((pos[0] - diameter / 2) + 1.0f);
676   ipos[1] = (int)floorf((pos[1] - diameter / 2) + 1.0f);
677
678   if (mapmode == MTEX_MAP_MODE_STENCIL) {
679     /* map from view coordinates of brush to region coordinates */
680     UI_view2d_view_to_region(s->v2d, ipos[0] * invw, ipos[1] * invh, &xmin, &ymin);
681     UI_view2d_view_to_region(
682         s->v2d, (ipos[0] + diameter) * invw, (ipos[1] + diameter) * invh, &xmax, &ymax);
683
684     /* output mapping from brush ibuf x/y to region coordinates */
685     mapping->xmin = xmin;
686     mapping->ymin = ymin;
687     mapping->xmax = (xmax - xmin) / (float)diameter;
688     mapping->ymax = (ymax - ymin) / (float)diameter;
689   }
690   else if (mapmode == MTEX_MAP_MODE_3D) {
691     /* 3D mapping, just mapping to canvas 0..1  */
692     mapping->xmin = 2.0f * (ipos[0] * invw - 0.5f);
693     mapping->ymin = 2.0f * (ipos[1] * invh - 0.5f);
694     mapping->xmax = 2.0f * invw;
695     mapping->ymax = 2.0f * invh;
696   }
697   else if (ELEM(mapmode, MTEX_MAP_MODE_VIEW, MTEX_MAP_MODE_RANDOM)) {
698     /* view mapping */
699     mapping->xmin = mouse[0] - diameter * 0.5f + 0.5f;
700     mapping->ymin = mouse[1] - diameter * 0.5f + 0.5f;
701     mapping->xmax = 1.0f;
702     mapping->ymax = 1.0f;
703   }
704   else /* if (mapmode == MTEX_MAP_MODE_TILED) */ {
705     mapping->xmin = (int)(-diameter * 0.5) + (int)floorf(pos[0]) - (int)floorf(startpos[0]);
706     mapping->ymin = (int)(-diameter * 0.5) + (int)floorf(pos[1]) - (int)floorf(startpos[1]);
707     mapping->xmax = 1.0f;
708     mapping->ymax = 1.0f;
709   }
710 }
711
712 static void brush_painter_2d_refresh_cache(ImagePaintState *s,
713                                            BrushPainter *painter,
714                                            const float pos[2],
715                                            const float mouse[2],
716                                            float pressure,
717                                            float distance,
718                                            float size)
719 {
720   const Scene *scene = painter->scene;
721   UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
722   Brush *brush = painter->brush;
723   BrushPainterCache *cache = &painter->cache;
724   const int diameter = 2 * size;
725
726   bool do_random = false;
727   bool do_partial_update = false;
728   bool update_color = ((brush->flag & BRUSH_USE_GRADIENT) &&
729                        ((ELEM(brush->gradient_stroke_mode,
730                               BRUSH_GRADIENT_SPACING_REPEAT,
731                               BRUSH_GRADIENT_SPACING_CLAMP)) ||
732                         (cache->last_pressure != pressure)));
733   float tex_rotation = -brush->mtex.rot;
734   float mask_rotation = -brush->mask_mtex.rot;
735
736   painter->pool = BKE_image_pool_new();
737
738   /* determine how can update based on textures used */
739   if (painter->cache.is_texbrush) {
740     if (brush->mtex.brush_map_mode == MTEX_MAP_MODE_VIEW) {
741       tex_rotation += ups->brush_rotation;
742     }
743     else if (brush->mtex.brush_map_mode == MTEX_MAP_MODE_RANDOM) {
744       do_random = true;
745     }
746     else if (!((brush->flag & BRUSH_ANCHORED) || update_color)) {
747       do_partial_update = true;
748     }
749
750     brush_painter_2d_tex_mapping(s,
751                                  diameter,
752                                  painter->startpaintpos,
753                                  pos,
754                                  mouse,
755                                  brush->mtex.brush_map_mode,
756                                  &painter->tex_mapping);
757   }
758
759   if (painter->cache.is_maskbrush) {
760     bool renew_maxmask = false;
761     bool do_partial_update_mask = false;
762     /* invalidate case for all mapping modes */
763     if (brush->mask_mtex.brush_map_mode == MTEX_MAP_MODE_VIEW) {
764       mask_rotation += ups->brush_rotation_sec;
765     }
766     else if (brush->mask_mtex.brush_map_mode == MTEX_MAP_MODE_RANDOM) {
767       renew_maxmask = true;
768     }
769     else if (!(brush->flag & BRUSH_ANCHORED)) {
770       do_partial_update_mask = true;
771       renew_maxmask = true;
772     }
773     /* explicitly disable partial update even if it has been enabled above */
774     if (brush->mask_pressure) {
775       do_partial_update_mask = false;
776       renew_maxmask = true;
777     }
778
779     if ((diameter != cache->lastdiameter) || (mask_rotation != cache->last_mask_rotation) ||
780         renew_maxmask) {
781       if (cache->tex_mask) {
782         MEM_freeN(cache->tex_mask);
783         cache->tex_mask = NULL;
784       }
785
786       brush_painter_2d_tex_mapping(s,
787                                    diameter,
788                                    painter->startpaintpos,
789                                    pos,
790                                    mouse,
791                                    brush->mask_mtex.brush_map_mode,
792                                    &painter->mask_mapping);
793
794       if (do_partial_update_mask) {
795         brush_painter_mask_imbuf_partial_update(painter, pos, diameter);
796       }
797       else {
798         cache->tex_mask = brush_painter_mask_ibuf_new(painter, diameter);
799       }
800       cache->last_mask_rotation = mask_rotation;
801     }
802   }
803
804   /* curve mask can only change if the size changes */
805   if (diameter != cache->lastdiameter) {
806     if (cache->curve_mask) {
807       MEM_freeN(cache->curve_mask);
808       cache->curve_mask = NULL;
809     }
810
811     cache->curve_mask = brush_painter_curve_mask_new(painter, diameter, size);
812   }
813
814   /* detect if we need to recreate image brush buffer */
815   if ((diameter != cache->lastdiameter) || (tex_rotation != cache->last_tex_rotation) ||
816       do_random || update_color) {
817     if (cache->ibuf) {
818       IMB_freeImBuf(cache->ibuf);
819       cache->ibuf = NULL;
820     }
821
822     if (do_partial_update) {
823       /* do partial update of texture */
824       brush_painter_imbuf_partial_update(painter, pos, diameter);
825     }
826     else {
827       /* create brush from scratch */
828       cache->ibuf = brush_painter_imbuf_new(painter, diameter, pressure, distance);
829     }
830
831     cache->lastdiameter = diameter;
832     cache->last_tex_rotation = tex_rotation;
833     cache->last_pressure = pressure;
834   }
835   else if (do_partial_update) {
836     /* do only partial update of texture */
837     int dx = (int)floorf(painter->lastpaintpos[0]) - (int)floorf(pos[0]);
838     int dy = (int)floorf(painter->lastpaintpos[1]) - (int)floorf(pos[1]);
839
840     if ((dx != 0) || (dy != 0)) {
841       brush_painter_imbuf_partial_update(painter, pos, diameter);
842     }
843   }
844
845   BKE_image_pool_free(painter->pool);
846   painter->pool = NULL;
847 }
848
849 /* keep these functions in sync */
850 static void paint_2d_ibuf_rgb_get(ImBuf *ibuf, int x, int y, float r_rgb[4])
851 {
852   if (ibuf->rect_float) {
853     const float *rrgbf = ibuf->rect_float + (ibuf->x * y + x) * 4;
854     copy_v4_v4(r_rgb, rrgbf);
855   }
856   else {
857     unsigned char *rrgb = (unsigned char *)ibuf->rect + (ibuf->x * y + x) * 4;
858     straight_uchar_to_premul_float(r_rgb, rrgb);
859   }
860 }
861 static void paint_2d_ibuf_rgb_set(
862     ImBuf *ibuf, int x, int y, const bool is_torus, const float rgb[4])
863 {
864   if (is_torus) {
865     x %= ibuf->x;
866     if (x < 0) {
867       x += ibuf->x;
868     }
869     y %= ibuf->y;
870     if (y < 0) {
871       y += ibuf->y;
872     }
873   }
874
875   if (ibuf->rect_float) {
876     float *rrgbf = ibuf->rect_float + (ibuf->x * y + x) * 4;
877     float map_alpha = (rgb[3] == 0.0f) ? rrgbf[3] : rrgbf[3] / rgb[3];
878
879     mul_v3_v3fl(rrgbf, rgb, map_alpha);
880     rrgbf[3] = rgb[3];
881   }
882   else {
883     unsigned char straight[4];
884     unsigned char *rrgb = (unsigned char *)ibuf->rect + (ibuf->x * y + x) * 4;
885
886     premul_float_to_straight_uchar(straight, rgb);
887     rrgb[0] = straight[0];
888     rrgb[1] = straight[1];
889     rrgb[2] = straight[2];
890     rrgb[3] = straight[3];
891   }
892 }
893
894 static void paint_2d_ibuf_tile_convert(ImBuf *ibuf, int *x, int *y, short tile)
895 {
896   if (tile & PAINT_TILE_X) {
897     *x %= ibuf->x;
898     if (*x < 0) {
899       *x += ibuf->x;
900     }
901   }
902   if (tile & PAINT_TILE_Y) {
903     *y %= ibuf->y;
904     if (*y < 0) {
905       *y += ibuf->y;
906     }
907   }
908 }
909
910 static float paint_2d_ibuf_add_if(ImBuf *ibuf, int x, int y, float *outrgb, short tile, float w)
911 {
912   float inrgb[4];
913
914   if (tile) {
915     paint_2d_ibuf_tile_convert(ibuf, &x, &y, tile);
916   }
917   /* need to also do clipping here always since tiled coordinates
918    * are not always within bounds */
919   if (x < ibuf->x && x >= 0 && y < ibuf->y && y >= 0) {
920     paint_2d_ibuf_rgb_get(ibuf, x, y, inrgb);
921   }
922   else {
923     return 0;
924   }
925
926   mul_v4_fl(inrgb, w);
927   add_v4_v4(outrgb, inrgb);
928
929   return w;
930 }
931
932 static void paint_2d_lift_soften(
933     ImagePaintState *s, ImBuf *ibuf, ImBuf *ibufb, int *pos, const short tile)
934 {
935   bool sharpen = (s->painter->cache.invert ^ ((s->brush->flag & BRUSH_DIR_IN) != 0));
936   float threshold = s->brush->sharp_threshold;
937   int x, y, xi, yi, xo, yo, xk, yk;
938   float count;
939   int out_off[2], in_off[2], dim[2];
940   int diff_pos[2];
941   float outrgb[4];
942   float rgba[4];
943   BlurKernel *kernel = s->blurkernel;
944
945   dim[0] = ibufb->x;
946   dim[1] = ibufb->y;
947   in_off[0] = pos[0];
948   in_off[1] = pos[1];
949   out_off[0] = out_off[1] = 0;
950
951   if (!tile) {
952     IMB_rectclip(ibuf, ibufb, &in_off[0], &in_off[1], &out_off[0], &out_off[1], &dim[0], &dim[1]);
953
954     if ((dim[0] == 0) || (dim[1] == 0)) {
955       return;
956     }
957   }
958
959   /* find offset inside mask buffers to sample them */
960   sub_v2_v2v2_int(diff_pos, out_off, in_off);
961
962   for (y = 0; y < dim[1]; y++) {
963     for (x = 0; x < dim[0]; x++) {
964       /* get input pixel */
965       xi = in_off[0] + x;
966       yi = in_off[1] + y;
967
968       count = 0.0;
969       if (tile) {
970         paint_2d_ibuf_tile_convert(ibuf, &xi, &yi, tile);
971         if (xi < ibuf->x && xi >= 0 && yi < ibuf->y && yi >= 0) {
972           paint_2d_ibuf_rgb_get(ibuf, xi, yi, rgba);
973         }
974         else {
975           zero_v4(rgba);
976         }
977       }
978       else {
979         /* coordinates have been clipped properly here, it should be safe to do this */
980         paint_2d_ibuf_rgb_get(ibuf, xi, yi, rgba);
981       }
982       zero_v4(outrgb);
983
984       for (yk = 0; yk < kernel->side; yk++) {
985         for (xk = 0; xk < kernel->side; xk++) {
986           count += paint_2d_ibuf_add_if(ibuf,
987                                         xi + xk - kernel->pixel_len,
988                                         yi + yk - kernel->pixel_len,
989                                         outrgb,
990                                         tile,
991                                         kernel->wdata[xk + yk * kernel->side]);
992         }
993       }
994
995       if (count > 0.0f) {
996         mul_v4_fl(outrgb, 1.0f / (float)count);
997
998         if (sharpen) {
999           /* subtract blurred image from normal image gives high pass filter */
1000           sub_v3_v3v3(outrgb, rgba, outrgb);
1001
1002           /* Now rgba_ub contains the edge result, but this should be converted to luminance to
1003            * avoid colored speckles appearing in final image, and also to check for threshold. */
1004           outrgb[0] = outrgb[1] = outrgb[2] = IMB_colormanagement_get_luminance(outrgb);
1005           if (fabsf(outrgb[0]) > threshold) {
1006             float mask = BKE_brush_alpha_get(s->scene, s->brush);
1007             float alpha = rgba[3];
1008             rgba[3] = outrgb[3] = mask;
1009
1010             /* add to enhance edges */
1011             blend_color_add_float(outrgb, rgba, outrgb);
1012             outrgb[3] = alpha;
1013           }
1014           else {
1015             copy_v4_v4(outrgb, rgba);
1016           }
1017         }
1018       }
1019       else {
1020         copy_v4_v4(outrgb, rgba);
1021       }
1022       /* write into brush buffer */
1023       xo = out_off[0] + x;
1024       yo = out_off[1] + y;
1025       paint_2d_ibuf_rgb_set(ibufb, xo, yo, 0, outrgb);
1026     }
1027   }
1028 }
1029
1030 static void paint_2d_set_region(
1031     ImagePaintRegion *region, int destx, int desty, int srcx, int srcy, int width, int height)
1032 {
1033   region->destx = destx;
1034   region->desty = desty;
1035   region->srcx = srcx;
1036   region->srcy = srcy;
1037   region->width = width;
1038   region->height = height;
1039 }
1040
1041 static int paint_2d_torus_split_region(ImagePaintRegion region[4],
1042                                        ImBuf *dbuf,
1043                                        ImBuf *sbuf,
1044                                        short tile)
1045 {
1046   int destx = region->destx;
1047   int desty = region->desty;
1048   int srcx = region->srcx;
1049   int srcy = region->srcy;
1050   int width = region->width;
1051   int height = region->height;
1052   int origw, origh, w, h, tot = 0;
1053
1054   /* convert destination and source coordinates to be within image */
1055   if (tile & PAINT_TILE_X) {
1056     destx = destx % dbuf->x;
1057     if (destx < 0) {
1058       destx += dbuf->x;
1059     }
1060     srcx = srcx % sbuf->x;
1061     if (srcx < 0) {
1062       srcx += sbuf->x;
1063     }
1064   }
1065   if (tile & PAINT_TILE_Y) {
1066     desty = desty % dbuf->y;
1067     if (desty < 0) {
1068       desty += dbuf->y;
1069     }
1070     srcy = srcy % sbuf->y;
1071     if (srcy < 0) {
1072       srcy += sbuf->y;
1073     }
1074   }
1075   /* clip width of blending area to destination imbuf, to avoid writing the
1076    * same pixel twice */
1077   origw = w = (width > dbuf->x) ? dbuf->x : width;
1078   origh = h = (height > dbuf->y) ? dbuf->y : height;
1079
1080   /* clip within image */
1081   IMB_rectclip(dbuf, sbuf, &destx, &desty, &srcx, &srcy, &w, &h);
1082   paint_2d_set_region(&region[tot++], destx, desty, srcx, srcy, w, h);
1083
1084   /* do 3 other rects if needed */
1085   if ((tile & PAINT_TILE_X) && w < origw) {
1086     paint_2d_set_region(
1087         &region[tot++], (destx + w) % dbuf->x, desty, (srcx + w) % sbuf->x, srcy, origw - w, h);
1088   }
1089   if ((tile & PAINT_TILE_Y) && h < origh) {
1090     paint_2d_set_region(
1091         &region[tot++], destx, (desty + h) % dbuf->y, srcx, (srcy + h) % sbuf->y, w, origh - h);
1092   }
1093   if ((tile & PAINT_TILE_X) && (tile & PAINT_TILE_Y) && (w < origw) && (h < origh)) {
1094     paint_2d_set_region(&region[tot++],
1095                         (destx + w) % dbuf->x,
1096                         (desty + h) % dbuf->y,
1097                         (srcx + w) % sbuf->x,
1098                         (srcy + h) % sbuf->y,
1099                         origw - w,
1100                         origh - h);
1101   }
1102
1103   return tot;
1104 }
1105
1106 static void paint_2d_lift_smear(ImBuf *ibuf, ImBuf *ibufb, int *pos, short tile)
1107 {
1108   ImagePaintRegion region[4];
1109   int a, tot;
1110
1111   paint_2d_set_region(region, 0, 0, pos[0], pos[1], ibufb->x, ibufb->y);
1112   tot = paint_2d_torus_split_region(region, ibufb, ibuf, tile);
1113
1114   for (a = 0; a < tot; a++) {
1115     IMB_rectblend(ibufb,
1116                   ibufb,
1117                   ibuf,
1118                   NULL,
1119                   NULL,
1120                   NULL,
1121                   0,
1122                   region[a].destx,
1123                   region[a].desty,
1124                   region[a].destx,
1125                   region[a].desty,
1126                   region[a].srcx,
1127                   region[a].srcy,
1128                   region[a].width,
1129                   region[a].height,
1130                   IMB_BLEND_COPY,
1131                   false);
1132   }
1133 }
1134
1135 static ImBuf *paint_2d_lift_clone(ImBuf *ibuf, ImBuf *ibufb, int *pos)
1136 {
1137   /* note: allocImbuf returns zero'd memory, so regions outside image will
1138    * have zero alpha, and hence not be blended onto the image */
1139   int w = ibufb->x, h = ibufb->y, destx = 0, desty = 0, srcx = pos[0], srcy = pos[1];
1140   ImBuf *clonebuf = IMB_allocImBuf(w, h, ibufb->planes, ibufb->flags);
1141
1142   IMB_rectclip(clonebuf, ibuf, &destx, &desty, &srcx, &srcy, &w, &h);
1143   IMB_rectblend(clonebuf,
1144                 clonebuf,
1145                 ibufb,
1146                 NULL,
1147                 NULL,
1148                 NULL,
1149                 0,
1150                 destx,
1151                 desty,
1152                 destx,
1153                 desty,
1154                 destx,
1155                 desty,
1156                 w,
1157                 h,
1158                 IMB_BLEND_COPY_ALPHA,
1159                 false);
1160   IMB_rectblend(clonebuf,
1161                 clonebuf,
1162                 ibuf,
1163                 NULL,
1164                 NULL,
1165                 NULL,
1166                 0,
1167                 destx,
1168                 desty,
1169                 destx,
1170                 desty,
1171                 srcx,
1172                 srcy,
1173                 w,
1174                 h,
1175                 IMB_BLEND_COPY_RGB,
1176                 false);
1177
1178   return clonebuf;
1179 }
1180
1181 static void paint_2d_convert_brushco(ImBuf *ibufb, const float pos[2], int ipos[2])
1182 {
1183   ipos[0] = (int)floorf((pos[0] - ibufb->x / 2));
1184   ipos[1] = (int)floorf((pos[1] - ibufb->y / 2));
1185 }
1186
1187 static void paint_2d_do_making_brush(ImagePaintState *s,
1188                                      ImagePaintRegion *region,
1189                                      unsigned short *curveb,
1190                                      unsigned short *texmaskb,
1191                                      ImBuf *frombuf,
1192                                      float mask_max,
1193                                      short blend,
1194                                      int tilex,
1195                                      int tiley,
1196                                      int tilew,
1197                                      int tileh)
1198 {
1199   ImBuf tmpbuf;
1200   IMB_initImBuf(&tmpbuf, IMAPAINT_TILE_SIZE, IMAPAINT_TILE_SIZE, 32, 0);
1201
1202   ListBase *undo_tiles = ED_image_undo_get_tiles();
1203
1204   for (int ty = tiley; ty <= tileh; ty++) {
1205     for (int tx = tilex; tx <= tilew; tx++) {
1206       /* retrieve original pixels + mask from undo buffer */
1207       unsigned short *mask;
1208       int origx = region->destx - tx * IMAPAINT_TILE_SIZE;
1209       int origy = region->desty - ty * IMAPAINT_TILE_SIZE;
1210
1211       if (s->canvas->rect_float) {
1212         tmpbuf.rect_float = image_undo_find_tile(
1213             undo_tiles, s->image, s->canvas, tx, ty, &mask, false);
1214       }
1215       else {
1216         tmpbuf.rect = image_undo_find_tile(undo_tiles, s->image, s->canvas, tx, ty, &mask, false);
1217       }
1218
1219       IMB_rectblend(s->canvas,
1220                     &tmpbuf,
1221                     frombuf,
1222                     mask,
1223                     curveb,
1224                     texmaskb,
1225                     mask_max,
1226                     region->destx,
1227                     region->desty,
1228                     origx,
1229                     origy,
1230                     region->srcx,
1231                     region->srcy,
1232                     region->width,
1233                     region->height,
1234                     blend,
1235                     ((s->brush->flag & BRUSH_ACCUMULATE) != 0));
1236     }
1237   }
1238 }
1239
1240 typedef struct Paint2DForeachData {
1241   ImagePaintState *s;
1242   ImagePaintRegion *region;
1243   unsigned short *curveb;
1244   unsigned short *texmaskb;
1245   ImBuf *frombuf;
1246   float mask_max;
1247   short blend;
1248   int tilex;
1249   int tilew;
1250 } Paint2DForeachData;
1251
1252 static void paint_2d_op_foreach_do(void *__restrict data_v,
1253                                    const int iter,
1254                                    const ParallelRangeTLS *__restrict UNUSED(tls))
1255 {
1256   Paint2DForeachData *data = (Paint2DForeachData *)data_v;
1257   paint_2d_do_making_brush(data->s,
1258                            data->region,
1259                            data->curveb,
1260                            data->texmaskb,
1261                            data->frombuf,
1262                            data->mask_max,
1263                            data->blend,
1264                            data->tilex,
1265                            iter,
1266                            data->tilew,
1267                            iter);
1268 }
1269
1270 static int paint_2d_op(void *state,
1271                        ImBuf *ibufb,
1272                        unsigned short *curveb,
1273                        unsigned short *texmaskb,
1274                        const float lastpos[2],
1275                        const float pos[2])
1276 {
1277   ImagePaintState *s = ((ImagePaintState *)state);
1278   ImBuf *clonebuf = NULL, *frombuf;
1279   ImagePaintRegion region[4];
1280   short tile = s->symmetry & (PAINT_TILE_X | PAINT_TILE_Y);
1281   short blend = s->blend;
1282   const float *offset = s->brush->clone.offset;
1283   float liftpos[2];
1284   float mask_max = BKE_brush_alpha_get(s->scene, s->brush);
1285   int bpos[2], blastpos[2], bliftpos[2];
1286   int a, tot;
1287
1288   paint_2d_convert_brushco(ibufb, pos, bpos);
1289
1290   /* lift from canvas */
1291   if (s->tool == PAINT_TOOL_SOFTEN) {
1292     paint_2d_lift_soften(s, s->canvas, ibufb, bpos, tile);
1293     blend = IMB_BLEND_INTERPOLATE;
1294   }
1295   else if (s->tool == PAINT_TOOL_SMEAR) {
1296     if (lastpos[0] == pos[0] && lastpos[1] == pos[1]) {
1297       return 0;
1298     }
1299
1300     paint_2d_convert_brushco(ibufb, lastpos, blastpos);
1301     paint_2d_lift_smear(s->canvas, ibufb, blastpos, tile);
1302     blend = IMB_BLEND_INTERPOLATE;
1303   }
1304   else if (s->tool == PAINT_TOOL_CLONE && s->clonecanvas) {
1305     liftpos[0] = pos[0] - offset[0] * s->canvas->x;
1306     liftpos[1] = pos[1] - offset[1] * s->canvas->y;
1307
1308     paint_2d_convert_brushco(ibufb, liftpos, bliftpos);
1309     clonebuf = paint_2d_lift_clone(s->clonecanvas, ibufb, bliftpos);
1310   }
1311
1312   frombuf = (clonebuf) ? clonebuf : ibufb;
1313
1314   if (tile) {
1315     paint_2d_set_region(region, bpos[0], bpos[1], 0, 0, frombuf->x, frombuf->y);
1316     tot = paint_2d_torus_split_region(region, s->canvas, frombuf, tile);
1317   }
1318   else {
1319     paint_2d_set_region(region, bpos[0], bpos[1], 0, 0, frombuf->x, frombuf->y);
1320     tot = 1;
1321   }
1322
1323   /* blend into canvas */
1324   for (a = 0; a < tot; a++) {
1325     ED_imapaint_dirty_region(s->image,
1326                              s->canvas,
1327                              region[a].destx,
1328                              region[a].desty,
1329                              region[a].width,
1330                              region[a].height,
1331                              true);
1332
1333     if (s->do_masking) {
1334       /* masking, find original pixels tiles from undo buffer to composite over */
1335       int tilex, tiley, tilew, tileh;
1336
1337       imapaint_region_tiles(s->canvas,
1338                             region[a].destx,
1339                             region[a].desty,
1340                             region[a].width,
1341                             region[a].height,
1342                             &tilex,
1343                             &tiley,
1344                             &tilew,
1345                             &tileh);
1346
1347       if (tiley == tileh) {
1348         paint_2d_do_making_brush(
1349             s, &region[a], curveb, texmaskb, frombuf, mask_max, blend, tilex, tiley, tilew, tileh);
1350       }
1351       else {
1352         Paint2DForeachData data;
1353         data.s = s;
1354         data.region = &region[a];
1355         data.curveb = curveb;
1356         data.texmaskb = texmaskb;
1357         data.frombuf = frombuf;
1358         data.mask_max = mask_max;
1359         data.blend = blend;
1360         data.tilex = tilex;
1361         data.tilew = tilew;
1362
1363         ParallelRangeSettings settings;
1364         BLI_parallel_range_settings_defaults(&settings);
1365         BLI_task_parallel_range(tiley, tileh + 1, &data, paint_2d_op_foreach_do, &settings);
1366       }
1367     }
1368     else {
1369       /* no masking, composite brush directly onto canvas */
1370       IMB_rectblend_threaded(s->canvas,
1371                              s->canvas,
1372                              frombuf,
1373                              NULL,
1374                              curveb,
1375                              texmaskb,
1376                              mask_max,
1377                              region[a].destx,
1378                              region[a].desty,
1379                              region[a].destx,
1380                              region[a].desty,
1381                              region[a].srcx,
1382                              region[a].srcy,
1383                              region[a].width,
1384                              region[a].height,
1385                              blend,
1386                              false);
1387     }
1388   }
1389
1390   if (clonebuf) {
1391     IMB_freeImBuf(clonebuf);
1392   }
1393
1394   return 1;
1395 }
1396
1397 static int paint_2d_canvas_set(ImagePaintState *s, Image *ima)
1398 {
1399   ImBuf *ibuf = BKE_image_acquire_ibuf(ima, s->sima ? &s->sima->iuser : NULL, NULL);
1400
1401   /* verify that we can paint and set canvas */
1402   if (ima == NULL) {
1403     return 0;
1404   }
1405   else if (BKE_image_has_packedfile(ima) && ima->rr) {
1406     s->warnpackedfile = ima->id.name + 2;
1407     return 0;
1408   }
1409   else if (ibuf && ibuf->channels != 4) {
1410     s->warnmultifile = ima->id.name + 2;
1411     return 0;
1412   }
1413   else if (!ibuf || !(ibuf->rect || ibuf->rect_float)) {
1414     return 0;
1415   }
1416
1417   s->image = ima;
1418   s->canvas = ibuf;
1419
1420   /* set clone canvas */
1421   if (s->tool == PAINT_TOOL_CLONE) {
1422     ima = s->brush->clone.image;
1423     ibuf = BKE_image_acquire_ibuf(ima, s->sima ? &s->sima->iuser : NULL, NULL);
1424
1425     if (!ima || !ibuf || !(ibuf->rect || ibuf->rect_float)) {
1426       BKE_image_release_ibuf(ima, ibuf, NULL);
1427       BKE_image_release_ibuf(s->image, s->canvas, NULL);
1428       return 0;
1429     }
1430
1431     s->clonecanvas = ibuf;
1432
1433     /* temporarily add float rect for cloning */
1434     if (s->canvas->rect_float && !s->clonecanvas->rect_float) {
1435       IMB_float_from_rect(s->clonecanvas);
1436     }
1437     else if (!s->canvas->rect_float && !s->clonecanvas->rect) {
1438       IMB_rect_from_float(s->clonecanvas);
1439     }
1440   }
1441
1442   /* set masking */
1443   s->do_masking = paint_use_opacity_masking(s->brush);
1444
1445   return 1;
1446 }
1447
1448 static void paint_2d_canvas_free(ImagePaintState *s)
1449 {
1450   BKE_image_release_ibuf(s->image, s->canvas, NULL);
1451   BKE_image_release_ibuf(s->brush->clone.image, s->clonecanvas, NULL);
1452
1453   if (s->blurkernel) {
1454     paint_delete_blur_kernel(s->blurkernel);
1455     MEM_freeN(s->blurkernel);
1456   }
1457
1458   image_undo_remove_masks();
1459 }
1460
1461 void paint_2d_stroke(void *ps,
1462                      const float prev_mval[2],
1463                      const float mval[2],
1464                      const bool eraser,
1465                      float pressure,
1466                      float distance,
1467                      float size)
1468 {
1469   float newuv[2], olduv[2];
1470   ImagePaintState *s = ps;
1471   BrushPainter *painter = s->painter;
1472   ImBuf *ibuf = BKE_image_acquire_ibuf(s->image, s->sima ? &s->sima->iuser : NULL, NULL);
1473   const bool is_data = (ibuf && ibuf->colormanage_flag & IMB_COLORMANAGE_IS_DATA);
1474
1475   if (!ibuf) {
1476     return;
1477   }
1478
1479   s->blend = s->brush->blend;
1480   if (eraser) {
1481     s->blend = IMB_BLEND_ERASE_ALPHA;
1482   }
1483
1484   UI_view2d_region_to_view(s->v2d, mval[0], mval[1], &newuv[0], &newuv[1]);
1485   UI_view2d_region_to_view(s->v2d, prev_mval[0], prev_mval[1], &olduv[0], &olduv[1]);
1486
1487   newuv[0] *= ibuf->x;
1488   newuv[1] *= ibuf->y;
1489
1490   olduv[0] *= ibuf->x;
1491   olduv[1] *= ibuf->y;
1492
1493   if (painter->firsttouch) {
1494     float startuv[2];
1495
1496     UI_view2d_region_to_view(s->v2d, 0, 0, &startuv[0], &startuv[1]);
1497
1498     /* paint exactly once on first touch */
1499     painter->startpaintpos[0] = startuv[0] * ibuf->x;
1500     painter->startpaintpos[1] = startuv[1] * ibuf->y;
1501
1502     painter->firsttouch = 0;
1503     copy_v2_v2(painter->lastpaintpos, newuv);
1504   }
1505   else {
1506     copy_v2_v2(painter->lastpaintpos, olduv);
1507   }
1508
1509   /* OCIO_TODO: float buffers are now always linear, so always use color correction
1510    *            this should probably be changed when texture painting color space is supported
1511    */
1512   brush_painter_2d_require_imbuf(painter, (ibuf->rect_float != NULL), !is_data);
1513
1514   brush_painter_2d_refresh_cache(s, painter, newuv, mval, pressure, distance, size);
1515
1516   if (paint_2d_op(s,
1517                   painter->cache.ibuf,
1518                   painter->cache.curve_mask,
1519                   painter->cache.tex_mask,
1520                   olduv,
1521                   newuv)) {
1522     s->need_redraw = true;
1523   }
1524
1525   BKE_image_release_ibuf(s->image, ibuf, NULL);
1526 }
1527
1528 void *paint_2d_new_stroke(bContext *C, wmOperator *op, int mode)
1529 {
1530   Scene *scene = CTX_data_scene(C);
1531   ToolSettings *settings = scene->toolsettings;
1532   Brush *brush = BKE_paint_brush(&settings->imapaint.paint);
1533
1534   ImagePaintState *s = MEM_callocN(sizeof(ImagePaintState), "ImagePaintState");
1535
1536   s->sima = CTX_wm_space_image(C);
1537   s->v2d = &CTX_wm_region(C)->v2d;
1538   s->scene = scene;
1539   s->screen = CTX_wm_screen(C);
1540
1541   s->brush = brush;
1542   s->tool = brush->imagepaint_tool;
1543   s->blend = brush->blend;
1544
1545   s->image = s->sima->image;
1546   s->symmetry = settings->imapaint.paint.symmetry_flags;
1547
1548   if (!paint_2d_canvas_set(s, s->image)) {
1549     if (s->warnmultifile) {
1550       BKE_report(op->reports, RPT_WARNING, "Image requires 4 color channels to paint");
1551     }
1552     if (s->warnpackedfile) {
1553       BKE_report(op->reports, RPT_WARNING, "Packed MultiLayer files cannot be painted");
1554     }
1555
1556     MEM_freeN(s);
1557     return NULL;
1558   }
1559
1560   if (brush->imagepaint_tool == PAINT_TOOL_SOFTEN) {
1561     s->blurkernel = paint_new_blur_kernel(brush, false);
1562   }
1563
1564   paint_brush_init_tex(s->brush);
1565
1566   /* create painter */
1567   s->painter = brush_painter_2d_new(scene, s->brush, mode == BRUSH_STROKE_INVERT);
1568
1569   return s;
1570 }
1571
1572 void paint_2d_redraw(const bContext *C, void *ps, bool final)
1573 {
1574   ImagePaintState *s = ps;
1575
1576   if (s->need_redraw) {
1577     ImBuf *ibuf = BKE_image_acquire_ibuf(s->image, s->sima ? &s->sima->iuser : NULL, NULL);
1578
1579     imapaint_image_update(s->sima, s->image, ibuf, false);
1580     ED_imapaint_clear_partial_redraw();
1581
1582     BKE_image_release_ibuf(s->image, ibuf, NULL);
1583
1584     s->need_redraw = false;
1585   }
1586   else if (!final) {
1587     return;
1588   }
1589
1590   if (final) {
1591     if (s->image && !(s->sima && s->sima->lock)) {
1592       GPU_free_image(s->image);
1593     }
1594
1595     /* compositor listener deals with updating */
1596     WM_event_add_notifier(C, NC_IMAGE | NA_EDITED, s->image);
1597     DEG_id_tag_update(&s->image->id, 0);
1598   }
1599   else {
1600     if (!s->sima || !s->sima->lock) {
1601       ED_region_tag_redraw(CTX_wm_region(C));
1602     }
1603     else {
1604       WM_event_add_notifier(C, NC_IMAGE | NA_PAINTING, s->image);
1605     }
1606   }
1607 }
1608
1609 void paint_2d_stroke_done(void *ps)
1610 {
1611   ImagePaintState *s = ps;
1612
1613   paint_2d_canvas_free(s);
1614   brush_painter_2d_free(s->painter);
1615   paint_brush_exit_tex(s->brush);
1616
1617   MEM_freeN(s);
1618 }
1619
1620 static void paint_2d_fill_add_pixel_byte(const int x_px,
1621                                          const int y_px,
1622                                          ImBuf *ibuf,
1623                                          BLI_Stack *stack,
1624                                          BLI_bitmap *touched,
1625                                          const float color[4],
1626                                          float threshold_sq)
1627 {
1628   size_t coordinate;
1629
1630   if (x_px >= ibuf->x || x_px < 0 || y_px >= ibuf->y || y_px < 0) {
1631     return;
1632   }
1633
1634   coordinate = ((size_t)y_px) * ibuf->x + x_px;
1635
1636   if (!BLI_BITMAP_TEST(touched, coordinate)) {
1637     float color_f[4];
1638     unsigned char *color_b = (unsigned char *)(ibuf->rect + coordinate);
1639     rgba_uchar_to_float(color_f, color_b);
1640     straight_to_premul_v4(color_f);
1641
1642     if (len_squared_v4v4(color_f, color) <= threshold_sq) {
1643       BLI_stack_push(stack, &coordinate);
1644     }
1645     BLI_BITMAP_SET(touched, coordinate, true);
1646   }
1647 }
1648
1649 static void paint_2d_fill_add_pixel_float(const int x_px,
1650                                           const int y_px,
1651                                           ImBuf *ibuf,
1652                                           BLI_Stack *stack,
1653                                           BLI_bitmap *touched,
1654                                           const float color[4],
1655                                           float threshold_sq)
1656 {
1657   size_t coordinate;
1658
1659   if (x_px >= ibuf->x || x_px < 0 || y_px >= ibuf->y || y_px < 0) {
1660     return;
1661   }
1662
1663   coordinate = ((size_t)y_px) * ibuf->x + x_px;
1664
1665   if (!BLI_BITMAP_TEST(touched, coordinate)) {
1666     if (len_squared_v4v4(ibuf->rect_float + 4 * coordinate, color) <= threshold_sq) {
1667       BLI_stack_push(stack, &coordinate);
1668     }
1669     BLI_BITMAP_SET(touched, coordinate, true);
1670   }
1671 }
1672
1673 /* this function expects linear space color values */
1674 void paint_2d_bucket_fill(
1675     const bContext *C, const float color[3], Brush *br, const float mouse_init[2], void *ps)
1676 {
1677   SpaceImage *sima = CTX_wm_space_image(C);
1678   Image *ima = sima->image;
1679
1680   ImagePaintState *s = ps;
1681
1682   ImBuf *ibuf;
1683   int x_px, y_px;
1684   unsigned int color_b;
1685   float color_f[4];
1686   float strength = br ? br->alpha : 1.0f;
1687
1688   bool do_float;
1689
1690   if (!ima) {
1691     return;
1692   }
1693
1694   ibuf = BKE_image_acquire_ibuf(ima, &sima->iuser, NULL);
1695
1696   if (!ibuf) {
1697     return;
1698   }
1699
1700   do_float = (ibuf->rect_float != NULL);
1701   /* first check if our image is float. If it is not we should correct the color to
1702    * be in gamma space. strictly speaking this is not correct, but blender does not paint
1703    * byte images in linear space */
1704   if (!do_float) {
1705     linearrgb_to_srgb_uchar3((unsigned char *)&color_b, color);
1706     *(((char *)&color_b) + 3) = strength * 255;
1707   }
1708   else {
1709     copy_v3_v3(color_f, color);
1710     color_f[3] = strength;
1711   }
1712
1713   if (!mouse_init || !br) {
1714     /* first case, no image UV, fill the whole image */
1715     ED_imapaint_dirty_region(ima, ibuf, 0, 0, ibuf->x, ibuf->y, false);
1716
1717     if (do_float) {
1718       for (x_px = 0; x_px < ibuf->x; x_px++) {
1719         for (y_px = 0; y_px < ibuf->y; y_px++) {
1720           blend_color_mix_float(ibuf->rect_float + 4 * (((size_t)y_px) * ibuf->x + x_px),
1721                                 ibuf->rect_float + 4 * (((size_t)y_px) * ibuf->x + x_px),
1722                                 color_f);
1723         }
1724       }
1725     }
1726     else {
1727       for (x_px = 0; x_px < ibuf->x; x_px++) {
1728         for (y_px = 0; y_px < ibuf->y; y_px++) {
1729           blend_color_mix_byte((unsigned char *)(ibuf->rect + ((size_t)y_px) * ibuf->x + x_px),
1730                                (unsigned char *)(ibuf->rect + ((size_t)y_px) * ibuf->x + x_px),
1731                                (unsigned char *)&color_b);
1732         }
1733       }
1734     }
1735   }
1736   else {
1737     /* second case, start sweeping the neighboring pixels, looking for pixels whose
1738      * value is within the brush fill threshold from the fill color */
1739     BLI_Stack *stack;
1740     BLI_bitmap *touched;
1741     size_t coordinate;
1742     int width = ibuf->x;
1743     float image_init[2];
1744     int minx = ibuf->x, miny = ibuf->y, maxx = 0, maxy = 0;
1745     float pixel_color[4];
1746     /* We are comparing to sum of three squared values
1747      * (assumed in range [0,1]), so need to multiply... */
1748     float threshold_sq = br->fill_threshold * br->fill_threshold * 3;
1749
1750     UI_view2d_region_to_view(s->v2d, mouse_init[0], mouse_init[1], &image_init[0], &image_init[1]);
1751
1752     x_px = image_init[0] * ibuf->x;
1753     y_px = image_init[1] * ibuf->y;
1754
1755     if (x_px >= ibuf->x || x_px < 0 || y_px > ibuf->y || y_px < 0) {
1756       BKE_image_release_ibuf(ima, ibuf, NULL);
1757       return;
1758     }
1759
1760     /* change image invalidation method later */
1761     ED_imapaint_dirty_region(ima, ibuf, 0, 0, ibuf->x, ibuf->y, false);
1762
1763     stack = BLI_stack_new(sizeof(size_t), __func__);
1764     touched = BLI_BITMAP_NEW(((size_t)ibuf->x) * ibuf->y, "bucket_fill_bitmap");
1765
1766     coordinate = (((size_t)y_px) * ibuf->x + x_px);
1767
1768     if (do_float) {
1769       copy_v4_v4(pixel_color, ibuf->rect_float + 4 * coordinate);
1770     }
1771     else {
1772       int pixel_color_b = *(ibuf->rect + coordinate);
1773       rgba_uchar_to_float(pixel_color, (unsigned char *)&pixel_color_b);
1774       straight_to_premul_v4(pixel_color);
1775     }
1776
1777     BLI_stack_push(stack, &coordinate);
1778     BLI_BITMAP_SET(touched, coordinate, true);
1779
1780     if (do_float) {
1781       while (!BLI_stack_is_empty(stack)) {
1782         BLI_stack_pop(stack, &coordinate);
1783
1784         IMB_blend_color_float(ibuf->rect_float + 4 * (coordinate),
1785                               ibuf->rect_float + 4 * (coordinate),
1786                               color_f,
1787                               br->blend);
1788
1789         /* reconstruct the coordinates here */
1790         x_px = coordinate % width;
1791         y_px = coordinate / width;
1792
1793         paint_2d_fill_add_pixel_float(
1794             x_px - 1, y_px - 1, ibuf, stack, touched, pixel_color, threshold_sq);
1795         paint_2d_fill_add_pixel_float(
1796             x_px - 1, y_px, ibuf, stack, touched, pixel_color, threshold_sq);
1797         paint_2d_fill_add_pixel_float(
1798             x_px - 1, y_px + 1, ibuf, stack, touched, pixel_color, threshold_sq);
1799         paint_2d_fill_add_pixel_float(
1800             x_px, y_px + 1, ibuf, stack, touched, pixel_color, threshold_sq);
1801         paint_2d_fill_add_pixel_float(
1802             x_px, y_px - 1, ibuf, stack, touched, pixel_color, threshold_sq);
1803         paint_2d_fill_add_pixel_float(
1804             x_px + 1, y_px - 1, ibuf, stack, touched, pixel_color, threshold_sq);
1805         paint_2d_fill_add_pixel_float(
1806             x_px + 1, y_px, ibuf, stack, touched, pixel_color, threshold_sq);
1807         paint_2d_fill_add_pixel_float(
1808             x_px + 1, y_px + 1, ibuf, stack, touched, pixel_color, threshold_sq);
1809
1810         if (x_px > maxx) {
1811           maxx = x_px;
1812         }
1813         if (x_px < minx) {
1814           minx = x_px;
1815         }
1816         if (y_px > maxy) {
1817           maxy = y_px;
1818         }
1819         if (x_px > miny) {
1820           miny = y_px;
1821         }
1822       }
1823     }
1824     else {
1825       while (!BLI_stack_is_empty(stack)) {
1826         BLI_stack_pop(stack, &coordinate);
1827
1828         IMB_blend_color_byte((unsigned char *)(ibuf->rect + coordinate),
1829                              (unsigned char *)(ibuf->rect + coordinate),
1830                              (unsigned char *)&color_b,
1831                              br->blend);
1832
1833         /* reconstruct the coordinates here */
1834         x_px = coordinate % width;
1835         y_px = coordinate / width;
1836
1837         paint_2d_fill_add_pixel_byte(
1838             x_px - 1, y_px - 1, ibuf, stack, touched, pixel_color, threshold_sq);
1839         paint_2d_fill_add_pixel_byte(
1840             x_px - 1, y_px, ibuf, stack, touched, pixel_color, threshold_sq);
1841         paint_2d_fill_add_pixel_byte(
1842             x_px - 1, y_px + 1, ibuf, stack, touched, pixel_color, threshold_sq);
1843         paint_2d_fill_add_pixel_byte(
1844             x_px, y_px + 1, ibuf, stack, touched, pixel_color, threshold_sq);
1845         paint_2d_fill_add_pixel_byte(
1846             x_px, y_px - 1, ibuf, stack, touched, pixel_color, threshold_sq);
1847         paint_2d_fill_add_pixel_byte(
1848             x_px + 1, y_px - 1, ibuf, stack, touched, pixel_color, threshold_sq);
1849         paint_2d_fill_add_pixel_byte(
1850             x_px + 1, y_px, ibuf, stack, touched, pixel_color, threshold_sq);
1851         paint_2d_fill_add_pixel_byte(
1852             x_px + 1, y_px + 1, ibuf, stack, touched, pixel_color, threshold_sq);
1853
1854         if (x_px > maxx) {
1855           maxx = x_px;
1856         }
1857         if (x_px < minx) {
1858           minx = x_px;
1859         }
1860         if (y_px > maxy) {
1861           maxy = y_px;
1862         }
1863         if (x_px > miny) {
1864           miny = y_px;
1865         }
1866       }
1867     }
1868
1869     MEM_freeN(touched);
1870     BLI_stack_free(stack);
1871   }
1872
1873   imapaint_image_update(sima, ima, ibuf, false);
1874   ED_imapaint_clear_partial_redraw();
1875
1876   BKE_image_release_ibuf(ima, ibuf, NULL);
1877
1878   WM_event_add_notifier(C, NC_IMAGE | NA_EDITED, ima);
1879 }
1880
1881 void paint_2d_gradient_fill(
1882     const bContext *C, Brush *br, const float mouse_init[2], const float mouse_final[2], void *ps)
1883 {
1884   SpaceImage *sima = CTX_wm_space_image(C);
1885   Image *ima = sima->image;
1886   ImagePaintState *s = ps;
1887
1888   ImBuf *ibuf;
1889   int x_px, y_px;
1890   unsigned int color_b;
1891   float color_f[4];
1892   float image_init[2], image_final[2];
1893   float tangent[2];
1894   float line_len_sq_inv, line_len;
1895
1896   bool do_float;
1897
1898   if (!ima) {
1899     return;
1900   }
1901
1902   ibuf = BKE_image_acquire_ibuf(ima, &sima->iuser, NULL);
1903
1904   if (!ibuf) {
1905     return;
1906   }
1907
1908   UI_view2d_region_to_view(
1909       s->v2d, mouse_final[0], mouse_final[1], &image_final[0], &image_final[1]);
1910   UI_view2d_region_to_view(s->v2d, mouse_init[0], mouse_init[1], &image_init[0], &image_init[1]);
1911
1912   image_final[0] *= ibuf->x;
1913   image_final[1] *= ibuf->y;
1914
1915   image_init[0] *= ibuf->x;
1916   image_init[1] *= ibuf->y;
1917
1918   /* some math to get needed gradient variables */
1919   sub_v2_v2v2(tangent, image_final, image_init);
1920   line_len = len_squared_v2(tangent);
1921   line_len_sq_inv = 1.0f / line_len;
1922   line_len = sqrtf(line_len);
1923
1924   do_float = (ibuf->rect_float != NULL);
1925
1926   /* this will be substituted by something else when selection is available */
1927   ED_imapaint_dirty_region(ima, ibuf, 0, 0, ibuf->x, ibuf->y, false);
1928
1929   if (do_float) {
1930     for (x_px = 0; x_px < ibuf->x; x_px++) {
1931       for (y_px = 0; y_px < ibuf->y; y_px++) {
1932         float f;
1933         float p[2] = {x_px - image_init[0], y_px - image_init[1]};
1934
1935         switch (br->gradient_fill_mode) {
1936           case BRUSH_GRADIENT_LINEAR: {
1937             f = dot_v2v2(p, tangent) * line_len_sq_inv;
1938             break;
1939           }
1940           case BRUSH_GRADIENT_RADIAL:
1941           default: {
1942             f = len_v2(p) / line_len;
1943             break;
1944           }
1945         }
1946         BKE_colorband_evaluate(br->gradient, f, color_f);
1947         /* convert to premultiplied */
1948         mul_v3_fl(color_f, color_f[3]);
1949         color_f[3] *= br->alpha;
1950         IMB_blend_color_float(ibuf->rect_float + 4 * (((size_t)y_px) * ibuf->x + x_px),
1951                               ibuf->rect_float + 4 * (((size_t)y_px) * ibuf->x + x_px),
1952                               color_f,
1953                               br->blend);
1954       }
1955     }
1956   }
1957   else {
1958     for (x_px = 0; x_px < ibuf->x; x_px++) {
1959       for (y_px = 0; y_px < ibuf->y; y_px++) {
1960         float f;
1961         float p[2] = {x_px - image_init[0], y_px - image_init[1]};
1962
1963         switch (br->gradient_fill_mode) {
1964           case BRUSH_GRADIENT_LINEAR: {
1965             f = dot_v2v2(p, tangent) * line_len_sq_inv;
1966             break;
1967           }
1968           case BRUSH_GRADIENT_RADIAL:
1969           default: {
1970             f = len_v2(p) / line_len;
1971             break;
1972           }
1973         }
1974
1975         BKE_colorband_evaluate(br->gradient, f, color_f);
1976         linearrgb_to_srgb_v3_v3(color_f, color_f);
1977         rgba_float_to_uchar((unsigned char *)&color_b, color_f);
1978         ((unsigned char *)&color_b)[3] *= br->alpha;
1979         IMB_blend_color_byte((unsigned char *)(ibuf->rect + ((size_t)y_px) * ibuf->x + x_px),
1980                              (unsigned char *)(ibuf->rect + ((size_t)y_px) * ibuf->x + x_px),
1981                              (unsigned char *)&color_b,
1982                              br->blend);
1983       }
1984     }
1985   }
1986
1987   imapaint_image_update(sima, ima, ibuf, false);
1988   ED_imapaint_clear_partial_redraw();
1989
1990   BKE_image_release_ibuf(ima, ibuf, NULL);
1991
1992   WM_event_add_notifier(C, NC_IMAGE | NA_EDITED, ima);
1993 }